summaryrefslogtreecommitdiffstats
path: root/flow/gsl/gslglib.h
blob: 18319854849cae8d80a9efd684fde65cf37fcca5 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
/* GSL - Generic Sound Layer
 * Copyright (C) 2001 Stefan Westerfeld and Tim Janik
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General
 * Public License along with this library; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */
#ifndef __GSL_GLIB_H__
#define __GSL_GLIB_H__

#ifndef G_LOG_DOMAIN
#define G_LOG_DOMAIN "GSL"
#endif


#include <limits.h>
#include <float.h>
#include <stddef.h>
#include <stdarg.h>

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

/* for -ansi -pedantic */
#ifdef __GNUC__
#define asm __asm__
#endif

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

#define	GSL_ASSERT(foo)		do { if (!(foo)) g_error ("assertion failed `%s'", #foo); } while (0)

/* --- GLib typedefs --- */
typedef void*		gpointer;
typedef const void*	gconstpointer;
typedef char		gchar;
typedef unsigned char	guchar;
typedef signed short	gshort;
typedef unsigned short	gushort;
typedef signed int	gint;
typedef unsigned int	guint;
typedef signed long	glong;
typedef unsigned long	gulong;
typedef float		gfloat;
typedef double		gdouble;
typedef size_t		gsize;
typedef gchar		gint8;
typedef guchar		guint8;
typedef gshort		gint16;
typedef gushort		guint16;
typedef gint		gint32;
typedef guint		guint32;
typedef gint		gboolean;
typedef gint32		GTime;
#ifdef __alpha
typedef long int		gint64;
typedef unsigned long int	guint64;
#else
typedef long long int	gint64;
typedef unsigned long long int  guint64;
#endif
typedef struct _GString GString;
typedef struct _GDebugKey       GDebugKey;
struct _GDebugKey
{
  const gchar *key;
  guint  value;
};
typedef struct _GTimeVal        GTimeVal;
struct _GTimeVal
{
  glong tv_sec;
  glong tv_usec;
};
typedef gint            (*GCompareFunc)         (gconstpointer  a,
                                                 gconstpointer  b);


/* --- standard macros --- */
#ifndef ABS
#define ABS(a)		((a) > 0 ? (a) : -(a))
#endif
#ifndef MAX
#define MAX(a,b)        ((a) > (b) ? (a) : (b))
#endif
#ifndef MIN
#define MIN(a,b)        ((a) < (b) ? (a) : (b))
#endif
#ifndef CLAMP
#define CLAMP(v,l,h)    ((v) < (l) ? (l) : (v) > (h) ? (h) : (v))
#endif
#ifndef FALSE
#define FALSE           0
#endif
#ifndef TRUE
#define TRUE            (!FALSE)
#endif
#ifndef NULL
#define NULL            ((void*) 0)
#endif


/* --- glib macros --- */
#define G_MINFLOAT      FLT_MIN
#define G_MAXFLOAT      FLT_MAX
#define G_MINDOUBLE     DBL_MIN
#define G_MAXDOUBLE     DBL_MAX
#define G_MINSHORT      SHRT_MIN
#define G_MAXSHORT      SHRT_MAX
#define G_MAXUSHORT     USHRT_MAX
#define G_MININT        INT_MIN
#define G_MININT64      ((gint64)  0x8000000000000000)
#define G_MAXINT        INT_MAX
#define G_MAXINT64      ((gint64)  0x7fffffffffffffff)
#define G_MAXUINT       UINT_MAX
#define G_MAXUINT64     ((guint64) 0xffffffffffffffff)
#define G_MINLONG       LONG_MIN
#define G_MAXLONG       LONG_MAX
#define G_MAXULONG      ULONG_MAX
#define	G_USEC_PER_SEC	1000000
#define G_LITTLE_ENDIAN 1234
#define G_BIG_ENDIAN    4321

#define G_DIR_SEPARATOR '/'
#ifdef	MAXPATHLEN
#define	G_PATH_LENGTH	MAXPATHLEN
#elif	defined (PATH_MAX)
#define	G_PATH_LENGTH	PATH_MAX
#elif   defined (_PC_PATH_MAX)
#define	G_PATH_LENGTH	sysconf(_PC_PATH_MAX)
#else
#define G_PATH_LENGTH   2048
#endif

#define G_N_ELEMENTS(arr)          (sizeof (arr) / sizeof ((arr)[0]))
#define G_STRINGIFY(macro_or_string)    G_STRINGIFY_ARG (macro_or_string)
#define G_STRINGIFY_ARG(contents)       #contents
#define G_STRLOC      __FILE__ ":" G_STRINGIFY (__LINE__)
#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
#define G_STRUCT_OFFSET(struct_type, member)    \
    ((glong) ((guint8*) &((struct_type*) 0)->member))
#define G_STRUCT_MEMBER_P(struct_p, struct_offset)   \
    ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset)))
#define G_STRUCT_MEMBER(member_type, struct_p, struct_offset)   \
    (*(member_type*) G_STRUCT_MEMBER_P ((struct_p), (struct_offset)))
#define GINT_TO_POINTER(i)     ((gpointer) (int) (i))
#define GUINT_TO_POINTER(i)     ((gpointer) (guint) (i))
#define GPOINTER_TO_INT(p)     ((int) (p))
#define GPOINTER_TO_UINT(p)    ((guint) (p))
#define GUINT16_SWAP_LE_BE(val)        ((guint16) ( \
    (((guint16) (val) & (guint16) 0x00ffU) << 8) | \
    (((guint16) (val) & (guint16) 0xff00U) >> 8)))
#define GUINT32_SWAP_LE_BE(val)        ((guint32) ( \
    (((guint32) (val) & (guint32) 0x000000ffU) << 24) | \
    (((guint32) (val) & (guint32) 0x0000ff00U) <<  8) | \
    (((guint32) (val) & (guint32) 0x00ff0000U) >>  8) | \
    (((guint32) (val) & (guint32) 0xff000000U) >> 24)))

#ifdef WORDS_BIGENDIAN
#define GUINT16_TO_LE(val) GUINT16_SWAP_LE_BE(val)
#define GUINT32_TO_LE(val) GUINT32_SWAP_LE_BE(val)
#define GUINT16_TO_BE(val) ((guint16) (val))
#define GUINT32_TO_BE(val) ((guint32) (val))
#else /* LITTLEENDIAN */
#define GUINT16_TO_LE(val) ((guint16) (val))
#define GUINT32_TO_LE(val) ((guint32) (val))
#define GUINT16_TO_BE(val) GUINT16_SWAP_LE_BE(val)
#define GUINT32_TO_BE(val) GUINT32_SWAP_LE_BE(val)
#endif

#define GUINT16_FROM_LE(val)    (GUINT16_TO_LE (val))
#define GUINT16_FROM_BE(val)    (GUINT16_TO_BE (val))
#define GUINT32_FROM_LE(val)    (GUINT32_TO_LE (val))
#define GUINT32_FROM_BE(val)    (GUINT32_TO_BE (val))


#define g_memmove memmove
#define g_assert  GSL_ASSERT
#define g_assert_not_reached()	g_assert(!G_STRLOC": should not be reached")
#define	g_return_if_fail(foo)		do { if (!(foo)) g_message (G_STRLOC ": assertion failed `%s'", #foo); } while (0)
#define	g_return_val_if_fail(foo,v)		do { if (!(foo)) { g_message (G_STRLOC ": assertion failed `%s'", #foo); return(v);}} while (0)

/* from galloca.h */

#ifdef  __GNUC__
/* GCC does the right thing */
# undef alloca
# define alloca(size)   __builtin_alloca (size)
#elif defined (GLIB_HAVE_ALLOCA_H)
/* a native and working alloca.h is there */
# include <alloca.h>
#else /* !__GNUC__ && !GLIB_HAVE_ALLOCA_H */
# ifdef _MSC_VER
#  include <malloc.h>
#  define alloca _alloca
# else /* !_MSC_VER */
#  ifdef _AIX
 #pragma alloca
#  else /* !_AIX */
#   ifndef alloca /* predefined by HP cc +Olibcalls */
char *alloca ();
#   endif /* !alloca */
#  endif /* !_AIX */
# endif /* !_MSC_VER */
#endif /* !__GNUC__ && !GLIB_HAVE_ALLOCA_H */

#define g_alloca(size) alloca (size)
#define g_newa(struct_type, n_structs)  ((struct_type*) g_alloca (sizeof (struct_type) * (gsize) (n_structs)))

/* needs inline configure check */
#if defined (__xlc__)
#  if !defined (inline)
#    define inline _Inline
#  endif
#elif defined (__GNUC__)
#define inline __inline__
#else
#define inline /* no inline */
#endif


/* --- inline functions --- */
void
gsl_g_log (const gchar*msg,const char *format, va_list ap);
void
gsl_g_print_fd (int fd,const char *format, va_list ap);
static inline void
g_error (const gchar *format,
	 ...)
{
  va_list args;
  va_start (args, format);
  gsl_g_log ("**ERROR**", format, args);
  va_end (args);
}
static inline void
g_message (const gchar *format,
	   ...)
{
  va_list args;
  va_start (args, format);
  gsl_g_log ("**MESSAGE**", format, args);
  va_end (args);
}
static inline void
g_critical (const gchar *format,
	    ...)
{
  va_list args;
  va_start (args, format);
  gsl_g_log ("**CRITICAL**", format, args);
  va_end (args);
}
static inline void
g_warning (const gchar *format,
	   ...)
{
  va_list args;
  va_start (args, format);
  gsl_g_log ("**WARNING**", format, args);
  va_end (args);
}
static inline void
g_print (const gchar *format,
	 ...)
{
  va_list args;
  va_start (args, format);
  gsl_g_print_fd (1, format, args);
  va_end (args);
}
static inline void
g_printerr (const gchar *format,
	    ...)
{
  va_list args;
  va_start (args, format);
  gsl_g_print_fd (2, format, args);
  va_end (args);
}
typedef struct _GTrashStack     GTrashStack;
struct _GTrashStack
{
  GTrashStack *next;
};
static inline  guint
g_bit_storage (gulong number)
{
  register guint n_bits = 0;

  do
    {
      n_bits++;
      number >>= 1;
    }
  while (number);
  return n_bits;
}
static inline void
g_trash_stack_push (GTrashStack **stack_p,
		    gpointer      data_p)
{
  GTrashStack *data = (GTrashStack *) data_p;

  data->next = *stack_p;
  *stack_p = data;
}
static inline gpointer
g_trash_stack_pop (GTrashStack **stack_p)
{
  GTrashStack *data;

  data = *stack_p;
  if (data)
    {
      *stack_p = data->next;
      /* NULLify private pointer here, most platforms store NULL as
       * subsequent 0 bytes
       */
      data->next = NULL;
    }

  return data;
}
static inline gpointer
g_trash_stack_peek (GTrashStack **stack_p)
{
  GTrashStack *data;

  data = *stack_p;

  return data;
}
static inline guint
g_trash_stack_height (GTrashStack **stack_p)
{
  GTrashStack *data;
  guint i = 0;

  for (data = *stack_p; data; data = data->next)
    i++;

  return i;
}


/* --- GCC features --- */
#if     __GNUC__ >= 2 && __GNUC_MINOR__ > 95
#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))
#define G_GNUC_UNUSED                           \
  __attribute__((unused))
#define G_GNUC_NO_INSTRUMENT                    \
  __attribute__((no_instrument_function))
#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
#define G_GNUC_UNUSED
#define G_GNUC_NO_INSTRUMENT
#endif  /* !__GNUC__ */



/* --- GPollFD (for poll(2)) --- */
#define G_IO_IN      (0x0001 /* There is data to read */)
#define G_IO_PRI     (0x0002 /* There is urgent data to read */)
#define G_IO_OUT     (0x0004 /* Writing now will not block */)
#define G_IO_ERR     (0x0008 /* Error condition */)
#define G_IO_HUP     (0x0010 /* Hung up */)
#define G_IO_NVAL    (0x0020 /* Invalid request: fd not open */)
typedef struct
{
  gint    fd;
  gushort events;
  gushort revents;
} GPollFD;



/* --- functions --- */
#define	g_malloc		gsl_g_malloc
#define	g_malloc0		gsl_g_malloc0
#define	g_realloc		gsl_g_realloc
#define	g_free			gsl_g_free
#define g_strdup		gsl_g_strdup
#define g_strndup		gsl_g_strndup
#define g_memdup		gsl_g_memdup
#define	g_strdup_printf		gsl_g_strdup_printf
#define	g_strdup_vprintf	gsl_g_strdup_vprintf
#define	g_strndup		gsl_g_strndup
#define	g_strconcat		gsl_g_strconcat
#define	g_usleep		gsl_g_usleep
#define	g_strerror		gsl_g_strerror
#define	g_convert		gsl_g_convert
#define g_direct_hash	 	gsl_g_direct_hash
#define g_direct_equal 		gsl_g_direct_equal
#define g_str_equal 		gsl_g_str_equal
#define g_str_hash 		gsl_g_str_hash
#define g_strtod		gsl_g_strtod
#define g_stpcpy		gsl_g_stpcpy
#define	g_strescape		gsl_g_strescape
#define g_get_current_dir       gsl_g_get_current_dir
#define g_path_is_absolute      gsl_g_path_is_absolute
#define g_printf_string_upper_bound gsl_g_printf_string_upper_bound

gpointer g_malloc         (gulong        n_bytes);
gpointer g_malloc0        (gulong        n_bytes);
gpointer g_realloc        (gpointer      mem,
			   gulong        n_bytes);
void     g_free           (gpointer      mem);
gpointer              g_memdup         (gconstpointer mem,
					guint          byte_size);
gchar*                g_strdup         (const gchar *str);
gchar*		      g_strndup (const gchar *str,
				 gsize        n);
gchar*                g_strdup_printf  (const gchar *format,
					...) G_GNUC_PRINTF (1, 2);
gchar*                g_strdup_vprintf (const gchar *format,
					va_list      args);
gchar*                g_strndup        (const gchar *str,
					gsize        n);
gchar*                g_strconcat      (const gchar *string1,
					...); /* NULL terminated */
gchar*		      g_convert	       (const gchar  *str,
					gsize        len,            /* gssize */
					const gchar  *to_codeset,
					const gchar  *from_codeset,
					gsize        *bytes_read,
					gsize        *bytes_written,
					void         **error);        /* GError */
void g_usleep(unsigned long usec);
char* g_strerror(int e);
guint g_direct_hash (gconstpointer v);
gboolean g_direct_equal (gconstpointer v1, gconstpointer v2);
gboolean g_str_equal (gconstpointer v1,   gconstpointer v2);
guint g_str_hash (gconstpointer key);
gdouble	g_strtod (const gchar *nptr, 	  gchar **endptr);
gsize g_printf_string_upper_bound (const gchar *format,  va_list      args);
gchar * g_stpcpy (gchar       *dest, 	  const gchar *src);
gchar * g_strescape (const gchar *source, const gchar *exceptions);
gchar * g_get_current_dir (void);
gboolean g_path_is_absolute (const gchar *file_name);



/* --- function defines --- */
#define g_new(struct_type, n_structs)           \
    ((struct_type *) g_malloc (((gsize) sizeof (struct_type)) * ((gsize) (n_structs))))
#define g_new0(struct_type, n_structs)          \
    ((struct_type *) g_malloc0 (((gsize) sizeof (struct_type)) * ((gsize) (n_structs))))
#define g_renew(struct_type, mem, n_structs)    \
    ((struct_type *) g_realloc ((mem), ((gsize) sizeof (struct_type)) * ((gsize) (n_structs))))
#define	g_try_malloc		malloc
#define	g_try_realloc		realloc



/* --- configure stuff!!! --- */
#ifdef WORDS_BIGENDIAN
#define G_BYTE_ORDER G_BIG_ENDIAN
#else
#define G_BYTE_ORDER G_LITTLE_ENDIAN
#endif

/* #define	GLIB_HAVE_STPCPY	1 */
/* Define G_VA_COPY() to do the right thing for copying va_list variables.
 * glibconfig.h may have already defined G_VA_COPY as va_copy or __va_copy.
 */
#if !defined (G_VA_COPY)
#  if defined (__GNUC__) && ( defined (__PPC__) || defined (__s390__) ) && (defined (_CALL_SYSV) || defined (_WIN32) || defined (__s390__) )
#    define G_VA_COPY(ap1, ap2)   (*(ap1) = *(ap2))
#  elif defined (G_VA_COPY_AS_ARRAY)
#    define G_VA_COPY(ap1, ap2)   g_memmove ((ap1), (ap2), sizeof (va_list))
#  else /* va_list is a pointer */
#    define G_VA_COPY(ap1, ap2)   ((ap1) = (ap2))
#  endif /* va_list is a pointer */
#endif /* !G_VA_COPY */




/* subtract from biased_exponent to form base2 exponent (normal numbers) */
typedef union  _GDoubleIEEE754  GDoubleIEEE754;
typedef union  _GFloatIEEE754   GFloatIEEE754;
#define G_IEEE754_FLOAT_BIAS    (127)
#define G_IEEE754_DOUBLE_BIAS   (1023)
/* multiply with base2 exponent to get base10 exponent (nomal numbers) */
#define G_LOG_2_BASE_10         (0.30102999566398119521)
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
union _GFloatIEEE754
{
  gfloat v_float;
  struct {
    guint mantissa : 23;
    guint biased_exponent : 8;
    guint sign : 1;
  } mpn;
};
union _GDoubleIEEE754
{
  gdouble v_double;
  struct {
    guint mantissa_low : 32;
    guint mantissa_high : 20;
    guint biased_exponent : 11;
    guint sign : 1;
  } mpn;
};
#elif G_BYTE_ORDER == G_BIG_ENDIAN
union _GFloatIEEE754
{
  gfloat v_float;
  struct {
    guint sign : 1;
    guint biased_exponent : 8;
    guint mantissa : 23;
  } mpn;
};
union _GDoubleIEEE754
{
  gdouble v_double;
  struct {
    guint sign : 1;
    guint biased_exponent : 11;
    guint mantissa_high : 20;
    guint mantissa_low : 32;
  } mpn;
};
#else /* !G_LITTLE_ENDIAN && !G_BIG_ENDIAN */
#error unknown ENDIAN type
#endif /* !G_LITTLE_ENDIAN && !G_BIG_ENDIAN */



/* --- GHashTable --- */
typedef struct _GHashTable  GHashTable;
typedef gboolean  (*GHRFunc)  (gpointer  key,
			       gpointer  value,
			       gpointer  user_data);
typedef void            (*GHFunc)               (gpointer       key,
						 gpointer       value,
						 gpointer       user_data);
typedef guint           (*GHashFunc)            (gconstpointer  key);
typedef gboolean        (*GEqualFunc)           (gconstpointer  a,
						 gconstpointer  b);
typedef void            (*GDestroyNotify)       (gpointer       data);
#define g_hash_table_new               	gsl_g_hash_table_new
#define g_hash_table_new_full          	gsl_g_hash_table_new_full
#define g_hash_table_destroy           	gsl_g_hash_table_destroy
#define g_hash_table_insert            	gsl_g_hash_table_insert
#define g_hash_table_replace           	gsl_g_hash_table_replace
#define g_hash_table_remove            	gsl_g_hash_table_remove
#define g_hash_table_steal             	gsl_g_hash_table_steal
#define g_hash_table_lookup            	gsl_g_hash_table_lookup
#define g_hash_table_lookup_extended   	gsl_g_hash_table_lookup_extended
#define g_hash_table_foreach           	gsl_g_hash_table_foreach
#define g_hash_table_foreach_remove    	gsl_g_hash_table_foreach_remove
#define g_hash_table_foreach_steal     	gsl_g_hash_table_foreach_steal
#define g_hash_table_size              	gsl_g_hash_table_size
GHashTable* g_hash_table_new               (GHashFunc       hash_func,
					    GEqualFunc      key_equal_func);
GHashTable* g_hash_table_new_full          (GHashFunc       hash_func,
					    GEqualFunc      key_equal_func,
					    GDestroyNotify  key_destroy_func,
					    GDestroyNotify  value_destroy_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_replace           (GHashTable     *hash_table,
					    gpointer        key,
					    gpointer        value);
gboolean    g_hash_table_remove            (GHashTable     *hash_table,
					    gconstpointer   key);
gboolean    g_hash_table_steal             (GHashTable     *hash_table,
					    gconstpointer   key);
gpointer    g_hash_table_lookup            (GHashTable     *hash_table,
					    gconstpointer   key);
gboolean    g_hash_table_lookup_extended   (GHashTable     *hash_table,
					    gconstpointer   lookup_key,
					    gpointer       *orig_key,
					    gpointer       *value);
void        g_hash_table_foreach           (GHashTable     *hash_table,
					    GHFunc          func,
					    gpointer        user_data);
guint       g_hash_table_foreach_remove    (GHashTable     *hash_table,
					    GHRFunc         func,
					    gpointer        user_data);
guint       g_hash_table_foreach_steal     (GHashTable     *hash_table,
					    GHRFunc         func,
					    gpointer        user_data);
guint       g_hash_table_size              (GHashTable     *hash_table);


/* --- GScanner --- */
typedef struct _GScanner	GScanner;
typedef struct _GScannerConfig	GScannerConfig;
typedef union  _GTokenValue     GTokenValue;
typedef void		(*GScannerMsgFunc)	(GScanner      *scanner,
						 gchar	       *message,
						 gint		error);
#define G_CSET_A_2_Z	"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
#define G_CSET_a_2_z	"abcdefghijklmnopqrstuvwxyz"
#define G_CSET_DIGITS	"0123456789"
#define G_CSET_LATINC	"\300\301\302\303\304\305\306"\
			"\307\310\311\312\313\314\315\316\317\320"\
			"\321\322\323\324\325\326"\
			"\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 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;
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	_GTokenValue
{
  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
{
  const gchar	*cset_skip_characters;		/* default: " \t\n" */
  const gchar	*cset_identifier_first;
  const gchar	*cset_identifier_nth;
  const gchar	*cpair_comment_single;		/* default: "#\n" */
  guint		case_sensitive : 1;
  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;
  guint		scope_0_fallback : 1;		/* try scope 0 on lookups? */
};
struct	_GScanner
{
  gpointer		user_data;
  guint			max_parse_errors;
  guint			parse_errors;
  const gchar		*input_name;
  /* GData			*qdata; */
  GScannerConfig	*config;
  GTokenType		token;
  GTokenValue		value;
  guint			line;
  guint			position;
  GTokenType		next_token;
  GTokenValue		next_value;
  guint			next_line;
  guint			next_position;
  GHashTable		*symbol_table;
  gint			input_fd;
  const gchar		*text;
  const gchar		*text_end;
  gchar			*buffer;
  guint			scope_id;
  GScannerMsgFunc	msg_handler;
};
#define g_scanner_new			   gsl_g_scanner_new
#define g_scanner_destroy		   gsl_g_scanner_destroy
#define g_scanner_input_file		   gsl_g_scanner_input_file
#define g_scanner_sync_file_offset	   gsl_g_scanner_sync_file_offset
#define g_scanner_input_text		   gsl_g_scanner_input_text
#define g_scanner_get_next_token	   gsl_g_scanner_get_next_token
#define g_scanner_peek_next_token	   gsl_g_scanner_peek_next_token
#define g_scanner_cur_token		   gsl_g_scanner_cur_token
#define g_scanner_cur_value		   gsl_g_scanner_cur_value
#define g_scanner_cur_line		   gsl_g_scanner_cur_line
#define g_scanner_cur_position		   gsl_g_scanner_cur_position
#define g_scanner_eof			   gsl_g_scanner_eof
#define g_scanner_set_scope		   gsl_g_scanner_set_scope
#define g_scanner_scope_add_symbol	   gsl_g_scanner_scope_add_symbol
#define g_scanner_scope_remove_symbol	   gsl_g_scanner_scope_remove_symbol
#define g_scanner_scope_lookup_symbol	   gsl_g_scanner_scope_lookup_symbol
#define g_scanner_scope_foreach_symbol	   gsl_g_scanner_scope_foreach_symbol
#define g_scanner_lookup_symbol		   gsl_g_scanner_lookup_symbol
#define g_scanner_unexp_token		   gsl_g_scanner_unexp_token
#define g_scanner_error			   gsl_g_scanner_error
#define g_scanner_warn			   gsl_g_scanner_warn
GScanner*	g_scanner_new			(const GScannerConfig *config_templ);
void		g_scanner_destroy		(GScanner	*scanner);
void		g_scanner_input_file		(GScanner	*scanner,
						 gint		input_fd);
void		g_scanner_sync_file_offset	(GScanner	*scanner);
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);
GTokenValue	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);
guint		g_scanner_set_scope		(GScanner	*scanner,
						 guint		 scope_id);
void		g_scanner_scope_add_symbol	(GScanner	*scanner,
						 guint		 scope_id,
						 const gchar	*symbol,
						 gpointer	value);
void		g_scanner_scope_remove_symbol	(GScanner	*scanner,
						 guint		 scope_id,
						 const gchar	*symbol);
gpointer	g_scanner_scope_lookup_symbol	(GScanner	*scanner,
						 guint		 scope_id,
						 const gchar	*symbol);
void		g_scanner_scope_foreach_symbol	(GScanner	*scanner,
						 guint		 scope_id,
						 GHFunc		 func,
						 gpointer	 user_data);
gpointer	g_scanner_lookup_symbol		(GScanner	*scanner,
						 const gchar	*symbol);
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);
#define		g_scanner_add_symbol( scanner, symbol, value )	G_STMT_START { \
  g_scanner_scope_add_symbol ((scanner), 0, (symbol), (value)); \
} G_STMT_END
#define		g_scanner_remove_symbol( scanner, symbol )	G_STMT_START { \
  g_scanner_scope_remove_symbol ((scanner), 0, (symbol)); \
} G_STMT_END
#define		g_scanner_foreach_symbol( scanner, func, data )	G_STMT_START { \
  g_scanner_scope_foreach_symbol ((scanner), 0, (func), (data)); \
} G_STMT_END




#ifdef __cplusplus
}
#endif /* __cplusplus */

#include <gsl/gslconfig.h>
#if GSL_USE_ARTS_THREADS
#include <gsl/gslartsthreads.h>
#endif

/* if inline is defined in C++ mode, it can cause a lot of grief with C++ */
/* header files so we need to undefine it here again */

#if defined(__cplusplus) && defined(inline)
#undef inline
#endif

#endif /* __GSL_GLIB_H__ */ /* vim: set ts=8 sw=2 sts=2: */