Attachment 158713 Details for Bug 247332 – Reading this mail, mail view flickers

Reading this mail, mail view flickers

flickering-mail.txt (text/plain), 350.46 KB, created by sangu on 2007-07-07 03:36:45 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: sangu

Created: 2007-07-07 03:36:45 UTC

Size: 350.46 KB

patch

obsolete

>From dbus-bounces@lists.freedesktop.org Tue May 29 09:51:40 2007
>Delivered-To: sangu.gnome@gmail.com
>Received: by 10.114.182.4 with SMTP id e4cs772751waf; Tue, 29 May 2007
>	09:51:40 -0700 (PDT)
>Received: by 10.114.26.1 with SMTP id 1mr3491126waz.1180457494449; Tue, 29
>	May 2007 09:51:34 -0700 (PDT)
>Return-Path: <dbus-bounces@lists.freedesktop.org>
>Received: from gabe.freedesktop.org (gabe.freedesktop.org
>	[131.252.210.177]) by mx.google.com with ESMTP id
>	a8si2927107poa.2007.05.29.09.51.19; Tue, 29 May 2007 09:51:34 -0700 (PDT)
>Received-SPF: pass (google.com: domain of
>	dbus-bounces@lists.freedesktop.org designates 131.252.210.177 as permitted
>	sender)
>Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by
>	gabe.freedesktop.org (Postfix) with ESMTP id D58209E772; Tue, 29 May 2007
>	09:51:14 -0700 (PDT)
>X-Original-To: dbus@lists.freedesktop.org
>Delivered-To: dbus@lists.freedesktop.org
>Received: from nz-out-0506.google.com (nz-out-0506.google.com
>	[64.233.162.232]) by gabe.freedesktop.org (Postfix) with ESMTP id
>	C16EB9E76A for <dbus@lists.freedesktop.org>; Tue, 29 May 2007 09:51:09
>	-0700 (PDT)
>Received: by nz-out-0506.google.com with SMTP id v1so1623935nzb for
>	<dbus@lists.freedesktop.org>; Tue, 29 May 2007 09:51:08 -0700 (PDT)
>Received: by 10.65.237.15 with SMTP id o15mr13313324qbr.1180457467727; Tue,
>	29 May 2007 09:51:07 -0700 (PDT)
>Received: by 10.65.107.15 with HTTP; Tue, 29 May 2007 09:51:07 -0700 (PDT)
>Message-ID: <ee9b16d00705290951j7719640egdaeaed2f094e0803@mail.gmail.com>
>Date: Tue, 29 May 2007 12:51:07 -0400
>From: "Scott Peterson" <lunchtimemama@gmail.com>
>To: "Ralf Habacker" <ralf.habacker@freenet.de>
>Subject: Re: dbus-glib Build Problem
>In-Reply-To: <465BCBAE.2050400@freenet.de>
>MIME-Version: 1.0
>Content-Disposition: inline
>References: <ee9b16d00705281829p31b60e33y96d29aa3eddedb19@mail.gmail.com>
>	 <200705290641.41774.thiago@kde.org> <465BCBAE.2050400@freenet.de>
>Cc: dbus@lists.freedesktop.org, Thiago Macieira <thiago@kde.org>
>X-BeenThere: dbus@lists.freedesktop.org
>X-Mailman-Version: 2.1.9
>Precedence: list
>List-Id: <dbus.lists.freedesktop.org>
>List-Unsubscribe: <http://lists.freedesktop.org/mailman/listinfo/dbus>,
>	<mailto:dbus-request@lists.freedesktop.org?subject=unsubscribe>
>List-Archive: <http://lists.freedesktop.org/archives/dbus>
>List-Post: <mailto:dbus@lists.freedesktop.org>
>List-Help: <mailto:dbus-request@lists.freedesktop.org?subject=help>
>List-Subscribe: <http://lists.freedesktop.org/mailman/listinfo/dbus>,
>	<mailto:dbus-request@lists.freedesktop.org?subject=subscribe>
>Content-Type: text/plain; charset="us-ascii"
>Sender: dbus-bounces@lists.freedesktop.org
>Errors-To: dbus-bounces@lists.freedesktop.org
>X-Evolution-Source: pop://sangu.gnome%40gmail.com@pop.gmail.com/
>Content-Transfer-Encoding: 8bit
>
>Here's the content of dbus-binding-tool-glib.i. I have no idea how to
>interpret this, so help would be greatly appreciated:
>
># 1 "dbus-binding-tool-glib.c"
># 1 "/home/Scott/downloads/dbus-glib-0.73/dbus//"
># 1 "<built-in>"
># 1 "<command line>"
># 1 "dbus-binding-tool-glib.c"
># 25 "dbus-binding-tool-glib.c"
># 1 "../config.h" 1
># 26 "dbus-binding-tool-glib.c" 2
># 1 "../dbus/dbus-glib.h" 1
># 27 "../dbus/dbus-glib.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib-object.h" 1
># 25 "C:/mono/Mono-1.2.4/include/glib-2.0/glib-object.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gboxed.h" 1
># 26 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gboxed.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gtype.h" 1
># 26 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gtype.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 1
># 30 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/galloca.h" 1
># 30 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/galloca.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gtypes.h" 1
># 30 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gtypes.h"
># 1 "C:/mono/Mono-1.2.4/lib/glib-2.0/include/glibconfig.h" 1
># 10 "C:/mono/Mono-1.2.4/lib/glib-2.0/include/glibconfig.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gmacros.h" 1
># 36 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gmacros.h"
># 1 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/stddef.h" 1 3 4
># 151 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/stddef.h" 3 4
>typedef int ptrdiff_t;
># 213 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/stddef.h" 3 4
>typedef unsigned int size_t;
># 325 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/stddef.h" 3 4
>typedef short unsigned int wchar_t;
># 37 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gmacros.h" 2
># 11 "C:/mono/Mono-1.2.4/lib/glib-2.0/include/glibconfig.h" 2
>
># 1 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/limits.h" 1 3 4
># 11 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/limits.h" 3 4
># 1 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/syslimits.h" 1 3 4
>
>
>
>
>
>
># 1 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/limits.h" 1 3 4
># 122 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/limits.h" 3 4
># 1 "/usr/include/limits.h" 1 3 4
># 13 "/usr/include/limits.h" 3 4
># 1 "/usr/include/features.h" 1 3 4
># 14 "/usr/include/features.h" 3 4
># 1 "/usr/include/sys/cdefs.h" 1 3 4
># 15 "/usr/include/features.h" 2 3 4
># 1 "/usr/include/sys/features.h" 1 3 4
># 16 "/usr/include/features.h" 2 3 4
># 14 "/usr/include/limits.h" 2 3 4
># 123 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/limits.h" 2 3 4
># 8 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/syslimits.h" 2 3 4
># 12 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/limits.h" 2 3 4
># 13 "C:/mono/Mono-1.2.4/lib/glib-2.0/include/glibconfig.h" 2
># 1 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/float.h" 1 3 4
># 14 "C:/mono/Mono-1.2.4/lib/glib-2.0/include/glibconfig.h" 2
>
>
># 31 "C:/mono/Mono-1.2.4/lib/glib-2.0/include/glibconfig.h"
>typedef signed char gint8;
>typedef unsigned char guint8;
>typedef signed short gint16;
>typedef unsigned short guint16;
>
>
>
>typedef signed int gint32;
>typedef unsigned int guint32;
>
>
>
>
>
>
>__extension__ typedef signed long long gint64;
>__extension__ typedef unsigned long long guint64;
># 71 "C:/mono/Mono-1.2.4/lib/glib-2.0/include/glibconfig.h"
>typedef signed int gssize;
>typedef unsigned int gsize;
># 148 "C:/mono/Mono-1.2.4/lib/glib-2.0/include/glibconfig.h"
>typedef struct _GMutex* GStaticMutex;
>
>
>
>
>
>
>
>typedef union _GSystemThread GSystemThread;
>union _GSystemThread
>{
>  char data[4];
>  double dummy_double;
>  void *dummy_pointer;
>  long dummy_long;
>};
># 196 "C:/mono/Mono-1.2.4/lib/glib-2.0/include/glibconfig.h"
>typedef void * GPid;
>
>
># 31 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gtypes.h" 2
>
>
># 41 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gtypes.h"
>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;
># 72 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gtypes.h"
>typedef void* gpointer;
>typedef const void *gconstpointer;
>
>typedef gint (*GCompareFunc) (gconstpointer a,
>                                                 gconstpointer b);
>typedef gint (*GCompareDataFunc) (gconstpointer a,
>                                                 gconstpointer b,
>       gpointer user_data);
>typedef gboolean (*GEqualFunc) (gconstpointer a,
>                                                 gconstpointer b);
>typedef void (*GDestroyNotify) (gpointer data);
>typedef void (*GFunc) (gpointer data,
>                                                 gpointer user_data);
>typedef guint (*GHashFunc) (gconstpointer key);
>typedef void (*GHFunc) (gpointer key,
>                                                 gpointer value,
>                                                 gpointer user_data);
>typedef void (*GFreeFunc) (gpointer data);
>typedef const gchar * (*GTranslateFunc) (const gchar *str,
>       gpointer data);
># 338 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gtypes.h"
>typedef union _GDoubleIEEE754 GDoubleIEEE754;
>typedef union _GFloatIEEE754 GFloatIEEE754;
>
>
>
>
>
>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;
>};
># 388 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gtypes.h"
>typedef struct _GTimeVal GTimeVal;
>
>struct _GTimeVal
>{
>  glong tv_sec;
>  glong tv_usec;
>};
>
>
># 31 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/galloca.h" 2
># 31 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/garray.h" 1
># 32 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/garray.h"
>
>
>typedef struct _GArray GArray;
>typedef struct _GByteArray GByteArray;
>typedef struct _GPtrArray GPtrArray;
>
>struct _GArray
>{
>  gchar *data;
>  guint len;
>};
>
>struct _GByteArray
>{
>  guint8 *data;
>  guint len;
>};
>
>struct _GPtrArray
>{
>  gpointer *pdata;
>  guint len;
>};
># 66 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/garray.h"
>GArray* g_array_new (gboolean zero_terminated,
>       gboolean clear_,
>       guint element_size);
>GArray* g_array_sized_new (gboolean zero_terminated,
>       gboolean clear_,
>       guint element_size,
>       guint reserved_size);
>gchar* g_array_free (GArray *array,
>       gboolean free_segment);
>GArray* g_array_append_vals (GArray *array,
>       gconstpointer data,
>       guint len);
>GArray* g_array_prepend_vals (GArray *array,
>       gconstpointer data,
>       guint len);
>GArray* g_array_insert_vals (GArray *array,
>       guint index_,
>       gconstpointer data,
>       guint len);
>GArray* g_array_set_size (GArray *array,
>       guint length);
>GArray* g_array_remove_index (GArray *array,
>       guint index_);
>GArray* g_array_remove_index_fast (GArray *array,
>       guint index_);
>GArray* g_array_remove_range (GArray *array,
>       guint index_,
>       guint length);
>void g_array_sort (GArray *array,
>       GCompareFunc compare_func);
>void g_array_sort_with_data (GArray *array,
>       GCompareDataFunc compare_func,
>       gpointer user_data);
>
>
>
>
>
>
>GPtrArray* g_ptr_array_new (void);
>GPtrArray* g_ptr_array_sized_new (guint reserved_size);
>gpointer* g_ptr_array_free (GPtrArray *array,
>        gboolean free_seg);
>void g_ptr_array_set_size (GPtrArray *array,
>        gint length);
>gpointer g_ptr_array_remove_index (GPtrArray *array,
>        guint index_);
>gpointer g_ptr_array_remove_index_fast (GPtrArray *array,
>        guint index_);
>gboolean g_ptr_array_remove (GPtrArray *array,
>        gpointer data);
>gboolean g_ptr_array_remove_fast (GPtrArray *array,
>        gpointer data);
>void g_ptr_array_remove_range (GPtrArray *array,
>        guint index_,
>        guint length);
>void g_ptr_array_add (GPtrArray *array,
>        gpointer data);
>void g_ptr_array_sort (GPtrArray *array,
>        GCompareFunc compare_func);
>void g_ptr_array_sort_with_data (GPtrArray *array,
>        GCompareDataFunc compare_func,
>        gpointer user_data);
>void g_ptr_array_foreach (GPtrArray *array,
>        GFunc func,
>        gpointer user_data);
>
>
>
>
>
>
>GByteArray* g_byte_array_new (void);
>GByteArray* g_byte_array_sized_new (guint reserved_size);
>guint8* g_byte_array_free (GByteArray *array,
>         gboolean free_segment);
>GByteArray* g_byte_array_append (GByteArray *array,
>         const guint8 *data,
>         guint len);
>GByteArray* g_byte_array_prepend (GByteArray *array,
>         const guint8 *data,
>         guint len);
>GByteArray* g_byte_array_set_size (GByteArray *array,
>         guint length);
>GByteArray* g_byte_array_remove_index (GByteArray *array,
>         guint index_);
>GByteArray* g_byte_array_remove_index_fast (GByteArray *array,
>         guint index_);
>GByteArray* g_byte_array_remove_range (GByteArray *array,
>         guint index_,
>         guint length);
>void g_byte_array_sort (GByteArray *array,
>         GCompareFunc compare_func);
>void g_byte_array_sort_with_data (GByteArray *array,
>         GCompareDataFunc compare_func,
>         gpointer user_data);
>
>
>
># 32 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gasyncqueue.h" 1
># 30 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gasyncqueue.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gthread.h" 1
># 30 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gthread.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gerror.h" 1
># 24 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gerror.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gquark.h" 1
># 32 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gquark.h"
>
>
>typedef guint32 GQuark;
>
>
>
>GQuark g_quark_try_string (const gchar *string);
>GQuark g_quark_from_static_string (const gchar *string);
>GQuark g_quark_from_string (const gchar *string);
>const gchar* g_quark_to_string (GQuark quark) __attribute__((__const__));
>
>const gchar* g_intern_string (const gchar *string);
>const gchar* g_intern_static_string (const gchar *string);
>
>
>
># 25 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gerror.h" 2
>
>
>
>typedef struct _GError GError;
>
>struct _GError
>{
>  GQuark domain;
>  gint code;
>  gchar *message;
>};
>
>GError* g_error_new (GQuark domain,
>                                gint code,
>                                const gchar *format,
>                                ...) __attribute__((__format__
>(__printf__, 3, 4)));
>
>GError* g_error_new_literal (GQuark domain,
>                                gint code,
>                                const gchar *message);
>
>void g_error_free (GError *error);
>GError* g_error_copy (const GError *error);
>
>gboolean g_error_matches (const GError *error,
>                                GQuark domain,
>                                gint code);
>
>
>
>
>void g_set_error (GError **err,
>                                GQuark domain,
>                                gint code,
>                                const gchar *format,
>                                ...) __attribute__((__format__
>(__printf__, 4, 5)));
>
>
>
>void g_propagate_error (GError **dest,
>    GError *src);
>
>
>void g_clear_error (GError **err);
>
>
>
># 31 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gthread.h" 2
>
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gatomic.h" 1
># 35 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gatomic.h"
>
>
>gint g_atomic_int_exchange_and_add (volatile gint *atomic,
>      gint val);
>void g_atomic_int_add (volatile gint *atomic,
>      gint val);
>gboolean g_atomic_int_compare_and_exchange (volatile gint *atomic,
>      gint oldval,
>      gint newval);
>gboolean g_atomic_pointer_compare_and_exchange (volatile gpointer *atomic,
>      gpointer oldval,
>      gpointer newval);
>
>gint g_atomic_int_get (volatile gint *atomic);
>void g_atomic_int_set (volatile gint *atomic,
>      gint newval);
>gpointer g_atomic_pointer_get (volatile gpointer *atomic);
>void g_atomic_pointer_set (volatile gpointer *atomic,
>      gpointer newval);
># 66 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gatomic.h"
>
># 33 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gthread.h" 2
>
>
>
>
>
>
>extern GQuark g_thread_error_quark (void);
>
>
>typedef enum
>{
>  G_THREAD_ERROR_AGAIN
>} GThreadError;
>
>typedef gpointer (*GThreadFunc) (gpointer data);
>
>typedef enum
>{
>  G_THREAD_PRIORITY_LOW,
>  G_THREAD_PRIORITY_NORMAL,
>  G_THREAD_PRIORITY_HIGH,
>  G_THREAD_PRIORITY_URGENT
>} GThreadPriority;
>
>typedef struct _GThread GThread;
>struct _GThread
>{
>
>  GThreadFunc func;
>  gpointer data;
>  gboolean joinable;
>  GThreadPriority priority;
>};
>
>typedef struct _GMutex GMutex;
>typedef struct _GCond GCond;
>typedef struct _GPrivate GPrivate;
>typedef struct _GStaticPrivate GStaticPrivate;
>
>typedef struct _GThreadFunctions GThreadFunctions;
>struct _GThreadFunctions
>{
>  GMutex* (*mutex_new) (void);
>  void (*mutex_lock) (GMutex *mutex);
>  gboolean (*mutex_trylock) (GMutex *mutex);
>  void (*mutex_unlock) (GMutex *mutex);
>  void (*mutex_free) (GMutex *mutex);
>  GCond* (*cond_new) (void);
>  void (*cond_signal) (GCond *cond);
>  void (*cond_broadcast) (GCond *cond);
>  void (*cond_wait) (GCond *cond,
>                                   GMutex *mutex);
>  gboolean (*cond_timed_wait) (GCond *cond,
>                                   GMutex *mutex,
>                                   GTimeVal *end_time);
>  void (*cond_free) (GCond *cond);
>  GPrivate* (*private_new) (GDestroyNotify destructor);
>  gpointer (*private_get) (GPrivate *private_key);
>  void (*private_set) (GPrivate *private_key,
>                                   gpointer data);
>  void (*thread_create) (GThreadFunc func,
>                                   gpointer data,
>                                   gulong stack_size,
>                                   gboolean joinable,
>                                   gboolean bound,
>                                   GThreadPriority priority,
>                                   gpointer thread,
>                                   GError **error);
>  void (*thread_yield) (void);
>  void (*thread_join) (gpointer thread);
>  void (*thread_exit) (void);
>  void (*thread_set_priority)(gpointer thread,
>                                   GThreadPriority priority);
>  void (*thread_self) (gpointer thread);
>  gboolean (*thread_equal) (gpointer thread1,
>       gpointer thread2);
>};
>
>extern __attribute__((dllimport)) GThreadFunctions
>g_thread_functions_for_glib_use;
>extern __attribute__((dllimport)) gboolean g_thread_use_default_impl;
>extern __attribute__((dllimport)) gboolean g_threads_got_initialized;
>
>
>
>
>
>void g_thread_init (GThreadFunctions *vtable);
># 128 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gthread.h"
>void g_thread_init_with_errorcheck_mutexes (GThreadFunctions* vtable);
># 138 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gthread.h"
>GMutex* g_static_mutex_get_mutex_impl (GMutex **mutex);
># 209 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gthread.h"
>GThread* g_thread_create_full (GThreadFunc func,
>                                gpointer data,
>                                gulong stack_size,
>                                gboolean joinable,
>                                gboolean bound,
>                                GThreadPriority priority,
>                                GError **error);
>GThread* g_thread_self (void);
>void g_thread_exit (gpointer retval);
>gpointer g_thread_join (GThread *thread);
>
>void g_thread_set_priority (GThread *thread,
>                                GThreadPriority priority);
># 234 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gthread.h"
>void g_static_mutex_init (GStaticMutex *mutex);
>void g_static_mutex_free (GStaticMutex *mutex);
>
>struct _GStaticPrivate
>{
>
>  guint index;
>};
>
>void g_static_private_init (GStaticPrivate *private_key);
>gpointer g_static_private_get (GStaticPrivate *private_key);
>void g_static_private_set (GStaticPrivate *private_key,
>       gpointer data,
>       GDestroyNotify notify);
>void g_static_private_free (GStaticPrivate *private_key);
>
>typedef struct _GStaticRecMutex GStaticRecMutex;
>struct _GStaticRecMutex
>{
>
>  GStaticMutex mutex;
>  guint depth;
>  GSystemThread owner;
>};
>
>
>void g_static_rec_mutex_init (GStaticRecMutex *mutex);
>void g_static_rec_mutex_lock (GStaticRecMutex *mutex);
>gboolean g_static_rec_mutex_trylock (GStaticRecMutex *mutex);
>void g_static_rec_mutex_unlock (GStaticRecMutex *mutex);
>void g_static_rec_mutex_lock_full (GStaticRecMutex *mutex,
>                                         guint depth);
>guint g_static_rec_mutex_unlock_full (GStaticRecMutex *mutex);
>void g_static_rec_mutex_free (GStaticRecMutex *mutex);
>
>typedef struct _GStaticRWLock GStaticRWLock;
>struct _GStaticRWLock
>{
>
>  GStaticMutex mutex;
>  GCond *read_cond;
>  GCond *write_cond;
>  guint read_counter;
>  gboolean have_writer;
>  guint want_to_read;
>  guint want_to_write;
>};
>
>
>
>void g_static_rw_lock_init (GStaticRWLock* lock);
>void g_static_rw_lock_reader_lock (GStaticRWLock* lock);
>gboolean g_static_rw_lock_reader_trylock (GStaticRWLock* lock);
>void g_static_rw_lock_reader_unlock (GStaticRWLock* lock);
>void g_static_rw_lock_writer_lock (GStaticRWLock* lock);
>gboolean g_static_rw_lock_writer_trylock (GStaticRWLock* lock);
>void g_static_rw_lock_writer_unlock (GStaticRWLock* lock);
>void g_static_rw_lock_free (GStaticRWLock* lock);
>
>void g_thread_foreach (GFunc thread_func,
>        gpointer user_data);
>
>typedef enum
>{
>  G_ONCE_STATUS_NOTCALLED,
>  G_ONCE_STATUS_PROGRESS,
>  G_ONCE_STATUS_READY
>} GOnceStatus;
>
>typedef struct _GOnce GOnce;
>struct _GOnce
>{
>  volatile GOnceStatus status;
>  volatile gpointer retval;
>};
>
>
>
>gpointer g_once_impl (GOnce *once, GThreadFunc func, gpointer arg);
># 332 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gthread.h"
>extern void glib_dummy_decl (void);
># 375 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gthread.h"
>
># 31 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gasyncqueue.h" 2
>
>
>
>typedef struct _GAsyncQueue GAsyncQueue;
>
>
>
>
>GAsyncQueue* g_async_queue_new (void);
>
>
>
>
>
>void g_async_queue_lock (GAsyncQueue *queue);
>void g_async_queue_unlock (GAsyncQueue *queue);
>
>
>GAsyncQueue* g_async_queue_ref (GAsyncQueue *queue);
>void g_async_queue_unref (GAsyncQueue *queue);
>
>
>
>void g_async_queue_ref_unlocked (GAsyncQueue *queue);
>void g_async_queue_unref_and_unlock (GAsyncQueue *queue);
>
>
>
>void g_async_queue_push (GAsyncQueue *queue,
>       gpointer data);
>void g_async_queue_push_unlocked (GAsyncQueue *queue,
>       gpointer data);
>
>void g_async_queue_push_sorted (GAsyncQueue *queue,
>       gpointer data,
>       GCompareDataFunc func,
>       gpointer user_data);
>void g_async_queue_push_sorted_unlocked (GAsyncQueue *queue,
>       gpointer data,
>       GCompareDataFunc func,
>       gpointer user_data);
>
>
>
>
>gpointer g_async_queue_pop (GAsyncQueue *queue);
>gpointer g_async_queue_pop_unlocked (GAsyncQueue *queue);
>
>
>gpointer g_async_queue_try_pop (GAsyncQueue *queue);
>gpointer g_async_queue_try_pop_unlocked (GAsyncQueue *queue);
>
>
>
>
>
>
>gpointer g_async_queue_timed_pop (GAsyncQueue *queue,
>       GTimeVal *end_time);
>gpointer g_async_queue_timed_pop_unlocked (GAsyncQueue *queue,
>       GTimeVal *end_time);
># 100 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gasyncqueue.h"
>gint g_async_queue_length (GAsyncQueue *queue);
>gint g_async_queue_length_unlocked (GAsyncQueue *queue);
>void g_async_queue_sort (GAsyncQueue *queue,
>       GCompareDataFunc func,
>       gpointer user_data);
>void g_async_queue_sort_unlocked (GAsyncQueue *queue,
>       GCompareDataFunc func,
>       gpointer user_data);
>
>
>GMutex* _g_async_queue_get_mutex (GAsyncQueue *queue);
>
>
># 33 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
>
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gbacktrace.h" 1
># 32 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gbacktrace.h"
>
># 43 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gbacktrace.h"
>void g_on_error_query (const gchar *prg_name);
>void g_on_error_stack_trace (const gchar *prg_name);
># 59 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gbacktrace.h"
>
># 35 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gbase64.h" 1
># 26 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gbase64.h"
>
>
>gsize g_base64_encode_step (const guchar *in,
>          gsize len,
>          gboolean break_lines,
>          gchar *out,
>          gint *state,
>          gint *save);
>gsize g_base64_encode_close (gboolean break_lines,
>          gchar *out,
>          gint *state,
>          gint *save);
>gchar* g_base64_encode (const guchar *data,
>          gsize len) __attribute__((__malloc__));
>gsize g_base64_decode_step (const gchar *in,
>          gsize len,
>          guchar *out,
>          gint *state,
>          guint *save);
>guchar *g_base64_decode (const gchar *text,
>          gsize *out_len) __attribute__((__malloc__));
>
>
># 36 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gbookmarkfile.h" 1
># 24 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gbookmarkfile.h"
># 1 "/usr/include/time.h" 1 3 4
># 10 "/usr/include/time.h" 3 4
># 1 "/usr/include/_ansi.h" 1 3 4
># 15 "/usr/include/_ansi.h" 3 4
># 1 "/usr/include/newlib.h" 1 3 4
># 16 "/usr/include/_ansi.h" 2 3 4
># 1 "/usr/include/sys/config.h" 1 3 4
>
>
>
># 1 "/usr/include/machine/ieeefp.h" 1 3 4
># 5 "/usr/include/sys/config.h" 2 3 4
># 167 "/usr/include/sys/config.h" 3 4
># 1 "/usr/include/cygwin/config.h" 1 3 4
># 168 "/usr/include/sys/config.h" 2 3 4
># 17 "/usr/include/_ansi.h" 2 3 4
># 11 "/usr/include/time.h" 2 3 4
># 1 "/usr/include/sys/reent.h" 1 3 4
># 13 "/usr/include/sys/reent.h" 3 4
># 1 "/usr/include/_ansi.h" 1 3 4
># 14 "/usr/include/sys/reent.h" 2 3 4
># 1 "/usr/include/sys/_types.h" 1 3 4
># 12 "/usr/include/sys/_types.h" 3 4
># 1 "/usr/include/sys/lock.h" 1 3 4
># 14 "/usr/include/sys/lock.h" 3 4
>typedef void *_LOCK_T;
># 44 "/usr/include/sys/lock.h" 3 4
>void __cygwin_lock_init(_LOCK_T *);
>void __cygwin_lock_init_recursive(_LOCK_T *);
>void __cygwin_lock_fini(_LOCK_T *);
>void __cygwin_lock_lock(_LOCK_T *);
>int __cygwin_lock_trylock(_LOCK_T *);
>void __cygwin_lock_unlock(_LOCK_T *);
># 13 "/usr/include/sys/_types.h" 2 3 4
>
>typedef long _off_t;
>__extension__ typedef long long _off64_t;
>
>
>typedef int _ssize_t;
>
>
>
>
>
># 1 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/stddef.h" 1 3 4
># 354 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/stddef.h" 3 4
>typedef unsigned int wint_t;
># 25 "/usr/include/sys/_types.h" 2 3 4
>
>
>typedef struct
>{
>  int __count;
>  union
>  {
>    wint_t __wch;
>    unsigned char __wchb[4];
>  } __value;
>} _mbstate_t;
>
>typedef _LOCK_T _flock_t;
>
>
>typedef void *_iconv_t;
># 15 "/usr/include/sys/reent.h" 2 3 4
>
>
>
>
>typedef unsigned long __ULong;
># 40 "/usr/include/sys/reent.h" 3 4
>struct _Bigint
>{
>  struct _Bigint *_next;
>  int _k, _maxwds, _sign, _wds;
>  __ULong _x[1];
>};
>
>
>struct __tm
>{
>  int __tm_sec;
>  int __tm_min;
>  int __tm_hour;
>  int __tm_mday;
>  int __tm_mon;
>  int __tm_year;
>  int __tm_wday;
>  int __tm_yday;
>  int __tm_isdst;
>};
>
>
>
>
>
>
>
>struct _on_exit_args {
> void * _fnargs[32];
> void * _dso_handle[32];
>
> __ULong _fntypes;
>
>
> __ULong _is_cxa;
>};
># 85 "/usr/include/sys/reent.h" 3 4
>struct _atexit {
> struct _atexit *_next;
> int _ind;
>
> void (*_fns[32])(void);
>        struct _on_exit_args _on_exit_args;
>};
># 101 "/usr/include/sys/reent.h" 3 4
>struct __sbuf {
> unsigned char *_base;
> int _size;
>};
>
>
>
>
>
>
>typedef long _fpos_t;
>
>
>
>typedef _off64_t _fpos64_t;
># 166 "/usr/include/sys/reent.h" 3 4
>struct __sFILE {
>  unsigned char *_p;
>  int _r;
>  int _w;
>  short _flags;
>  short _file;
>  struct __sbuf _bf;
>  int _lbfsize;
>
>
>
>
>
>
>  void * _cookie;
>
>  _ssize_t __attribute__((__cdecl__)) (*_read) (void * _cookie, char
>*_buf, int _n);
>  _ssize_t __attribute__((__cdecl__)) (*_write) (void * _cookie, const
>char *_buf, int _n);
>
>  _fpos_t __attribute__((__cdecl__)) (*_seek) (void * _cookie, _fpos_t
>_offset, int _whence);
>  int __attribute__((__cdecl__)) (*_close) (void * _cookie);
>
>
>  struct __sbuf _ub;
>  unsigned char *_up;
>  int _ur;
>
>
>  unsigned char _ubuf[3];
>  unsigned char _nbuf[1];
>
>
>  struct __sbuf _lb;
>
>
>  int _blksize;
>  int _offset;
>
>
>  struct _reent *_data;
>
>
>
>  _flock_t _lock;
>
>};
>
>
>struct __sFILE64 {
>  unsigned char *_p;
>  int _r;
>  int _w;
>  short _flags;
>  short _file;
>  struct __sbuf _bf;
>  int _lbfsize;
>
>  struct _reent *_data;
>
>
>  void * _cookie;
>
>  _ssize_t __attribute__((__cdecl__)) (*_read) (void * _cookie, char
>*_buf, int _n);
>  _ssize_t __attribute__((__cdecl__)) (*_write) (void * _cookie, const
>char *_buf, int _n);
>
>  _fpos_t __attribute__((__cdecl__)) (*_seek) (void * _cookie, _fpos_t
>_offset, int _whence);
>  int __attribute__((__cdecl__)) (*_close) (void * _cookie);
>
>
>  struct __sbuf _ub;
>  unsigned char *_up;
>  int _ur;
>
>
>  unsigned char _ubuf[3];
>  unsigned char _nbuf[1];
>
>
>  struct __sbuf _lb;
>
>
>  int _blksize;
>  int _flags2;
>
>  _off64_t _offset;
>  _fpos64_t __attribute__((__cdecl__)) (*_seek64) (void * _cookie,
>_fpos64_t _offset, int _whence);
>
>
>  _flock_t _lock;
>
>};
>typedef struct __sFILE64 __FILE;
>
>
>
>
>struct _glue
>{
>  struct _glue *_next;
>  int _niobs;
>  __FILE *_iobs;
>};
># 290 "/usr/include/sys/reent.h" 3 4
>struct _rand48 {
>  unsigned short _seed[3];
>  unsigned short _mult[3];
>  unsigned short _add;
>
>
>
>
>};
># 565 "/usr/include/sys/reent.h" 3 4
>struct _reent
>{
>  int _errno;
>
>
>
>
>  __FILE *_stdin, *_stdout, *_stderr;
>
>  int _inc;
>  char _emergency[25];
>
>  int _current_category;
>  const char *_current_locale;
>
>  int __sdidinit;
>
>  void __attribute__((__cdecl__)) (*__cleanup) (struct _reent *);
>
>
>  struct _Bigint *_result;
>  int _result_k;
>  struct _Bigint *_p5s;
>  struct _Bigint **_freelist;
>
>
>  int _cvtlen;
>  char *_cvtbuf;
>
>  union
>    {
>      struct
>        {
>          unsigned int _unused_rand;
>          char * _strtok_last;
>          char _asctime_buf[26];
>          struct __tm _localtime_buf;
>          int _gamma_signgam;
>          __extension__ unsigned long long _rand_next;
>          struct _rand48 _r48;
>          _mbstate_t _mblen_state;
>          _mbstate_t _mbtowc_state;
>          _mbstate_t _wctomb_state;
>          char _l64a_buf[8];
>          char _signal_buf[24];
>          int _getdate_err;
>          _mbstate_t _mbrlen_state;
>          _mbstate_t _mbrtowc_state;
>          _mbstate_t _mbsrtowcs_state;
>          _mbstate_t _wcrtomb_state;
>          _mbstate_t _wcsrtombs_state;
>        } _reent;
>
>
>
>      struct
>        {
>
>          unsigned char * _nextf[30];
>          unsigned int _nmalloc[30];
>        } _unused;
>    } _new;
>
>
>  struct _atexit *_atexit;
>  struct _atexit _atexit0;
>
>
>  void (**(_sig_func))(int);
>
>
>
>
>  struct _glue __sglue;
>  __FILE __sf[3];
>};
># 799 "/usr/include/sys/reent.h" 3 4
>extern struct _reent *_impure_ptr ;
>extern struct _reent *const _global_impure_ptr ;
>
>void _reclaim_reent (struct _reent *);
>
>
>
>
>
>
>
>  struct _reent * __attribute__((__cdecl__)) __getreent (void);
># 12 "/usr/include/time.h" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/machine/time.h" 1 3 4
># 19 "/usr/include/time.h" 2 3 4
># 27 "/usr/include/time.h" 3 4
># 1 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/stddef.h" 1 3 4
># 28 "/usr/include/time.h" 2 3 4
>
># 1 "/usr/include/sys/types.h" 1 3 4
># 25 "/usr/include/sys/types.h" 3 4
># 1 "/usr/include/machine/_types.h" 1 3 4
># 26 "/usr/include/machine/_types.h" 3 4
>typedef signed char __int8_t ;
>typedef unsigned char __uint8_t ;
># 36 "/usr/include/machine/_types.h" 3 4
>typedef signed short __int16_t;
>typedef unsigned short __uint16_t;
># 46 "/usr/include/machine/_types.h" 3 4
>typedef __int16_t __int_least16_t;
>typedef __uint16_t __uint_least16_t;
># 58 "/usr/include/machine/_types.h" 3 4
>typedef signed int __int32_t;
>typedef unsigned int __uint32_t;
># 76 "/usr/include/machine/_types.h" 3 4
>typedef __int32_t __int_least32_t;
>typedef __uint32_t __uint_least32_t;
># 99 "/usr/include/machine/_types.h" 3 4
>typedef signed long long __int64_t;
>typedef unsigned long long __uint64_t;
># 26 "/usr/include/sys/types.h" 2 3 4
># 69 "/usr/include/sys/types.h" 3 4
># 1 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/stddef.h" 1 3 4
># 70 "/usr/include/sys/types.h" 2 3 4
># 1 "/usr/include/machine/types.h" 1 3 4
># 19 "/usr/include/machine/types.h" 3 4
>typedef long int __off_t;
>typedef int __pid_t;
>
>__extension__ typedef long long int __loff_t;
># 71 "/usr/include/sys/types.h" 2 3 4
># 92 "/usr/include/sys/types.h" 3 4
>typedef unsigned char u_char;
>typedef unsigned short u_short;
>typedef unsigned int u_int;
>typedef unsigned long u_long;
>
>
>
>typedef unsigned short ushort;
>typedef unsigned int uint;
>
>
>
>typedef unsigned long clock_t;
>
>
>
>
>typedef long time_t;
>
>
>
>
>struct timespec {
>  time_t tv_sec;
>  long tv_nsec;
>};
>
>struct itimerspec {
>  struct timespec it_interval;
>  struct timespec it_value;
>};
>
>
>typedef long daddr_t;
>typedef char * caddr_t;
># 180 "/usr/include/sys/types.h" 3 4
>typedef int pid_t;
>
>
>
>typedef _ssize_t ssize_t;
># 203 "/usr/include/sys/types.h" 3 4
>typedef unsigned short nlink_t;
># 225 "/usr/include/sys/types.h" 3 4
>typedef long fd_mask;
>
>
>
>
>
>
>
>typedef struct _types_fd_set {
> fd_mask fds_bits[(((64)+(((sizeof (fd_mask) * 8))-1))/((sizeof
>(fd_mask) * 8)))];
>} _types_fd_set;
># 256 "/usr/include/sys/types.h" 3 4
>typedef unsigned long clockid_t;
>
>
>
>
>typedef unsigned long timer_t;
>
>
>
>typedef unsigned long useconds_t;
>typedef long suseconds_t;
># 373 "/usr/include/sys/types.h" 3 4
># 1 "/usr/include/cygwin/types.h" 1 3 4
># 20 "/usr/include/cygwin/types.h" 3 4
># 1 "/usr/include/sys/sysmacros.h" 1 3 4
># 21 "/usr/include/cygwin/types.h" 2 3 4
># 1 "/usr/include/stdint.h" 1 3 4
># 18 "/usr/include/stdint.h" 3 4
>typedef signed char int8_t;
>typedef short int16_t;
>typedef long int32_t;
>typedef long long int64_t;
>
>
>typedef unsigned char uint8_t;
>typedef unsigned short uint16_t;
>
>
>typedef unsigned long uint32_t;
>
>typedef unsigned long long uint64_t;
>
>
>
>typedef signed char int_least8_t;
>typedef short int_least16_t;
>typedef long int_least32_t;
>typedef long long int_least64_t;
>
>typedef unsigned char uint_least8_t;
>typedef unsigned short uint_least16_t;
>typedef unsigned long uint_least32_t;
>typedef unsigned long long uint_least64_t;
>
>
>
>typedef signed char int_fast8_t;
>typedef long int_fast16_t;
>typedef long int_fast32_t;
>typedef long long int_fast64_t;
>
>typedef unsigned char uint_fast8_t;
>typedef unsigned long uint_fast16_t;
>typedef unsigned long uint_fast32_t;
>typedef unsigned long long uint_fast64_t;
>
>
>
>
>
>typedef long intptr_t;
>
>typedef unsigned long uintptr_t;
>
>
>
>typedef long long intmax_t;
>typedef unsigned long long uintmax_t;
># 22 "/usr/include/cygwin/types.h" 2 3 4
># 1 "/usr/include/endian.h" 1 3 4
># 23 "/usr/include/cygwin/types.h" 2 3 4
>
>
>
>typedef struct timespec timespec_t;
>
>
>
>
>typedef struct timespec timestruc_t;
>
>
>
>
>
>typedef _off64_t off_t;
>
>
>
>
>
>typedef __loff_t loff_t;
>
>
>
>typedef short __dev16_t;
>typedef unsigned long __dev32_t;
>
>typedef __dev32_t dev_t;
>
>
>
>
>
>
>
>typedef long blksize_t;
>
>
>
>
>typedef long __blkcnt32_t;
>typedef long long __blkcnt64_t;
>
>typedef __blkcnt64_t blkcnt_t;
>
>
>
>
>
>
>
>typedef unsigned long fsblkcnt_t;
>
>
>
>
>typedef unsigned long fsfilcnt_t;
>
>
>
>
>typedef unsigned short __uid16_t;
>typedef unsigned long __uid32_t;
>
>typedef __uid32_t uid_t;
>
>
>
>
>
>
>
>typedef unsigned short __gid16_t;
>typedef unsigned long __gid32_t;
>
>typedef __gid32_t gid_t;
>
>
>
>
>
>
>
>typedef unsigned long __ino32_t;
>typedef unsigned long long __ino64_t;
>
>typedef __ino64_t ino_t;
># 118 "/usr/include/cygwin/types.h" 3 4
>typedef unsigned long id_t;
># 140 "/usr/include/cygwin/types.h" 3 4
>struct flock {
> short l_type;
> short l_whence;
> off_t l_start;
> off_t l_len;
>
> pid_t l_pid;
>
>
>
>
>};
>
>
>
>typedef long long key_t;
>
>
>
>
>
>
>
>typedef unsigned long vm_offset_t;
>
>
>
>
>typedef unsigned long vm_size_t;
>
>
>
>
>typedef void *vm_object_t;
>
>
>
>
>typedef unsigned char u_int8_t;
>
>
>
>typedef __uint16_t u_int16_t;
>
>
>
>typedef __uint32_t u_int32_t;
>
>
>
>typedef __uint64_t u_int64_t;
>
>
>
>
>typedef __int32_t register_t;
>
>
>
>
>typedef char *addr_t;
>
>
>
>
>typedef unsigned mode_t;
>
>
>
>
>
>typedef struct __pthread_t {char __dummy;} *pthread_t;
>typedef struct __pthread_mutex_t {char __dummy;} *pthread_mutex_t;
>
>typedef struct __pthread_key_t {char __dummy;} *pthread_key_t;
>typedef struct __pthread_attr_t {char __dummy;} *pthread_attr_t;
>typedef struct __pthread_mutexattr_t {char __dummy;} *pthread_mutexattr_t;
>typedef struct __pthread_condattr_t {char __dummy;} *pthread_condattr_t;
>typedef struct __pthread_cond_t {char __dummy;} *pthread_cond_t;
>
>
>typedef struct
>{
>  pthread_mutex_t mutex;
>  int state;
>}
>pthread_once_t;
>typedef struct __pthread_rwlock_t {char __dummy;} *pthread_rwlock_t;
>typedef struct __pthread_rwlockattr_t {char __dummy;} *pthread_rwlockattr_t;
># 374 "/usr/include/sys/types.h" 2 3 4
># 30 "/usr/include/time.h" 2 3 4
>
>
>
>struct tm
>{
>  int tm_sec;
>  int tm_min;
>  int tm_hour;
>  int tm_mday;
>  int tm_mon;
>  int tm_year;
>  int tm_wday;
>  int tm_yday;
>  int tm_isdst;
>};
>
>clock_t __attribute__((__cdecl__)) clock (void);
>double __attribute__((__cdecl__)) difftime (time_t _time2, time_t _time1);
>time_t __attribute__((__cdecl__)) mktime (struct tm *_timeptr);
>time_t __attribute__((__cdecl__)) time (time_t *_timer);
>
>char *__attribute__((__cdecl__)) asctime (const struct tm *_tblock);
>char *__attribute__((__cdecl__)) ctime (const time_t *_time);
>struct tm *__attribute__((__cdecl__)) gmtime (const time_t *_timer);
>struct tm *__attribute__((__cdecl__)) localtime (const time_t *_timer);
>
>size_t __attribute__((__cdecl__)) strftime (char *_s, size_t _maxsize,
>const char *_fmt, const struct tm *_t);
>
>char *__attribute__((__cdecl__)) asctime_r (const struct tm *, char *);
>char *__attribute__((__cdecl__)) ctime_r (const time_t *, char *);
>struct tm *__attribute__((__cdecl__)) gmtime_r (const time_t *, struct tm *);
>struct tm *__attribute__((__cdecl__)) localtime_r (const time_t *, struct tm *);
>
>
>
>
>
>
>
>
>char *__attribute__((__cdecl__)) strptime (const char *, const char *,
>struct tm *);
>void __attribute__((__cdecl__)) tzset (void);
>void __attribute__((__cdecl__)) _tzset_r (struct _reent *);
>
>typedef struct __tzrule_struct
>{
>  char ch;
>  int m;
>  int n;
>  int d;
>  int s;
>  time_t change;
>  long offset;
>} __tzrule_type;
>
>typedef struct __tzinfo_struct
>{
>  int __tznorth;
>  int __tzyear;
>  __tzrule_type __tzrule[2];
>} __tzinfo_type;
>
>__tzinfo_type *__attribute__((__cdecl__)) __gettzinfo (void);
># 118 "/usr/include/time.h" 3 4
>extern __attribute__((dllimport)) long _timezone;
>extern __attribute__((dllimport)) int _daylight;
>extern __attribute__((dllimport)) char *_tzname[2];
># 135 "/usr/include/time.h" 3 4
># 1 "/usr/include/cygwin/time.h" 1 3 4
># 18 "/usr/include/cygwin/time.h" 3 4
>int nanosleep (const struct timespec *, struct timespec *);
>int clock_setres (clockid_t, struct timespec *);
>int clock_getres (clockid_t, struct timespec *);
>
>
>time_t timelocal (struct tm *);
>time_t timegm (struct tm *);
># 34 "/usr/include/cygwin/time.h" 3 4
>char *timezone (void);
># 136 "/usr/include/time.h" 2 3 4
>
>
>
>
># 1 "/usr/include/signal.h" 1 3 4
>
>
>
>
># 1 "/usr/include/sys/signal.h" 1 3 4
># 18 "/usr/include/sys/signal.h" 3 4
>typedef unsigned long sigset_t;
># 107 "/usr/include/sys/signal.h" 3 4
># 1 "/usr/include/cygwin/signal.h" 1 3 4
># 17 "/usr/include/cygwin/signal.h" 3 4
>struct _fpstate
>{
>  unsigned long cw;
>  unsigned long sw;
>  unsigned long tag;
>  unsigned long ipoff;
>  unsigned long cssel;
>  unsigned long dataoff;
>  unsigned long datasel;
>  unsigned char _st[80];
>  unsigned long nxst;
>};
>
>struct ucontext
>{
>  unsigned long cr2;
>  unsigned long dr0;
>  unsigned long dr1;
>  unsigned long dr2;
>  unsigned long dr3;
>  unsigned long dr6;
>  unsigned long dr7;
>  struct _fpstate fpstate;
>  unsigned long gs;
>  unsigned long fs;
>  unsigned long es;
>  unsigned long ds;
>  unsigned long edi;
>  unsigned long esi;
>  unsigned long ebx;
>  unsigned long edx;
>  unsigned long ecx;
>  unsigned long eax;
>  unsigned long ebp;
>  unsigned long eip;
>  unsigned long cs;
>  unsigned long eflags;
>  unsigned long esp;
>  unsigned long ss;
>  unsigned char _internal;
>  unsigned long oldmask;
>};
>
>
>
>typedef union sigval
>{
>  int sival_int;
>  void *sival_ptr;
>} sigval_t;
>
>typedef struct sigevent
>{
>  sigval_t sigev_value;
>  int sigev_signo;
>  int sigev_notify;
>  void (*sigev_notify_function) (sigval_t);
>  pthread_attr_t *sigev_notify_attributes;
>} sigevent_t;
>
>#pragma pack(push,4)
>struct _sigcommune
>{
>  __uint32_t _si_code;
>  void *_si_read_handle;
>  void *_si_write_handle;
>  void *_si_process_handle;
>  __extension__ union
>  {
>    int _si_fd;
>    void *_si_pipe_fhandler;
>    char *_si_str;
>  };
>};
>
>typedef struct
>{
>  int si_signo;
>  int si_code;
>  pid_t si_pid;
>  uid_t si_uid;
>  int si_errno;
>
>  __extension__ union
>  {
>    __uint32_t __pad[32];
>    struct _sigcommune _si_commune;
>    union
>    {
>
>      struct
>      {
> union
> {
>   struct
>   {
>     timer_t si_tid;
>     unsigned int si_overrun;
>   };
>   sigval_t si_sigval;
>   sigval_t si_value;
> };
>      };
>    };
>
>
>    __extension__ struct
>    {
>      int si_status;
>      clock_t si_utime;
>      clock_t si_stime;
>    };
>
>
>    void *si_addr;
>  };
>} siginfo_t;
>#pragma pack(pop)
>
>enum
>{
>  SI_USER = 0,
>  SI_ASYNCIO = 2,
>
>  SI_MESGQ,
>
>  SI_TIMER,
>  SI_QUEUE,
>
>  SI_KERNEL,
>
>  ILL_ILLOPC,
>  ILL_ILLOPN,
>  ILL_ILLADR,
>  ILL_ILLTRP,
>  ILL_PRVOPC,
>  ILL_PRVREG,
>  ILL_COPROC,
>  ILL_BADSTK,
>
>  FPE_INTDIV,
>  FPE_INTOVF,
>  FPE_FLTDIV,
>  FPE_FLTOVF,
>  FPE_FLTUND,
>  FPE_FLTRES,
>  FPE_FLTINV,
>  FPE_FLTSUB,
>
>  SEGV_MAPERR,
>  SEGV_ACCERR,
>
>  BUS_ADRALN,
>  BUS_ADRERR,
>  BUS_OBJERR,
>
>  CLD_EXITED,
>  CLD_KILLED,
>  CLD_DUMPED,
>  CLD_TRAPPED,
>  CLD_STOPPED,
>  CLD_CONTINUED
>};
>
>enum
>{
>  SIGEV_SIGNAL = 0,
>
>
>  SIGEV_NONE,
>
>
>  SIGEV_THREAD
>
>};
>
>typedef void (*_sig_func_ptr)(int);
>
>struct sigaction
>{
>  __extension__ union
>  {
>    _sig_func_ptr sa_handler;
>    void (*sa_sigaction) ( int, siginfo_t *, void * );
>  };
>  sigset_t sa_mask;
>  int sa_flags;
>};
># 263 "/usr/include/cygwin/signal.h" 3 4
>int sigwait (const sigset_t *, int *);
>int sigwaitinfo (const sigset_t *, siginfo_t *);
>int sighold (int);
>int sigignore (int);
>int sigrelse (int);
>_sig_func_ptr sigset (int, _sig_func_ptr);
>
>int sigqueue(pid_t, int, const union sigval);
>int siginterrupt (int, int);
># 108 "/usr/include/sys/signal.h" 2 3 4
># 134 "/usr/include/sys/signal.h" 3 4
>int __attribute__((__cdecl__)) sigprocmask (int how, const sigset_t
>*set, sigset_t *oset);
>
>
>int __attribute__((__cdecl__)) pthread_sigmask (int how, const
>sigset_t *set, sigset_t *oset);
># 151 "/usr/include/sys/signal.h" 3 4
>int __attribute__((__cdecl__)) kill (int, int);
>int __attribute__((__cdecl__)) killpg (pid_t, int);
>int __attribute__((__cdecl__)) sigaction (int, const struct sigaction
>*, struct sigaction *);
>int __attribute__((__cdecl__)) sigaddset (sigset_t *, const int);
>int __attribute__((__cdecl__)) sigdelset (sigset_t *, const int);
>int __attribute__((__cdecl__)) sigismember (const sigset_t *, int);
>int __attribute__((__cdecl__)) sigfillset (sigset_t *);
>int __attribute__((__cdecl__)) sigemptyset (sigset_t *);
>int __attribute__((__cdecl__)) sigpending (sigset_t *);
>int __attribute__((__cdecl__)) sigsuspend (const sigset_t *);
>int __attribute__((__cdecl__)) sigpause (int);
>
>
>
>
>
>
>
>int __attribute__((__cdecl__)) pthread_kill (pthread_t thread, int sig);
># 6 "/usr/include/signal.h" 2 3 4
>
>
>
>typedef int sig_atomic_t;
>
>
>
>
>
>struct _reent;
>
>_sig_func_ptr __attribute__((__cdecl__)) _signal_r (struct _reent *,
>int, _sig_func_ptr);
>int __attribute__((__cdecl__)) _raise_r (struct _reent *, int);
>
>
>_sig_func_ptr __attribute__((__cdecl__)) signal (int, _sig_func_ptr);
>int __attribute__((__cdecl__)) raise (int);
>
>
>
># 141 "/usr/include/time.h" 2 3 4
>
>
>
>
>
>
>
>int __attribute__((__cdecl__)) clock_settime (clockid_t clock_id,
>const struct timespec *tp);
>int __attribute__((__cdecl__)) clock_gettime (clockid_t clock_id,
>struct timespec *tp);
>int __attribute__((__cdecl__)) clock_getres (clockid_t clock_id,
>struct timespec *res);
>
>
>
>int __attribute__((__cdecl__)) timer_create (clockid_t clock_id,
>struct sigevent *evp, timer_t *timerid);
>
>
>
>
>int __attribute__((__cdecl__)) timer_delete (timer_t timerid);
>
>
>
>int __attribute__((__cdecl__)) timer_settime (timer_t timerid, int
>flags, const struct itimerspec *value, struct itimerspec *ovalue);
>
>
>int __attribute__((__cdecl__)) timer_gettime (timer_t timerid, struct
>itimerspec *value);
>int __attribute__((__cdecl__)) timer_getoverrun (timer_t timerid);
>
>
>
>int __attribute__((__cdecl__)) nanosleep (const struct timespec *rqtp,
>struct timespec *rmtp);
># 25 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gbookmarkfile.h" 2
>
>
>
>
>
>
>
>typedef enum
>{
>  G_BOOKMARK_FILE_ERROR_INVALID_URI,
>  G_BOOKMARK_FILE_ERROR_INVALID_VALUE,
>  G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED,
>  G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND,
>  G_BOOKMARK_FILE_ERROR_READ,
>  G_BOOKMARK_FILE_ERROR_UNKNOWN_ENCODING,
>  G_BOOKMARK_FILE_ERROR_WRITE,
>  G_BOOKMARK_FILE_ERROR_FILE_NOT_FOUND
>} GBookmarkFileError;
>
>GQuark g_bookmark_file_error_quark (void);
>
>
>
>
>typedef struct _GBookmarkFile GBookmarkFile;
>
>GBookmarkFile *g_bookmark_file_new (void);
>void g_bookmark_file_free (GBookmarkFile *bookmark);
>
>gboolean g_bookmark_file_load_from_file (GBookmarkFile *bookmark,
>          const gchar *filename,
>          GError **error);
>gboolean g_bookmark_file_load_from_data (GBookmarkFile *bookmark,
>          const gchar *data,
>          gsize length,
>          GError **error);
>gboolean g_bookmark_file_load_from_data_dirs (GBookmarkFile *bookmark,
>          const gchar *file,
>          gchar **full_path,
>          GError **error);
>gchar * g_bookmark_file_to_data (GBookmarkFile *bookmark,
>          gsize *length,
>          GError **error) __attribute__((__malloc__));
>gboolean g_bookmark_file_to_file (GBookmarkFile *bookmark,
>          const gchar *filename,
>          GError **error);
>
>void g_bookmark_file_set_title (GBookmarkFile *bookmark,
>          const gchar *uri,
>          const gchar *title);
>gchar * g_bookmark_file_get_title (GBookmarkFile *bookmark,
>          const gchar *uri,
>          GError **error) __attribute__((__malloc__));
>void g_bookmark_file_set_description (GBookmarkFile *bookmark,
>          const gchar *uri,
>          const gchar *description);
>gchar * g_bookmark_file_get_description (GBookmarkFile *bookmark,
>          const gchar *uri,
>          GError **error) __attribute__((__malloc__));
>void g_bookmark_file_set_mime_type (GBookmarkFile *bookmark,
>          const gchar *uri,
>          const gchar *mime_type);
>gchar * g_bookmark_file_get_mime_type (GBookmarkFile *bookmark,
>          const gchar *uri,
>          GError **error) __attribute__((__malloc__));
>void g_bookmark_file_set_groups (GBookmarkFile *bookmark,
>          const gchar *uri,
>          const gchar **groups,
>          gsize length);
>void g_bookmark_file_add_group (GBookmarkFile *bookmark,
>          const gchar *uri,
>          const gchar *group);
>gboolean g_bookmark_file_has_group (GBookmarkFile *bookmark,
>          const gchar *uri,
>          const gchar *group,
>          GError **error);
>gchar ** g_bookmark_file_get_groups (GBookmarkFile *bookmark,
>          const gchar *uri,
>          gsize *length,
>          GError **error) __attribute__((__malloc__));
>void g_bookmark_file_add_application (GBookmarkFile *bookmark,
>          const gchar *uri,
>          const gchar *name,
>          const gchar *exec);
>gboolean g_bookmark_file_has_application (GBookmarkFile *bookmark,
>          const gchar *uri,
>          const gchar *name,
>          GError **error);
>gchar ** g_bookmark_file_get_applications (GBookmarkFile *bookmark,
>          const gchar *uri,
>          gsize *length,
>          GError **error) __attribute__((__malloc__));
>gboolean g_bookmark_file_set_app_info (GBookmarkFile *bookmark,
>          const gchar *uri,
>          const gchar *name,
>          const gchar *exec,
>          gint count,
>          time_t stamp,
>          GError **error);
>gboolean g_bookmark_file_get_app_info (GBookmarkFile *bookmark,
>          const gchar *uri,
>          const gchar *name,
>          gchar **exec,
>          guint *count,
>          time_t *stamp,
>          GError **error);
>void g_bookmark_file_set_is_private (GBookmarkFile *bookmark,
>          const gchar *uri,
>          gboolean is_private);
>gboolean g_bookmark_file_get_is_private (GBookmarkFile *bookmark,
>          const gchar *uri,
>          GError **error);
>void g_bookmark_file_set_icon (GBookmarkFile *bookmark,
>          const gchar *uri,
>          const gchar *href,
>          const gchar *mime_type);
>gboolean g_bookmark_file_get_icon (GBookmarkFile *bookmark,
>          const gchar *uri,
>          gchar **href,
>          gchar **mime_type,
>          GError **error);
>void g_bookmark_file_set_added (GBookmarkFile *bookmark,
>          const gchar *uri,
>          time_t added);
>time_t g_bookmark_file_get_added (GBookmarkFile *bookmark,
>          const gchar *uri,
>          GError **error);
>void g_bookmark_file_set_modified (GBookmarkFile *bookmark,
>          const gchar *uri,
>          time_t modified);
>time_t g_bookmark_file_get_modified (GBookmarkFile *bookmark,
>          const gchar *uri,
>          GError **error);
>void g_bookmark_file_set_visited (GBookmarkFile *bookmark,
>          const gchar *uri,
>          time_t visited);
>time_t g_bookmark_file_get_visited (GBookmarkFile *bookmark,
>          const gchar *uri,
>          GError **error);
>gboolean g_bookmark_file_has_item (GBookmarkFile *bookmark,
>          const gchar *uri);
>gint g_bookmark_file_get_size (GBookmarkFile *bookmark);
>gchar ** g_bookmark_file_get_uris (GBookmarkFile *bookmark,
>          gsize *length) __attribute__((__malloc__));
>gboolean g_bookmark_file_remove_group (GBookmarkFile *bookmark,
>          const gchar *uri,
>          const gchar *group,
>          GError **error);
>gboolean g_bookmark_file_remove_application (GBookmarkFile *bookmark,
>          const gchar *uri,
>          const gchar *name,
>          GError **error);
>gboolean g_bookmark_file_remove_item (GBookmarkFile *bookmark,
>          const gchar *uri,
>          GError **error);
>gboolean g_bookmark_file_move_item (GBookmarkFile *bookmark,
>          const gchar *old_uri,
>          const gchar *new_uri,
>          GError **error);
>
>
># 37 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gcache.h" 1
># 30 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gcache.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/glist.h" 1
># 30 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/glist.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gmem.h" 1
># 30 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gmem.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gslice.h" 1
># 28 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gslice.h"
>
>
>
>
>gpointer g_slice_alloc (gsize block_size) __attribute__((__malloc__));
>gpointer g_slice_alloc0 (gsize block_size) __attribute__((__malloc__));
>void g_slice_free1 (gsize block_size,
>      gpointer mem_block);
>void g_slice_free_chain_with_offset (gsize block_size,
>      gpointer mem_chain,
>      gsize next_offset);
># 63 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gslice.h"
>typedef enum {
>  G_SLICE_CONFIG_ALWAYS_MALLOC = 1,
>  G_SLICE_CONFIG_BYPASS_MAGAZINES,
>  G_SLICE_CONFIG_WORKING_SET_MSECS,
>  G_SLICE_CONFIG_COLOR_INCREMENT,
>  G_SLICE_CONFIG_CHUNK_SIZES,
>  G_SLICE_CONFIG_CONTENTION_COUNTER
>} GSliceConfig;
>void g_slice_set_config (GSliceConfig ckey, gint64 value);
>gint64 g_slice_get_config (GSliceConfig ckey);
>gint64* g_slice_get_config_state (GSliceConfig ckey, gint64 address,
>guint *n_values);
>
>
># 31 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gmem.h" 2
>
>
>
>
>typedef struct _GMemVTable GMemVTable;
># 47 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gmem.h"
>gpointer g_malloc (gulong n_bytes) __attribute__((__malloc__));
>gpointer g_malloc0 (gulong n_bytes) __attribute__((__malloc__));
>gpointer g_realloc (gpointer mem,
>      gulong n_bytes) __attribute__((warn_unused_result));
>void g_free (gpointer mem);
>gpointer g_try_malloc (gulong n_bytes) __attribute__((__malloc__));
>gpointer g_try_malloc0 (gulong n_bytes) __attribute__((__malloc__));
>gpointer g_try_realloc (gpointer mem,
>      gulong n_bytes) __attribute__((warn_unused_result));
># 79 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gmem.h"
>struct _GMemVTable
>{
>  gpointer (*malloc) (gsize n_bytes);
>  gpointer (*realloc) (gpointer mem,
>      gsize n_bytes);
>  void (*free) (gpointer mem);
>
>  gpointer (*calloc) (gsize n_blocks,
>      gsize n_block_bytes);
>  gpointer (*try_malloc) (gsize n_bytes);
>  gpointer (*try_realloc) (gpointer mem,
>      gsize n_bytes);
>};
>void g_mem_set_vtable (GMemVTable *vtable);
>gboolean g_mem_is_system_malloc (void);
>
>extern __attribute__((dllimport)) gboolean g_mem_gc_friendly;
>
>
>
>extern __attribute__((dllimport)) GMemVTable *glib_mem_profiler_table;
>void g_mem_profile (void);
>
>
>
>
>typedef struct _GAllocator GAllocator;
>typedef struct _GMemChunk GMemChunk;
># 124 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gmem.h"
>GMemChunk* g_mem_chunk_new (const 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);
>gpointer g_mem_chunk_alloc0 (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);
>void g_blow_chunks (void);
>GAllocator*g_allocator_new (const gchar *name,
>    guint n_preallocs);
>void g_allocator_free (GAllocator *allocator);
>
>
>
>
>
>
># 31 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/glist.h" 2
>
>
>
>typedef struct _GList GList;
>
>struct _GList
>{
>  gpointer data;
>  GList *next;
>  GList *prev;
>};
>
>
>
>GList* g_list_alloc (void) __attribute__((warn_unused_result));
>void g_list_free (GList *list);
>void g_list_free_1 (GList *list);
>
>GList* g_list_append (GList *list,
>      gpointer data) __attribute__((warn_unused_result));
>GList* g_list_prepend (GList *list,
>      gpointer data) __attribute__((warn_unused_result));
>GList* g_list_insert (GList *list,
>      gpointer data,
>      gint position) __attribute__((warn_unused_result));
>GList* g_list_insert_sorted (GList *list,
>      gpointer data,
>      GCompareFunc func) __attribute__((warn_unused_result));
>GList* g_list_insert_sorted_with_data (GList *list,
>      gpointer data,
>      GCompareDataFunc func,
>      gpointer user_data) __attribute__((warn_unused_result));
>GList* g_list_insert_before (GList *list,
>      GList *sibling,
>      gpointer data) __attribute__((warn_unused_result));
>GList* g_list_concat (GList *list1,
>      GList *list2) __attribute__((warn_unused_result));
>GList* g_list_remove (GList *list,
>      gconstpointer data) __attribute__((warn_unused_result));
>GList* g_list_remove_all (GList *list,
>      gconstpointer data) __attribute__((warn_unused_result));
>GList* g_list_remove_link (GList *list,
>      GList *llink) __attribute__((warn_unused_result));
>GList* g_list_delete_link (GList *list,
>      GList *link_) __attribute__((warn_unused_result));
>GList* g_list_reverse (GList *list) __attribute__((warn_unused_result));
>GList* g_list_copy (GList *list) __attribute__((warn_unused_result));
>GList* g_list_nth (GList *list,
>      guint n);
>GList* g_list_nth_prev (GList *list,
>      guint n);
>GList* g_list_find (GList *list,
>      gconstpointer data);
>GList* g_list_find_custom (GList *list,
>      gconstpointer data,
>      GCompareFunc func);
>gint g_list_position (GList *list,
>      GList *llink);
>gint g_list_index (GList *list,
>      gconstpointer 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);
>GList* g_list_sort (GList *list,
>      GCompareFunc compare_func) __attribute__((warn_unused_result));
>GList* g_list_sort_with_data (GList *list,
>      GCompareDataFunc compare_func,
>      gpointer user_data) __attribute__((warn_unused_result));
>gpointer g_list_nth_data (GList *list,
>      guint n);
>
>
>
>
>
>
>void g_list_push_allocator (gpointer allocator);
>void g_list_pop_allocator (void);
>
>
># 31 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gcache.h" 2
>
>
>
>typedef struct _GCache GCache;
>
>typedef gpointer (*GCacheNewFunc) (gpointer key);
>typedef gpointer (*GCacheDupFunc) (gpointer value);
>typedef void (*GCacheDestroyFunc) (gpointer value);
>
>
>
>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,
>                                GEqualFunc key_equal_func);
>void g_cache_destroy (GCache *cache);
>gpointer g_cache_insert (GCache *cache,
>                                gpointer key);
>void g_cache_remove (GCache *cache,
>                                gconstpointer 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);
>
>
>
># 38 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gcompletion.h" 1
># 32 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gcompletion.h"
>
>
>typedef struct _GCompletion GCompletion;
>
>typedef gchar* (*GCompletionFunc) (gpointer);
>
>
>
>
>typedef gint (*GCompletionStrncmpFunc) (const gchar *s1,
>     const gchar *s2,
>     gsize n);
>
>struct _GCompletion
>{
>  GList* items;
>  GCompletionFunc func;
>
>  gchar* prefix;
>  GList* cache;
>  GCompletionStrncmpFunc strncmp_func;
>};
>
>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,
>                                         const gchar* prefix,
>                                         gchar** new_prefix);
>GList* g_completion_complete_utf8 (GCompletion *cmp,
>                                         const gchar* prefix,
>                                         gchar** new_prefix);
>void g_completion_set_compare (GCompletion *cmp,
>             GCompletionStrncmpFunc strncmp_func);
>void g_completion_free (GCompletion* cmp);
>
>
># 39 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gconvert.h" 1
># 30 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gconvert.h"
># 1 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/stddef.h" 1 3 4
># 31 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gconvert.h" 2
>
>
>
>
>typedef enum
>{
>  G_CONVERT_ERROR_NO_CONVERSION,
>  G_CONVERT_ERROR_ILLEGAL_SEQUENCE,
>  G_CONVERT_ERROR_FAILED,
>  G_CONVERT_ERROR_PARTIAL_INPUT,
>  G_CONVERT_ERROR_BAD_URI,
>  G_CONVERT_ERROR_NOT_ABSOLUTE_PATH
>} GConvertError;
>
>
>GQuark g_convert_error_quark (void);
>
>
>
>typedef struct _GIConv *GIConv;
>
>GIConv g_iconv_open (const gchar *to_codeset,
>         const gchar *from_codeset);
>size_t g_iconv (GIConv converter,
>         gchar **inbuf,
>         gsize *inbytes_left,
>         gchar **outbuf,
>         gsize *outbytes_left);
>gint g_iconv_close (GIConv converter);
>
>
>gchar* g_convert (const gchar *str,
>    gssize len,
>    const gchar *to_codeset,
>    const gchar *from_codeset,
>    gsize *bytes_read,
>    gsize *bytes_written,
>    GError **error) __attribute__((__malloc__));
>gchar* g_convert_with_iconv (const gchar *str,
>    gssize len,
>    GIConv converter,
>    gsize *bytes_read,
>    gsize *bytes_written,
>    GError **error) __attribute__((__malloc__));
>gchar* g_convert_with_fallback (const gchar *str,
>    gssize len,
>    const gchar *to_codeset,
>    const gchar *from_codeset,
>    gchar *fallback,
>    gsize *bytes_read,
>    gsize *bytes_written,
>    GError **error) __attribute__((__malloc__));
>
>
>
>
>gchar* g_locale_to_utf8 (const gchar *opsysstring,
>      gssize len,
>      gsize *bytes_read,
>      gsize *bytes_written,
>      GError **error) __attribute__((__malloc__));
>gchar* g_locale_from_utf8 (const gchar *utf8string,
>      gssize len,
>      gsize *bytes_read,
>      gsize *bytes_written,
>      GError **error) __attribute__((__malloc__));
># 108 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gconvert.h"
>gchar* g_filename_to_utf8_utf8 (const gchar *opsysstring,
>        gssize len,
>        gsize *bytes_read,
>        gsize *bytes_written,
>        GError **error) __attribute__((__malloc__));
>gchar* g_filename_from_utf8_utf8 (const gchar *utf8string,
>        gssize len,
>        gsize *bytes_read,
>        gsize *bytes_written,
>        GError **error) __attribute__((__malloc__));
>
>gchar *g_filename_from_uri_utf8 (const gchar *uri,
>       gchar **hostname,
>       GError **error) __attribute__((__malloc__));
>
>gchar *g_filename_to_uri_utf8 (const gchar *filename,
>       const gchar *hostname,
>       GError **error) __attribute__((__malloc__));
>gchar *g_filename_display_name (const gchar *filename)
>__attribute__((__malloc__));
>gboolean g_get_filename_charsets (const gchar ***charsets);
>
>gchar *g_filename_display_basename (const gchar *filename)
>__attribute__((__malloc__));
>
>gchar **g_uri_list_extract_uris (const gchar *uri_list)
>__attribute__((__malloc__));
>
>
># 40 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gdataset.h" 1
># 32 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gdataset.h"
>
>
>typedef struct _GData GData;
>
>typedef void (*GDataForeachFunc) (GQuark key_id,
>                                                 gpointer data,
>                                                 gpointer user_data);
>
>
>
>void g_datalist_init (GData **datalist);
>void g_datalist_clear (GData **datalist);
>gpointer g_datalist_id_get_data (GData **datalist,
>      GQuark key_id);
>void g_datalist_id_set_data_full (GData **datalist,
>      GQuark key_id,
>      gpointer data,
>      GDestroyNotify destroy_func);
>gpointer g_datalist_id_remove_no_notify (GData **datalist,
>      GQuark key_id);
>void g_datalist_foreach (GData **datalist,
>      GDataForeachFunc func,
>      gpointer user_data);
># 65 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gdataset.h"
>void g_datalist_set_flags (GData **datalist,
>      guint flags);
>void g_datalist_unset_flags (GData **datalist,
>      guint flags);
>guint g_datalist_get_flags (GData **datalist);
># 89 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gdataset.h"
>void g_dataset_destroy (gconstpointer dataset_location);
>gpointer g_dataset_id_get_data (gconstpointer dataset_location,
>                                         GQuark key_id);
>void g_dataset_id_set_data_full (gconstpointer dataset_location,
>                                         GQuark key_id,
>                                         gpointer data,
>                                         GDestroyNotify destroy_func);
>gpointer g_dataset_id_remove_no_notify (gconstpointer dataset_location,
>                                         GQuark key_id);
>void g_dataset_foreach (gconstpointer dataset_location,
>                                         GDataForeachFunc func,
>                                         gpointer user_data);
># 116 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gdataset.h"
>
># 41 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gdate.h" 1
># 35 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gdate.h"
>
># 46 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gdate.h"
>typedef gint32 GTime;
>typedef guint16 GDateYear;
>typedef guint8 GDateDay;
>typedef struct _GDate GDate;
>
>struct tm;
>
>
>typedef enum
>{
>  G_DATE_DAY = 0,
>  G_DATE_MONTH = 1,
>  G_DATE_YEAR = 2
>} GDateDMY;
>
>
>typedef enum
>{
>  G_DATE_BAD_WEEKDAY = 0,
>  G_DATE_MONDAY = 1,
>  G_DATE_TUESDAY = 2,
>  G_DATE_WEDNESDAY = 3,
>  G_DATE_THURSDAY = 4,
>  G_DATE_FRIDAY = 5,
>  G_DATE_SATURDAY = 6,
>  G_DATE_SUNDAY = 7
>} GDateWeekday;
>typedef enum
>{
>  G_DATE_BAD_MONTH = 0,
>  G_DATE_JANUARY = 1,
>  G_DATE_FEBRUARY = 2,
>  G_DATE_MARCH = 3,
>  G_DATE_APRIL = 4,
>  G_DATE_MAY = 5,
>  G_DATE_JUNE = 6,
>  G_DATE_JULY = 7,
>  G_DATE_AUGUST = 8,
>  G_DATE_SEPTEMBER = 9,
>  G_DATE_OCTOBER = 10,
>  G_DATE_NOVEMBER = 11,
>  G_DATE_DECEMBER = 12
>} GDateMonth;
># 99 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gdate.h"
>struct _GDate
>{
>  guint julian_days : 32;
>
>
>
>
>
>  guint julian : 1;
>  guint dmy : 1;
>
>
>  guint day : 6;
>  guint month : 4;
>  guint year : 16;
>};
>
>
>
>
>
>GDate* g_date_new (void);
>GDate* g_date_new_dmy (GDateDay day,
>                                           GDateMonth month,
>                                           GDateYear year);
>GDate* g_date_new_julian (guint32 julian_day);
>void g_date_free (GDate *date);
>
>
>
>
>
>
>gboolean g_date_valid (const GDate *date);
>gboolean g_date_valid_day (GDateDay day) __attribute__((__const__));
>gboolean g_date_valid_month (GDateMonth month) __attribute__((__const__));
>gboolean g_date_valid_year (GDateYear year) __attribute__((__const__));
>gboolean g_date_valid_weekday (GDateWeekday weekday) __attribute__((__const__));
>gboolean g_date_valid_julian (guint32 julian_date) __attribute__((__const__));
>gboolean g_date_valid_dmy (GDateDay day,
>                                           GDateMonth month,
>                                           GDateYear year)
>__attribute__((__const__));
>
>GDateWeekday g_date_get_weekday (const GDate *date);
>GDateMonth g_date_get_month (const GDate *date);
>GDateYear g_date_get_year (const GDate *date);
>GDateDay g_date_get_day (const GDate *date);
>guint32 g_date_get_julian (const GDate *date);
>guint g_date_get_day_of_year (const GDate *date);
>
>
>
>
>
>
>guint g_date_get_monday_week_of_year (const GDate *date);
>guint g_date_get_sunday_week_of_year (const GDate *date);
>guint g_date_get_iso8601_week_of_year (const GDate *date);
>
>
>
>
>
>void g_date_clear (GDate *date,
>                                           guint n_dates);
>
>
>
>
>
>void g_date_set_parse (GDate *date,
>                                           const gchar *str);
>void g_date_set_time_t (GDate *date,
>        time_t timet);
>void g_date_set_time_val (GDate *date,
>        GTimeVal *timeval);
>
>void g_date_set_time (GDate *date,
>                                           GTime time_);
>
>void g_date_set_month (GDate *date,
>                                           GDateMonth month);
>void g_date_set_day (GDate *date,
>                                           GDateDay day);
>void g_date_set_year (GDate *date,
>                                           GDateYear year);
>void g_date_set_dmy (GDate *date,
>                                           GDateDay day,
>                                           GDateMonth month,
>                                           GDateYear y);
>void g_date_set_julian (GDate *date,
>                                           guint32 julian_date);
>gboolean g_date_is_first_of_month (const GDate *date);
>gboolean g_date_is_last_of_month (const GDate *date);
>
>
>void g_date_add_days (GDate *date,
>                                           guint n_days);
>void g_date_subtract_days (GDate *date,
>                                           guint n_days);
>
>
>void g_date_add_months (GDate *date,
>                                           guint n_months);
>void g_date_subtract_months (GDate *date,
>                                           guint n_months);
>
>
>void g_date_add_years (GDate *date,
>                                           guint n_years);
>void g_date_subtract_years (GDate *date,
>                                           guint n_years);
>gboolean g_date_is_leap_year (GDateYear year) __attribute__((__const__));
>guint8 g_date_get_days_in_month (GDateMonth month,
>                                           GDateYear year)
>__attribute__((__const__));
>guint8 g_date_get_monday_weeks_in_year (GDateYear year)
>__attribute__((__const__));
>guint8 g_date_get_sunday_weeks_in_year (GDateYear year)
>__attribute__((__const__));
>
>
>
>gint g_date_days_between (const GDate *date1,
>        const GDate *date2);
>
>
>gint g_date_compare (const GDate *lhs,
>                                           const GDate *rhs);
>void g_date_to_struct_tm (const GDate *date,
>                                           struct tm *tm);
>
>void g_date_clamp (GDate *date,
>        const GDate *min_date,
>        const GDate *max_date);
>
>
>void g_date_order (GDate *date1, GDate *date2);
>
>
>
>
>gsize g_date_strftime (gchar *s,
>                                           gsize slen,
>                                           const gchar *format,
>                                           const GDate *date);
># 259 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gdate.h"
>
># 42 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gdir.h" 1
># 28 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gdir.h"
>
>
>typedef struct _GDir GDir;
>
>
>
>
>
>
>
>GDir * g_dir_open_utf8 (const gchar *path,
>            guint flags,
>            GError **error);
>const gchar *g_dir_read_name_utf8 (GDir *dir);
>void g_dir_rewind (GDir *dir);
>void g_dir_close (GDir *dir);
>
>
># 43 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
>
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gfileutils.h" 1
># 26 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gfileutils.h"
>
>
>
>
>typedef enum
>{
>  G_FILE_ERROR_EXIST,
>  G_FILE_ERROR_ISDIR,
>  G_FILE_ERROR_ACCES,
>  G_FILE_ERROR_NAMETOOLONG,
>  G_FILE_ERROR_NOENT,
>  G_FILE_ERROR_NOTDIR,
>  G_FILE_ERROR_NXIO,
>  G_FILE_ERROR_NODEV,
>  G_FILE_ERROR_ROFS,
>  G_FILE_ERROR_TXTBSY,
>  G_FILE_ERROR_FAULT,
>  G_FILE_ERROR_LOOP,
>  G_FILE_ERROR_NOSPC,
>  G_FILE_ERROR_NOMEM,
>  G_FILE_ERROR_MFILE,
>  G_FILE_ERROR_NFILE,
>  G_FILE_ERROR_BADF,
>  G_FILE_ERROR_INVAL,
>  G_FILE_ERROR_PIPE,
>  G_FILE_ERROR_AGAIN,
>  G_FILE_ERROR_INTR,
>  G_FILE_ERROR_IO,
>  G_FILE_ERROR_PERM,
>  G_FILE_ERROR_NOSYS,
>  G_FILE_ERROR_FAILED
>} GFileError;
>
>
>
>
>
>typedef enum
>{
>  G_FILE_TEST_IS_REGULAR = 1 << 0,
>  G_FILE_TEST_IS_SYMLINK = 1 << 1,
>  G_FILE_TEST_IS_DIR = 1 << 2,
>  G_FILE_TEST_IS_EXECUTABLE = 1 << 3,
>  G_FILE_TEST_EXISTS = 1 << 4
>} GFileTest;
>
>GQuark g_file_error_quark (void);
>
>GFileError g_file_error_from_errno (gint err_no);
># 83 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gfileutils.h"
>gboolean g_file_test_utf8 (const gchar *filename,
>                              GFileTest test);
>gboolean g_file_get_contents_utf8 (const gchar *filename,
>                              gchar **contents,
>                              gsize *length,
>                              GError **error);
>gboolean g_file_set_contents (const gchar *filename,
>         const gchar *contents,
>         gssize length,
>         GError **error);
>gchar *g_file_read_link (const gchar *filename,
>         GError **error);
>
>
>gint g_mkstemp_utf8 (gchar *tmpl);
>
>
>gint g_file_open_tmp_utf8 (const gchar *tmpl,
>         gchar **name_used,
>         GError **error);
>
>gchar *g_build_path (const gchar *separator,
>    const gchar *first_element,
>    ...) __attribute__((__malloc__)) ;
>gchar *g_build_pathv (const gchar *separator,
>    gchar **args) __attribute__((__malloc__));
>
>gchar *g_build_filename (const gchar *first_element,
>    ...) __attribute__((__malloc__)) ;
>gchar *g_build_filenamev (gchar **args) __attribute__((__malloc__));
>
>int g_mkdir_with_parents (const gchar *pathname,
>        int mode);
>
>
># 45 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/ghash.h" 1
># 32 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/ghash.h"
>
>
>typedef struct _GHashTable GHashTable;
>
>typedef gboolean (*GHRFunc) (gpointer key,
>                               gpointer value,
>                               gpointer user_data);
>
>
>
>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);
>void g_hash_table_remove_all (GHashTable *hash_table);
>gboolean g_hash_table_steal (GHashTable *hash_table,
>         gconstpointer key);
>void g_hash_table_steal_all (GHashTable *hash_table);
>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);
>gpointer g_hash_table_find (GHashTable *hash_table,
>         GHRFunc predicate,
>         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);
>
>
>GHashTable* g_hash_table_ref (GHashTable *hash_table);
>void g_hash_table_unref (GHashTable *hash_table);
># 96 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/ghash.h"
>gboolean g_str_equal (gconstpointer v1,
>                      gconstpointer v2);
>guint g_str_hash (gconstpointer v);
>
>gboolean g_int_equal (gconstpointer v1,
>                      gconstpointer v2);
>guint g_int_hash (gconstpointer v);
>
>
>
>
>
>
>
>guint g_direct_hash (gconstpointer v) __attribute__((__const__));
>gboolean g_direct_equal (gconstpointer v1,
>                         gconstpointer v2) __attribute__((__const__));
>
>
># 46 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/ghook.h" 1
># 32 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/ghook.h"
>
>
>
>
>typedef struct _GHook GHook;
>typedef struct _GHookList GHookList;
>
>typedef gint (*GHookCompareFunc) (GHook *new_hook,
>       GHook *sibling);
>typedef gboolean (*GHookFindFunc) (GHook *hook,
>       gpointer data);
>typedef void (*GHookMarshaller) (GHook *hook,
>       gpointer marshal_data);
>typedef gboolean (*GHookCheckMarshaller) (GHook *hook,
>       gpointer marshal_data);
>typedef void (*GHookFunc) (gpointer data);
>typedef gboolean (*GHookCheckFunc) (gpointer data);
>typedef void (*GHookFinalizeFunc) (GHookList *hook_list,
>       GHook *hook);
>typedef enum
>{
>  G_HOOK_FLAG_ACTIVE = 1 << 0,
>  G_HOOK_FLAG_IN_CALL = 1 << 1,
>  G_HOOK_FLAG_MASK = 0x0f
>} GHookFlagMask;
>
>
>
>
>struct _GHookList
>{
>  gulong seq_id;
>  guint hook_size : 16;
>  guint is_setup : 1;
>  GHook *hooks;
>  gpointer dummy3;
>  GHookFinalizeFunc finalize_hook;
>  gpointer dummy[2];
>};
>struct _GHook
>{
>  gpointer data;
>  GHook *next;
>  GHook *prev;
>  guint ref_count;
>  gulong hook_id;
>  guint flags;
>  gpointer func;
>  GDestroyNotify destroy;
>};
># 102 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/ghook.h"
>void g_hook_list_init (GHookList *hook_list,
>      guint hook_size);
>void g_hook_list_clear (GHookList *hook_list);
>GHook* g_hook_alloc (GHookList *hook_list);
>void g_hook_free (GHookList *hook_list,
>      GHook *hook);
>GHook * g_hook_ref (GHookList *hook_list,
>      GHook *hook);
>void g_hook_unref (GHookList *hook_list,
>      GHook *hook);
>gboolean g_hook_destroy (GHookList *hook_list,
>      gulong hook_id);
>void g_hook_destroy_link (GHookList *hook_list,
>      GHook *hook);
>void g_hook_prepend (GHookList *hook_list,
>      GHook *hook);
>void g_hook_insert_before (GHookList *hook_list,
>      GHook *sibling,
>      GHook *hook);
>void g_hook_insert_sorted (GHookList *hook_list,
>      GHook *hook,
>      GHookCompareFunc func);
>GHook* g_hook_get (GHookList *hook_list,
>      gulong hook_id);
>GHook* g_hook_find (GHookList *hook_list,
>      gboolean need_valids,
>      GHookFindFunc func,
>      gpointer data);
>GHook* g_hook_find_data (GHookList *hook_list,
>      gboolean need_valids,
>      gpointer data);
>GHook* g_hook_find_func (GHookList *hook_list,
>      gboolean need_valids,
>      gpointer func);
>GHook* g_hook_find_func_data (GHookList *hook_list,
>      gboolean need_valids,
>      gpointer func,
>      gpointer data);
>
>GHook* g_hook_first_valid (GHookList *hook_list,
>      gboolean may_be_in_call);
>
>
>
>GHook* g_hook_next_valid (GHookList *hook_list,
>      GHook *hook,
>      gboolean may_be_in_call);
>
>gint g_hook_compare_ids (GHook *new_hook,
>      GHook *sibling);
>
>
>
>
>
>void g_hook_list_invoke (GHookList *hook_list,
>      gboolean may_recurse);
>
>
>
>void g_hook_list_invoke_check (GHookList *hook_list,
>      gboolean may_recurse);
>
>
>void g_hook_list_marshal (GHookList *hook_list,
>      gboolean may_recurse,
>      GHookMarshaller marshaller,
>      gpointer marshal_data);
>void g_hook_list_marshal_check (GHookList *hook_list,
>      gboolean may_recurse,
>      GHookCheckMarshaller marshaller,
>      gpointer marshal_data);
>
>
># 47 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/giochannel.h" 1
># 31 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/giochannel.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gmain.h" 1
># 23 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gmain.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gslist.h" 1
># 32 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gslist.h"
>
>
>typedef struct _GSList GSList;
>
>struct _GSList
>{
>  gpointer data;
>  GSList *next;
>};
>
>
>
>GSList* g_slist_alloc (void) __attribute__((warn_unused_result));
>void g_slist_free (GSList *list);
>void g_slist_free_1 (GSList *list);
>
>GSList* g_slist_append (GSList *list,
>       gpointer data) __attribute__((warn_unused_result));
>GSList* g_slist_prepend (GSList *list,
>       gpointer data) __attribute__((warn_unused_result));
>GSList* g_slist_insert (GSList *list,
>       gpointer data,
>       gint position) __attribute__((warn_unused_result));
>GSList* g_slist_insert_sorted (GSList *list,
>       gpointer data,
>       GCompareFunc func) __attribute__((warn_unused_result));
>GSList* g_slist_insert_sorted_with_data (GSList *list,
>       gpointer data,
>       GCompareDataFunc func,
>       gpointer user_data) __attribute__((warn_unused_result));
>GSList* g_slist_insert_before (GSList *slist,
>       GSList *sibling,
>       gpointer data) __attribute__((warn_unused_result));
>GSList* g_slist_concat (GSList *list1,
>       GSList *list2) __attribute__((warn_unused_result));
>GSList* g_slist_remove (GSList *list,
>       gconstpointer data) __attribute__((warn_unused_result));
>GSList* g_slist_remove_all (GSList *list,
>       gconstpointer data) __attribute__((warn_unused_result));
>GSList* g_slist_remove_link (GSList *list,
>       GSList *link_) __attribute__((warn_unused_result));
>GSList* g_slist_delete_link (GSList *list,
>       GSList *link_) __attribute__((warn_unused_result));
>GSList* g_slist_reverse (GSList *list) __attribute__((warn_unused_result));
>GSList* g_slist_copy (GSList *list) __attribute__((warn_unused_result));
>GSList* g_slist_nth (GSList *list,
>       guint n);
>GSList* g_slist_find (GSList *list,
>       gconstpointer data);
>GSList* g_slist_find_custom (GSList *list,
>       gconstpointer data,
>       GCompareFunc func);
>gint g_slist_position (GSList *list,
>       GSList *llink);
>gint g_slist_index (GSList *list,
>       gconstpointer data);
>GSList* g_slist_last (GSList *list);
>guint g_slist_length (GSList *list);
>void g_slist_foreach (GSList *list,
>       GFunc func,
>       gpointer user_data);
>GSList* g_slist_sort (GSList *list,
>       GCompareFunc compare_func) __attribute__((warn_unused_result));
>GSList* g_slist_sort_with_data (GSList *list,
>       GCompareDataFunc compare_func,
>       gpointer user_data) __attribute__((warn_unused_result));
>gpointer g_slist_nth_data (GSList *list,
>       guint n);
>
>
>
>
>void g_slist_push_allocator (gpointer dummy);
>void g_slist_pop_allocator (void);
>
>
># 24 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gmain.h" 2
>
>
>
>
>typedef struct _GMainContext GMainContext;
>typedef struct _GMainLoop GMainLoop;
>typedef struct _GSource GSource;
>typedef struct _GSourceCallbackFuncs GSourceCallbackFuncs;
>typedef struct _GSourceFuncs GSourceFuncs;
>
>typedef gboolean (*GSourceFunc) (gpointer data);
>typedef void (*GChildWatchFunc) (GPid pid,
>           gint status,
>           gpointer data);
>struct _GSource
>{
>
>  gpointer callback_data;
>  GSourceCallbackFuncs *callback_funcs;
>
>  GSourceFuncs *source_funcs;
>  guint ref_count;
>
>  GMainContext *context;
>
>  gint priority;
>  guint flags;
>  guint source_id;
>
>  GSList *poll_fds;
>
>  GSource *prev;
>  GSource *next;
>
>  gpointer reserved1;
>  gpointer reserved2;
>};
>
>struct _GSourceCallbackFuncs
>{
>  void (*ref) (gpointer cb_data);
>  void (*unref) (gpointer cb_data);
>  void (*get) (gpointer cb_data,
>   GSource *source,
>   GSourceFunc *func,
>   gpointer *data);
>};
>
>typedef void (*GSourceDummyMarshal) (void);
>
>struct _GSourceFuncs
>{
>  gboolean (*prepare) (GSource *source,
>   gint *timeout_);
>  gboolean (*check) (GSource *source);
>  gboolean (*dispatch) (GSource *source,
>   GSourceFunc callback,
>   gpointer user_data);
>  void (*finalize) (GSource *source);
>
>
>  GSourceFunc closure_callback;
>  GSourceDummyMarshal closure_marshal;
>};
># 116 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gmain.h"
>typedef struct _GPollFD GPollFD;
>typedef gint (*GPollFunc) (GPollFD *ufds,
>     guint nfsd,
>     gint timeout_);
>
>struct _GPollFD
>{
>  gint fd;
>  gushort events;
>  gushort revents;
>};
># 138 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gmain.h"
>GMainContext *g_main_context_new (void);
>GMainContext *g_main_context_ref (GMainContext *context);
>void g_main_context_unref (GMainContext *context);
>GMainContext *g_main_context_default (void);
>
>gboolean g_main_context_iteration (GMainContext *context,
>     gboolean may_block);
>gboolean g_main_context_pending (GMainContext *context);
>
>
>
>GSource *g_main_context_find_source_by_id (GMainContext *context,
>            guint source_id);
>GSource *g_main_context_find_source_by_user_data (GMainContext *context,
>            gpointer user_data);
>GSource *g_main_context_find_source_by_funcs_user_data (GMainContext *context,
>             GSourceFuncs *funcs,
>            gpointer user_data);
>
>
>
>void g_main_context_wakeup (GMainContext *context);
>gboolean g_main_context_acquire (GMainContext *context);
>void g_main_context_release (GMainContext *context);
>gboolean g_main_context_is_owner (GMainContext *context);
>gboolean g_main_context_wait (GMainContext *context,
>     GCond *cond,
>     GMutex *mutex);
>
>gboolean g_main_context_prepare (GMainContext *context,
>      gint *priority);
>gint g_main_context_query (GMainContext *context,
>      gint max_priority,
>      gint *timeout_,
>      GPollFD *fds,
>      gint n_fds);
>gint g_main_context_check (GMainContext *context,
>      gint max_priority,
>      GPollFD *fds,
>      gint n_fds);
>void g_main_context_dispatch (GMainContext *context);
>
>void g_main_context_set_poll_func (GMainContext *context,
>           GPollFunc func);
>GPollFunc g_main_context_get_poll_func (GMainContext *context);
>
>
>
>void g_main_context_add_poll (GMainContext *context,
>         GPollFD *fd,
>         gint priority);
>void g_main_context_remove_poll (GMainContext *context,
>         GPollFD *fd);
>
>gint g_main_depth (void);
>GSource *g_main_current_source (void);
>
>
>
>
>GMainLoop *g_main_loop_new (GMainContext *context,
>           gboolean is_running);
>void g_main_loop_run (GMainLoop *loop);
>void g_main_loop_quit (GMainLoop *loop);
>GMainLoop *g_main_loop_ref (GMainLoop *loop);
>void g_main_loop_unref (GMainLoop *loop);
>gboolean g_main_loop_is_running (GMainLoop *loop);
>GMainContext *g_main_loop_get_context (GMainLoop *loop);
>
>
>
>GSource *g_source_new (GSourceFuncs *source_funcs,
>       guint struct_size);
>GSource *g_source_ref (GSource *source);
>void g_source_unref (GSource *source);
>
>guint g_source_attach (GSource *source,
>       GMainContext *context);
>void g_source_destroy (GSource *source);
>
>void g_source_set_priority (GSource *source,
>       gint priority);
>gint g_source_get_priority (GSource *source);
>void g_source_set_can_recurse (GSource *source,
>       gboolean can_recurse);
>gboolean g_source_get_can_recurse (GSource *source);
>guint g_source_get_id (GSource *source);
>
>GMainContext *g_source_get_context (GSource *source);
>
>void g_source_set_callback (GSource *source,
>       GSourceFunc func,
>       gpointer data,
>       GDestroyNotify notify);
>
>void g_source_set_funcs (GSource *source,
>                                   GSourceFuncs *funcs);
>gboolean g_source_is_destroyed (GSource *source);
>
>
>void g_source_set_callback_indirect (GSource *source,
>         gpointer callback_data,
>         GSourceCallbackFuncs *callback_funcs);
>
>void g_source_add_poll (GSource *source,
>        GPollFD *fd);
>void g_source_remove_poll (GSource *source,
>        GPollFD *fd);
>
>void g_source_get_current_time (GSource *source,
>        GTimeVal *timeval);
>
>
>
>
>
>
>
>GSource *g_idle_source_new (void);
>GSource *g_child_watch_source_new (GPid pid);
>GSource *g_timeout_source_new (guint interval);
>
>
>
>void g_get_current_time (GTimeVal *result);
># 287 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gmain.h"
>gboolean g_source_remove (guint tag);
>gboolean g_source_remove_by_user_data (gpointer user_data);
>gboolean g_source_remove_by_funcs_user_data (GSourceFuncs *funcs,
>           gpointer user_data);
>
>
>guint g_timeout_add_full (gint priority,
>     guint interval,
>     GSourceFunc function,
>     gpointer data,
>     GDestroyNotify notify);
>guint g_timeout_add (guint interval,
>     GSourceFunc function,
>     gpointer data);
>guint g_child_watch_add_full (gint priority,
>     GPid pid,
>     GChildWatchFunc function,
>     gpointer data,
>     GDestroyNotify notify);
>guint g_child_watch_add (GPid pid,
>     GChildWatchFunc function,
>     gpointer data);
>guint g_idle_add (GSourceFunc function,
>     gpointer data);
>guint g_idle_add_full (gint priority,
>     GSourceFunc function,
>     gpointer data,
>     GDestroyNotify notify);
>gboolean g_idle_remove_by_data (gpointer data);
>
>
>extern __attribute__((dllimport)) GSourceFuncs g_timeout_funcs;
>extern __attribute__((dllimport)) GSourceFuncs g_child_watch_funcs;
>extern __attribute__((dllimport)) GSourceFuncs g_idle_funcs;
>
>
># 32 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/giochannel.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gstring.h" 1
># 31 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gstring.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gunicode.h" 1
># 28 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gunicode.h"
>
>
>typedef guint32 gunichar;
>typedef guint16 gunichar2;
>
>
>
>
>typedef enum
>{
>  G_UNICODE_CONTROL,
>  G_UNICODE_FORMAT,
>  G_UNICODE_UNASSIGNED,
>  G_UNICODE_PRIVATE_USE,
>  G_UNICODE_SURROGATE,
>  G_UNICODE_LOWERCASE_LETTER,
>  G_UNICODE_MODIFIER_LETTER,
>  G_UNICODE_OTHER_LETTER,
>  G_UNICODE_TITLECASE_LETTER,
>  G_UNICODE_UPPERCASE_LETTER,
>  G_UNICODE_COMBINING_MARK,
>  G_UNICODE_ENCLOSING_MARK,
>  G_UNICODE_NON_SPACING_MARK,
>  G_UNICODE_DECIMAL_NUMBER,
>  G_UNICODE_LETTER_NUMBER,
>  G_UNICODE_OTHER_NUMBER,
>  G_UNICODE_CONNECT_PUNCTUATION,
>  G_UNICODE_DASH_PUNCTUATION,
>  G_UNICODE_CLOSE_PUNCTUATION,
>  G_UNICODE_FINAL_PUNCTUATION,
>  G_UNICODE_INITIAL_PUNCTUATION,
>  G_UNICODE_OTHER_PUNCTUATION,
>  G_UNICODE_OPEN_PUNCTUATION,
>  G_UNICODE_CURRENCY_SYMBOL,
>  G_UNICODE_MODIFIER_SYMBOL,
>  G_UNICODE_MATH_SYMBOL,
>  G_UNICODE_OTHER_SYMBOL,
>  G_UNICODE_LINE_SEPARATOR,
>  G_UNICODE_PARAGRAPH_SEPARATOR,
>  G_UNICODE_SPACE_SEPARATOR
>} GUnicodeType;
>
>
>
>
>
>
>typedef enum
>{
>  G_UNICODE_BREAK_MANDATORY,
>  G_UNICODE_BREAK_CARRIAGE_RETURN,
>  G_UNICODE_BREAK_LINE_FEED,
>  G_UNICODE_BREAK_COMBINING_MARK,
>  G_UNICODE_BREAK_SURROGATE,
>  G_UNICODE_BREAK_ZERO_WIDTH_SPACE,
>  G_UNICODE_BREAK_INSEPARABLE,
>  G_UNICODE_BREAK_NON_BREAKING_GLUE,
>  G_UNICODE_BREAK_CONTINGENT,
>  G_UNICODE_BREAK_SPACE,
>  G_UNICODE_BREAK_AFTER,
>  G_UNICODE_BREAK_BEFORE,
>  G_UNICODE_BREAK_BEFORE_AND_AFTER,
>  G_UNICODE_BREAK_HYPHEN,
>  G_UNICODE_BREAK_NON_STARTER,
>  G_UNICODE_BREAK_OPEN_PUNCTUATION,
>  G_UNICODE_BREAK_CLOSE_PUNCTUATION,
>  G_UNICODE_BREAK_QUOTATION,
>  G_UNICODE_BREAK_EXCLAMATION,
>  G_UNICODE_BREAK_IDEOGRAPHIC,
>  G_UNICODE_BREAK_NUMERIC,
>  G_UNICODE_BREAK_INFIX_SEPARATOR,
>  G_UNICODE_BREAK_SYMBOL,
>  G_UNICODE_BREAK_ALPHABETIC,
>  G_UNICODE_BREAK_PREFIX,
>  G_UNICODE_BREAK_POSTFIX,
>  G_UNICODE_BREAK_COMPLEX_CONTEXT,
>  G_UNICODE_BREAK_AMBIGUOUS,
>  G_UNICODE_BREAK_UNKNOWN,
>  G_UNICODE_BREAK_NEXT_LINE,
>  G_UNICODE_BREAK_WORD_JOINER,
>  G_UNICODE_BREAK_HANGUL_L_JAMO,
>  G_UNICODE_BREAK_HANGUL_V_JAMO,
>  G_UNICODE_BREAK_HANGUL_T_JAMO,
>  G_UNICODE_BREAK_HANGUL_LV_SYLLABLE,
>  G_UNICODE_BREAK_HANGUL_LVT_SYLLABLE
>} GUnicodeBreakType;
>
>
>
>
>
>
>
>gboolean g_get_charset (const char **charset);
>
>
>
>gboolean g_unichar_isalnum (gunichar c) __attribute__((__const__));
>gboolean g_unichar_isalpha (gunichar c) __attribute__((__const__));
>gboolean g_unichar_iscntrl (gunichar c) __attribute__((__const__));
>gboolean g_unichar_isdigit (gunichar c) __attribute__((__const__));
>gboolean g_unichar_isgraph (gunichar c) __attribute__((__const__));
>gboolean g_unichar_islower (gunichar c) __attribute__((__const__));
>gboolean g_unichar_isprint (gunichar c) __attribute__((__const__));
>gboolean g_unichar_ispunct (gunichar c) __attribute__((__const__));
>gboolean g_unichar_isspace (gunichar c) __attribute__((__const__));
>gboolean g_unichar_isupper (gunichar c) __attribute__((__const__));
>gboolean g_unichar_isxdigit (gunichar c) __attribute__((__const__));
>gboolean g_unichar_istitle (gunichar c) __attribute__((__const__));
>gboolean g_unichar_isdefined (gunichar c) __attribute__((__const__));
>gboolean g_unichar_iswide (gunichar c) __attribute__((__const__));
>gboolean g_unichar_iswide_cjk(gunichar c) __attribute__((__const__));
>
>
>
>gunichar g_unichar_toupper (gunichar c) __attribute__((__const__));
>gunichar g_unichar_tolower (gunichar c) __attribute__((__const__));
>gunichar g_unichar_totitle (gunichar c) __attribute__((__const__));
>
>
>
>gint g_unichar_digit_value (gunichar c) __attribute__((__const__));
>
>gint g_unichar_xdigit_value (gunichar c) __attribute__((__const__));
>
>
>GUnicodeType g_unichar_type (gunichar c) __attribute__((__const__));
>
>
>GUnicodeBreakType g_unichar_break_type (gunichar c) __attribute__((__const__));
>
>
>
>
>
>void g_unicode_canonical_ordering (gunichar *string,
>       gsize len);
>
>
>
>
>gunichar *g_unicode_canonical_decomposition (gunichar ch,
>          gsize *result_len) __attribute__((__malloc__));
>
>
>
>extern __attribute__((dllimport)) const gchar * const g_utf8_skip;
>
>
>
>gunichar g_utf8_get_char (const gchar *p);
>gunichar g_utf8_get_char_validated (const gchar *p,
>        gssize max_len);
>
>gchar* g_utf8_offset_to_pointer (const gchar *str,
>                                   glong offset);
>glong g_utf8_pointer_to_offset (const gchar *str,
>       const gchar *pos);
>gchar* g_utf8_prev_char (const gchar *p);
>gchar* g_utf8_find_next_char (const gchar *p,
>       const gchar *end);
>gchar* g_utf8_find_prev_char (const gchar *str,
>       const gchar *p);
>
>glong g_utf8_strlen (const gchar *p,
>       gssize max);
>
>
>gchar* g_utf8_strncpy (gchar *dest,
>         const gchar *src,
>         gsize n);
>
>
>
>gchar* g_utf8_strchr (const gchar *p,
>         gssize len,
>         gunichar c);
>gchar* g_utf8_strrchr (const gchar *p,
>         gssize len,
>         gunichar c);
>gchar* g_utf8_strreverse (const gchar *str,
>     gssize len);
>
>gunichar2 *g_utf8_to_utf16 (const gchar *str,
>    glong len,
>    glong *items_read,
>    glong *items_written,
>    GError **error) __attribute__((__malloc__));
>gunichar * g_utf8_to_ucs4 (const gchar *str,
>    glong len,
>    glong *items_read,
>    glong *items_written,
>    GError **error) __attribute__((__malloc__));
>gunichar * g_utf8_to_ucs4_fast (const gchar *str,
>    glong len,
>    glong *items_written) __attribute__((__malloc__));
>gunichar * g_utf16_to_ucs4 (const gunichar2 *str,
>    glong len,
>    glong *items_read,
>    glong *items_written,
>    GError **error) __attribute__((__malloc__));
>gchar* g_utf16_to_utf8 (const gunichar2 *str,
>    glong len,
>    glong *items_read,
>    glong *items_written,
>    GError **error) __attribute__((__malloc__));
>gunichar2 *g_ucs4_to_utf16 (const gunichar *str,
>    glong len,
>    glong *items_read,
>    glong *items_written,
>    GError **error) __attribute__((__malloc__));
>gchar* g_ucs4_to_utf8 (const gunichar *str,
>    glong len,
>    glong *items_read,
>    glong *items_written,
>    GError **error) __attribute__((__malloc__));
>
>
>
>
>
>gint g_unichar_to_utf8 (gunichar c,
>        gchar *outbuf);
>
>
>
>
>
>gboolean g_utf8_validate (const gchar *str,
>                          gssize max_len,
>                          const gchar **end);
>
>
>gboolean g_unichar_validate (gunichar ch);
>
>gchar *g_utf8_strup (const gchar *str,
>         gssize len) __attribute__((__malloc__));
>gchar *g_utf8_strdown (const gchar *str,
>         gssize len) __attribute__((__malloc__));
>gchar *g_utf8_casefold (const gchar *str,
>   gssize len) __attribute__((__malloc__));
>
>typedef enum {
>  G_NORMALIZE_DEFAULT,
>  G_NORMALIZE_NFD = G_NORMALIZE_DEFAULT,
>  G_NORMALIZE_DEFAULT_COMPOSE,
>  G_NORMALIZE_NFC = G_NORMALIZE_DEFAULT_COMPOSE,
>  G_NORMALIZE_ALL,
>  G_NORMALIZE_NFKD = G_NORMALIZE_ALL,
>  G_NORMALIZE_ALL_COMPOSE,
>  G_NORMALIZE_NFKC = G_NORMALIZE_ALL_COMPOSE
>} GNormalizeMode;
>
>gchar *g_utf8_normalize (const gchar *str,
>    gssize len,
>    GNormalizeMode mode) __attribute__((__malloc__));
>
>gint g_utf8_collate (const gchar *str1,
>      const gchar *str2);
>gchar *g_utf8_collate_key (const gchar *str,
>      gssize len) __attribute__((__malloc__));
>gchar *g_utf8_collate_key_for_filename (const gchar *str,
>                   gssize len) __attribute__((__malloc__));
>
>gboolean g_unichar_get_mirror_char (gunichar ch,
>                                    gunichar *mirrored_ch);
>
>
>
>gchar *_g_utf8_make_valid (const gchar *name);
>
>
>
># 32 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gstring.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gutils.h" 1
># 31 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gutils.h"
># 1 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/stdarg.h" 1 3 4
># 44 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/stdarg.h" 3 4
>typedef __builtin_va_list __gnuc_va_list;
># 106 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/stdarg.h" 3 4
>typedef __gnuc_va_list va_list;
># 32 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gutils.h" 2
>
>
># 116 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gutils.h"
>const gchar* g_get_user_name_utf8 (void);
>const gchar* g_get_real_name_utf8 (void);
>const gchar* g_get_home_dir_utf8 (void);
>const gchar* g_get_tmp_dir_utf8 (void);
>const gchar* g_get_host_name (void);
>gchar* g_get_prgname (void);
>void g_set_prgname (const gchar *prgname);
>const gchar* g_get_application_name (void);
>void g_set_application_name (const gchar *application_name);
>
>const gchar* g_get_user_data_dir (void);
>const gchar* g_get_user_config_dir (void);
>const gchar* g_get_user_cache_dir (void);
>const gchar* const * g_get_system_data_dirs (void);
>
>
>const gchar* const * g_win32_get_system_data_dirs_for_module
>(gconstpointer address);
>
>
>
>static inline const gchar * const *
>g_win32_get_system_data_dirs (void)
>{
>  return g_win32_get_system_data_dirs_for_module ((gconstpointer)
>&g_win32_get_system_data_dirs);
>}
>
>
>
>const gchar* const * g_get_system_config_dirs (void);
>
>const gchar* const * g_get_language_names (void);
>
>typedef struct _GDebugKey GDebugKey;
>struct _GDebugKey
>{
>  gchar *key;
>  guint value;
>};
>
>
>
>guint g_parse_debug_string (const gchar *string,
>         const GDebugKey *keys,
>         guint nkeys);
>
>gint g_snprintf (gchar *string,
>         gulong n,
>         gchar const *format,
>         ...) __attribute__((__format__ (__printf__, 3, 4)));
>gint g_vsnprintf (gchar *string,
>         gulong n,
>         gchar const *format,
>         va_list args);
>
>
>gboolean g_path_is_absolute (const gchar *file_name);
>
>
>const gchar* g_path_skip_root (const gchar *file_name);
>
>
>
>
>
>
>
>const gchar* g_basename (const gchar *file_name);
># 192 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gutils.h"
>gchar* g_get_current_dir_utf8 (void);
>gchar* g_path_get_basename (const gchar *file_name) __attribute__((__malloc__));
>gchar* g_path_get_dirname (const gchar *file_name) __attribute__((__malloc__));
>
>
>void g_nullify_pointer (gpointer *nullify_location);
># 208 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gutils.h"
>const gchar* g_getenv_utf8 (const gchar *variable);
>gboolean g_setenv_utf8 (const gchar *variable,
>         const gchar *value,
>         gboolean overwrite);
>void g_unsetenv_utf8 (const gchar *variable);
>gchar** g_listenv (void);
>const gchar* _g_getenv_nomalloc (const gchar *variable,
>         gchar buffer[1024]);
>
>
>
>
>
>typedef void (*GVoidFunc) (void);
># 232 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gutils.h"
>void g_atexit (GVoidFunc func);
># 241 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gutils.h"
>int atexit (void (*)(void));
>
>
>
>
>gchar* g_find_program_in_path_utf8 (const gchar *program);
>
>
>
>extern inline gint g_bit_nth_lsf (gulong mask,
>           gint nth_bit);
>extern inline gint g_bit_nth_msf (gulong mask,
>           gint nth_bit);
>extern inline guint g_bit_storage (gulong number);
>
>
>
>
>typedef struct _GTrashStack GTrashStack;
>struct _GTrashStack
>{
>  GTrashStack *next;
>};
>
>extern inline void g_trash_stack_push (GTrashStack **stack_p,
>       gpointer data_p);
>extern inline gpointer g_trash_stack_pop (GTrashStack **stack_p);
>extern inline gpointer g_trash_stack_peek (GTrashStack **stack_p);
>extern inline guint g_trash_stack_height (GTrashStack **stack_p);
>
>
>
>
>extern inline gint
>g_bit_nth_lsf (gulong mask,
>        gint nth_bit)
>{
>  do
>    {
>      nth_bit++;
>      if (mask & (1UL << nth_bit))
> return nth_bit;
>    }
>  while (nth_bit < ((4 * 8) - 1));
>  return -1;
>}
>extern inline gint
>g_bit_nth_msf (gulong mask,
>        gint nth_bit)
>{
>  if (nth_bit < 0)
>    nth_bit = 4 * 8;
>  do
>    {
>      nth_bit--;
>      if (mask & (1UL << nth_bit))
> return nth_bit;
>    }
>  while (nth_bit > 0);
>  return -1;
>}
>extern inline guint
>g_bit_storage (gulong number)
>{
>  register guint n_bits = 0;
>
>  do
>    {
>      n_bits++;
>      number >>= 1;
>    }
>  while (number);
>  return n_bits;
>}
>extern inline void
>g_trash_stack_push (GTrashStack **stack_p,
>      gpointer data_p)
>{
>  GTrashStack *data = (GTrashStack *) data_p;
>
>  data->next = *stack_p;
>  *stack_p = data;
>}
>extern inline gpointer
>g_trash_stack_pop (GTrashStack **stack_p)
>{
>  GTrashStack *data;
>
>  data = *stack_p;
>  if (data)
>    {
>      *stack_p = data->next;
>
>
>
>      data->next = ((void *)0);
>    }
>
>  return data;
>}
>extern inline gpointer
>g_trash_stack_peek (GTrashStack **stack_p)
>{
>  GTrashStack *data;
>
>  data = *stack_p;
>
>  return data;
>}
>extern 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;
>}
>
>
>
>
>
>
>extern __attribute__((dllimport)) const guint glib_major_version;
>extern __attribute__((dllimport)) const guint glib_minor_version;
>extern __attribute__((dllimport)) const guint glib_micro_version;
>extern __attribute__((dllimport)) const guint glib_interface_age;
>extern __attribute__((dllimport)) const guint glib_binary_age;
>
>const gchar * glib_check_version (guint required_major,
>                                  guint required_minor,
>                                  guint required_micro);
>
>
>
>
>
>
>
>
># 33 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gstring.h" 2
>
>
>
>typedef struct _GString GString;
>typedef struct _GStringChunk GStringChunk;
>
>struct _GString
>{
>  gchar *str;
>  gsize len;
>  gsize allocated_len;
>};
>
>
>
>GStringChunk* g_string_chunk_new (gsize size);
>void g_string_chunk_free (GStringChunk *chunk);
>gchar* g_string_chunk_insert (GStringChunk *chunk,
>         const gchar *string);
>gchar* g_string_chunk_insert_len (GStringChunk *chunk,
>         const gchar *string,
>         gssize len);
>gchar* g_string_chunk_insert_const (GStringChunk *chunk,
>         const gchar *string);
>
>
>
>
>GString* g_string_new (const gchar *init);
>GString* g_string_new_len (const gchar *init,
>                                         gssize len);
>GString* g_string_sized_new (gsize dfl_size);
>gchar* g_string_free (GString *string,
>      gboolean free_segment);
>gboolean g_string_equal (const GString *v,
>      const GString *v2);
>guint g_string_hash (const GString *str);
>GString* g_string_assign (GString *string,
>      const gchar *rval);
>GString* g_string_truncate (GString *string,
>      gsize len);
>GString* g_string_set_size (GString *string,
>      gsize len);
>GString* g_string_insert_len (GString *string,
>                                         gssize pos,
>                                         const gchar *val,
>                                         gssize len);
>GString* g_string_append (GString *string,
>                    const gchar *val);
>GString* g_string_append_len (GString *string,
>                    const gchar *val,
>                                         gssize len);
>GString* g_string_append_c (GString *string,
>      gchar c);
>GString* g_string_append_unichar (GString *string,
>      gunichar wc);
>GString* g_string_prepend (GString *string,
>      const gchar *val);
>GString* g_string_prepend_c (GString *string,
>      gchar c);
>GString* g_string_prepend_unichar (GString *string,
>      gunichar wc);
>GString* g_string_prepend_len (GString *string,
>                    const gchar *val,
>                                         gssize len);
>GString* g_string_insert (GString *string,
>      gssize pos,
>      const gchar *val);
>GString* g_string_insert_c (GString *string,
>      gssize pos,
>      gchar c);
>GString* g_string_insert_unichar (GString *string,
>      gssize pos,
>      gunichar wc);
>GString* g_string_erase (GString *string,
>      gssize pos,
>      gssize len);
>GString* g_string_ascii_down (GString *string);
>GString* g_string_ascii_up (GString *string);
>void g_string_printf (GString *string,
>      const gchar *format,
>      ...) __attribute__((__format__ (__printf__, 2, 3)));
>void g_string_append_printf (GString *string,
>      const gchar *format,
>      ...) __attribute__((__format__ (__printf__, 2, 3)));
>
>
>
>static inline GString*
>g_string_append_c_inline (GString *gstring,
>                          gchar c)
>{
>  if (gstring->len + 1 < gstring->allocated_len)
>    {
>      gstring->str[gstring->len++] = c;
>      gstring->str[gstring->len] = 0;
>    }
>  else
>    g_string_insert_c (gstring, -1, c);
>  return gstring;
>}
># 145 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gstring.h"
>GString* g_string_down (GString *string);
>GString* g_string_up (GString *string);
>
>
>
>
>
>
>
>
># 33 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/giochannel.h" 2
>
>
>
>
>
>
>typedef struct _GIOChannel GIOChannel;
>typedef struct _GIOFuncs GIOFuncs;
>
>typedef enum
>{
>  G_IO_ERROR_NONE,
>  G_IO_ERROR_AGAIN,
>  G_IO_ERROR_INVAL,
>  G_IO_ERROR_UNKNOWN
>} GIOError;
>
>
>
>typedef enum
>{
>
>  G_IO_CHANNEL_ERROR_FBIG,
>  G_IO_CHANNEL_ERROR_INVAL,
>  G_IO_CHANNEL_ERROR_IO,
>  G_IO_CHANNEL_ERROR_ISDIR,
>  G_IO_CHANNEL_ERROR_NOSPC,
>  G_IO_CHANNEL_ERROR_NXIO,
>  G_IO_CHANNEL_ERROR_OVERFLOW,
>  G_IO_CHANNEL_ERROR_PIPE,
>
>  G_IO_CHANNEL_ERROR_FAILED
>} GIOChannelError;
>
>typedef enum
>{
>  G_IO_STATUS_ERROR,
>  G_IO_STATUS_NORMAL,
>  G_IO_STATUS_EOF,
>  G_IO_STATUS_AGAIN
>} GIOStatus;
>
>typedef enum
>{
>  G_SEEK_CUR,
>  G_SEEK_SET,
>  G_SEEK_END
>} GSeekType;
>
>typedef enum
>{
>  G_IO_IN =1,
>  G_IO_OUT =4,
>  G_IO_PRI =2,
>  G_IO_ERR =8,
>  G_IO_HUP =16,
>  G_IO_NVAL =32
>} GIOCondition;
>
>typedef enum
>{
>  G_IO_FLAG_APPEND = 1 << 0,
>  G_IO_FLAG_NONBLOCK = 1 << 1,
>  G_IO_FLAG_IS_READABLE = 1 << 2,
>  G_IO_FLAG_IS_WRITEABLE = 1 << 3,
>  G_IO_FLAG_IS_SEEKABLE = 1 << 4,
>  G_IO_FLAG_MASK = (1 << 5) - 1,
>  G_IO_FLAG_GET_MASK = G_IO_FLAG_MASK,
>  G_IO_FLAG_SET_MASK = G_IO_FLAG_APPEND | G_IO_FLAG_NONBLOCK
>} GIOFlags;
>
>struct _GIOChannel
>{
>
>  guint ref_count;
>  GIOFuncs *funcs;
>
>  gchar *encoding;
>  GIConv read_cd;
>  GIConv write_cd;
>  gchar *line_term;
>  guint line_term_len;
>
>  gsize buf_size;
>  GString *read_buf;
>  GString *encoded_read_buf;
>  GString *write_buf;
>  gchar partial_write_buf[6];
>
>
>
>  guint use_buffer : 1;
>  guint do_encode : 1;
>  guint close_on_unref : 1;
>  guint is_readable : 1;
>  guint is_writeable : 1;
>  guint is_seekable : 1;
>
>  gpointer reserved1;
>  gpointer reserved2;
>};
>
>typedef gboolean (*GIOFunc) (GIOChannel *source,
>        GIOCondition condition,
>        gpointer data);
>struct _GIOFuncs
>{
>  GIOStatus (*io_read) (GIOChannel *channel,
>             gchar *buf,
>      gsize count,
>      gsize *bytes_read,
>      GError **err);
>  GIOStatus (*io_write) (GIOChannel *channel,
>      const gchar *buf,
>      gsize count,
>      gsize *bytes_written,
>      GError **err);
>  GIOStatus (*io_seek) (GIOChannel *channel,
>      gint64 offset,
>      GSeekType type,
>      GError **err);
>  GIOStatus (*io_close) (GIOChannel *channel,
>      GError **err);
>  GSource* (*io_create_watch) (GIOChannel *channel,
>      GIOCondition condition);
>  void (*io_free) (GIOChannel *channel);
>  GIOStatus (*io_set_flags) (GIOChannel *channel,
>                                  GIOFlags flags,
>      GError **err);
>  GIOFlags (*io_get_flags) (GIOChannel *channel);
>};
>
>void g_io_channel_init (GIOChannel *channel);
>GIOChannel *g_io_channel_ref (GIOChannel *channel);
>void g_io_channel_unref (GIOChannel *channel);
>
>
>GIOError g_io_channel_read (GIOChannel *channel,
>            gchar *buf,
>            gsize count,
>            gsize *bytes_read);
>GIOError g_io_channel_write (GIOChannel *channel,
>            const gchar *buf,
>            gsize count,
>            gsize *bytes_written);
>GIOError g_io_channel_seek (GIOChannel *channel,
>            gint64 offset,
>            GSeekType type);
>void g_io_channel_close (GIOChannel *channel);
>
>
>GIOStatus g_io_channel_shutdown (GIOChannel *channel,
>     gboolean flush,
>     GError **err);
>guint g_io_add_watch_full (GIOChannel *channel,
>     gint priority,
>     GIOCondition condition,
>     GIOFunc func,
>     gpointer user_data,
>     GDestroyNotify notify);
>GSource * g_io_create_watch (GIOChannel *channel,
>     GIOCondition condition);
>guint g_io_add_watch (GIOChannel *channel,
>     GIOCondition condition,
>     GIOFunc func,
>     gpointer user_data);
>
>
>
>
>void g_io_channel_set_buffer_size (GIOChannel *channel,
>        gsize size);
>gsize g_io_channel_get_buffer_size (GIOChannel *channel);
>GIOCondition g_io_channel_get_buffer_condition (GIOChannel *channel);
>GIOStatus g_io_channel_set_flags (GIOChannel *channel,
>        GIOFlags flags,
>        GError **error);
>GIOFlags g_io_channel_get_flags (GIOChannel *channel);
>void g_io_channel_set_line_term (GIOChannel *channel,
>        const gchar *line_term,
>        gint length);
>const gchar* g_io_channel_get_line_term (GIOChannel *channel,
>        gint *length);
>void g_io_channel_set_buffered (GIOChannel *channel,
>        gboolean buffered);
>gboolean g_io_channel_get_buffered (GIOChannel *channel);
>GIOStatus g_io_channel_set_encoding (GIOChannel *channel,
>        const gchar *encoding,
>        GError **error);
>const gchar* g_io_channel_get_encoding (GIOChannel *channel);
>void g_io_channel_set_close_on_unref (GIOChannel *channel,
>        gboolean do_close);
>gboolean g_io_channel_get_close_on_unref (GIOChannel *channel);
>
>
>GIOStatus g_io_channel_flush (GIOChannel *channel,
>        GError **error);
>GIOStatus g_io_channel_read_line (GIOChannel *channel,
>        gchar **str_return,
>        gsize *length,
>        gsize *terminator_pos,
>        GError **error);
>GIOStatus g_io_channel_read_line_string (GIOChannel *channel,
>        GString *buffer,
>        gsize *terminator_pos,
>        GError **error);
>GIOStatus g_io_channel_read_to_end (GIOChannel *channel,
>        gchar **str_return,
>        gsize *length,
>        GError **error);
>GIOStatus g_io_channel_read_chars (GIOChannel *channel,
>        gchar *buf,
>        gsize count,
>        gsize *bytes_read,
>        GError **error);
>GIOStatus g_io_channel_read_unichar (GIOChannel *channel,
>        gunichar *thechar,
>        GError **error);
>GIOStatus g_io_channel_write_chars (GIOChannel *channel,
>        const gchar *buf,
>        gssize count,
>        gsize *bytes_written,
>        GError **error);
>GIOStatus g_io_channel_write_unichar (GIOChannel *channel,
>        gunichar thechar,
>        GError **error);
>GIOStatus g_io_channel_seek_position (GIOChannel *channel,
>        gint64 offset,
>        GSeekType type,
>        GError **error);
>
>
>
>
>GIOChannel* g_io_channel_new_file_utf8 (const gchar *filename,
>        const gchar *mode,
>        GError **error);
>
>
>
>GQuark g_io_channel_error_quark (void);
>GIOChannelError g_io_channel_error_from_errno (gint en);
># 294 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/giochannel.h"
>GIOChannel* g_io_channel_unix_new (int fd);
>gint g_io_channel_unix_get_fd (GIOChannel *channel);
>
>
>
>extern __attribute__((dllimport)) GSourceFuncs g_io_watch_funcs;
># 315 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/giochannel.h"
>void g_io_channel_win32_make_pollfd (GIOChannel *channel,
>         GIOCondition condition,
>         GPollFD *fd);
>
>
>
>
>gint g_io_channel_win32_poll (GPollFD *fds,
>           gint n_fds,
>           gint timeout_);
>
>
>GIOChannel *g_io_channel_win32_new_messages (guint hwnd);
># 338 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/giochannel.h"
>GIOChannel* g_io_channel_win32_new_fd (gint fd);
>
>
>gint g_io_channel_win32_get_fd (GIOChannel *channel);
>
>
>
>
>
>
>GIOChannel *g_io_channel_win32_new_socket (gint socket);
>
>
>
>
># 48 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gkeyfile.h" 1
># 28 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gkeyfile.h"
>
>
>typedef enum
>{
>  G_KEY_FILE_ERROR_UNKNOWN_ENCODING,
>  G_KEY_FILE_ERROR_PARSE,
>  G_KEY_FILE_ERROR_NOT_FOUND,
>  G_KEY_FILE_ERROR_KEY_NOT_FOUND,
>  G_KEY_FILE_ERROR_GROUP_NOT_FOUND,
>  G_KEY_FILE_ERROR_INVALID_VALUE
>} GKeyFileError;
>
>
>
>GQuark g_key_file_error_quark (void);
>
>typedef struct _GKeyFile GKeyFile;
>
>typedef enum
>{
>  G_KEY_FILE_NONE = 0,
>  G_KEY_FILE_KEEP_COMMENTS = 1 << 0,
>  G_KEY_FILE_KEEP_TRANSLATIONS = 1 << 1
>} GKeyFileFlags;
>
>GKeyFile *g_key_file_new (void);
>void g_key_file_free (GKeyFile *key_file);
>void g_key_file_set_list_separator (GKeyFile *key_file,
>          gchar separator);
>gboolean g_key_file_load_from_file (GKeyFile *key_file,
>          const gchar *file,
>          GKeyFileFlags flags,
>          GError **error);
>gboolean g_key_file_load_from_data (GKeyFile *key_file,
>          const gchar *data,
>          gsize length,
>          GKeyFileFlags flags,
>          GError **error);
>gboolean g_key_file_load_from_data_dirs (GKeyFile *key_file,
>          const gchar *file,
>          gchar **full_path,
>          GKeyFileFlags flags,
>          GError **error);
>gchar *g_key_file_to_data (GKeyFile *key_file,
>          gsize *length,
>          GError **error) __attribute__((__malloc__));
>gchar *g_key_file_get_start_group (GKeyFile *key_file)
>__attribute__((__malloc__));
>gchar **g_key_file_get_groups (GKeyFile *key_file,
>          gsize *length) __attribute__((__malloc__));
>gchar **g_key_file_get_keys (GKeyFile *key_file,
>          const gchar *group_name,
>          gsize *length,
>          GError **error) __attribute__((__malloc__));
>gboolean g_key_file_has_group (GKeyFile *key_file,
>          const gchar *group_name);
>gboolean g_key_file_has_key (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          GError **error);
>gchar *g_key_file_get_value (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          GError **error) __attribute__((__malloc__));
>void g_key_file_set_value (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          const gchar *value);
>gchar *g_key_file_get_string (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          GError **error) __attribute__((__malloc__));
>void g_key_file_set_string (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          const gchar *string);
>gchar *g_key_file_get_locale_string (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          const gchar *locale,
>          GError **error) __attribute__((__malloc__));
>void g_key_file_set_locale_string (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          const gchar *locale,
>          const gchar *string);
>gboolean g_key_file_get_boolean (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          GError **error);
>void g_key_file_set_boolean (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          gboolean value);
>gint g_key_file_get_integer (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          GError **error);
>void g_key_file_set_integer (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          gint value);
>gdouble g_key_file_get_double (GKeyFile *key_file,
>                                             const gchar *group_name,
>                                             const gchar *key,
>                                             GError **error);
>void g_key_file_set_double (GKeyFile *key_file,
>                                             const gchar *group_name,
>                                             const gchar *key,
>                                             gdouble value);
>gchar **g_key_file_get_string_list (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          gsize *length,
>          GError **error) __attribute__((__malloc__));
>void g_key_file_set_string_list (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          const gchar * const list[],
>          gsize length);
>gchar **g_key_file_get_locale_string_list (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          const gchar *locale,
>          gsize *length,
>          GError **error) __attribute__((__malloc__));
>void g_key_file_set_locale_string_list (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          const gchar *locale,
>          const gchar * const list[],
>          gsize length);
>gboolean *g_key_file_get_boolean_list (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          gsize *length,
>          GError **error) __attribute__((__malloc__));
>void g_key_file_set_boolean_list (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          gboolean list[],
>          gsize length);
>gint *g_key_file_get_integer_list (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          gsize *length,
>          GError **error) __attribute__((__malloc__));
>void g_key_file_set_double_list (GKeyFile *key_file,
>                                             const gchar *group_name,
>                                             const gchar *key,
>                                             gdouble list[],
>                                             gsize length);
>gdouble *g_key_file_get_double_list (GKeyFile *key_file,
>                                             const gchar *group_name,
>                                             const gchar *key,
>                                             gsize *length,
>                                             GError **error)
>__attribute__((__malloc__));
>void g_key_file_set_integer_list (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          gint list[],
>          gsize length);
>void g_key_file_set_comment (GKeyFile *key_file,
>                                             const gchar *group_name,
>                                             const gchar *key,
>                                             const gchar *comment,
>                                             GError **error);
>gchar *g_key_file_get_comment (GKeyFile *key_file,
>                                             const gchar *group_name,
>                                             const gchar *key,
>                                             GError **error)
>__attribute__((__malloc__));
>
>void g_key_file_remove_comment (GKeyFile *key_file,
>                                             const gchar *group_name,
>                                             const gchar *key,
>          GError **error);
>void g_key_file_remove_key (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          GError **error);
>void g_key_file_remove_group (GKeyFile *key_file,
>          const gchar *group_name,
>          GError **error);
>
>
># 49 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
>
>
>
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gmappedfile.h" 1
># 26 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gmappedfile.h"
>
>
>typedef struct _GMappedFile GMappedFile;
>
>GMappedFile *g_mapped_file_new (const gchar *filename,
>             gboolean writable,
>             GError **error) __attribute__((__malloc__));
>gsize g_mapped_file_get_length (GMappedFile *file);
>gchar *g_mapped_file_get_contents (GMappedFile *file);
>void g_mapped_file_free (GMappedFile *file);
>
>
># 53 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gmarkup.h" 1
># 28 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gmarkup.h"
>
>
>typedef enum
>{
>  G_MARKUP_ERROR_BAD_UTF8,
>  G_MARKUP_ERROR_EMPTY,
>  G_MARKUP_ERROR_PARSE,
>
>
>
>  G_MARKUP_ERROR_UNKNOWN_ELEMENT,
>  G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
>  G_MARKUP_ERROR_INVALID_CONTENT
>} GMarkupError;
>
>
>
>GQuark g_markup_error_quark (void);
>
>typedef enum
>{
>  G_MARKUP_DO_NOT_USE_THIS_UNSUPPORTED_FLAG = 1 << 0,
>  G_MARKUP_TREAT_CDATA_AS_TEXT = 1 << 1
>} GMarkupParseFlags;
>
>typedef struct _GMarkupParseContext GMarkupParseContext;
>typedef struct _GMarkupParser GMarkupParser;
>
>struct _GMarkupParser
>{
>
>  void (*start_element) (GMarkupParseContext *context,
>                          const gchar *element_name,
>                          const gchar **attribute_names,
>                          const gchar **attribute_values,
>                          gpointer user_data,
>                          GError **error);
>
>
>  void (*end_element) (GMarkupParseContext *context,
>                          const gchar *element_name,
>                          gpointer user_data,
>                          GError **error);
>
>
>
>  void (*text) (GMarkupParseContext *context,
>                          const gchar *text,
>                          gsize text_len,
>                          gpointer user_data,
>                          GError **error);
>
>
>
>
>
>
>  void (*passthrough) (GMarkupParseContext *context,
>                          const gchar *passthrough_text,
>                          gsize text_len,
>                          gpointer user_data,
>                          GError **error);
>
>
>
>
>  void (*error) (GMarkupParseContext *context,
>                          GError *error,
>                          gpointer user_data);
>};
>
>GMarkupParseContext *g_markup_parse_context_new (const GMarkupParser *parser,
>                                                   GMarkupParseFlags flags,
>                                                   gpointer user_data,
>                                                   GDestroyNotify
>user_data_dnotify);
>void g_markup_parse_context_free (GMarkupParseContext *context);
>gboolean g_markup_parse_context_parse (GMarkupParseContext *context,
>                                                   const gchar *text,
>                                                   gssize text_len,
>                                                   GError **error);
>
>gboolean g_markup_parse_context_end_parse (GMarkupParseContext *context,
>                                                       GError **error);
>const gchar *g_markup_parse_context_get_element (GMarkupParseContext *context);
>
>
>void g_markup_parse_context_get_position (GMarkupParseContext *context,
>                                                          gint *line_number,
>                                                          gint *char_number);
>
>
>gchar* g_markup_escape_text (const gchar *text,
>                             gssize length);
>
>gchar *g_markup_printf_escaped (const char *format,
>    ...) __attribute__((__format__ (__printf__, 1, 2)));
>gchar *g_markup_vprintf_escaped (const char *format,
>     va_list args);
>
>
># 54 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
>
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gmessages.h" 1
># 37 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gmessages.h"
>
># 38 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gmessages.h" 3
>
>
>
>
>
>
>gsize g_printf_string_upper_bound (const gchar* format,
>         va_list args);
># 54 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gmessages.h" 3
>typedef enum
>{
>
>  G_LOG_FLAG_RECURSION = 1 << 0,
>  G_LOG_FLAG_FATAL = 1 << 1,
>
>
>  G_LOG_LEVEL_ERROR = 1 << 2,
>  G_LOG_LEVEL_CRITICAL = 1 << 3,
>  G_LOG_LEVEL_WARNING = 1 << 4,
>  G_LOG_LEVEL_MESSAGE = 1 << 5,
>  G_LOG_LEVEL_INFO = 1 << 6,
>  G_LOG_LEVEL_DEBUG = 1 << 7,
>
>  G_LOG_LEVEL_MASK = ~(G_LOG_FLAG_RECURSION | G_LOG_FLAG_FATAL)
>} GLogLevelFlags;
>
>
>
>
>typedef void (*GLogFunc) (const gchar *log_domain,
>                                                 GLogLevelFlags log_level,
>                                                 const gchar *message,
>                                                 gpointer user_data);
>
>
>
>guint g_log_set_handler (const gchar *log_domain,
>                                         GLogLevelFlags log_levels,
>                                         GLogFunc log_func,
>                                         gpointer user_data);
>void g_log_remove_handler (const gchar *log_domain,
>                                         guint handler_id);
>void g_log_default_handler (const gchar *log_domain,
>                                         GLogLevelFlags log_level,
>                                         const gchar *message,
>                                         gpointer unused_data);
>GLogFunc g_log_set_default_handler (GLogFunc log_func,
>        gpointer user_data);
>void g_log (const gchar *log_domain,
>                                         GLogLevelFlags log_level,
>                                         const gchar *format,
>                                         ...)
>__attribute__((__format__ (__printf__, 3, 4)));
>void g_logv (const gchar *log_domain,
>                                         GLogLevelFlags log_level,
>                                         const gchar *format,
>                                         va_list args);
>GLogLevelFlags g_log_set_fatal_mask (const gchar *log_domain,
>                                         GLogLevelFlags fatal_mask);
>GLogLevelFlags g_log_set_always_fatal (GLogLevelFlags fatal_mask);
>
>
>void _g_log_fallback_handler (const gchar *log_domain,
>     GLogLevelFlags log_level,
>     const gchar *message,
>     gpointer unused_data) ;
>
>
>void g_return_if_fail_warning (const char *log_domain,
>          const char *pretty_function,
>          const char *expression);
>void g_assert_warning (const char *log_domain,
>          const char *file,
>          const int line,
>                 const char *pretty_function,
>                 const char *expression) __attribute__((__noreturn__));
># 205 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gmessages.h" 3
>typedef void (*GPrintFunc) (const gchar *string);
>void g_print (const gchar *format,
>                                         ...)
>__attribute__((__format__ (__printf__, 1, 2)));
>GPrintFunc g_set_print_handler (GPrintFunc func);
>void g_printerr (const gchar *format,
>                                         ...)
>__attribute__((__format__ (__printf__, 1, 2)));
>GPrintFunc g_set_printerr_handler (GPrintFunc func);
># 361 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gmessages.h" 3
>
># 56 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gnode.h" 1
># 32 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gnode.h"
>
>
>typedef struct _GNode GNode;
>
>
>typedef enum
>{
>  G_TRAVERSE_LEAVES = 1 << 0,
>  G_TRAVERSE_NON_LEAVES = 1 << 1,
>  G_TRAVERSE_ALL = G_TRAVERSE_LEAVES | G_TRAVERSE_NON_LEAVES,
>  G_TRAVERSE_MASK = 0x03,
>  G_TRAVERSE_LEAFS = G_TRAVERSE_LEAVES,
>  G_TRAVERSE_NON_LEAFS = G_TRAVERSE_NON_LEAVES
>} GTraverseFlags;
>
>
>typedef enum
>{
>  G_IN_ORDER,
>  G_PRE_ORDER,
>  G_POST_ORDER,
>  G_LEVEL_ORDER
>} GTraverseType;
>
>typedef gboolean (*GNodeTraverseFunc) (GNode *node,
>       gpointer data);
>typedef void (*GNodeForeachFunc) (GNode *node,
>       gpointer data);
>typedef gpointer (*GCopyFunc) (gconstpointer src,
>                                                 gpointer data);
>
>
>
>struct _GNode
>{
>  gpointer data;
>  GNode *next;
>  GNode *prev;
>  GNode *parent;
>  GNode *children;
>};
>
>
>
>
>
>
>GNode* g_node_new (gpointer data);
>void g_node_destroy (GNode *root);
>void g_node_unlink (GNode *node);
>GNode* g_node_copy_deep (GNode *node,
>     GCopyFunc copy_func,
>     gpointer data);
>GNode* g_node_copy (GNode *node);
>GNode* g_node_insert (GNode *parent,
>     gint position,
>     GNode *node);
>GNode* g_node_insert_before (GNode *parent,
>     GNode *sibling,
>     GNode *node);
>GNode* g_node_insert_after (GNode *parent,
>     GNode *sibling,
>     GNode *node);
>GNode* g_node_prepend (GNode *parent,
>     GNode *node);
>guint g_node_n_nodes (GNode *root,
>     GTraverseFlags flags);
>GNode* g_node_get_root (GNode *node);
>gboolean g_node_is_ancestor (GNode *node,
>     GNode *descendant);
>guint g_node_depth (GNode *node);
>GNode* g_node_find (GNode *root,
>     GTraverseType order,
>     GTraverseFlags flags,
>     gpointer data);
># 125 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gnode.h"
>void g_node_traverse (GNode *root,
>     GTraverseType order,
>     GTraverseFlags flags,
>     gint max_depth,
>     GNodeTraverseFunc func,
>     gpointer data);
>
>
>
>
>
>
>guint g_node_max_height (GNode *root);
>
>void g_node_children_foreach (GNode *node,
>      GTraverseFlags flags,
>      GNodeForeachFunc func,
>      gpointer data);
>void g_node_reverse_children (GNode *node);
>guint g_node_n_children (GNode *node);
>GNode* g_node_nth_child (GNode *node,
>      guint n);
>GNode* g_node_last_child (GNode *node);
>GNode* g_node_find_child (GNode *node,
>      GTraverseFlags flags,
>      gpointer data);
>gint g_node_child_position (GNode *node,
>      GNode *child);
>gint g_node_child_index (GNode *node,
>      gpointer data);
>
>GNode* g_node_first_sibling (GNode *node);
>GNode* g_node_last_sibling (GNode *node);
># 167 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gnode.h"
>void g_node_push_allocator (gpointer dummy);
>void g_node_pop_allocator (void);
>
>
># 57 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/goption.h" 1
># 27 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/goption.h"
>
>
>typedef struct _GOptionContext GOptionContext;
>typedef struct _GOptionGroup GOptionGroup;
>typedef struct _GOptionEntry GOptionEntry;
>
>typedef enum
>{
>  G_OPTION_FLAG_HIDDEN = 1 << 0,
>  G_OPTION_FLAG_IN_MAIN = 1 << 1,
>  G_OPTION_FLAG_REVERSE = 1 << 2,
>  G_OPTION_FLAG_NO_ARG = 1 << 3,
>  G_OPTION_FLAG_FILENAME = 1 << 4,
>  G_OPTION_FLAG_OPTIONAL_ARG = 1 << 5,
>  G_OPTION_FLAG_NOALIAS = 1 << 6
>} GOptionFlags;
>
>typedef enum
>{
>  G_OPTION_ARG_NONE,
>  G_OPTION_ARG_STRING,
>  G_OPTION_ARG_INT,
>  G_OPTION_ARG_CALLBACK,
>  G_OPTION_ARG_FILENAME,
>  G_OPTION_ARG_STRING_ARRAY,
>  G_OPTION_ARG_FILENAME_ARRAY,
>  G_OPTION_ARG_DOUBLE,
>  G_OPTION_ARG_INT64
>} GOptionArg;
>
>typedef gboolean (*GOptionArgFunc) (const gchar *option_name,
>        const gchar *value,
>        gpointer data,
>        GError **error);
>
>typedef gboolean (*GOptionParseFunc) (GOptionContext *context,
>          GOptionGroup *group,
>          gpointer data,
>          GError **error);
>
>typedef void (*GOptionErrorFunc) (GOptionContext *context,
>      GOptionGroup *group,
>      gpointer data,
>      GError **error);
>
>
>
>typedef enum
>{
>  G_OPTION_ERROR_UNKNOWN_OPTION,
>  G_OPTION_ERROR_BAD_VALUE,
>  G_OPTION_ERROR_FAILED
>} GOptionError;
>
>GQuark g_option_error_quark (void);
>
>
>struct _GOptionEntry
>{
>  const gchar *long_name;
>  gchar short_name;
>  gint flags;
>
>  GOptionArg arg;
>  gpointer arg_data;
>
>  const gchar *description;
>  const gchar *arg_description;
>};
>
>
>
>GOptionContext *g_option_context_new (const gchar *parameter_string);
>void g_option_context_set_summary (GOptionContext *context,
>                                                   const gchar *summary);
>const gchar *g_option_context_get_summary (GOptionContext *context);
>void g_option_context_set_description (GOptionContext *context,
>                                                   const gchar *description);
>const gchar *g_option_context_get_description (GOptionContext *context);
>void g_option_context_free (GOptionContext *context);
>void g_option_context_set_help_enabled (GOptionContext *context,
>         gboolean help_enabled);
>gboolean g_option_context_get_help_enabled (GOptionContext *context);
>void g_option_context_set_ignore_unknown_options (GOptionContext *context,
>            gboolean ignore_unknown);
>gboolean g_option_context_get_ignore_unknown_options (GOptionContext *context);
>
>void g_option_context_add_main_entries (GOptionContext *context,
>         const GOptionEntry *entries,
>         const gchar *translation_domain);
>gboolean g_option_context_parse (GOptionContext *context,
>         gint *argc,
>         gchar ***argv,
>         GError **error);
>void g_option_context_set_translate_func (GOptionContext *context,
>           GTranslateFunc func,
>           gpointer data,
>           GDestroyNotify destroy_notify);
>void g_option_context_set_translation_domain (GOptionContext *context,
>        const gchar *domain);
>
>void g_option_context_add_group (GOptionContext *context,
>       GOptionGroup *group);
>void g_option_context_set_main_group (GOptionContext *context,
>            GOptionGroup *group);
>GOptionGroup *g_option_context_get_main_group (GOptionContext *context);
>
>
>GOptionGroup *g_option_group_new (const gchar *name,
>           const gchar *description,
>           const gchar *help_description,
>           gpointer user_data,
>           GDestroyNotify destroy);
>void g_option_group_set_parse_hooks (GOptionGroup *group,
>           GOptionParseFunc pre_parse_func,
>           GOptionParseFunc post_parse_func);
>void g_option_group_set_error_hook (GOptionGroup *group,
>           GOptionErrorFunc error_func);
>void g_option_group_free (GOptionGroup *group);
>void g_option_group_add_entries (GOptionGroup *group,
>           const GOptionEntry *entries);
>void g_option_group_set_translate_func (GOptionGroup *group,
>           GTranslateFunc func,
>           gpointer data,
>           GDestroyNotify destroy_notify);
>void g_option_group_set_translation_domain (GOptionGroup *group,
>           const gchar *domain);
>
>
>
># 58 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gpattern.h" 1
># 24 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gpattern.h"
>
>
>
>typedef struct _GPatternSpec GPatternSpec;
>
>GPatternSpec* g_pattern_spec_new (const gchar *pattern);
>void g_pattern_spec_free (GPatternSpec *pspec);
>gboolean g_pattern_spec_equal (GPatternSpec *pspec1,
>     GPatternSpec *pspec2);
>gboolean g_pattern_match (GPatternSpec *pspec,
>     guint string_length,
>     const gchar *string,
>     const gchar *string_reversed);
>gboolean g_pattern_match_string (GPatternSpec *pspec,
>     const gchar *string);
>gboolean g_pattern_match_simple (const gchar *pattern,
>     const gchar *string);
>
>
># 59 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gprimes.h" 1
># 32 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gprimes.h"
>
># 43 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gprimes.h"
>guint g_spaced_primes_closest (guint num) __attribute__((__const__));
>
>
># 60 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gqsort.h" 1
># 33 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gqsort.h"
>
>
>void g_qsort_with_data (gconstpointer pbase,
>   gint total_elems,
>   gsize size,
>   GCompareDataFunc compare_func,
>   gpointer user_data);
>
>
># 61 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
>
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gqueue.h" 1
># 32 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gqueue.h"
>
>
>typedef struct _GQueue GQueue;
>
>struct _GQueue
>{
>  GList *head;
>  GList *tail;
>  guint length;
>};
>
>
>
>GQueue* g_queue_new (void);
>void g_queue_free (GQueue *queue);
>gboolean g_queue_is_empty (GQueue *queue);
>guint g_queue_get_length (GQueue *queue);
>void g_queue_reverse (GQueue *queue);
>GQueue * g_queue_copy (GQueue *queue);
>void g_queue_foreach (GQueue *queue,
>     GFunc func,
>     gpointer user_data);
>GList * g_queue_find (GQueue *queue,
>     gconstpointer data);
>GList * g_queue_find_custom (GQueue *queue,
>     gconstpointer data,
>     GCompareFunc func);
>void g_queue_sort (GQueue *queue,
>     GCompareDataFunc compare_func,
>     gpointer user_data);
>
>void g_queue_push_head (GQueue *queue,
>     gpointer data);
>void g_queue_push_tail (GQueue *queue,
>     gpointer data);
>void g_queue_push_nth (GQueue *queue,
>     gpointer data,
>     gint n);
>gpointer g_queue_pop_head (GQueue *queue);
>gpointer g_queue_pop_tail (GQueue *queue);
>gpointer g_queue_pop_nth (GQueue *queue,
>     guint n);
>gpointer g_queue_peek_head (GQueue *queue);
>gpointer g_queue_peek_tail (GQueue *queue);
>gpointer g_queue_peek_nth (GQueue *queue,
>     guint n);
>gint g_queue_index (GQueue *queue,
>     gconstpointer data);
>void g_queue_remove (GQueue *queue,
>     gconstpointer data);
>void g_queue_remove_all (GQueue *queue,
>     gconstpointer data);
>void g_queue_insert_before (GQueue *queue,
>     GList *sibling,
>     gpointer data);
>void g_queue_insert_after (GQueue *queue,
>     GList *sibling,
>     gpointer data);
>void g_queue_insert_sorted (GQueue *queue,
>     gpointer data,
>     GCompareDataFunc func,
>     gpointer user_data);
>
>void g_queue_push_head_link (GQueue *queue,
>     GList *link_);
>void g_queue_push_tail_link (GQueue *queue,
>     GList *link_);
>void g_queue_push_nth_link (GQueue *queue,
>     gint n,
>     GList *link_);
>GList* g_queue_pop_head_link (GQueue *queue);
>GList* g_queue_pop_tail_link (GQueue *queue);
>GList* g_queue_pop_nth_link (GQueue *queue,
>     guint n);
>GList* g_queue_peek_head_link (GQueue *queue);
>GList* g_queue_peek_tail_link (GQueue *queue);
>GList* g_queue_peek_nth_link (GQueue *queue,
>     guint n);
>gint g_queue_link_index (GQueue *queue,
>     GList *link_);
>void g_queue_unlink (GQueue *queue,
>     GList *link_);
>void g_queue_delete_link (GQueue *queue,
>     GList *link_);
>
>
># 63 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/grand.h" 1
># 32 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/grand.h"
>
>
>typedef struct _GRand GRand;
># 45 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/grand.h"
>GRand* g_rand_new_with_seed (guint32 seed);
>GRand* g_rand_new_with_seed_array (const guint32 *seed,
>        guint seed_length);
>GRand* g_rand_new (void);
>void g_rand_free (GRand *rand_);
>GRand* g_rand_copy (GRand *rand_);
>void g_rand_set_seed (GRand *rand_,
>          guint32 seed);
>void g_rand_set_seed_array (GRand *rand_,
>          const guint32 *seed,
>          guint seed_length);
>
>
>
>guint32 g_rand_int (GRand *rand_);
>gint32 g_rand_int_range (GRand *rand_,
>          gint32 begin,
>          gint32 end);
>gdouble g_rand_double (GRand *rand_);
>gdouble g_rand_double_range (GRand *rand_,
>          gdouble begin,
>          gdouble end);
>void g_random_set_seed (guint32 seed);
>
>
>
>guint32 g_random_int (void);
>gint32 g_random_int_range (gint32 begin,
>          gint32 end);
>gdouble g_random_double (void);
>gdouble g_random_double_range (gdouble begin,
>          gdouble end);
>
>
>
># 64 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/grel.h" 1
># 32 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/grel.h"
>
>
>typedef struct _GRelation GRelation;
>typedef struct _GTuples GTuples;
>
>struct _GTuples
>{
>  guint len;
>};
># 65 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/grel.h"
>GRelation* g_relation_new (gint fields);
>void g_relation_destroy (GRelation *relation);
>void g_relation_index (GRelation *relation,
>                               gint field,
>                               GHashFunc hash_func,
>                               GEqualFunc key_equal_func);
>void g_relation_insert (GRelation *relation,
>                               ...);
>gint g_relation_delete (GRelation *relation,
>                               gconstpointer key,
>                               gint field);
>GTuples* g_relation_select (GRelation *relation,
>                               gconstpointer key,
>                               gint field);
>gint g_relation_count (GRelation *relation,
>                               gconstpointer key,
>                               gint field);
>gboolean g_relation_exists (GRelation *relation,
>                               ...);
>void g_relation_print (GRelation *relation);
>
>void g_tuples_destroy (GTuples *tuples);
>gpointer g_tuples_index (GTuples *tuples,
>                               gint index_,
>                               gint field);
>
>
># 65 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gscanner.h" 1
># 33 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gscanner.h"
>
>
>typedef struct _GScanner GScanner;
>typedef struct _GScannerConfig GScannerConfig;
>typedef union _GTokenValue GTokenValue;
>
>typedef void (*GScannerMsgFunc) (GScanner *scanner,
>       gchar *message,
>       gboolean error);
># 60 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gscanner.h"
>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;
>  guint64 v_int64;
>  gdouble v_float;
>  gulong v_hex;
>  gchar *v_string;
>  gchar *v_comment;
>  guchar v_char;
>  guint v_error;
>};
>
>struct _GScannerConfig
>{
>
>
>  gchar *cset_skip_characters;
>  gchar *cset_identifier_first;
>  gchar *cset_identifier_nth;
>  gchar *cpair_comment_single;
>
>
>
>  guint case_sensitive : 1;
>
>
>
>
>  guint skip_comment_multi : 1;
>  guint skip_comment_single : 1;
>  guint scan_comment_multi : 1;
>  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;
>  guint scan_hex_dollar : 1;
>  guint scan_string_sq : 1;
>  guint scan_string_dq : 1;
>  guint numbers_2_int : 1;
>  guint int_2_float : 1;
>  guint identifier_2_string : 1;
>  guint char_2_token : 1;
>  guint symbol_2_token : 1;
>  guint scope_0_fallback : 1;
>  guint store_int64 : 1;
>  guint padding_dummy;
>};
>
>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;
>};
>
>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,
>       ...) __attribute__((__format__ (__printf__, 2, 3)));
>void g_scanner_warn (GScanner *scanner,
>       const gchar *format,
>       ...) __attribute__((__format__ (__printf__, 2, 3)));
># 272 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gscanner.h"
>
># 66 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gshell.h" 1
># 26 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gshell.h"
>
>
>
>
>typedef enum
>{
>
>  G_SHELL_ERROR_BAD_QUOTING,
>
>  G_SHELL_ERROR_EMPTY_STRING,
>  G_SHELL_ERROR_FAILED
>} GShellError;
>
>GQuark g_shell_error_quark (void);
>
>gchar* g_shell_quote (const gchar *unquoted_string);
>gchar* g_shell_unquote (const gchar *quoted_string,
>                             GError **error);
>gboolean g_shell_parse_argv (const gchar *command_line,
>                             gint *argcp,
>                             gchar ***argvp,
>                             GError **error);
>
>
># 67 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
>
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gspawn.h" 1
># 26 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gspawn.h"
>
>
>
>
>
>typedef enum
>{
>  G_SPAWN_ERROR_FORK,
>  G_SPAWN_ERROR_READ,
>  G_SPAWN_ERROR_CHDIR,
>  G_SPAWN_ERROR_ACCES,
>  G_SPAWN_ERROR_PERM,
>  G_SPAWN_ERROR_2BIG,
>  G_SPAWN_ERROR_NOEXEC,
>  G_SPAWN_ERROR_NAMETOOLONG,
>  G_SPAWN_ERROR_NOENT,
>  G_SPAWN_ERROR_NOMEM,
>  G_SPAWN_ERROR_NOTDIR,
>  G_SPAWN_ERROR_LOOP,
>  G_SPAWN_ERROR_TXTBUSY,
>  G_SPAWN_ERROR_IO,
>  G_SPAWN_ERROR_NFILE,
>  G_SPAWN_ERROR_MFILE,
>  G_SPAWN_ERROR_INVAL,
>  G_SPAWN_ERROR_ISDIR,
>  G_SPAWN_ERROR_LIBBAD,
>  G_SPAWN_ERROR_FAILED
>
>
>} GSpawnError;
>
>typedef void (* GSpawnChildSetupFunc) (gpointer user_data);
>
>typedef enum
>{
>  G_SPAWN_LEAVE_DESCRIPTORS_OPEN = 1 << 0,
>  G_SPAWN_DO_NOT_REAP_CHILD = 1 << 1,
>
>  G_SPAWN_SEARCH_PATH = 1 << 2,
>
>  G_SPAWN_STDOUT_TO_DEV_NULL = 1 << 3,
>  G_SPAWN_STDERR_TO_DEV_NULL = 1 << 4,
>  G_SPAWN_CHILD_INHERITS_STDIN = 1 << 5,
>  G_SPAWN_FILE_AND_ARGV_ZERO = 1 << 6
>} GSpawnFlags;
>
>GQuark g_spawn_error_quark (void);
># 82 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gspawn.h"
>gboolean g_spawn_async_utf8 (const gchar *working_directory,
>                        gchar **argv,
>                        gchar **envp,
>                        GSpawnFlags flags,
>                        GSpawnChildSetupFunc child_setup,
>                        gpointer user_data,
>                        GPid *child_pid,
>                        GError **error);
>
>
>
>
>
>gboolean g_spawn_async_with_pipes_utf8 (const gchar *working_directory,
>                                   gchar **argv,
>                                   gchar **envp,
>                                   GSpawnFlags flags,
>                                   GSpawnChildSetupFunc child_setup,
>                                   gpointer user_data,
>                                   GPid *child_pid,
>                                   gint *standard_input,
>                                   gint *standard_output,
>                                   gint *standard_error,
>                                   GError **error);
>
>
>
>
>
>
>gboolean g_spawn_sync_utf8 (const gchar *working_directory,
>                               gchar **argv,
>                               gchar **envp,
>                               GSpawnFlags flags,
>                               GSpawnChildSetupFunc child_setup,
>                               gpointer user_data,
>                               gchar **standard_output,
>                               gchar **standard_error,
>                               gint *exit_status,
>                               GError **error);
>
>gboolean g_spawn_command_line_sync_utf8 (const gchar *command_line,
>                                     gchar **standard_output,
>                                     gchar **standard_error,
>                                     gint *exit_status,
>                                     GError **error);
>gboolean g_spawn_command_line_async_utf8 (const gchar *command_line,
>                                     GError **error);
>
>void g_spawn_close_pid (GPid pid);
>
>
>
># 69 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gstrfuncs.h" 1
># 33 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gstrfuncs.h"
>
>
>
>typedef enum {
>  G_ASCII_ALNUM = 1 << 0,
>  G_ASCII_ALPHA = 1 << 1,
>  G_ASCII_CNTRL = 1 << 2,
>  G_ASCII_DIGIT = 1 << 3,
>  G_ASCII_GRAPH = 1 << 4,
>  G_ASCII_LOWER = 1 << 5,
>  G_ASCII_PRINT = 1 << 6,
>  G_ASCII_PUNCT = 1 << 7,
>  G_ASCII_SPACE = 1 << 8,
>  G_ASCII_UPPER = 1 << 9,
>  G_ASCII_XDIGIT = 1 << 10
>} GAsciiType;
>
>extern __attribute__((dllimport)) const guint16 * const g_ascii_table;
># 85 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gstrfuncs.h"
>gchar g_ascii_tolower (gchar c) __attribute__((__const__));
>gchar g_ascii_toupper (gchar c) __attribute__((__const__));
>
>gint g_ascii_digit_value (gchar c) __attribute__((__const__));
>gint g_ascii_xdigit_value (gchar c) __attribute__((__const__));
>
>
>
>
>
>gchar* g_strdelimit (gchar *string,
>     const gchar *delimiters,
>     gchar new_delimiter);
>gchar* g_strcanon (gchar *string,
>     const gchar *valid_chars,
>     gchar substitutor);
>const gchar* g_strerror (gint errnum) __attribute__((__const__));
>const gchar* g_strsignal (gint signum) __attribute__((__const__));
>gchar* g_strreverse (gchar *string);
>gsize g_strlcpy (gchar *dest,
>     const gchar *src,
>     gsize dest_size);
>gsize g_strlcat (gchar *dest,
>     const gchar *src,
>     gsize dest_size);
>gchar * g_strstr_len (const gchar *haystack,
>     gssize haystack_len,
>     const gchar *needle);
>gchar * g_strrstr (const gchar *haystack,
>     const gchar *needle);
>gchar * g_strrstr_len (const gchar *haystack,
>     gssize haystack_len,
>     const gchar *needle);
>
>gboolean g_str_has_suffix (const gchar *str,
>     const gchar *suffix);
>gboolean g_str_has_prefix (const gchar *str,
>     const gchar *prefix);
>
>
>
>gdouble g_strtod (const gchar *nptr,
>     gchar **endptr);
>gdouble g_ascii_strtod (const gchar *nptr,
>     gchar **endptr);
>guint64 g_ascii_strtoull (const gchar *nptr,
>     gchar **endptr,
>     guint base);
>gint64 g_ascii_strtoll (const gchar *nptr,
>     gchar **endptr,
>     guint base);
>
>
>
>
>gchar * g_ascii_dtostr (gchar *buffer,
>     gint buf_len,
>     gdouble d);
>gchar * g_ascii_formatd (gchar *buffer,
>     gint buf_len,
>     const gchar *format,
>     gdouble d);
>
>
>gchar* g_strchug (gchar *string);
>
>gchar* g_strchomp (gchar *string);
>
>
>
>gint g_ascii_strcasecmp (const gchar *s1,
>        const gchar *s2);
>gint g_ascii_strncasecmp (const gchar *s1,
>        const gchar *s2,
>        gsize n);
>gchar* g_ascii_strdown (const gchar *str,
>        gssize len) __attribute__((__malloc__));
>gchar* g_ascii_strup (const gchar *str,
>        gssize len) __attribute__((__malloc__));
># 172 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gstrfuncs.h"
>gint g_strcasecmp (const gchar *s1,
>     const gchar *s2);
>gint g_strncasecmp (const gchar *s1,
>     const gchar *s2,
>     guint n);
>gchar* g_strdown (gchar *string);
>gchar* g_strup (gchar *string);
>
>
>
>
>
>
>gchar* g_strdup (const gchar *str) __attribute__((__malloc__));
>gchar* g_strdup_printf (const gchar *format,
>     ...) __attribute__((__format__ (__printf__, 1, 2)))
>__attribute__((__malloc__));
>gchar* g_strdup_vprintf (const gchar *format,
>     va_list args) __attribute__((__malloc__));
>gchar* g_strndup (const gchar *str,
>     gsize n) __attribute__((__malloc__));
>gchar* g_strnfill (gsize length,
>     gchar fill_char) __attribute__((__malloc__));
>gchar* g_strconcat (const gchar *string1,
>     ...) __attribute__((__malloc__)) ;
>gchar* g_strjoin (const gchar *separator,
>     ...) __attribute__((__malloc__)) ;
>
>
>
>
>
>gchar* g_strcompress (const gchar *source) __attribute__((__malloc__));
># 213 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gstrfuncs.h"
>gchar* g_strescape (const gchar *source,
>     const gchar *exceptions) __attribute__((__malloc__));
>
>gpointer g_memdup (gconstpointer mem,
>     guint byte_size) __attribute__((__malloc__));
># 228 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gstrfuncs.h"
>gchar** g_strsplit (const gchar *string,
>     const gchar *delimiter,
>     gint max_tokens) __attribute__((__malloc__));
>gchar ** g_strsplit_set (const gchar *string,
>     const gchar *delimiters,
>     gint max_tokens) __attribute__((__malloc__));
>gchar* g_strjoinv (const gchar *separator,
>     gchar **str_array) __attribute__((__malloc__));
>void g_strfreev (gchar **str_array);
>gchar** g_strdupv (gchar **str_array) __attribute__((__malloc__));
>guint g_strv_length (gchar **str_array);
>
>gchar* g_stpcpy (gchar *dest,
>                                        const char *src);
>
>const gchar *g_strip_context (const gchar *msgid,
>     const gchar *msgval);
>
>
># 70 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
>
>
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gthreadpool.h" 1
># 32 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gthreadpool.h"
>
>
>typedef struct _GThreadPool GThreadPool;
>
>
>
>
>
>
>struct _GThreadPool
>{
>  GFunc func;
>  gpointer user_data;
>  gboolean exclusive;
>};
>
>
>
>
>
>
>GThreadPool* g_thread_pool_new (GFunc func,
>                                               gpointer user_data,
>                                               gint max_threads,
>                                               gboolean exclusive,
>                                               GError **error);
>
>
>
>
>
>void g_thread_pool_push (GThreadPool *pool,
>                                               gpointer data,
>                                               GError **error);
>
>
>
>
>void g_thread_pool_set_max_threads (GThreadPool *pool,
>                                               gint max_threads,
>                                               GError **error);
>gint g_thread_pool_get_max_threads (GThreadPool *pool);
>
>
>
>guint g_thread_pool_get_num_threads (GThreadPool *pool);
>
>
>guint g_thread_pool_unprocessed (GThreadPool *pool);
>
>
>
>
>
>void g_thread_pool_free (GThreadPool *pool,
>                                               gboolean immediate,
>                                               gboolean wait);
>
>
>
>void g_thread_pool_set_max_unused_threads (gint max_threads);
>gint g_thread_pool_get_max_unused_threads (void);
>guint g_thread_pool_get_num_unused_threads (void);
>
>
>void g_thread_pool_stop_unused_threads (void);
>
>
>void g_thread_pool_set_sort_function (GThreadPool *pool,
>                                        GCompareDataFunc func,
>            gpointer user_data);
>
>
>void g_thread_pool_set_max_idle_time (guint interval);
>guint g_thread_pool_get_max_idle_time (void);
>
>
># 73 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gtimer.h" 1
># 32 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gtimer.h"
>
>
>
>
>
>
>typedef struct _GTimer GTimer;
>
>
>
>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);
>void g_timer_continue (GTimer *timer);
>gdouble g_timer_elapsed (GTimer *timer,
>      gulong *microseconds);
>
>void g_usleep (gulong microseconds);
>
>void g_time_val_add (GTimeVal *time_,
>                                  glong microseconds);
>gboolean g_time_val_from_iso8601 (const gchar *iso_date,
>      GTimeVal *time_);
>gchar* g_time_val_to_iso8601 (GTimeVal *time_) __attribute__((__malloc__));
>
>
># 74 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gtree.h" 1
># 32 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gtree.h"
>
>
>typedef struct _GTree GTree;
>
>typedef gboolean (*GTraverseFunc) (gpointer key,
>                                   gpointer value,
>                                   gpointer data);
>
>
>
>GTree* g_tree_new (GCompareFunc key_compare_func);
>GTree* g_tree_new_with_data (GCompareDataFunc key_compare_func,
>                                 gpointer key_compare_data);
>GTree* g_tree_new_full (GCompareDataFunc key_compare_func,
>                                 gpointer key_compare_data,
>                                 GDestroyNotify key_destroy_func,
>                                 GDestroyNotify value_destroy_func);
>void g_tree_destroy (GTree *tree);
>void g_tree_insert (GTree *tree,
>                                 gpointer key,
>                                 gpointer value);
>void g_tree_replace (GTree *tree,
>                                 gpointer key,
>                                 gpointer value);
>gboolean g_tree_remove (GTree *tree,
>                                 gconstpointer key);
>gboolean g_tree_steal (GTree *tree,
>                                 gconstpointer key);
>gpointer g_tree_lookup (GTree *tree,
>                                 gconstpointer key);
>gboolean g_tree_lookup_extended (GTree *tree,
>                                 gconstpointer lookup_key,
>                                 gpointer *orig_key,
>                                 gpointer *value);
>void g_tree_foreach (GTree *tree,
>                                 GTraverseFunc func,
>                                 gpointer user_data);
>
>
>void g_tree_traverse (GTree *tree,
>                                 GTraverseFunc traverse_func,
>                                 GTraverseType traverse_type,
>                                 gpointer user_data);
>
>
>gpointer g_tree_search (GTree *tree,
>                                 GCompareFunc search_func,
>                                 gconstpointer user_data);
>gint g_tree_height (GTree *tree);
>gint g_tree_nnodes (GTree *tree);
>
>
>
>
># 75 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
>
>
>
>
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gwin32.h" 1
># 34 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gwin32.h"
>
># 64 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gwin32.h"
>gint g_win32_ftruncate (gint f,
>      guint size);
># 74 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gwin32.h"
>gchar* g_win32_getlocale (void);
>
>
>
>
>
>gchar* g_win32_error_message (gint error);
>
>
>
>
>gchar* g_win32_get_package_installation_directory_utf8 (gchar *package,
>           gchar *dll_name);
>
>gchar* g_win32_get_package_installation_subdirectory_utf8 (gchar *package,
>              gchar *dll_name,
>              gchar *subdir);
>
>guint g_win32_get_windows_version (void);
>
>gchar* g_win32_locale_filename_from_utf8 (const gchar *utf8filename);
>
>
>
>
>
># 80 "C:/mono/Mono-1.2.4/include/glib-2.0/glib.h" 2
># 27 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gtype.h" 2
>
>
># 92 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gtype.h"
>typedef gulong GType;
>
>
>
>typedef struct _GValue GValue;
>typedef union _GTypeCValue GTypeCValue;
>typedef struct _GTypePlugin GTypePlugin;
>typedef struct _GTypeClass GTypeClass;
>typedef struct _GTypeInterface GTypeInterface;
>typedef struct _GTypeInstance GTypeInstance;
>typedef struct _GTypeInfo GTypeInfo;
>typedef struct _GTypeFundamentalInfo GTypeFundamentalInfo;
>typedef struct _GInterfaceInfo GInterfaceInfo;
>typedef struct _GTypeValueTable GTypeValueTable;
>typedef struct _GTypeQuery GTypeQuery;
>
>
>
>
>struct _GTypeClass
>{
>
>  GType g_type;
>};
>struct _GTypeInstance
>{
>
>  GTypeClass *g_class;
>};
>struct _GTypeInterface
>{
>
>  GType g_type;
>  GType g_instance_type;
>};
>struct _GTypeQuery
>{
>  GType type;
>  const gchar *type_name;
>  guint class_size;
>  guint instance_size;
>};
># 157 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gtype.h"
>typedef enum
>{
>  G_TYPE_DEBUG_NONE = 0,
>  G_TYPE_DEBUG_OBJECTS = 1 << 0,
>  G_TYPE_DEBUG_SIGNALS = 1 << 1,
>  G_TYPE_DEBUG_MASK = 0x03
>} GTypeDebugFlags;
>
>
>
>void g_type_init (void);
>void g_type_init_with_debug_flags (GTypeDebugFlags debug_flags);
>const gchar* g_type_name (GType type);
>GQuark g_type_qname (GType type);
>GType g_type_from_name (const gchar *name);
>GType g_type_parent (GType type);
>guint g_type_depth (GType type);
>GType g_type_next_base (GType leaf_type,
>            GType root_type);
>gboolean g_type_is_a (GType type,
>            GType is_a_type);
>gpointer g_type_class_ref (GType type);
>gpointer g_type_class_peek (GType type);
>gpointer g_type_class_peek_static (GType type);
>void g_type_class_unref (gpointer g_class);
>gpointer g_type_class_peek_parent (gpointer g_class);
>gpointer g_type_interface_peek (gpointer instance_class,
>            GType iface_type);
>gpointer g_type_interface_peek_parent (gpointer g_iface);
>
>gpointer g_type_default_interface_ref (GType g_type);
>gpointer g_type_default_interface_peek (GType g_type);
>void g_type_default_interface_unref (gpointer g_iface);
>
>
>GType* g_type_children (GType type,
>            guint *n_children);
>GType* g_type_interfaces (GType type,
>            guint *n_interfaces);
>
>
>void g_type_set_qdata (GType type,
>            GQuark quark,
>            gpointer data);
>gpointer g_type_get_qdata (GType type,
>            GQuark quark);
>void g_type_query (GType type,
>            GTypeQuery *query);
>
>
>
>typedef void (*GBaseInitFunc) (gpointer g_class);
>typedef void (*GBaseFinalizeFunc) (gpointer g_class);
>typedef void (*GClassInitFunc) (gpointer g_class,
>           gpointer class_data);
>typedef void (*GClassFinalizeFunc) (gpointer g_class,
>           gpointer class_data);
>typedef void (*GInstanceInitFunc) (GTypeInstance *instance,
>           gpointer g_class);
>typedef void (*GInterfaceInitFunc) (gpointer g_iface,
>           gpointer iface_data);
>typedef void (*GInterfaceFinalizeFunc) (gpointer g_iface,
>           gpointer iface_data);
>typedef gboolean (*GTypeClassCacheFunc) (gpointer cache_data,
>           GTypeClass *g_class);
>typedef void (*GTypeInterfaceCheckFunc) (gpointer check_data,
>           gpointer g_iface);
>typedef enum
>{
>  G_TYPE_FLAG_CLASSED = (1 << 0),
>  G_TYPE_FLAG_INSTANTIATABLE = (1 << 1),
>  G_TYPE_FLAG_DERIVABLE = (1 << 2),
>  G_TYPE_FLAG_DEEP_DERIVABLE = (1 << 3)
>} GTypeFundamentalFlags;
>typedef enum
>{
>  G_TYPE_FLAG_ABSTRACT = (1 << 4),
>  G_TYPE_FLAG_VALUE_ABSTRACT = (1 << 5)
>} GTypeFlags;
>struct _GTypeInfo
>{
>
>  guint16 class_size;
>
>  GBaseInitFunc base_init;
>  GBaseFinalizeFunc base_finalize;
>
>
>  GClassInitFunc class_init;
>  GClassFinalizeFunc class_finalize;
>  gconstpointer class_data;
>
>
>  guint16 instance_size;
>  guint16 n_preallocs;
>  GInstanceInitFunc instance_init;
>
>
>  const GTypeValueTable *value_table;
>};
>struct _GTypeFundamentalInfo
>{
>  GTypeFundamentalFlags type_flags;
>};
>struct _GInterfaceInfo
>{
>  GInterfaceInitFunc interface_init;
>  GInterfaceFinalizeFunc interface_finalize;
>  gpointer interface_data;
>};
>struct _GTypeValueTable
>{
>  void (*value_init) (GValue *value);
>  void (*value_free) (GValue *value);
>  void (*value_copy) (const GValue *src_value,
>      GValue *dest_value);
>
>  gpointer (*value_peek_pointer) (const GValue *value);
>  gchar *collect_format;
>  gchar* (*collect_value) (GValue *value,
>      guint n_collect_values,
>      GTypeCValue *collect_values,
>      guint collect_flags);
>  gchar *lcopy_format;
>  gchar* (*lcopy_value) (const GValue *value,
>      guint n_collect_values,
>      GTypeCValue *collect_values,
>      guint collect_flags);
>};
>GType g_type_register_static (GType parent_type,
>      const gchar *type_name,
>      const GTypeInfo *info,
>      GTypeFlags flags);
>GType g_type_register_static_simple (GType parent_type,
>      const gchar *type_name,
>      guint class_size,
>      GClassInitFunc class_init,
>      guint instance_size,
>      GInstanceInitFunc instance_init,
>      GTypeFlags flags);
>
>GType g_type_register_dynamic (GType parent_type,
>      const gchar *type_name,
>      GTypePlugin *plugin,
>      GTypeFlags flags);
>GType g_type_register_fundamental (GType type_id,
>      const gchar *type_name,
>      const GTypeInfo *info,
>      const GTypeFundamentalInfo *finfo,
>      GTypeFlags flags);
>void g_type_add_interface_static (GType instance_type,
>      GType interface_type,
>      const GInterfaceInfo *info);
>void g_type_add_interface_dynamic (GType instance_type,
>      GType interface_type,
>      GTypePlugin *plugin);
>void g_type_interface_add_prerequisite (GType interface_type,
>      GType prerequisite_type);
>GType*g_type_interface_prerequisites (GType interface_type,
>      guint *n_prerequisites);
>void g_type_class_add_private (gpointer g_class,
>                                         gsize private_size);
>gpointer g_type_instance_get_private (GTypeInstance *instance,
>                                         GType private_type);
># 392 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gtype.h"
>GTypePlugin* g_type_get_plugin (GType type);
>GTypePlugin* g_type_interface_get_plugin (GType instance_type,
>       GType interface_type);
>GType g_type_fundamental_next (void);
>GType g_type_fundamental (GType type_id);
>GTypeInstance* g_type_create_instance (GType type);
>void g_type_free_instance (GTypeInstance *instance);
>
>void g_type_add_class_cache_func (gpointer cache_data,
>       GTypeClassCacheFunc cache_func);
>void g_type_remove_class_cache_func (gpointer cache_data,
>       GTypeClassCacheFunc cache_func);
>void g_type_class_unref_uncached (gpointer g_class);
>
>void g_type_add_interface_check (gpointer check_data,
>       GTypeInterfaceCheckFunc check_func);
>void g_type_remove_interface_check (gpointer check_data,
>       GTypeInterfaceCheckFunc check_func);
>
>GTypeValueTable* g_type_value_table_peek (GType type);
>
>
>
>gboolean g_type_check_instance (GTypeInstance *instance);
>GTypeInstance* g_type_check_instance_cast (GTypeInstance *instance,
>       GType iface_type);
>gboolean g_type_check_instance_is_a (GTypeInstance *instance,
>       GType iface_type);
>GTypeClass* g_type_check_class_cast (GTypeClass *g_class,
>       GType is_a_type);
>gboolean g_type_check_class_is_a (GTypeClass *g_class,
>       GType is_a_type);
>gboolean g_type_check_is_value_type (GType type);
>gboolean g_type_check_value (GValue *value);
>gboolean g_type_check_value_holds (GValue *value,
>       GType type);
>gboolean g_type_test_flags (GType type,
>       guint flags);
>
>
>
>const gchar* g_type_name_from_instance (GTypeInstance *instance);
>const gchar* g_type_name_from_class (GTypeClass *g_class);
>
>
>
>void g_value_c_init (void) ;
>void g_value_types_init (void) ;
>void g_enum_types_init (void) ;
>void g_param_type_init (void) ;
>void g_boxed_type_init (void) ;
>void g_object_type_init (void) ;
>void g_param_spec_types_init (void) ;
>void g_value_transforms_init (void) ;
>void g_signal_init (void) ;
># 494 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gtype.h"
>extern GTypeDebugFlags _g_type_debug_flags;
>
>
># 27 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gboxed.h" 2
>
>
>
>
>
>
>
>
>
>typedef gpointer (*GBoxedCopyFunc) (gpointer boxed);
>typedef void (*GBoxedFreeFunc) (gpointer boxed);
>
>
>
>gpointer g_boxed_copy (GType boxed_type,
>       gconstpointer src_boxed);
>void g_boxed_free (GType boxed_type,
>       gpointer boxed);
>void g_value_set_boxed (GValue *value,
>       gconstpointer v_boxed);
>void g_value_set_static_boxed (GValue *value,
>       gconstpointer v_boxed);
>gpointer g_value_get_boxed (const GValue *value);
>gpointer g_value_dup_boxed (const GValue *value);
>
>
>
>GType g_boxed_type_register_static (const gchar *name,
>       GBoxedCopyFunc boxed_copy,
>       GBoxedFreeFunc boxed_free);
># 69 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gboxed.h"
>void g_value_take_boxed (GValue *value,
>     gconstpointer v_boxed);
>
>void g_value_set_boxed_take_ownership (GValue *value,
>       gconstpointer v_boxed);
>
>GType g_closure_get_type (void) __attribute__((__const__));
>GType g_value_get_type (void) __attribute__((__const__));
>GType g_value_array_get_type (void) __attribute__((__const__));
>GType g_date_get_type (void) __attribute__((__const__));
>GType g_strv_get_type (void) __attribute__((__const__));
>GType g_gstring_get_type (void) __attribute__((__const__));
>GType g_hash_table_get_type (void) __attribute__((__const__));
>
>typedef gchar** GStrv;
>
>
># 26 "C:/mono/Mono-1.2.4/include/glib-2.0/glib-object.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/genums.h" 1
># 26 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/genums.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gtype.h" 1
># 27 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/genums.h" 2
>
>
># 46 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/genums.h"
>typedef struct _GEnumClass GEnumClass;
>typedef struct _GFlagsClass GFlagsClass;
>typedef struct _GEnumValue GEnumValue;
>typedef struct _GFlagsValue GFlagsValue;
>struct _GEnumClass
>{
>  GTypeClass g_type_class;
>
>
>  gint minimum;
>  gint maximum;
>  guint n_values;
>  GEnumValue *values;
>};
>struct _GFlagsClass
>{
>  GTypeClass g_type_class;
>
>
>  guint mask;
>  guint n_values;
>  GFlagsValue *values;
>};
>struct _GEnumValue
>{
>  gint value;
>  const gchar *value_name;
>  const gchar *value_nick;
>};
>struct _GFlagsValue
>{
>  guint value;
>  const gchar *value_name;
>  const gchar *value_nick;
>};
>
>
>
>GEnumValue* g_enum_get_value (GEnumClass *enum_class,
>       gint value);
>GEnumValue* g_enum_get_value_by_name (GEnumClass *enum_class,
>       const gchar *name);
>GEnumValue* g_enum_get_value_by_nick (GEnumClass *enum_class,
>       const gchar *nick);
>GFlagsValue* g_flags_get_first_value (GFlagsClass *flags_class,
>       guint value);
>GFlagsValue* g_flags_get_value_by_name (GFlagsClass *flags_class,
>       const gchar *name);
>GFlagsValue* g_flags_get_value_by_nick (GFlagsClass *flags_class,
>       const gchar *nick);
>void g_value_set_enum (GValue *value,
>       gint v_enum);
>gint g_value_get_enum (const GValue *value);
>void g_value_set_flags (GValue *value,
>       guint v_flags);
>guint g_value_get_flags (const GValue *value);
>
>
>
>
>
>
>
>GType g_enum_register_static (const gchar *name,
>        const GEnumValue *const_static_values);
>GType g_flags_register_static (const gchar *name,
>        const GFlagsValue *const_static_values);
>
>
>
>void g_enum_complete_type_info (GType g_enum_type,
>        GTypeInfo *info,
>        const GEnumValue *const_values);
>void g_flags_complete_type_info (GType g_flags_type,
>        GTypeInfo *info,
>        const GFlagsValue *const_values);
>
>
># 27 "C:/mono/Mono-1.2.4/include/glib-2.0/glib-object.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gobject.h" 1
># 26 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gobject.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gtype.h" 1
># 27 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gobject.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gvalue.h" 1
># 28 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gvalue.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gtype.h" 1
># 29 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gvalue.h" 2
>
>
># 41 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gvalue.h"
>typedef void (*GValueTransform) (const GValue *src_value,
>     GValue *dest_value);
>struct _GValue
>{
>
>  GType g_type;
>
>
>  union {
>    gint v_int;
>    guint v_uint;
>    glong v_long;
>    gulong v_ulong;
>    gint64 v_int64;
>    guint64 v_uint64;
>    gfloat v_float;
>    gdouble v_double;
>    gpointer v_pointer;
>  } data[2];
>};
>
>
>
>GValue* g_value_init (GValue *value,
>      GType g_type);
>void g_value_copy (const GValue *src_value,
>      GValue *dest_value);
>GValue* g_value_reset (GValue *value);
>void g_value_unset (GValue *value);
>void g_value_set_instance (GValue *value,
>      gpointer instance);
>
>
>
>gboolean g_value_fits_pointer (const GValue *value);
>gpointer g_value_peek_pointer (const GValue *value);
>
>
>
>gboolean g_value_type_compatible (GType src_type,
>      GType dest_type);
>gboolean g_value_type_transformable (GType src_type,
>      GType dest_type);
>gboolean g_value_transform (const GValue *src_value,
>      GValue *dest_value);
>void g_value_register_transform_func (GType src_type,
>      GType dest_type,
>      GValueTransform transform_func);
>
>
>
>
># 28 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gobject.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gparam.h" 1
># 28 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gparam.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gvalue.h" 1
># 29 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gparam.h" 2
>
>
># 49 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gparam.h"
>typedef enum
>{
>  G_PARAM_READABLE = 1 << 0,
>  G_PARAM_WRITABLE = 1 << 1,
>  G_PARAM_CONSTRUCT = 1 << 2,
>  G_PARAM_CONSTRUCT_ONLY = 1 << 3,
>  G_PARAM_LAX_VALIDATION = 1 << 4,
>  G_PARAM_STATIC_NAME = 1 << 5,
>
>  G_PARAM_PRIVATE = G_PARAM_STATIC_NAME,
>
>  G_PARAM_STATIC_NICK = 1 << 6,
>  G_PARAM_STATIC_BLURB = 1 << 7
>} GParamFlags;
>
>
>
>
>
>
>
>typedef struct _GParamSpec GParamSpec;
>typedef struct _GParamSpecClass GParamSpecClass;
>typedef struct _GParameter GParameter;
>typedef struct _GParamSpecPool GParamSpecPool;
>struct _GParamSpec
>{
>  GTypeInstance g_type_instance;
>
>  gchar *name;
>  GParamFlags flags;
>  GType value_type;
>  GType owner_type;
>
>
>  gchar *_nick;
>  gchar *_blurb;
>  GData *qdata;
>  guint ref_count;
>  guint param_id;
>};
>struct _GParamSpecClass
>{
>  GTypeClass g_type_class;
>
>  GType value_type;
>
>  void (*finalize) (GParamSpec *pspec);
>
>
>  void (*value_set_default) (GParamSpec *pspec,
>      GValue *value);
>  gboolean (*value_validate) (GParamSpec *pspec,
>      GValue *value);
>  gint (*values_cmp) (GParamSpec *pspec,
>      const GValue *value1,
>      const GValue *value2);
>
>  gpointer dummy[4];
>};
>struct _GParameter
>{
>  const gchar *name;
>  GValue value;
>};
>
>
>
>GParamSpec* g_param_spec_ref (GParamSpec *pspec);
>void g_param_spec_unref (GParamSpec *pspec);
>void g_param_spec_sink (GParamSpec *pspec);
>GParamSpec* g_param_spec_ref_sink (GParamSpec *pspec);
>gpointer g_param_spec_get_qdata (GParamSpec *pspec,
>       GQuark quark);
>void g_param_spec_set_qdata (GParamSpec *pspec,
>       GQuark quark,
>       gpointer data);
>void g_param_spec_set_qdata_full (GParamSpec *pspec,
>       GQuark quark,
>       gpointer data,
>       GDestroyNotify destroy);
>gpointer g_param_spec_steal_qdata (GParamSpec *pspec,
>       GQuark quark);
>GParamSpec* g_param_spec_get_redirect_target (GParamSpec *pspec);
>
>void g_param_value_set_default (GParamSpec *pspec,
>       GValue *value);
>gboolean g_param_value_defaults (GParamSpec *pspec,
>       GValue *value);
>gboolean g_param_value_validate (GParamSpec *pspec,
>       GValue *value);
>gboolean g_param_value_convert (GParamSpec *pspec,
>       const GValue *src_value,
>       GValue *dest_value,
>       gboolean strict_validation);
>gint g_param_values_cmp (GParamSpec *pspec,
>       const GValue *value1,
>       const GValue *value2);
>const gchar* g_param_spec_get_name (GParamSpec *pspec);
>const gchar* g_param_spec_get_nick (GParamSpec *pspec);
>const gchar* g_param_spec_get_blurb (GParamSpec *pspec);
>void g_value_set_param (GValue *value,
>       GParamSpec *param);
>GParamSpec* g_value_get_param (const GValue *value);
>GParamSpec* g_value_dup_param (const GValue *value);
>
>
>void g_value_take_param (GValue *value,
>              GParamSpec *param);
>
>void g_value_set_param_take_ownership (GValue *value,
>              GParamSpec *param);
>
>
>
>typedef struct _GParamSpecTypeInfo GParamSpecTypeInfo;
>struct _GParamSpecTypeInfo
>{
>
>  guint16 instance_size;
>  guint16 n_preallocs;
>  void (*instance_init) (GParamSpec *pspec);
>
>
>  GType value_type;
>  void (*finalize) (GParamSpec *pspec);
>  void (*value_set_default) (GParamSpec *pspec,
>      GValue *value);
>  gboolean (*value_validate) (GParamSpec *pspec,
>      GValue *value);
>  gint (*values_cmp) (GParamSpec *pspec,
>      const GValue *value1,
>      const GValue *value2);
>};
>GType g_param_type_register_static (const gchar *name,
>      const GParamSpecTypeInfo *pspec_info);
>
>
>GType _g_param_type_register_static_constant (const gchar *name,
>            const GParamSpecTypeInfo *pspec_info,
>            GType opt_type);
>
>
>
>gpointer g_param_spec_internal (GType param_type,
>       const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       GParamFlags flags);
>GParamSpecPool* g_param_spec_pool_new (gboolean type_prefixing);
>void g_param_spec_pool_insert (GParamSpecPool *pool,
>       GParamSpec *pspec,
>       GType owner_type);
>void g_param_spec_pool_remove (GParamSpecPool *pool,
>       GParamSpec *pspec);
>GParamSpec* g_param_spec_pool_lookup (GParamSpecPool *pool,
>       const gchar *param_name,
>       GType owner_type,
>       gboolean walk_ancestors);
>GList* g_param_spec_pool_list_owned (GParamSpecPool *pool,
>       GType owner_type);
>GParamSpec** g_param_spec_pool_list (GParamSpecPool *pool,
>       GType owner_type,
>       guint *n_pspecs_p);
># 232 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gparam.h"
>
># 29 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gobject.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gclosure.h" 1
># 27 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gclosure.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gtype.h" 1
># 28 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gclosure.h" 2
>
>
># 40 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gclosure.h"
>typedef struct _GClosure GClosure;
>typedef struct _GClosureNotifyData GClosureNotifyData;
>typedef void (*GCallback) (void);
>typedef void (*GClosureNotify) (gpointer data,
>      GClosure *closure);
>typedef void (*GClosureMarshal) (GClosure *closure,
>      GValue *return_value,
>      guint n_param_values,
>      const GValue *param_values,
>      gpointer invocation_hint,
>      gpointer marshal_data);
>typedef struct _GCClosure GCClosure;
>
>
>
>struct _GClosureNotifyData
>{
>  gpointer data;
>  GClosureNotify notify;
>};
>struct _GClosure
>{
>
>  volatile guint ref_count : 15;
>  volatile guint meta_marshal : 1;
>  volatile guint n_guards : 1;
>  volatile guint n_fnotifiers : 2;
>  volatile guint n_inotifiers : 8;
>  volatile guint in_inotify : 1;
>  volatile guint floating : 1;
>
>  volatile guint derivative_flag : 1;
>
>  volatile guint in_marshal : 1;
>  volatile guint is_invalid : 1;
>
>                  void (*marshal) (GClosure *closure,
>         GValue *return_value,
>         guint n_param_values,
>         const GValue *param_values,
>         gpointer invocation_hint,
>         gpointer marshal_data);
>                    gpointer data;
>
>                  GClosureNotifyData *notifiers;
># 96 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gclosure.h"
>};
>
>
>struct _GCClosure
>{
>  GClosure closure;
>  gpointer callback;
>};
>
>
>
>GClosure* g_cclosure_new (GCallback callback_func,
>       gpointer user_data,
>       GClosureNotify destroy_data);
>GClosure* g_cclosure_new_swap (GCallback callback_func,
>       gpointer user_data,
>       GClosureNotify destroy_data);
>GClosure* g_signal_type_cclosure_new (GType itype,
>       guint struct_offset);
>
>
>
>GClosure* g_closure_ref (GClosure *closure);
>void g_closure_sink (GClosure *closure);
>void g_closure_unref (GClosure *closure);
>
>GClosure* g_closure_new_simple (guint sizeof_closure,
>       gpointer data);
>void g_closure_add_finalize_notifier (GClosure *closure,
>       gpointer notify_data,
>       GClosureNotify notify_func);
>void g_closure_remove_finalize_notifier (GClosure *closure,
>       gpointer notify_data,
>       GClosureNotify notify_func);
>void g_closure_add_invalidate_notifier (GClosure *closure,
>       gpointer notify_data,
>       GClosureNotify notify_func);
>void g_closure_remove_invalidate_notifier (GClosure *closure,
>       gpointer notify_data,
>       GClosureNotify notify_func);
>void g_closure_add_marshal_guards (GClosure *closure,
>       gpointer pre_marshal_data,
>       GClosureNotify pre_marshal_notify,
>       gpointer post_marshal_data,
>       GClosureNotify post_marshal_notify);
>void g_closure_set_marshal (GClosure *closure,
>       GClosureMarshal marshal);
>void g_closure_set_meta_marshal (GClosure *closure,
>       gpointer marshal_data,
>       GClosureMarshal meta_marshal);
>void g_closure_invalidate (GClosure *closure);
>void g_closure_invoke (GClosure *closure,
>       GValue *return_value,
>       guint n_param_values,
>       const GValue *param_values,
>       gpointer invocation_hint);
># 164 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gclosure.h"
>
># 30 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gobject.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gsignal.h" 1
># 26 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gsignal.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gclosure.h" 1
># 27 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gsignal.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gvalue.h" 1
># 28 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gsignal.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gparam.h" 1
># 29 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gsignal.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gmarshal.h" 1
>
>
>
>
>
>
>extern void g_cclosure_marshal_VOID__VOID (GClosure *closure,
>                                           GValue *return_value,
>                                           guint n_param_values,
>                                           const GValue *param_values,
>                                           gpointer invocation_hint,
>                                           gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__BOOLEAN (GClosure *closure,
>                                              GValue *return_value,
>                                              guint n_param_values,
>                                              const GValue *param_values,
>                                              gpointer invocation_hint,
>                                              gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__CHAR (GClosure *closure,
>                                           GValue *return_value,
>                                           guint n_param_values,
>                                           const GValue *param_values,
>                                           gpointer invocation_hint,
>                                           gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__UCHAR (GClosure *closure,
>                                            GValue *return_value,
>                                            guint n_param_values,
>                                            const GValue *param_values,
>                                            gpointer invocation_hint,
>                                            gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__INT (GClosure *closure,
>                                          GValue *return_value,
>                                          guint n_param_values,
>                                          const GValue *param_values,
>                                          gpointer invocation_hint,
>                                          gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__UINT (GClosure *closure,
>                                           GValue *return_value,
>                                           guint n_param_values,
>                                           const GValue *param_values,
>                                           gpointer invocation_hint,
>                                           gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__LONG (GClosure *closure,
>                                           GValue *return_value,
>                                           guint n_param_values,
>                                           const GValue *param_values,
>                                           gpointer invocation_hint,
>                                           gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__ULONG (GClosure *closure,
>                                            GValue *return_value,
>                                            guint n_param_values,
>                                            const GValue *param_values,
>                                            gpointer invocation_hint,
>                                            gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__ENUM (GClosure *closure,
>                                           GValue *return_value,
>                                           guint n_param_values,
>                                           const GValue *param_values,
>                                           gpointer invocation_hint,
>                                           gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__FLAGS (GClosure *closure,
>                                            GValue *return_value,
>                                            guint n_param_values,
>                                            const GValue *param_values,
>                                            gpointer invocation_hint,
>                                            gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__FLOAT (GClosure *closure,
>                                            GValue *return_value,
>                                            guint n_param_values,
>                                            const GValue *param_values,
>                                            gpointer invocation_hint,
>                                            gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__DOUBLE (GClosure *closure,
>                                             GValue *return_value,
>                                             guint n_param_values,
>                                             const GValue *param_values,
>                                             gpointer invocation_hint,
>                                             gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__STRING (GClosure *closure,
>                                             GValue *return_value,
>                                             guint n_param_values,
>                                             const GValue *param_values,
>                                             gpointer invocation_hint,
>                                             gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__PARAM (GClosure *closure,
>                                            GValue *return_value,
>                                            guint n_param_values,
>                                            const GValue *param_values,
>                                            gpointer invocation_hint,
>                                            gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__BOXED (GClosure *closure,
>                                            GValue *return_value,
>                                            guint n_param_values,
>                                            const GValue *param_values,
>                                            gpointer invocation_hint,
>                                            gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__POINTER (GClosure *closure,
>                                              GValue *return_value,
>                                              guint n_param_values,
>                                              const GValue *param_values,
>                                              gpointer invocation_hint,
>                                              gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__OBJECT (GClosure *closure,
>                                             GValue *return_value,
>                                             guint n_param_values,
>                                             const GValue *param_values,
>                                             gpointer invocation_hint,
>                                             gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__UINT_POINTER (GClosure *closure,
>                                                   GValue *return_value,
>                                                   guint n_param_values,
>                                                   const GValue *param_values,
>                                                   gpointer invocation_hint,
>                                                   gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_BOOLEAN__FLAGS (GClosure *closure,
>                                               GValue *return_value,
>                                               guint n_param_values,
>                                               const GValue *param_values,
>                                               gpointer invocation_hint,
>                                               gpointer marshal_data);
>
>
>
>extern void g_cclosure_marshal_STRING__OBJECT_POINTER (GClosure *closure,
>                                                       GValue *return_value,
>                                                       guint n_param_values,
>                                                       const GValue
>*param_values,
>                                                       gpointer invocation_hint,
>                                                       gpointer marshal_data);
>
>
># 30 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gsignal.h" 2
>
>
>
>
>typedef struct _GSignalQuery GSignalQuery;
>typedef struct _GSignalInvocationHint GSignalInvocationHint;
>typedef GClosureMarshal GSignalCMarshaller;
>typedef gboolean (*GSignalEmissionHook) (GSignalInvocationHint *ihint,
>      guint n_param_values,
>      const GValue *param_values,
>      gpointer data);
>typedef gboolean (*GSignalAccumulator) (GSignalInvocationHint *ihint,
>      GValue *return_accu,
>      const GValue *handler_return,
>      gpointer data);
>
>
>
>typedef enum
>{
>  G_SIGNAL_RUN_FIRST = 1 << 0,
>  G_SIGNAL_RUN_LAST = 1 << 1,
>  G_SIGNAL_RUN_CLEANUP = 1 << 2,
>  G_SIGNAL_NO_RECURSE = 1 << 3,
>  G_SIGNAL_DETAILED = 1 << 4,
>  G_SIGNAL_ACTION = 1 << 5,
>  G_SIGNAL_NO_HOOKS = 1 << 6
>} GSignalFlags;
>
>typedef enum
>{
>  G_CONNECT_AFTER = 1 << 0,
>  G_CONNECT_SWAPPED = 1 << 1
>} GConnectFlags;
>typedef enum
>{
>  G_SIGNAL_MATCH_ID = 1 << 0,
>  G_SIGNAL_MATCH_DETAIL = 1 << 1,
>  G_SIGNAL_MATCH_CLOSURE = 1 << 2,
>  G_SIGNAL_MATCH_FUNC = 1 << 3,
>  G_SIGNAL_MATCH_DATA = 1 << 4,
>  G_SIGNAL_MATCH_UNBLOCKED = 1 << 5
>} GSignalMatchType;
>
>
>
>
>
>struct _GSignalInvocationHint
>{
>  guint signal_id;
>  GQuark detail;
>  GSignalFlags run_type;
>};
>struct _GSignalQuery
>{
>  guint signal_id;
>  const gchar *signal_name;
>  GType itype;
>  GSignalFlags signal_flags;
>  GType return_type;
>  guint n_params;
>  const GType *param_types;
>};
>
>
>
>guint g_signal_newv (const gchar *signal_name,
>          GType itype,
>          GSignalFlags signal_flags,
>          GClosure *class_closure,
>          GSignalAccumulator accumulator,
>          gpointer accu_data,
>          GSignalCMarshaller c_marshaller,
>          GType return_type,
>          guint n_params,
>          GType *param_types);
>guint g_signal_new_valist (const gchar *signal_name,
>          GType itype,
>          GSignalFlags signal_flags,
>          GClosure *class_closure,
>          GSignalAccumulator accumulator,
>          gpointer accu_data,
>          GSignalCMarshaller c_marshaller,
>          GType return_type,
>          guint n_params,
>          va_list args);
>guint g_signal_new (const gchar *signal_name,
>          GType itype,
>          GSignalFlags signal_flags,
>          guint class_offset,
>          GSignalAccumulator accumulator,
>          gpointer accu_data,
>          GSignalCMarshaller c_marshaller,
>          GType return_type,
>          guint n_params,
>          ...);
>void g_signal_emitv (const GValue *instance_and_params,
>          guint signal_id,
>          GQuark detail,
>          GValue *return_value);
>void g_signal_emit_valist (gpointer instance,
>          guint signal_id,
>          GQuark detail,
>          va_list var_args);
>void g_signal_emit (gpointer instance,
>          guint signal_id,
>          GQuark detail,
>          ...);
>void g_signal_emit_by_name (gpointer instance,
>          const gchar *detailed_signal,
>          ...);
>guint g_signal_lookup (const gchar *name,
>          GType itype);
>const gchar* g_signal_name (guint signal_id);
>void g_signal_query (guint signal_id,
>          GSignalQuery *query);
>guint* g_signal_list_ids (GType itype,
>          guint *n_ids);
>gboolean g_signal_parse_name (const gchar *detailed_signal,
>          GType itype,
>          guint *signal_id_p,
>          GQuark *detail_p,
>          gboolean force_detail_quark);
>GSignalInvocationHint* g_signal_get_invocation_hint (gpointer instance);
>
>
>
>void g_signal_stop_emission (gpointer instance,
>          guint signal_id,
>          GQuark detail);
>void g_signal_stop_emission_by_name (gpointer instance,
>          const gchar *detailed_signal);
>gulong g_signal_add_emission_hook (guint signal_id,
>          GQuark detail,
>          GSignalEmissionHook hook_func,
>          gpointer hook_data,
>          GDestroyNotify data_destroy);
>void g_signal_remove_emission_hook (guint signal_id,
>          gulong hook_id);
>
>
>
>gboolean g_signal_has_handler_pending (gpointer instance,
>            guint signal_id,
>            GQuark detail,
>            gboolean may_be_blocked);
>gulong g_signal_connect_closure_by_id (gpointer instance,
>            guint signal_id,
>            GQuark detail,
>            GClosure *closure,
>            gboolean after);
>gulong g_signal_connect_closure (gpointer instance,
>            const gchar *detailed_signal,
>            GClosure *closure,
>            gboolean after);
>gulong g_signal_connect_data (gpointer instance,
>            const gchar *detailed_signal,
>            GCallback c_handler,
>            gpointer data,
>            GClosureNotify destroy_data,
>            GConnectFlags connect_flags);
>void g_signal_handler_block (gpointer instance,
>            gulong handler_id);
>void g_signal_handler_unblock (gpointer instance,
>            gulong handler_id);
>void g_signal_handler_disconnect (gpointer instance,
>            gulong handler_id);
>gboolean g_signal_handler_is_connected (gpointer instance,
>            gulong handler_id);
>gulong g_signal_handler_find (gpointer instance,
>            GSignalMatchType mask,
>            guint signal_id,
>            GQuark detail,
>            GClosure *closure,
>            gpointer func,
>            gpointer data);
>guint g_signal_handlers_block_matched (gpointer instance,
>            GSignalMatchType mask,
>            guint signal_id,
>            GQuark detail,
>            GClosure *closure,
>            gpointer func,
>            gpointer data);
>guint g_signal_handlers_unblock_matched (gpointer instance,
>            GSignalMatchType mask,
>            guint signal_id,
>            GQuark detail,
>            GClosure *closure,
>            gpointer func,
>            gpointer data);
>guint g_signal_handlers_disconnect_matched (gpointer instance,
>            GSignalMatchType mask,
>            guint signal_id,
>            GQuark detail,
>            GClosure *closure,
>            gpointer func,
>            gpointer data);
>
>
>
>void g_signal_override_class_closure (guint signal_id,
>            GType instance_type,
>            GClosure *class_closure);
>void g_signal_chain_from_overridden (const GValue *instance_and_params,
>            GValue *return_value);
># 259 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gsignal.h"
>gboolean g_signal_accumulator_true_handled (GSignalInvocationHint *ihint,
>         GValue *return_accu,
>         const GValue *handler_return,
>         gpointer dummy);
>
>
>void g_signal_handlers_destroy (gpointer instance);
>void _g_signals_destroy (GType itype);
>
>
># 31 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gobject.h" 2
>
>
># 58 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gobject.h"
>typedef struct _GObject GObject;
>typedef struct _GObjectClass GObjectClass;
>typedef struct _GObject GInitiallyUnowned;
>typedef struct _GObjectClass GInitiallyUnownedClass;
>typedef struct _GObjectConstructParam GObjectConstructParam;
>typedef void (*GObjectGetPropertyFunc) (GObject *object,
>                                         guint property_id,
>                                         GValue *value,
>                                         GParamSpec *pspec);
>typedef void (*GObjectSetPropertyFunc) (GObject *object,
>                                         guint property_id,
>                                         const GValue *value,
>                                         GParamSpec *pspec);
>typedef void (*GObjectFinalizeFunc) (GObject *object);
>typedef void (*GWeakNotify) (gpointer data,
>      GObject *where_the_object_was);
>struct _GObject
>{
>  GTypeInstance g_type_instance;
>
>
>  volatile guint ref_count;
>  GData *qdata;
>};
>struct _GObjectClass
>{
>  GTypeClass g_type_class;
>
>
>  GSList *construct_properties;
>
>
>
>  GObject* (*constructor) (GType type,
>                                 guint n_construct_properties,
>                                 GObjectConstructParam *construct_properties);
>  void (*set_property) (GObject *object,
>                                         guint property_id,
>                                         const GValue *value,
>                                         GParamSpec *pspec);
>  void (*get_property) (GObject *object,
>                                         guint property_id,
>                                         GValue *value,
>                                         GParamSpec *pspec);
>  void (*dispose) (GObject *object);
>  void (*finalize) (GObject *object);
>
>
>  void (*dispatch_properties_changed) (GObject *object,
>          guint n_pspecs,
>          GParamSpec **pspecs);
>
>
>  void (*notify) (GObject *object,
>      GParamSpec *pspec);
>
>
>  gpointer pdummy[8];
>};
>struct _GObjectConstructParam
>{
>  GParamSpec *pspec;
>  GValue *value;
>};
>
>
>
>GType g_initially_unowned_get_type (void);
>void g_object_class_install_property (GObjectClass *oclass,
>            guint property_id,
>            GParamSpec *pspec);
>GParamSpec* g_object_class_find_property (GObjectClass *oclass,
>            const gchar *property_name);
>GParamSpec**g_object_class_list_properties (GObjectClass *oclass,
>            guint *n_properties);
>void g_object_class_override_property (GObjectClass *oclass,
>            guint property_id,
>            const gchar *name);
>
>void g_object_interface_install_property (gpointer g_iface,
>       GParamSpec *pspec);
>GParamSpec* g_object_interface_find_property (gpointer g_iface,
>       const gchar *property_name);
>GParamSpec**g_object_interface_list_properties (gpointer g_iface,
>       guint *n_properties_p);
>
>gpointer g_object_new (GType object_type,
>            const gchar *first_property_name,
>            ...);
>gpointer g_object_newv (GType object_type,
>            guint n_parameters,
>            GParameter *parameters);
>GObject* g_object_new_valist (GType object_type,
>            const gchar *first_property_name,
>            va_list var_args);
>void g_object_set (gpointer object,
>            const gchar *first_property_name,
>            ...) ;
>void g_object_get (gpointer object,
>            const gchar *first_property_name,
>            ...) ;
>gpointer g_object_connect (gpointer object,
>            const gchar *signal_spec,
>            ...) ;
>void g_object_disconnect (gpointer object,
>            const gchar *signal_spec,
>            ...) ;
>void g_object_set_valist (GObject *object,
>            const gchar *first_property_name,
>            va_list var_args);
>void g_object_get_valist (GObject *object,
>            const gchar *first_property_name,
>            va_list var_args);
>void g_object_set_property (GObject *object,
>            const gchar *property_name,
>            const GValue *value);
>void g_object_get_property (GObject *object,
>            const gchar *property_name,
>            GValue *value);
>void g_object_freeze_notify (GObject *object);
>void g_object_notify (GObject *object,
>            const gchar *property_name);
>void g_object_thaw_notify (GObject *object);
>gboolean g_object_is_floating (gpointer object);
>gpointer g_object_ref_sink (gpointer object);
>gpointer g_object_ref (gpointer object);
>void g_object_unref (gpointer object);
>void g_object_weak_ref (GObject *object,
>            GWeakNotify notify,
>            gpointer data);
>void g_object_weak_unref (GObject *object,
>            GWeakNotify notify,
>            gpointer data);
>void g_object_add_weak_pointer (GObject *object,
>                                               gpointer *weak_pointer_location);
>void g_object_remove_weak_pointer (GObject *object,
>                                               gpointer *weak_pointer_location);
>
>typedef void (*GToggleNotify) (gpointer data,
>          GObject *object,
>          gboolean is_last_ref);
>
>void g_object_add_toggle_ref (GObject *object,
>     GToggleNotify notify,
>     gpointer data);
>void g_object_remove_toggle_ref (GObject *object,
>     GToggleNotify notify,
>     gpointer data);
>
>gpointer g_object_get_qdata (GObject *object,
>            GQuark quark);
>void g_object_set_qdata (GObject *object,
>            GQuark quark,
>            gpointer data);
>void g_object_set_qdata_full (GObject *object,
>            GQuark quark,
>            gpointer data,
>            GDestroyNotify destroy);
>gpointer g_object_steal_qdata (GObject *object,
>            GQuark quark);
>gpointer g_object_get_data (GObject *object,
>            const gchar *key);
>void g_object_set_data (GObject *object,
>            const gchar *key,
>            gpointer data);
>void g_object_set_data_full (GObject *object,
>            const gchar *key,
>            gpointer data,
>            GDestroyNotify destroy);
>gpointer g_object_steal_data (GObject *object,
>            const gchar *key);
>void g_object_watch_closure (GObject *object,
>            GClosure *closure);
>GClosure* g_cclosure_new_object (GCallback callback_func,
>            GObject *object);
>GClosure* g_cclosure_new_object_swap (GCallback callback_func,
>            GObject *object);
>GClosure* g_closure_new_object (guint sizeof_closure,
>            GObject *object);
>void g_value_set_object (GValue *value,
>            gpointer v_object);
>gpointer g_value_get_object (const GValue *value);
>GObject* g_value_dup_object (const GValue *value);
>gulong g_signal_connect_object (gpointer instance,
>            const gchar *detailed_signal,
>            GCallback c_handler,
>            gpointer gobject,
>            GConnectFlags connect_flags);
>
>
>void g_object_force_floating (GObject *object);
>void g_object_run_dispose (GObject *object);
>
>
>void g_value_take_object (GValue *value,
>            gpointer v_object);
>
>void g_value_set_object_take_ownership (GValue *value,
>            gpointer v_object);
>
>
>
>gsize g_object_compat_control (gsize what,
>            gpointer data);
># 281 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gobject.h"
>
># 28 "C:/mono/Mono-1.2.4/include/glib-2.0/glib-object.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gparam.h" 1
># 29 "C:/mono/Mono-1.2.4/include/glib-2.0/glib-object.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gparamspecs.h" 1
># 28 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gparamspecs.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gvalue.h" 1
># 29 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gparamspecs.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/genums.h" 1
># 30 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gparamspecs.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gboxed.h" 1
># 31 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gparamspecs.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gobject.h" 1
># 32 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gparamspecs.h" 2
>
>
># 105 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gparamspecs.h"
>typedef struct _GParamSpecChar GParamSpecChar;
>typedef struct _GParamSpecUChar GParamSpecUChar;
>typedef struct _GParamSpecBoolean GParamSpecBoolean;
>typedef struct _GParamSpecInt GParamSpecInt;
>typedef struct _GParamSpecUInt GParamSpecUInt;
>typedef struct _GParamSpecLong GParamSpecLong;
>typedef struct _GParamSpecULong GParamSpecULong;
>typedef struct _GParamSpecInt64 GParamSpecInt64;
>typedef struct _GParamSpecUInt64 GParamSpecUInt64;
>typedef struct _GParamSpecUnichar GParamSpecUnichar;
>typedef struct _GParamSpecEnum GParamSpecEnum;
>typedef struct _GParamSpecFlags GParamSpecFlags;
>typedef struct _GParamSpecFloat GParamSpecFloat;
>typedef struct _GParamSpecDouble GParamSpecDouble;
>typedef struct _GParamSpecString GParamSpecString;
>typedef struct _GParamSpecParam GParamSpecParam;
>typedef struct _GParamSpecBoxed GParamSpecBoxed;
>typedef struct _GParamSpecPointer GParamSpecPointer;
>typedef struct _GParamSpecValueArray GParamSpecValueArray;
>typedef struct _GParamSpecObject GParamSpecObject;
>typedef struct _GParamSpecOverride GParamSpecOverride;
>typedef struct _GParamSpecGType GParamSpecGType;
>
>struct _GParamSpecChar
>{
>  GParamSpec parent_instance;
>
>  gint8 minimum;
>  gint8 maximum;
>  gint8 default_value;
>};
>struct _GParamSpecUChar
>{
>  GParamSpec parent_instance;
>
>  guint8 minimum;
>  guint8 maximum;
>  guint8 default_value;
>};
>struct _GParamSpecBoolean
>{
>  GParamSpec parent_instance;
>
>  gboolean default_value;
>};
>struct _GParamSpecInt
>{
>  GParamSpec parent_instance;
>
>  gint minimum;
>  gint maximum;
>  gint default_value;
>};
>struct _GParamSpecUInt
>{
>  GParamSpec parent_instance;
>
>  guint minimum;
>  guint maximum;
>  guint default_value;
>};
>struct _GParamSpecLong
>{
>  GParamSpec parent_instance;
>
>  glong minimum;
>  glong maximum;
>  glong default_value;
>};
>struct _GParamSpecULong
>{
>  GParamSpec parent_instance;
>
>  gulong minimum;
>  gulong maximum;
>  gulong default_value;
>};
>struct _GParamSpecInt64
>{
>  GParamSpec parent_instance;
>
>  gint64 minimum;
>  gint64 maximum;
>  gint64 default_value;
>};
>struct _GParamSpecUInt64
>{
>  GParamSpec parent_instance;
>
>  guint64 minimum;
>  guint64 maximum;
>  guint64 default_value;
>};
>struct _GParamSpecUnichar
>{
>  GParamSpec parent_instance;
>
>  gunichar default_value;
>};
>struct _GParamSpecEnum
>{
>  GParamSpec parent_instance;
>
>  GEnumClass *enum_class;
>  gint default_value;
>};
>struct _GParamSpecFlags
>{
>  GParamSpec parent_instance;
>
>  GFlagsClass *flags_class;
>  guint default_value;
>};
>struct _GParamSpecFloat
>{
>  GParamSpec parent_instance;
>
>  gfloat minimum;
>  gfloat maximum;
>  gfloat default_value;
>  gfloat epsilon;
>};
>struct _GParamSpecDouble
>{
>  GParamSpec parent_instance;
>
>  gdouble minimum;
>  gdouble maximum;
>  gdouble default_value;
>  gdouble epsilon;
>};
>struct _GParamSpecString
>{
>  GParamSpec parent_instance;
>
>  gchar *default_value;
>  gchar *cset_first;
>  gchar *cset_nth;
>  gchar substitutor;
>  guint null_fold_if_empty : 1;
>  guint ensure_non_null : 1;
>};
>struct _GParamSpecParam
>{
>  GParamSpec parent_instance;
>};
>struct _GParamSpecBoxed
>{
>  GParamSpec parent_instance;
>};
>struct _GParamSpecPointer
>{
>  GParamSpec parent_instance;
>};
>struct _GParamSpecValueArray
>{
>  GParamSpec parent_instance;
>  GParamSpec *element_spec;
>  guint fixed_n_elements;
>};
>struct _GParamSpecObject
>{
>  GParamSpec parent_instance;
>};
>struct _GParamSpecOverride
>{
>
>  GParamSpec parent_instance;
>  GParamSpec *overridden;
>};
>struct _GParamSpecGType
>{
>  GParamSpec parent_instance;
>  GType is_a_type;
>};
>
>
>GParamSpec* g_param_spec_char (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       gint8 minimum,
>       gint8 maximum,
>       gint8 default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_uchar (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       guint8 minimum,
>       guint8 maximum,
>       guint8 default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_boolean (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       gboolean default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_int (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       gint minimum,
>       gint maximum,
>       gint default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_uint (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       guint minimum,
>       guint maximum,
>       guint default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_long (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       glong minimum,
>       glong maximum,
>       glong default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_ulong (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       gulong minimum,
>       gulong maximum,
>       gulong default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_int64 (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       gint64 minimum,
>       gint64 maximum,
>       gint64 default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_uint64 (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       guint64 minimum,
>       guint64 maximum,
>       guint64 default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_unichar (const gchar *name,
>              const gchar *nick,
>              const gchar *blurb,
>              gunichar default_value,
>              GParamFlags flags);
>GParamSpec* g_param_spec_enum (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       GType enum_type,
>       gint default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_flags (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       GType flags_type,
>       guint default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_float (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       gfloat minimum,
>       gfloat maximum,
>       gfloat default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_double (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       gdouble minimum,
>       gdouble maximum,
>       gdouble default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_string (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       const gchar *default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_param (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       GType param_type,
>       GParamFlags flags);
>GParamSpec* g_param_spec_boxed (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       GType boxed_type,
>       GParamFlags flags);
>GParamSpec* g_param_spec_pointer (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       GParamFlags flags);
>GParamSpec* g_param_spec_value_array (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       GParamSpec *element_spec,
>       GParamFlags flags);
>GParamSpec* g_param_spec_object (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       GType object_type,
>       GParamFlags flags);
>GParamSpec* g_param_spec_override (const gchar *name,
>       GParamSpec *overridden);
>GParamSpec* g_param_spec_gtype (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       GType is_a_type,
>       GParamFlags flags);
># 435 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gparamspecs.h"
>extern __attribute__((dllimport)) GType *g_param_spec_types;
>
>
># 30 "C:/mono/Mono-1.2.4/include/glib-2.0/glib-object.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gsignal.h" 1
># 31 "C:/mono/Mono-1.2.4/include/glib-2.0/glib-object.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gsourceclosure.h" 1
># 26 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gsourceclosure.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gclosure.h" 1
># 27 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gsourceclosure.h" 2
>
>
>
>void g_source_set_closure (GSource *source,
>      GClosure *closure);
>
>GType g_io_channel_get_type (void);
>GType g_io_condition_get_type (void);
>
>
>
>
>
># 32 "C:/mono/Mono-1.2.4/include/glib-2.0/glib-object.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gtype.h" 1
># 33 "C:/mono/Mono-1.2.4/include/glib-2.0/glib-object.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gtypemodule.h" 1
># 26 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gtypemodule.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gobject.h" 1
># 27 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gtypemodule.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/genums.h" 1
># 28 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gtypemodule.h" 2
>
>
>
>typedef struct _GTypeModule GTypeModule;
>typedef struct _GTypeModuleClass GTypeModuleClass;
># 41 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gtypemodule.h"
>struct _GTypeModule
>{
>  GObject parent_instance;
>
>  guint use_count;
>  GSList *type_infos;
>  GSList *interface_infos;
>
>
>  gchar *name;
>};
>
>struct _GTypeModuleClass
>{
>  GObjectClass parent_class;
>
>
>  gboolean (* load) (GTypeModule *module);
>  void (* unload) (GTypeModule *module);
>
>
>
>  void (*reserved1) (void);
>  void (*reserved2) (void);
>  void (*reserved3) (void);
>  void (*reserved4) (void);
>};
>
>GType g_type_module_get_type (void) __attribute__((__const__));
>gboolean g_type_module_use (GTypeModule *module);
>void g_type_module_unuse (GTypeModule *module);
>void g_type_module_set_name (GTypeModule *module,
>                                       const gchar *name);
>GType g_type_module_register_type (GTypeModule *module,
>                                       GType parent_type,
>                                       const gchar *type_name,
>                                       const GTypeInfo *type_info,
>                                       GTypeFlags flags);
>void g_type_module_add_interface (GTypeModule *module,
>                                       GType instance_type,
>                                       GType interface_type,
>                                       const GInterfaceInfo *interface_info);
>GType g_type_module_register_enum (GTypeModule *module,
>                                       const gchar *name,
>                                       const GEnumValue *const_static_values);
>GType g_type_module_register_flags (GTypeModule *module,
>                                       const gchar *name,
>                                       const GFlagsValue *const_static_values);
>
>
># 34 "C:/mono/Mono-1.2.4/include/glib-2.0/glib-object.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gtypeplugin.h" 1
># 26 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gtypeplugin.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gtype.h" 1
># 27 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gtypeplugin.h" 2
>
>
># 40 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gtypeplugin.h"
>typedef struct _GTypePluginClass GTypePluginClass;
>typedef void (*GTypePluginUse) (GTypePlugin *plugin);
>typedef void (*GTypePluginUnuse) (GTypePlugin *plugin);
>typedef void (*GTypePluginCompleteTypeInfo) (GTypePlugin *plugin,
>         GType g_type,
>         GTypeInfo *info,
>         GTypeValueTable *value_table);
>typedef void (*GTypePluginCompleteInterfaceInfo) (GTypePlugin *plugin,
>         GType instance_type,
>         GType interface_type,
>         GInterfaceInfo *info);
>struct _GTypePluginClass
>{
>
>  GTypeInterface base_iface;
>
>
>  GTypePluginUse use_plugin;
>  GTypePluginUnuse unuse_plugin;
>  GTypePluginCompleteTypeInfo complete_type_info;
>  GTypePluginCompleteInterfaceInfo complete_interface_info;
>};
>
>
>
>GType g_type_plugin_get_type (void) __attribute__((__const__));
>void g_type_plugin_use (GTypePlugin *plugin);
>void g_type_plugin_unuse (GTypePlugin *plugin);
>void g_type_plugin_complete_type_info (GTypePlugin *plugin,
>       GType g_type,
>       GTypeInfo *info,
>       GTypeValueTable *value_table);
>void g_type_plugin_complete_interface_info (GTypePlugin *plugin,
>       GType instance_type,
>       GType interface_type,
>       GInterfaceInfo *info);
>
>
># 35 "C:/mono/Mono-1.2.4/include/glib-2.0/glib-object.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gvalue.h" 1
># 36 "C:/mono/Mono-1.2.4/include/glib-2.0/glib-object.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gvaluearray.h" 1
># 28 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gvaluearray.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gvalue.h" 1
># 29 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gvaluearray.h" 2
>
>
>
>
>
>
>typedef struct _GValueArray GValueArray;
>struct _GValueArray
>{
>  guint n_values;
>  GValue *values;
>
>
>  guint n_prealloced;
>};
>
>
>
>GValue* g_value_array_get_nth (GValueArray *value_array,
>           guint index_);
>GValueArray* g_value_array_new (guint n_prealloced);
>void g_value_array_free (GValueArray *value_array);
>GValueArray* g_value_array_copy (const GValueArray *value_array);
>GValueArray* g_value_array_prepend (GValueArray *value_array,
>           const GValue *value);
>GValueArray* g_value_array_append (GValueArray *value_array,
>           const GValue *value);
>GValueArray* g_value_array_insert (GValueArray *value_array,
>           guint index_,
>           const GValue *value);
>GValueArray* g_value_array_remove (GValueArray *value_array,
>           guint index_);
>GValueArray* g_value_array_sort (GValueArray *value_array,
>           GCompareFunc compare_func);
>GValueArray* g_value_array_sort_with_data (GValueArray *value_array,
>           GCompareDataFunc compare_func,
>           gpointer user_data);
>
>
>
># 37 "C:/mono/Mono-1.2.4/include/glib-2.0/glib-object.h" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gvaluetypes.h" 1
># 28 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gvaluetypes.h"
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gvalue.h" 1
># 29 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gvaluetypes.h" 2
>
>
># 51 "C:/mono/Mono-1.2.4/include/glib-2.0/gobject/gvaluetypes.h"
>void g_value_set_char (GValue *value,
>       gchar v_char);
>gchar g_value_get_char (const GValue *value);
>void g_value_set_uchar (GValue *value,
>       guchar v_uchar);
>guchar g_value_get_uchar (const GValue *value);
>void g_value_set_boolean (GValue *value,
>       gboolean v_boolean);
>gboolean g_value_get_boolean (const GValue *value);
>void g_value_set_int (GValue *value,
>       gint v_int);
>gint g_value_get_int (const GValue *value);
>void g_value_set_uint (GValue *value,
>       guint v_uint);
>guint g_value_get_uint (const GValue *value);
>void g_value_set_long (GValue *value,
>       glong v_long);
>glong g_value_get_long (const GValue *value);
>void g_value_set_ulong (GValue *value,
>       gulong v_ulong);
>gulong g_value_get_ulong (const GValue *value);
>void g_value_set_int64 (GValue *value,
>       gint64 v_int64);
>gint64 g_value_get_int64 (const GValue *value);
>void g_value_set_uint64 (GValue *value,
>       guint64 v_uint64);
>guint64 g_value_get_uint64 (const GValue *value);
>void g_value_set_float (GValue *value,
>       gfloat v_float);
>gfloat g_value_get_float (const GValue *value);
>void g_value_set_double (GValue *value,
>       gdouble v_double);
>gdouble g_value_get_double (const GValue *value);
>void g_value_set_string (GValue *value,
>       const gchar *v_string);
>void g_value_set_static_string (GValue *value,
>       const gchar *v_string);
>const gchar* g_value_get_string (const GValue *value);
>gchar* g_value_dup_string (const GValue *value);
>void g_value_set_pointer (GValue *value,
>       gpointer v_pointer);
>gpointer g_value_get_pointer (const GValue *value);
>GType g_gtype_get_type (void);
>void g_value_set_gtype (GValue *value,
>       GType v_gtype);
>GType g_value_get_gtype (const GValue *value);
>
>
>
>GType g_pointer_type_register_static (const gchar *name);
>
>
>gchar* g_strdup_value_contents (const GValue *value);
>
>
>void g_value_take_string (GValue *value,
>       gchar *v_string);
>
>void g_value_set_string_take_ownership (GValue *value,
>       gchar *v_string);
>
>
>
>
>typedef gchar* gchararray;
>
>
>
># 38 "C:/mono/Mono-1.2.4/include/glib-2.0/glib-object.h" 2
># 28 "../dbus/dbus-glib.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-shared.h" 1
># 56 "/usr/include/dbus-1.0/dbus/dbus-shared.h"
>typedef enum
>{
>  DBUS_BUS_SESSION,
>  DBUS_BUS_SYSTEM,
>  DBUS_BUS_STARTER
>} DBusBusType;
>
>
>
>
>typedef enum
>{
>  DBUS_HANDLER_RESULT_HANDLED,
>  DBUS_HANDLER_RESULT_NOT_YET_HANDLED,
>  DBUS_HANDLER_RESULT_NEED_MEMORY
>} DBusHandlerResult;
># 29 "../dbus/dbus-glib.h" 2
>
>
>
>
>
>
>
>
>
>typedef struct _DBusGConnection DBusGConnection;
>
>
>
>typedef struct _DBusGMessage DBusGMessage;
>
>
>
>
>GType dbus_g_connection_get_g_type (void) __attribute__((__const__));
>GType dbus_g_message_get_g_type (void) __attribute__((__const__));
>
>
>DBusGConnection* dbus_g_connection_ref (DBusGConnection *connection);
>void dbus_g_connection_unref (DBusGConnection *connection);
>DBusGMessage* dbus_g_message_ref (DBusGMessage *message);
>void dbus_g_message_unref (DBusGMessage *message);
>
>void dbus_g_connection_flush (DBusGConnection *connection);
>
>GQuark dbus_g_error_quark (void);
>
>
>typedef enum
>{
># 1 "../dbus/dbus-glib-error-enum.h" 1
>DBUS_GERROR_FAILED,
>DBUS_GERROR_NO_MEMORY,
>DBUS_GERROR_SERVICE_UNKNOWN,
>DBUS_GERROR_NAME_HAS_NO_OWNER,
>DBUS_GERROR_NO_REPLY,
>DBUS_GERROR_IO_ERROR,
>DBUS_GERROR_BAD_ADDRESS,
>DBUS_GERROR_NOT_SUPPORTED,
>DBUS_GERROR_LIMITS_EXCEEDED,
>DBUS_GERROR_ACCESS_DENIED,
>DBUS_GERROR_AUTH_FAILED,
>DBUS_GERROR_NO_SERVER,
>DBUS_GERROR_TIMEOUT,
>DBUS_GERROR_NO_NETWORK,
>DBUS_GERROR_ADDRESS_IN_USE,
>DBUS_GERROR_DISCONNECTED,
>DBUS_GERROR_INVALID_ARGS,
>DBUS_GERROR_FILE_NOT_FOUND,
>DBUS_GERROR_FILE_EXISTS,
>DBUS_GERROR_UNKNOWN_METHOD,
>DBUS_GERROR_TIMED_OUT,
>DBUS_GERROR_MATCH_RULE_NOT_FOUND,
>DBUS_GERROR_MATCH_RULE_INVALID,
>DBUS_GERROR_SPAWN_EXEC_FAILED,
>DBUS_GERROR_SPAWN_FORK_FAILED,
>DBUS_GERROR_SPAWN_CHILD_EXITED,
>DBUS_GERROR_SPAWN_CHILD_SIGNALED,
>DBUS_GERROR_SPAWN_FAILED,
>DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN,
>DBUS_GERROR_INVALID_SIGNATURE,
>DBUS_GERROR_INVALID_FILE_CONTENT,
>DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN,
>DBUS_GERROR_REMOTE_EXCEPTION
># 64 "../dbus/dbus-glib.h" 2
>} DBusGError;
>
>gboolean dbus_g_error_has_name (GError *error,
>        const char *name);
>const char * dbus_g_error_get_name (GError *error);
>
>void dbus_g_thread_init (void);
>
>DBusGConnection* dbus_g_connection_open (const gchar *address,
>                                         GError **error);
>DBusGConnection* dbus_g_bus_get (DBusBusType type,
>                                         GError **error);
>
>typedef struct _DBusGObjectInfo DBusGObjectInfo;
>typedef struct _DBusGMethodInfo DBusGMethodInfo;
># 90 "../dbus/dbus-glib.h"
>struct _DBusGMethodInfo
>{
>  GCallback function;
>  GClosureMarshal marshaller;
>  int data_offset;
>};
># 110 "../dbus/dbus-glib.h"
>struct _DBusGObjectInfo
>{
>  int format_version;
>
>  const DBusGMethodInfo *method_infos;
>  int n_method_infos;
>  const char *data;
>  const char *exported_signals;
>  const char *exported_properties;
>};
>
>void dbus_g_object_type_install_info (GType object_type,
>                                                const DBusGObjectInfo *info);
>
>void dbus_g_error_domain_register (GQuark domain,
>      const char * default_iface,
>      GType code_enum);
>
>void dbus_g_connection_register_g_object (DBusGConnection *connection,
>      const char *at_path,
>      GObject *object);
>GObject * dbus_g_connection_lookup_g_object (DBusGConnection *connection,
>      const char *at_path);
>
>
># 1 "../dbus/dbus-gtype-specialized.h" 1
># 30 "../dbus/dbus-gtype-specialized.h"
>
>
>GType dbus_g_type_get_collection (const char *container,
>            GType specialization);
>GType dbus_g_type_get_map (const char *container,
>            GType key_specialization,
>            GType value_specialization);
>GType dbus_g_type_get_structv (const char *container,
>            guint num_items,
>            GType *types);
>GType dbus_g_type_get_struct (const char *container,
>                                                             GType first_type,
>                                                             ...);
>gboolean dbus_g_type_is_collection (GType gtype);
>gboolean dbus_g_type_is_map (GType gtype);
>gboolean dbus_g_type_is_struct (GType gtype);
>GType dbus_g_type_get_collection_specialization (GType gtype);
>GType dbus_g_type_get_map_key_specialization (GType gtype);
>GType dbus_g_type_get_map_value_specialization (GType gtype);
>GType dbus_g_type_get_struct_member_type (GType gtype,
>                                                             guint index);
>guint dbus_g_type_get_struct_size (GType gtype);
>
>typedef void (*DBusGTypeSpecializedCollectionIterator) (const GValue *val,
>            gpointer user_data);
>typedef void (*DBusGTypeSpecializedMapIterator) (const GValue *key_val,
>            const GValue *value_val,
>            gpointer user_data);
>
>gpointer dbus_g_type_specialized_construct (GType type);
>
>typedef struct {
>
>  GValue *val;
>  GType specialization_type;
>
>  gpointer b;
>  guint c;
>  gpointer d;
>} DBusGTypeSpecializedAppendContext;
>
>void dbus_g_type_specialized_init_append (GValue *val,
>DBusGTypeSpecializedAppendContext *ctx);
>
>void dbus_g_type_specialized_collection_append
>(DBusGTypeSpecializedAppendContext *ctx, GValue *elt);
>
>void dbus_g_type_specialized_collection_end_append
>(DBusGTypeSpecializedAppendContext *ctx);
>
>void dbus_g_type_specialized_map_append (DBusGTypeSpecializedAppendContext *ctx,
>        GValue *key,
>        GValue *val);
>
>
>gboolean dbus_g_type_collection_get_fixed (GValue *value,
>            gpointer *data,
>            guint *len);
>
>void dbus_g_type_collection_value_iterate (const GValue *value,
>            DBusGTypeSpecializedCollectionIterator iterator,
>            gpointer user_data);
>
>void dbus_g_type_map_value_iterate (const GValue *value,
>            DBusGTypeSpecializedMapIterator iterator,
>            gpointer user_data);
>
>gboolean dbus_g_type_struct_get_member (const GValue *value,
>                                                         guint index,
>                                                         GValue *dest);
>gboolean dbus_g_type_struct_set_member (GValue *value,
>                                                         guint index,
>                                                         const GValue *src);
>
>gboolean dbus_g_type_struct_get (const GValue *value,
>                                                         guint member,
>                                                         ...);
>
>gboolean dbus_g_type_struct_set (GValue *value,
>                                                         guint member,
>                                                         ...);
>
>typedef gpointer (*DBusGTypeSpecializedConstructor) (GType type);
>typedef void (*DBusGTypeSpecializedFreeFunc) (GType type, gpointer val);
>typedef gpointer (*DBusGTypeSpecializedCopyFunc) (GType type, gpointer src);
>
>typedef struct {
>  DBusGTypeSpecializedConstructor constructor;
>  DBusGTypeSpecializedFreeFunc free_func;
>  DBusGTypeSpecializedCopyFunc copy_func;
>  GDestroyNotify simple_free_func;
>  gpointer padding2;
>  gpointer padding3;
>} DBusGTypeSpecializedVtable;
>
>typedef gboolean (*DBusGTypeSpecializedCollectionFixedAccessorFunc)
>(GType type, gpointer instance, gpointer *values, guint *len);
>typedef void (*DBusGTypeSpecializedCollectionIteratorFunc) (GType
>type, gpointer instance, DBusGTypeSpecializedCollectionIterator
>iterator, gpointer user_data);
>typedef void (*DBusGTypeSpecializedCollectionAppendFunc)
>(DBusGTypeSpecializedAppendContext *ctx, GValue *val);
>typedef void (*DBusGTypeSpecializedCollectionEndAppendFunc)
>(DBusGTypeSpecializedAppendContext *ctx);
>
>typedef struct {
>  DBusGTypeSpecializedVtable base_vtable;
>  DBusGTypeSpecializedCollectionFixedAccessorFunc fixed_accessor;
>  DBusGTypeSpecializedCollectionIteratorFunc iterator;
>  DBusGTypeSpecializedCollectionAppendFunc append_func;
>  DBusGTypeSpecializedCollectionEndAppendFunc end_append_func;
>} DBusGTypeSpecializedCollectionVtable;
>
>typedef void (*DBusGTypeSpecializedMapIteratorFunc) (GType type,
>gpointer instance, DBusGTypeSpecializedMapIterator iterator, gpointer
>user_data);
>typedef void (*DBusGTypeSpecializedMapAppendFunc)
>(DBusGTypeSpecializedAppendContext *ctx, GValue *key, GValue *val);
>
>typedef struct {
>  DBusGTypeSpecializedVtable base_vtable;
>  DBusGTypeSpecializedMapIteratorFunc iterator;
>  DBusGTypeSpecializedMapAppendFunc append_func;
>} DBusGTypeSpecializedMapVtable;
>
>typedef gboolean (*DBusGTypeSpecializedStructGetMember) (GType type,
>gpointer instance, guint member, GValue *ret_value);
>typedef gboolean (*DBusGTypeSpecializedStructSetMember) (GType type,
>gpointer instance, guint member, const GValue *new_value);
>
>typedef struct {
>  DBusGTypeSpecializedVtable base_vtable;
>  DBusGTypeSpecializedStructGetMember get_member;
>  DBusGTypeSpecializedStructSetMember set_member;
>} DBusGTypeSpecializedStructVtable;
>
>void dbus_g_type_specialized_init (void);
>
>void dbus_g_type_register_collection (const char *name,
>             const DBusGTypeSpecializedCollectionVtable *vtable,
>             guint flags);
>
>void dbus_g_type_register_map (const char *name,
>             const DBusGTypeSpecializedMapVtable *vtable,
>             guint flags);
>const DBusGTypeSpecializedMapVtable* dbus_g_type_map_peek_vtable
>(GType map_type);
>const DBusGTypeSpecializedCollectionVtable*
>dbus_g_type_collection_peek_vtable (GType collection_type);
>
>void dbus_g_type_register_struct (const char *name,
>             const DBusGTypeSpecializedStructVtable *vtable,
>             guint flags);
>
>const DBusGTypeSpecializedMapVtable* dbus_g_type_map_peek_vtable
>(GType map_type);
>const DBusGTypeSpecializedCollectionVtable*
>dbus_g_type_collection_peek_vtable (GType collection_type);
>
>const DBusGTypeSpecializedStructVtable* dbus_g_type_struct_peek_vtable
>(GType struct_type);
>
>
># 136 "../dbus/dbus-glib.h" 2
># 151 "../dbus/dbus-glib.h"
>GType dbus_g_object_path_get_g_type (void) __attribute__((__const__));
>
>
>void dbus_g_object_register_marshaller (GClosureMarshal marshaller,
>           GType rettype,
>           ...);
>void dbus_g_object_register_marshaller_array(GClosureMarshal marshaller,
>           GType rettype,
>           guint n_types,
>           const GType* types);
>
>typedef struct _DBusGProxy DBusGProxy;
>typedef struct _DBusGProxyClass DBusGProxyClass;
># 172 "../dbus/dbus-glib.h"
>struct _DBusGProxy
>{
>  GObject parent;
>};
>
>struct _DBusGProxyClass
>{
>  GObjectClass parent_class;
>};
>
>typedef struct _DBusGProxyCall DBusGProxyCall;
>typedef void (* DBusGProxyCallNotify) (DBusGProxy *proxy,
>           DBusGProxyCall *call_id,
>           void *user_data);
>
>GType dbus_g_proxy_get_type (void) __attribute__((__const__));
>DBusGProxy* dbus_g_proxy_new_for_name (DBusGConnection *connection,
>                                                      const char *name,
>                                                      const char *path,
>                                                      const char *interface);
>DBusGProxy* dbus_g_proxy_new_for_name_owner (DBusGConnection *connection,
>                                                      const char *name,
>                                                      const char *path,
>                                                      const char *interface,
>                                                      GError **error);
>DBusGProxy* dbus_g_proxy_new_from_proxy (DBusGProxy *proxy,
>                                                      const char *interface,
>                                                      const char *path_name);
>DBusGProxy* dbus_g_proxy_new_for_peer (DBusGConnection *connection,
>                                                      const char *path_name,
>                                                      const char
>*interface_name);
>
>void dbus_g_proxy_set_interface (DBusGProxy *proxy,
>            const char *interface_name);
>void dbus_g_proxy_add_signal (DBusGProxy *proxy,
>            const char *signal_name,
>            GType first_type,
>            ...);
>
>void dbus_g_proxy_connect_signal (DBusGProxy *proxy,
>                                                      const char *signal_name,
>                                                      GCallback handler,
>                                                      void *data,
>                                                      GClosureNotify
>free_data_func);
>void dbus_g_proxy_disconnect_signal (DBusGProxy *proxy,
>                                                      const char *signal_name,
>                                                      GCallback handler,
>                                                      void *data);
>
>gboolean dbus_g_proxy_call (DBusGProxy *proxy,
>            const char *method,
>            GError **error,
>            GType first_arg_type,
>            ...);
>
>gboolean dbus_g_proxy_call_with_timeout (DBusGProxy *proxy,
>                          const char *method,
>                             int timeout,
>                             GError **error,
>                             GType first_arg_type,
>                          ...);
>
>void dbus_g_proxy_call_no_reply (DBusGProxy *proxy,
>                                                      const char *method,
>                                                      GType first_arg_type,
>                                                      ...);
>
>DBusGProxyCall * dbus_g_proxy_begin_call (DBusGProxy *proxy,
>                                                      const char *method,
>            DBusGProxyCallNotify notify,
>            gpointer data,
>            GDestroyNotify destroy,
>                                                      GType first_arg_type,
>                                                      ...);
>DBusGProxyCall * dbus_g_proxy_begin_call_with_timeout (DBusGProxy *proxy,
>                                         const char *method,
>                                         DBusGProxyCallNotify notify,
>                                                       gpointer user_data,
>                                                       GDestroyNotify destroy,
>                                                       int timeout,
>                                                       GType first_arg_type,
>                           ...);
>
>gboolean dbus_g_proxy_end_call (DBusGProxy *proxy,
>                                                      DBusGProxyCall *call,
>                                                      GError **error,
>                                                      GType first_arg_type,
>                                                      ...);
>void dbus_g_proxy_cancel_call (DBusGProxy *proxy,
>                                                      DBusGProxyCall *call);
>
>const char* dbus_g_proxy_get_path (DBusGProxy *proxy);
>
>const char* dbus_g_proxy_get_bus_name (DBusGProxy *proxy);
>
>const char* dbus_g_proxy_get_interface (DBusGProxy *proxy);
>
>typedef struct _DBusGMethodInvocation DBusGMethodInvocation;
>
>void dbus_g_method_return (DBusGMethodInvocation *context, ...);
>
>void dbus_g_method_return_error (DBusGMethodInvocation *context, GError *error);
>
>
>typedef struct {
>  GCallback cb;
>  gpointer userdata;
>} DBusGAsyncData;
>
>
>
>
># 27 "dbus-binding-tool-glib.c" 2
># 1 "dbus-gidl.h" 1
># 29 "dbus-gidl.h"
># 1 "/usr/include/dbus-1.0/dbus/dbus.h" 1
># 29 "/usr/include/dbus-1.0/dbus/dbus.h"
># 1 "/usr/lib/dbus-1.0/include/dbus/dbus-arch-deps.h" 1
># 30 "/usr/lib/dbus-1.0/include/dbus/dbus-arch-deps.h"
># 1 "/usr/include/dbus-1.0/dbus/dbus-macros.h" 1
># 31 "/usr/lib/dbus-1.0/include/dbus/dbus-arch-deps.h" 2
>
>
>
>
>
>typedef long long dbus_int64_t;
>typedef unsigned long long dbus_uint64_t;
># 48 "/usr/lib/dbus-1.0/include/dbus/dbus-arch-deps.h"
>typedef int dbus_int32_t;
>typedef unsigned int dbus_uint32_t;
>
>typedef short dbus_int16_t;
>typedef unsigned short dbus_uint16_t;
>
>
># 30 "/usr/include/dbus-1.0/dbus/dbus.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-address.h" 1
># 30 "/usr/include/dbus-1.0/dbus/dbus-address.h"
># 1 "/usr/include/dbus-1.0/dbus/dbus-types.h" 1
># 30 "/usr/include/dbus-1.0/dbus/dbus-types.h"
># 1 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/stddef.h" 1 3 4
># 31 "/usr/include/dbus-1.0/dbus/dbus-types.h" 2
># 1 "/usr/lib/dbus-1.0/include/dbus/dbus-arch-deps.h" 1
># 32 "/usr/include/dbus-1.0/dbus/dbus-types.h" 2
>
>typedef dbus_uint32_t dbus_unichar_t;
>
>typedef dbus_uint32_t dbus_bool_t;
># 31 "/usr/include/dbus-1.0/dbus/dbus-address.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-errors.h" 1
># 31 "/usr/include/dbus-1.0/dbus/dbus-errors.h"
># 1 "/usr/include/dbus-1.0/dbus/dbus-macros.h" 1
># 32 "/usr/include/dbus-1.0/dbus/dbus-errors.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-types.h" 1
># 33 "/usr/include/dbus-1.0/dbus/dbus-errors.h" 2
>
>
>
>
>
>
>
>
>
>typedef struct DBusError DBusError;
>
>
>
>
>struct DBusError
>{
>  const char *name;
>  const char *message;
>
>  unsigned int dummy1 : 1;
>  unsigned int dummy2 : 1;
>  unsigned int dummy3 : 1;
>  unsigned int dummy4 : 1;
>  unsigned int dummy5 : 1;
>
>  void *padding1;
>};
>
>void dbus_error_init (DBusError *error);
>void dbus_error_free (DBusError *error);
>void dbus_set_error (DBusError *error,
>                                  const char *name,
>                                  const char *message,
>                                  ...);
>void dbus_set_error_const (DBusError *error,
>                                  const char *name,
>                                  const char *message);
>void dbus_move_error (DBusError *src,
>                                  DBusError *dest);
>dbus_bool_t dbus_error_has_name (const DBusError *error,
>                                  const char *name);
>dbus_bool_t dbus_error_is_set (const DBusError *error);
>
>
>
>
># 32 "/usr/include/dbus-1.0/dbus/dbus-address.h" 2
>
>
>
>
>
>
>
>
>
>typedef struct DBusAddressEntry DBusAddressEntry;
>
>dbus_bool_t dbus_parse_address (const char *address,
>        DBusAddressEntry ***entry,
>        int *array_len,
>        DBusError *error);
>const char *dbus_address_entry_get_value (DBusAddressEntry *entry,
>        const char *key);
>const char *dbus_address_entry_get_method (DBusAddressEntry *entry);
>void dbus_address_entries_free (DBusAddressEntry **entries);
>
>char* dbus_address_escape_value (const char *value);
>char* dbus_address_unescape_value (const char *value,
>                                   DBusError *error);
>
>
>
>
># 31 "/usr/include/dbus-1.0/dbus/dbus.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-bus.h" 1
># 30 "/usr/include/dbus-1.0/dbus/dbus-bus.h"
># 1 "/usr/include/dbus-1.0/dbus/dbus-connection.h" 1
># 30 "/usr/include/dbus-1.0/dbus/dbus-connection.h"
># 1 "/usr/include/dbus-1.0/dbus/dbus-errors.h" 1
># 31 "/usr/include/dbus-1.0/dbus/dbus-connection.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-memory.h" 1
># 30 "/usr/include/dbus-1.0/dbus/dbus-memory.h"
># 1 "/usr/include/dbus-1.0/dbus/dbus-macros.h" 1
># 31 "/usr/include/dbus-1.0/dbus/dbus-memory.h" 2
># 1 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/stddef.h" 1 3 4
># 32 "/usr/include/dbus-1.0/dbus/dbus-memory.h" 2
>
>
>
>
>
>
>
>
>void* dbus_malloc (size_t bytes);
>void* dbus_malloc0 (size_t bytes);
>void* dbus_realloc (void *memory,
>                          size_t bytes);
>void dbus_free (void *memory);
>
>
>
>
>void dbus_free_string_array (char **str_array);
>
>typedef void (* DBusFreeFunction) (void *memory);
>
>void dbus_shutdown (void);
>
>
>
>
># 32 "/usr/include/dbus-1.0/dbus/dbus-connection.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-message.h" 1
># 30 "/usr/include/dbus-1.0/dbus/dbus-message.h"
># 1 "/usr/include/dbus-1.0/dbus/dbus-macros.h" 1
># 31 "/usr/include/dbus-1.0/dbus/dbus-message.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-types.h" 1
># 32 "/usr/include/dbus-1.0/dbus/dbus-message.h" 2
># 1 "/usr/lib/dbus-1.0/include/dbus/dbus-arch-deps.h" 1
># 33 "/usr/include/dbus-1.0/dbus/dbus-message.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-memory.h" 1
># 34 "/usr/include/dbus-1.0/dbus/dbus-message.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-errors.h" 1
># 35 "/usr/include/dbus-1.0/dbus/dbus-message.h" 2
>
>
>
>
>
>
>
>
>
>typedef struct DBusMessage DBusMessage;
>
>typedef struct DBusMessageIter DBusMessageIter;
>
>
>
>
>struct DBusMessageIter
>{
>  void *dummy1;
>  void *dummy2;
>  dbus_uint32_t dummy3;
>  int dummy4;
>  int dummy5;
>  int dummy6;
>  int dummy7;
>  int dummy8;
>  int dummy9;
>  int dummy10;
>  int dummy11;
>  int pad1;
>  int pad2;
>  void *pad3;
>};
>
>DBusMessage* dbus_message_new (int message_type);
>DBusMessage* dbus_message_new_method_call (const char *bus_name,
>                                             const char *path,
>                                             const char *interface,
>                                             const char *method);
>DBusMessage* dbus_message_new_method_return (DBusMessage *method_call);
>DBusMessage* dbus_message_new_signal (const char *path,
>                                             const char *interface,
>                                             const char *name);
>DBusMessage* dbus_message_new_error (DBusMessage *reply_to,
>                                             const char *error_name,
>                                             const char *error_message);
>DBusMessage* dbus_message_new_error_printf (DBusMessage *reply_to,
>                                             const char *error_name,
>                                             const char *error_format,
>          ...);
>
>DBusMessage* dbus_message_copy (const DBusMessage *message);
>
>DBusMessage* dbus_message_ref (DBusMessage *message);
>void dbus_message_unref (DBusMessage *message);
>int dbus_message_get_type (DBusMessage *message);
>dbus_bool_t dbus_message_set_path (DBusMessage *message,
>                                             const char *object_path);
>const char* dbus_message_get_path (DBusMessage *message);
>dbus_bool_t dbus_message_has_path (DBusMessage *message,
>                                             const char *object_path);
>dbus_bool_t dbus_message_set_interface (DBusMessage *message,
>                                             const char *interface);
>const char* dbus_message_get_interface (DBusMessage *message);
>dbus_bool_t dbus_message_has_interface (DBusMessage *message,
>                                             const char *interface);
>dbus_bool_t dbus_message_set_member (DBusMessage *message,
>                                             const char *member);
>const char* dbus_message_get_member (DBusMessage *message);
>dbus_bool_t dbus_message_has_member (DBusMessage *message,
>                                             const char *member);
>dbus_bool_t dbus_message_set_error_name (DBusMessage *message,
>                                             const char *name);
>const char* dbus_message_get_error_name (DBusMessage *message);
>dbus_bool_t dbus_message_set_destination (DBusMessage *message,
>                                             const char *destination);
>const char* dbus_message_get_destination (DBusMessage *message);
>dbus_bool_t dbus_message_set_sender (DBusMessage *message,
>                                             const char *sender);
>const char* dbus_message_get_sender (DBusMessage *message);
>const char* dbus_message_get_signature (DBusMessage *message);
>void dbus_message_set_no_reply (DBusMessage *message,
>                                             dbus_bool_t no_reply);
>dbus_bool_t dbus_message_get_no_reply (DBusMessage *message);
>dbus_bool_t dbus_message_is_method_call (DBusMessage *message,
>                                             const char *interface,
>                                             const char *method);
>dbus_bool_t dbus_message_is_signal (DBusMessage *message,
>                                             const char *interface,
>                                             const char *signal_name);
>dbus_bool_t dbus_message_is_error (DBusMessage *message,
>                                             const char *error_name);
>dbus_bool_t dbus_message_has_destination (DBusMessage *message,
>                                             const char *bus_name);
>dbus_bool_t dbus_message_has_sender (DBusMessage *message,
>                                             const char *unique_bus_name);
>dbus_bool_t dbus_message_has_signature (DBusMessage *message,
>                                             const char *signature);
>dbus_uint32_t dbus_message_get_serial (DBusMessage *message);
>dbus_bool_t dbus_message_set_reply_serial (DBusMessage *message,
>                                             dbus_uint32_t reply_serial);
>dbus_uint32_t dbus_message_get_reply_serial (DBusMessage *message);
>
>void dbus_message_set_auto_start (DBusMessage *message,
>                                             dbus_bool_t auto_start);
>dbus_bool_t dbus_message_get_auto_start (DBusMessage *message);
>
>dbus_bool_t dbus_message_get_path_decomposed (DBusMessage *message,
>                                                char ***path);
>
>dbus_bool_t dbus_message_append_args (DBusMessage *message,
>            int first_arg_type,
>            ...);
>dbus_bool_t dbus_message_append_args_valist (DBusMessage *message,
>            int first_arg_type,
>            va_list var_args);
>dbus_bool_t dbus_message_get_args (DBusMessage *message,
>            DBusError *error,
>            int first_arg_type,
>            ...);
>dbus_bool_t dbus_message_get_args_valist (DBusMessage *message,
>            DBusError *error,
>            int first_arg_type,
>            va_list var_args);
>
>
>dbus_bool_t dbus_message_iter_init (DBusMessage *message,
>                                                DBusMessageIter *iter);
>dbus_bool_t dbus_message_iter_has_next (DBusMessageIter *iter);
>dbus_bool_t dbus_message_iter_next (DBusMessageIter *iter);
>char* dbus_message_iter_get_signature (DBusMessageIter *iter);
>int dbus_message_iter_get_arg_type (DBusMessageIter *iter);
>int dbus_message_iter_get_element_type (DBusMessageIter *iter);
>void dbus_message_iter_recurse (DBusMessageIter *iter,
>                                                DBusMessageIter *sub);
>void dbus_message_iter_get_basic (DBusMessageIter *iter,
>                                                void *value);
>
>
>
>
>int dbus_message_iter_get_array_len (DBusMessageIter *iter)
>__attribute__((__deprecated__));
>
>void dbus_message_iter_get_fixed_array (DBusMessageIter *iter,
>                                                void *value,
>                                                int *n_elements);
>
>
>void dbus_message_iter_init_append (DBusMessage *message,
>                                                  DBusMessageIter *iter);
>dbus_bool_t dbus_message_iter_append_basic (DBusMessageIter *iter,
>                                                  int type,
>                                                  const void *value);
>dbus_bool_t dbus_message_iter_append_fixed_array (DBusMessageIter *iter,
>                                                  int element_type,
>                                                  const void *value,
>                                                  int n_elements);
>dbus_bool_t dbus_message_iter_open_container (DBusMessageIter *iter,
>                                                  int type,
>                                                  const char
>*contained_signature,
>                                                  DBusMessageIter *sub);
>dbus_bool_t dbus_message_iter_close_container (DBusMessageIter *iter,
>                                                  DBusMessageIter *sub);
>
>
>dbus_bool_t dbus_set_error_from_message (DBusError *error,
>                                           DBusMessage *message);
>
>
>dbus_bool_t dbus_message_allocate_data_slot (dbus_int32_t *slot_p);
>void dbus_message_free_data_slot (dbus_int32_t *slot_p);
>dbus_bool_t dbus_message_set_data (DBusMessage *message,
>                                             dbus_int32_t slot,
>                                             void *data,
>                                             DBusFreeFunction free_data_func);
>void* dbus_message_get_data (DBusMessage *message,
>                                             dbus_int32_t slot);
>
>int dbus_message_type_from_string (const char *type_str);
>const char * dbus_message_type_to_string (int type);
>
>
>
>
># 33 "/usr/include/dbus-1.0/dbus/dbus-connection.h" 2
>
>
>
>
>
>
>
>
>
>
>typedef struct DBusWatch DBusWatch;
>
>typedef struct DBusTimeout DBusTimeout;
>
>typedef struct DBusPreallocatedSend DBusPreallocatedSend;
>
>typedef struct DBusPendingCall DBusPendingCall;
>
>typedef struct DBusConnection DBusConnection;
>
>typedef struct DBusObjectPathVTable DBusObjectPathVTable;
>
>
>
>
>typedef enum
>{
>  DBUS_WATCH_READABLE = 1 << 0,
>  DBUS_WATCH_WRITABLE = 1 << 1,
>  DBUS_WATCH_ERROR = 1 << 2,
>
>
>
>
>  DBUS_WATCH_HANGUP = 1 << 3
>
>
>
>
>} DBusWatchFlags;
>
>
>
>
>
>typedef enum
>{
>  DBUS_DISPATCH_DATA_REMAINS,
>  DBUS_DISPATCH_COMPLETE,
>  DBUS_DISPATCH_NEED_MEMORY
>} DBusDispatchStatus;
>
>
>
>
>
>
>typedef dbus_bool_t (* DBusAddWatchFunction) (DBusWatch *watch,
>                                                    void *data);
>
>
>
>
>typedef void (* DBusWatchToggledFunction) (DBusWatch *watch,
>                                                    void *data);
>
>
>
>
>typedef void (* DBusRemoveWatchFunction) (DBusWatch *watch,
>                                                    void *data);
>
>
>
>
>
>typedef dbus_bool_t (* DBusAddTimeoutFunction) (DBusTimeout *timeout,
>                                                    void *data);
>
>
>
>
>
>typedef void (* DBusTimeoutToggledFunction) (DBusTimeout *timeout,
>                                                    void *data);
>
>
>
>
>typedef void (* DBusRemoveTimeoutFunction) (DBusTimeout *timeout,
>                                                    void *data);
>
>
>
>typedef void (* DBusDispatchStatusFunction) (DBusConnection *connection,
>                                                    DBusDispatchStatus
>new_status,
>                                                    void *data);
>
>
>
>
>typedef void (* DBusWakeupMainFunction) (void *data);
>
>
>
>
>
>typedef dbus_bool_t (* DBusAllowUnixUserFunction) (DBusConnection *connection,
>                                                    unsigned long uid,
>                                                    void *data);
>
>
>
>
>typedef void (* DBusPendingCallNotifyFunction) (DBusPendingCall *pending,
>                                                void *user_data);
>
>
>
>
>
>typedef DBusHandlerResult (* DBusHandleMessageFunction)
>(DBusConnection *connection,
>                                                         DBusMessage *message,
>                                                         void *user_data);
>
>DBusConnection* dbus_connection_open (const char *address,
>
>DBusError *error);
>DBusConnection* dbus_connection_open_private (const char *address,
>
>DBusError *error);
>DBusConnection* dbus_connection_ref (DBusConnection *connection);
>void dbus_connection_unref (DBusConnection *connection);
>void dbus_connection_close (DBusConnection *connection);
>dbus_bool_t dbus_connection_get_is_connected (DBusConnection *connection);
>dbus_bool_t dbus_connection_get_is_authenticated (DBusConnection *connection);
>void dbus_connection_set_exit_on_disconnect (DBusConnection *connection,
>
>dbus_bool_t exit_on_disconnect);
>void dbus_connection_flush (DBusConnection *connection);
>dbus_bool_t dbus_connection_read_write_dispatch (DBusConnection *connection,
>                                                                 int
>timeout_milliseconds);
>dbus_bool_t dbus_connection_read_write (DBusConnection *connection,
>                                                                 int
>timeout_milliseconds);
>DBusMessage* dbus_connection_borrow_message (DBusConnection *connection);
>void dbus_connection_return_message (DBusConnection *connection,
>
>DBusMessage *message);
>void dbus_connection_steal_borrowed_message (DBusConnection *connection,
>
>DBusMessage *message);
>DBusMessage* dbus_connection_pop_message (DBusConnection *connection);
>DBusDispatchStatus dbus_connection_get_dispatch_status (DBusConnection
>*connection);
>DBusDispatchStatus dbus_connection_dispatch (DBusConnection *connection);
>dbus_bool_t dbus_connection_has_messages_to_send (DBusConnection *connection);
>dbus_bool_t dbus_connection_send (DBusConnection *connection,
>
>DBusMessage *message,
>
>dbus_uint32_t *client_serial);
>dbus_bool_t dbus_connection_send_with_reply (DBusConnection *connection,
>
>DBusMessage *message,
>
>DBusPendingCall **pending_return,
>                                                                 int
>timeout_milliseconds);
>DBusMessage * dbus_connection_send_with_reply_and_block
>(DBusConnection *connection,
>
>DBusMessage *message,
>                                                                 int
>timeout_milliseconds,
>
>DBusError *error);
>dbus_bool_t dbus_connection_set_watch_functions (DBusConnection *connection,
>
>DBusAddWatchFunction add_function,
>
>DBusRemoveWatchFunction remove_function,
>
>DBusWatchToggledFunction toggled_function,
>                                                                 void *data,
>
>DBusFreeFunction free_data_function);
>dbus_bool_t dbus_connection_set_timeout_functions (DBusConnection *connection,
>
>DBusAddTimeoutFunction add_function,
>
>DBusRemoveTimeoutFunction remove_function,
>
>DBusTimeoutToggledFunction toggled_function,
>                                                                 void *data,
>
>DBusFreeFunction free_data_function);
>void dbus_connection_set_wakeup_main_function (DBusConnection *connection,
>
>DBusWakeupMainFunction wakeup_main_function,
>                                                                 void *data,
>
>DBusFreeFunction free_data_function);
>void dbus_connection_set_dispatch_status_function (DBusConnection *connection,
>
>DBusDispatchStatusFunction function,
>                                                                 void *data,
>
>DBusFreeFunction free_data_function);
>dbus_bool_t dbus_connection_get_unix_user (DBusConnection *connection,
>
>unsigned long *uid);
>dbus_bool_t dbus_connection_get_unix_process_id (DBusConnection *connection,
>
>unsigned long *pid);
>void dbus_connection_set_unix_user_function (DBusConnection *connection,
>
>DBusAllowUnixUserFunction function,
>                                                                 void *data,
>
>DBusFreeFunction free_data_function);
>void dbus_connection_set_route_peer_messages (DBusConnection *connection,
>
>dbus_bool_t value);
>
>
>
>
>dbus_bool_t dbus_connection_add_filter (DBusConnection *connection,
>                                           DBusHandleMessageFunction function,
>                                           void *user_data,
>                                           DBusFreeFunction free_data_function);
>void dbus_connection_remove_filter (DBusConnection *connection,
>                                           DBusHandleMessageFunction function,
>                                           void *user_data);
>
>
>
>dbus_bool_t dbus_connection_allocate_data_slot (dbus_int32_t *slot_p);
>void dbus_connection_free_data_slot (dbus_int32_t *slot_p);
>dbus_bool_t dbus_connection_set_data (DBusConnection *connection,
>                                                dbus_int32_t slot,
>                                                void *data,
>                                                DBusFreeFunction
>free_data_func);
>void* dbus_connection_get_data (DBusConnection *connection,
>                                                dbus_int32_t slot);
>
>void dbus_connection_set_change_sigpipe (dbus_bool_t will_modify_sigpipe);
>
>void dbus_connection_set_max_message_size (DBusConnection *connection,
>                                            long size);
>long dbus_connection_get_max_message_size (DBusConnection *connection);
>void dbus_connection_set_max_received_size (DBusConnection *connection,
>                                            long size);
>long dbus_connection_get_max_received_size (DBusConnection *connection);
>long dbus_connection_get_outgoing_size (DBusConnection *connection);
>
>DBusPreallocatedSend* dbus_connection_preallocate_send (DBusConnection
>*connection);
>void dbus_connection_free_preallocated_send (DBusConnection *connection,
>
>DBusPreallocatedSend *preallocated);
>void dbus_connection_send_preallocated (DBusConnection *connection,
>
>DBusPreallocatedSend *preallocated,
>
>DBusMessage *message,
>
>dbus_uint32_t *client_serial);
># 272 "/usr/include/dbus-1.0/dbus/dbus-connection.h"
>typedef void (* DBusObjectPathUnregisterFunction) (DBusConnection *connection,
>                                                                void
>*user_data);
>
>
>
>
>
>typedef DBusHandlerResult (* DBusObjectPathMessageFunction)
>(DBusConnection *connection,
>
>DBusMessage *message,
>                                                                void
>*user_data);
>
>
>
>
>
>
>
>struct DBusObjectPathVTable
>{
>  DBusObjectPathUnregisterFunction unregister_function;
>  DBusObjectPathMessageFunction message_function;
>
>  void (* dbus_internal_pad1) (void *);
>  void (* dbus_internal_pad2) (void *);
>  void (* dbus_internal_pad3) (void *);
>  void (* dbus_internal_pad4) (void *);
>};
>
>dbus_bool_t dbus_connection_register_object_path (DBusConnection *connection,
>                                                    const char *path,
>                                                    const
>DBusObjectPathVTable *vtable,
>                                                    void *user_data);
>dbus_bool_t dbus_connection_register_fallback (DBusConnection *connection,
>                                                    const char *path,
>                                                    const
>DBusObjectPathVTable *vtable,
>                                                    void *user_data);
>dbus_bool_t dbus_connection_unregister_object_path (DBusConnection *connection,
>                                                    const char *path);
>
>dbus_bool_t dbus_connection_get_object_path_data (DBusConnection *connection,
>                                                    const char *path,
>                                                    void **data_p);
>
>dbus_bool_t dbus_connection_list_registered (DBusConnection *connection,
>                                                    const char *parent_path,
>                                                    char ***child_entries);
>
>dbus_bool_t dbus_connection_get_unix_fd (DBusConnection *connection,
>                                                    int *fd);
>dbus_bool_t dbus_connection_get_socket (DBusConnection *connection,
>                                                    int *fd);
># 332 "/usr/include/dbus-1.0/dbus/dbus-connection.h"
>int dbus_watch_get_fd (DBusWatch *watch);
>unsigned int dbus_watch_get_flags (DBusWatch *watch);
>void* dbus_watch_get_data (DBusWatch *watch);
>void dbus_watch_set_data (DBusWatch *watch,
>                                     void *data,
>                                     DBusFreeFunction free_data_function);
>dbus_bool_t dbus_watch_handle (DBusWatch *watch,
>                                     unsigned int flags);
>dbus_bool_t dbus_watch_get_enabled (DBusWatch *watch);
># 349 "/usr/include/dbus-1.0/dbus/dbus-connection.h"
>int dbus_timeout_get_interval (DBusTimeout *timeout);
>void* dbus_timeout_get_data (DBusTimeout *timeout);
>void dbus_timeout_set_data (DBusTimeout *timeout,
>                                       void *data,
>                                       DBusFreeFunction free_data_function);
>dbus_bool_t dbus_timeout_handle (DBusTimeout *timeout);
>dbus_bool_t dbus_timeout_get_enabled (DBusTimeout *timeout);
>
>
>
>
># 31 "/usr/include/dbus-1.0/dbus/dbus-bus.h" 2
>
>
>
>
>
>
>
>
>DBusConnection *dbus_bus_get (DBusBusType type,
>        DBusError *error);
>DBusConnection *dbus_bus_get_private (DBusBusType type,
>        DBusError *error);
>
>dbus_bool_t dbus_bus_register (DBusConnection *connection,
>        DBusError *error);
>dbus_bool_t dbus_bus_set_unique_name (DBusConnection *connection,
>        const char *unique_name);
>const char* dbus_bus_get_unique_name (DBusConnection *connection);
>unsigned long dbus_bus_get_unix_user (DBusConnection *connection,
>                      const char *name,
>                                           DBusError *error);
>int dbus_bus_request_name (DBusConnection *connection,
>        const char *name,
>        unsigned int flags,
>        DBusError *error);
>int dbus_bus_release_name (DBusConnection *connection,
>        const char *name,
>        DBusError *error);
>dbus_bool_t dbus_bus_name_has_owner (DBusConnection *connection,
>        const char *name,
>        DBusError *error);
>
>dbus_bool_t dbus_bus_start_service_by_name (DBusConnection *connection,
>                                                const char *name,
>                                                dbus_uint32_t flags,
>                                                dbus_uint32_t *reply,
>                                                DBusError *error);
>
>void dbus_bus_add_match (DBusConnection *connection,
>                                           const char *rule,
>                                           DBusError *error);
>void dbus_bus_remove_match (DBusConnection *connection,
>                                           const char *rule,
>                                           DBusError *error);
>
>
>
>
># 32 "/usr/include/dbus-1.0/dbus/dbus.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-connection.h" 1
># 33 "/usr/include/dbus-1.0/dbus/dbus.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-errors.h" 1
># 34 "/usr/include/dbus-1.0/dbus/dbus.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-macros.h" 1
># 35 "/usr/include/dbus-1.0/dbus/dbus.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-message.h" 1
># 36 "/usr/include/dbus-1.0/dbus/dbus.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-misc.h" 1
># 30 "/usr/include/dbus-1.0/dbus/dbus-misc.h"
># 1 "/usr/include/dbus-1.0/dbus/dbus-types.h" 1
># 31 "/usr/include/dbus-1.0/dbus/dbus-misc.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-errors.h" 1
># 32 "/usr/include/dbus-1.0/dbus/dbus-misc.h" 2
>
>
>
>
>
>
>
>
>char* dbus_get_local_machine_id (void);
>
>
>
>
># 37 "/usr/include/dbus-1.0/dbus/dbus.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-pending-call.h" 1
># 30 "/usr/include/dbus-1.0/dbus/dbus-pending-call.h"
># 1 "/usr/include/dbus-1.0/dbus/dbus-macros.h" 1
># 31 "/usr/include/dbus-1.0/dbus/dbus-pending-call.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-types.h" 1
># 32 "/usr/include/dbus-1.0/dbus/dbus-pending-call.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-connection.h" 1
># 33 "/usr/include/dbus-1.0/dbus/dbus-pending-call.h" 2
>
>
>
>
>
>
>
>
>DBusPendingCall* dbus_pending_call_ref (DBusPendingCall *pending);
>void dbus_pending_call_unref (DBusPendingCall *pending);
>dbus_bool_t dbus_pending_call_set_notify (DBusPendingCall *pending,
>
>DBusPendingCallNotifyFunction function,
>                                              void *user_data,
>                                              DBusFreeFunction free_user_data);
>void dbus_pending_call_cancel (DBusPendingCall *pending);
>dbus_bool_t dbus_pending_call_get_completed (DBusPendingCall *pending);
>DBusMessage* dbus_pending_call_steal_reply (DBusPendingCall *pending);
>void dbus_pending_call_block (DBusPendingCall *pending);
>
>dbus_bool_t dbus_pending_call_allocate_data_slot (dbus_int32_t *slot_p);
>void dbus_pending_call_free_data_slot (dbus_int32_t *slot_p);
>dbus_bool_t dbus_pending_call_set_data (DBusPendingCall *pending,
>                                                  dbus_int32_t slot,
>                                                  void *data,
>                                                  DBusFreeFunction
>free_data_func);
>void* dbus_pending_call_get_data (DBusPendingCall *pending,
>                                                  dbus_int32_t slot);
>
>
>
>
># 38 "/usr/include/dbus-1.0/dbus/dbus.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-protocol.h" 1
># 39 "/usr/include/dbus-1.0/dbus/dbus.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-server.h" 1
># 30 "/usr/include/dbus-1.0/dbus/dbus-server.h"
># 1 "/usr/include/dbus-1.0/dbus/dbus-errors.h" 1
># 31 "/usr/include/dbus-1.0/dbus/dbus-server.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-message.h" 1
># 32 "/usr/include/dbus-1.0/dbus/dbus-server.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-connection.h" 1
># 33 "/usr/include/dbus-1.0/dbus/dbus-server.h" 2
>
>
>
>
>
>
>
>
>
>typedef struct DBusServer DBusServer;
>
>
>
>
>typedef void (* DBusNewConnectionFunction) (DBusServer *server,
>                                            DBusConnection *new_connection,
>                                            void *data);
>
>DBusServer* dbus_server_listen (const char *address,
>                                          DBusError *error);
>DBusServer* dbus_server_ref (DBusServer *server);
>void dbus_server_unref (DBusServer *server);
>void dbus_server_disconnect (DBusServer *server);
>dbus_bool_t dbus_server_get_is_connected (DBusServer *server);
>char* dbus_server_get_address (DBusServer *server);
>void dbus_server_set_new_connection_function (DBusServer *server,
>
>DBusNewConnectionFunction function,
>                                                     void *data,
>                                                     DBusFreeFunction
>free_data_function);
>dbus_bool_t dbus_server_set_watch_functions (DBusServer *server,
>
>DBusAddWatchFunction add_function,
>
>DBusRemoveWatchFunction remove_function,
>
>DBusWatchToggledFunction toggled_function,
>                                                     void *data,
>                                                     DBusFreeFunction
>free_data_function);
>dbus_bool_t dbus_server_set_timeout_functions (DBusServer *server,
>
>DBusAddTimeoutFunction add_function,
>
>DBusRemoveTimeoutFunction remove_function,
>
>DBusTimeoutToggledFunction toggled_function,
>                                                     void *data,
>                                                     DBusFreeFunction
>free_data_function);
>dbus_bool_t dbus_server_set_auth_mechanisms (DBusServer *server,
>                                                     const char **mechanisms);
>
>dbus_bool_t dbus_server_allocate_data_slot (dbus_int32_t *slot_p);
>void dbus_server_free_data_slot (dbus_int32_t *slot_p);
>dbus_bool_t dbus_server_set_data (DBusServer *server,
>                                            int slot,
>                                            void *data,
>                                            DBusFreeFunction free_data_func);
>void* dbus_server_get_data (DBusServer *server,
>                                            int slot);
>
>
>
>
># 40 "/usr/include/dbus-1.0/dbus/dbus.h" 2
>
># 1 "/usr/include/dbus-1.0/dbus/dbus-signature.h" 1
># 30 "/usr/include/dbus-1.0/dbus/dbus-signature.h"
># 1 "/usr/include/dbus-1.0/dbus/dbus-macros.h" 1
># 31 "/usr/include/dbus-1.0/dbus/dbus-signature.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-types.h" 1
># 32 "/usr/include/dbus-1.0/dbus/dbus-signature.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-errors.h" 1
># 33 "/usr/include/dbus-1.0/dbus/dbus-signature.h" 2
>
>
># 44 "/usr/include/dbus-1.0/dbus/dbus-signature.h"
>typedef struct
>{
>  void *dummy1;
>  void *dummy2;
>  dbus_uint32_t dummy8;
>  int dummy12;
>  int dummy17;
>} DBusSignatureIter;
>
>void dbus_signature_iter_init (DBusSignatureIter *iter,
>            const char *signature);
>
>int dbus_signature_iter_get_current_type (const DBusSignatureIter *iter);
>
>char * dbus_signature_iter_get_signature (const DBusSignatureIter *iter);
>
>int dbus_signature_iter_get_element_type (const DBusSignatureIter *iter);
>
>dbus_bool_t dbus_signature_iter_next (DBusSignatureIter *iter);
>
>void dbus_signature_iter_recurse (const DBusSignatureIter *iter,
>            DBusSignatureIter *subiter);
>
>dbus_bool_t dbus_signature_validate (const char *signature,
>            DBusError *error);
>
>dbus_bool_t dbus_signature_validate_single (const char *signature,
>            DBusError *error);
>
>dbus_bool_t dbus_type_is_basic (int typecode);
>dbus_bool_t dbus_type_is_container (int typecode);
>dbus_bool_t dbus_type_is_fixed (int typecode);
>
>
>
>
># 42 "/usr/include/dbus-1.0/dbus/dbus.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-threads.h" 1
># 30 "/usr/include/dbus-1.0/dbus/dbus-threads.h"
># 1 "/usr/include/dbus-1.0/dbus/dbus-macros.h" 1
># 31 "/usr/include/dbus-1.0/dbus/dbus-threads.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-types.h" 1
># 32 "/usr/include/dbus-1.0/dbus/dbus-threads.h" 2
>
>
>
>
>
>
>
>
>
>typedef struct DBusMutex DBusMutex;
>
>typedef struct DBusCondVar DBusCondVar;
>
>
>typedef DBusMutex* (* DBusMutexNewFunction) (void);
>
>typedef void (* DBusMutexFreeFunction) (DBusMutex *mutex);
>
>typedef dbus_bool_t (* DBusMutexLockFunction) (DBusMutex *mutex);
>
>typedef dbus_bool_t (* DBusMutexUnlockFunction) (DBusMutex *mutex);
># 61 "/usr/include/dbus-1.0/dbus/dbus-threads.h"
>typedef DBusMutex* (* DBusRecursiveMutexNewFunction) (void);
>
>
>typedef void (* DBusRecursiveMutexFreeFunction) (DBusMutex *mutex);
>
>
>
>typedef void (* DBusRecursiveMutexLockFunction) (DBusMutex *mutex);
>
>
>
>typedef void (* DBusRecursiveMutexUnlockFunction) (DBusMutex *mutex);
>
>
>
>
>typedef DBusCondVar* (* DBusCondVarNewFunction) (void);
>
>
>typedef void (* DBusCondVarFreeFunction) (DBusCondVar *cond);
># 92 "/usr/include/dbus-1.0/dbus/dbus-threads.h"
>typedef void (* DBusCondVarWaitFunction) (DBusCondVar *cond,
>         DBusMutex *mutex);
>
>
>
>
>
>
>
>typedef dbus_bool_t (* DBusCondVarWaitTimeoutFunction) (DBusCondVar *cond,
>         DBusMutex *mutex,
>         int timeout_milliseconds);
>
>
>
>
>typedef void (* DBusCondVarWakeOneFunction) (DBusCondVar *cond);
>
>
>
>
>
>typedef void (* DBusCondVarWakeAllFunction) (DBusCondVar *cond);
>
>
>
>
>
>
>typedef enum
>{
>  DBUS_THREAD_FUNCTIONS_MUTEX_NEW_MASK = 1 << 0,
>  DBUS_THREAD_FUNCTIONS_MUTEX_FREE_MASK = 1 << 1,
>  DBUS_THREAD_FUNCTIONS_MUTEX_LOCK_MASK = 1 << 2,
>  DBUS_THREAD_FUNCTIONS_MUTEX_UNLOCK_MASK = 1 << 3,
>  DBUS_THREAD_FUNCTIONS_CONDVAR_NEW_MASK = 1 << 4,
>  DBUS_THREAD_FUNCTIONS_CONDVAR_FREE_MASK = 1 << 5,
>  DBUS_THREAD_FUNCTIONS_CONDVAR_WAIT_MASK = 1 << 6,
>  DBUS_THREAD_FUNCTIONS_CONDVAR_WAIT_TIMEOUT_MASK = 1 << 7,
>  DBUS_THREAD_FUNCTIONS_CONDVAR_WAKE_ONE_MASK = 1 << 8,
>  DBUS_THREAD_FUNCTIONS_CONDVAR_WAKE_ALL_MASK = 1 << 9,
>  DBUS_THREAD_FUNCTIONS_RECURSIVE_MUTEX_NEW_MASK = 1 << 10,
>  DBUS_THREAD_FUNCTIONS_RECURSIVE_MUTEX_FREE_MASK = 1 << 11,
>  DBUS_THREAD_FUNCTIONS_RECURSIVE_MUTEX_LOCK_MASK = 1 << 12,
>  DBUS_THREAD_FUNCTIONS_RECURSIVE_MUTEX_UNLOCK_MASK = 1 << 13,
>  DBUS_THREAD_FUNCTIONS_ALL_MASK = (1 << 14) - 1
>} DBusThreadFunctionsMask;
># 161 "/usr/include/dbus-1.0/dbus/dbus-threads.h"
>typedef struct
>{
>  unsigned int mask;
>
>  DBusMutexNewFunction mutex_new;
>  DBusMutexFreeFunction mutex_free;
>  DBusMutexLockFunction mutex_lock;
>  DBusMutexUnlockFunction mutex_unlock;
>
>  DBusCondVarNewFunction condvar_new;
>  DBusCondVarFreeFunction condvar_free;
>  DBusCondVarWaitFunction condvar_wait;
>  DBusCondVarWaitTimeoutFunction condvar_wait_timeout;
>  DBusCondVarWakeOneFunction condvar_wake_one;
>  DBusCondVarWakeAllFunction condvar_wake_all;
>
>  DBusRecursiveMutexNewFunction recursive_mutex_new;
>  DBusRecursiveMutexFreeFunction recursive_mutex_free;
>  DBusRecursiveMutexLockFunction recursive_mutex_lock;
>  DBusRecursiveMutexUnlockFunction recursive_mutex_unlock;
>
>  void (* padding1) (void);
>  void (* padding2) (void);
>  void (* padding3) (void);
>  void (* padding4) (void);
>
>} DBusThreadFunctions;
>
>dbus_bool_t dbus_threads_init (const DBusThreadFunctions *functions);
>dbus_bool_t dbus_threads_init_default (void);
>
>
>
>
># 43 "/usr/include/dbus-1.0/dbus/dbus.h" 2
># 1 "/usr/include/dbus-1.0/dbus/dbus-types.h" 1
># 44 "/usr/include/dbus-1.0/dbus/dbus.h" 2
># 30 "dbus-gidl.h" 2
>
>
>
>
>typedef struct BaseInfo BaseInfo;
>typedef struct NodeInfo NodeInfo;
>typedef struct InterfaceInfo InterfaceInfo;
>typedef struct MethodInfo MethodInfo;
>typedef struct SignalInfo SignalInfo;
>typedef struct PropertyInfo PropertyInfo;
>typedef struct ArgInfo ArgInfo;
>
>typedef enum
>{
>  ARG_INVALID = -1,
>  ARG_IN,
>  ARG_OUT
>} ArgDirection;
>
>typedef enum
>{
>  PROPERTY_READ = 1 << 0,
>  PROPERTY_WRITE = 1 << 1
>} PropertyAccessFlags;
>
>typedef enum
>{
>  INFO_TYPE_NODE,
>  INFO_TYPE_INTERFACE,
>  INFO_TYPE_METHOD,
>  INFO_TYPE_SIGNAL,
>  INFO_TYPE_ARG,
>  INFO_TYPE_PROPERTY
>
>} InfoType;
>
>BaseInfo* base_info_ref (BaseInfo *info);
>void base_info_unref (BaseInfo *info);
>InfoType base_info_get_type (BaseInfo *info);
>const char* base_info_get_name (BaseInfo *info);
>void base_info_set_name (BaseInfo *info,
>                                           const char *name);
>GType base_info_get_gtype (void);
>
>
>
>NodeInfo* node_info_new (const char *name);
>NodeInfo* node_info_ref (NodeInfo *info);
>void node_info_unref (NodeInfo *info);
>const char* node_info_get_name (NodeInfo *info);
>GSList* node_info_get_interfaces (NodeInfo *info);
>GSList* node_info_get_nodes (NodeInfo *info);
>void node_info_add_interface (NodeInfo *info,
>                                                   InterfaceInfo *interface);
>void node_info_add_node (NodeInfo *info,
>                                                   NodeInfo *child);
>void node_info_replace_node (NodeInfo *info,
>                                                   NodeInfo *old_child,
>                                                   NodeInfo *new_child);
>InterfaceInfo* interface_info_new (const char *name);
>InterfaceInfo* interface_info_ref (InterfaceInfo *info);
>void interface_info_unref (InterfaceInfo *info);
>const char* interface_info_get_name (InterfaceInfo *info);
>GSList* interface_info_get_annotations(InterfaceInfo *info);
>const char* interface_info_get_annotation (InterfaceInfo*info,
>         const char *annotation);
>GSList* interface_info_get_methods (InterfaceInfo *info);
>GSList* interface_info_get_signals (InterfaceInfo *info);
>GSList* interface_info_get_properties (InterfaceInfo *info);
>void interface_info_add_annotation (InterfaceInfo *info,
>         const char *name,
>         const char *value);
>void interface_info_add_method (InterfaceInfo *info,
>                                                   MethodInfo *method);
>void interface_info_add_signal (InterfaceInfo *info,
>                                                   SignalInfo *signal);
>void interface_info_add_property (InterfaceInfo *info,
>                                                   PropertyInfo *property);
>MethodInfo* method_info_new (const char *name);
>MethodInfo* method_info_ref (MethodInfo *info);
>void method_info_unref (MethodInfo *info);
>const char* method_info_get_name (MethodInfo *info);
>GSList* method_info_get_annotations (MethodInfo *info);
>const char* method_info_get_annotation (MethodInfo *info,
>         const char *annotation);
>void method_info_add_annotation (MethodInfo *info,
>         const char *name,
>         const char *value);
>GSList* method_info_get_args (MethodInfo *info);
>void method_info_add_arg (MethodInfo *info,
>                                                   ArgInfo *arg);
>int method_info_get_n_args (MethodInfo *info);
>SignalInfo* signal_info_new (const char *name);
>SignalInfo* signal_info_ref (SignalInfo *info);
>void signal_info_unref (SignalInfo *info);
>const char* signal_info_get_name (SignalInfo *info);
>GSList* signal_info_get_args (SignalInfo *info);
>void signal_info_add_arg (SignalInfo *info,
>                                                   ArgInfo *arg);
>int signal_info_get_n_args (SignalInfo *info);
>PropertyInfo* property_info_new (const char *name,
>                                                   const char *type,
>                                                   PropertyAccessFlags access);
>PropertyInfo* property_info_ref (PropertyInfo *info);
>void property_info_unref (PropertyInfo *info);
>const char* property_info_get_name (PropertyInfo *info);
>const char* property_info_get_type (PropertyInfo *info);
>PropertyAccessFlags property_info_get_access (PropertyInfo *info);
>ArgInfo* arg_info_new (const char *name,
>                                                   ArgDirection direction,
>                                                   const char *type);
>ArgInfo* arg_info_ref (ArgInfo *info);
>void arg_info_unref (ArgInfo *info);
>const char* arg_info_get_name (ArgInfo *info);
>const char* arg_info_get_type (ArgInfo *info);
>ArgDirection arg_info_get_direction (ArgInfo *info);
>GSList* arg_info_get_annotations (ArgInfo *info);
>const char* arg_info_get_annotation (ArgInfo *info,
>         const char *annotation);
>void arg_info_add_annotation (ArgInfo *info,
>         const char *name,
>         const char *value);
>
>
>
># 28 "dbus-binding-tool-glib.c" 2
># 1 "dbus-gparser.h" 1
># 30 "dbus-gparser.h"
>
>
>typedef struct Parser Parser;
>
>Parser* parser_new (void);
>Parser* parser_ref (Parser *parser);
>void parser_unref (Parser *parser);
>gboolean parser_check_doctype (Parser *parser,
>                               const char *doctype,
>                               GError **error);
>gboolean parser_start_element (Parser *parser,
>                               const char *element_name,
>                               const char **attribute_names,
>                               const char **attribute_values,
>                               GError **error);
>gboolean parser_end_element (Parser *parser,
>                               const char *element_name,
>                               GError **error);
>gboolean parser_content (Parser *parser,
>                               const char *content,
>                               int len,
>                               GError **error);
>gboolean parser_finished (Parser *parser,
>                               GError **error);
>
>NodeInfo* description_load_from_file (const char *filename,
>                                        GError **error);
>NodeInfo* description_load_from_string (const char *str,
>                                        int len,
>                                        GError **error);
>
>NodeInfo* parser_get_nodes (Parser *parser);
>
>
># 29 "dbus-binding-tool-glib.c" 2
># 1 "dbus-gutils.h" 1
># 32 "dbus-gutils.h"
>
>
>char **_dbus_gutils_split_path (const char *path);
>
>char *_dbus_gutils_wincaps_to_uscore (const char *uscore);
># 53 "dbus-gutils.h"
>
># 30 "dbus-binding-tool-glib.c" 2
># 1 "dbus-gtype-specialized.h" 1
># 31 "dbus-binding-tool-glib.c" 2
># 1 "dbus-gsignature.h" 1
>
>
>
>
># 1 "/usr/include/dbus-1.0/dbus/dbus-signature.h" 1
># 6 "dbus-gsignature.h" 2
>
>
>GType _dbus_gtype_from_basic_typecode (int typecode);
>
>GType _dbus_gtype_from_signature (const char *signature,
>            gboolean is_client);
>
>GType _dbus_gtype_from_signature_iter (DBusSignatureIter *sigiter,
>            gboolean is_client);
>
>GArray * _dbus_gtypes_from_arg_signature (const char *signature,
>      gboolean is_client);
># 32 "dbus-binding-tool-glib.c" 2
># 1 "dbus-gvalue-utils.h" 1
># 30 "dbus-gvalue-utils.h"
>
>
>void _dbus_g_type_specialized_builtins_init (void);
>
>gboolean _dbus_g_type_is_fixed (GType gtype);
>guint _dbus_g_type_fixed_get_size (GType gtype);
>
>gboolean _dbus_gvalue_set_from_pointer (GValue *value,
>            gconstpointer storage);
>
>typedef void (*DBusGHashValueForeachFunc) (GValue * key, GValue *val,
>gpointer data);
>
>void _dbus_g_hash_table_value_foreach (GHashTable *table,
>            GType hash_type,
>            DBusGHashValueForeachFunc func,
>            gpointer data);
>
>void _dbus_g_hash_table_insert_values (GHashTable *table,
>            GValue *key_val,
>            GValue *value_val);
>void _dbus_g_hash_table_insert_steal_values (GHashTable *table,
>            GValue *key_val,
>            GValue *value_val);
>
>gboolean _dbus_gtype_is_valid_hash_key (GType type);
>gboolean _dbus_gtype_is_valid_hash_value (GType type);
>
>GHashFunc _dbus_g_hash_func_from_gtype (GType gtype);
>GEqualFunc _dbus_g_hash_equal_from_gtype (GType gtype);
>GDestroyNotify _dbus_g_hash_free_from_gtype (GType gtype);
>
>gboolean _dbus_gvalue_store (GValue *value,
>            gpointer storage);
>
>gboolean _dbus_gvalue_take (GValue *value,
>            GTypeCValue *cvalue);
>
>gboolean _dbus_gtype_can_signal_error (GType gtype);
>gboolean _dbus_gvalue_signals_error (const GValue *value);
>
>
>
># 33 "dbus-binding-tool-glib.c" 2
># 1 "dbus-glib-tool.h" 1
># 28 "dbus-glib-tool.h"
>typedef enum
>{
>  DBUS_BINDING_TOOL_ERROR_UNSUPPORTED_CONVERSION,
>  DBUS_BINDING_TOOL_ERROR_INVALID_ANNOTATION
>} DBusBindingToolError;
>
>
>
>GQuark dbus_binding_tool_error_quark (void);
># 34 "dbus-binding-tool-glib.c" 2
># 1 "dbus-binding-tool-glib.h" 1
># 26 "dbus-binding-tool-glib.h"
>
># 35 "dbus-binding-tool-glib.h"
>gboolean dbus_binding_tool_output_glib_client (BaseInfo *info,
>GIOChannel *channel, gboolean ignore_unsupported, GError **error);
>gboolean dbus_binding_tool_output_glib_server (BaseInfo *info,
>GIOChannel *channel, const char *prefix, GError **error);
>
>
># 35 "dbus-binding-tool-glib.c" 2
># 1 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gi18n.h" 1
># 23 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gi18n.h"
># 1 "/usr/include/libintl.h" 1 3 4
># 22 "/usr/include/libintl.h" 3 4
># 1 "/usr/include/locale.h" 1 3 4
># 24 "/usr/include/locale.h" 3 4
>
>
>struct lconv
>{
>  char *decimal_point;
>  char *thousands_sep;
>  char *grouping;
>  char *int_curr_symbol;
>  char *currency_symbol;
>  char *mon_decimal_point;
>  char *mon_thousands_sep;
>  char *mon_grouping;
>  char *positive_sign;
>  char *negative_sign;
>  char int_frac_digits;
>  char frac_digits;
>  char p_cs_precedes;
>  char p_sep_by_space;
>  char n_cs_precedes;
>  char n_sep_by_space;
>  char p_sign_posn;
>  char n_sign_posn;
>};
>
>
>char *__attribute__((__cdecl__)) setlocale (int category, const char *locale);
>struct lconv *__attribute__((__cdecl__)) localeconv (void);
>
>
>struct _reent;
>char *__attribute__((__cdecl__)) _setlocale_r (struct _reent *, int
>category, const char *locale);
>struct lconv *__attribute__((__cdecl__)) _localeconv_r (struct _reent *);
>
>
># 23 "/usr/include/libintl.h" 2 3 4
># 57 "/usr/include/libintl.h" 3 4
>extern int libintl_version;
># 133 "/usr/include/libintl.h" 3 4
>extern char *gettext (const char *__msgid)
>       __asm__ ("_" "libintl_gettext")
>       __attribute__ ((__format_arg__ (1)));
># 151 "/usr/include/libintl.h" 3 4
>extern char *dgettext (const char *__domainname, const char *__msgid)
>       __asm__ ("_" "libintl_dgettext")
>       __attribute__ ((__format_arg__ (2)));
># 171 "/usr/include/libintl.h" 3 4
>extern char *dcgettext (const char *__domainname, const char *__msgid,
>   int __category)
>       __asm__ ("_" "libintl_dcgettext")
>       __attribute__ ((__format_arg__ (2)));
># 193 "/usr/include/libintl.h" 3 4
>extern char *ngettext (const char *__msgid1, const char *__msgid2,
>         unsigned long int __n)
>       __asm__ ("_" "libintl_ngettext")
>       __attribute__ ((__format_arg__ (1))) __attribute__
>((__format_arg__ (2)));
># 214 "/usr/include/libintl.h" 3 4
>extern char *dngettext (const char *__domainname,
>   const char *__msgid1, const char *__msgid2,
>   unsigned long int __n)
>       __asm__ ("_" "libintl_dngettext")
>       __attribute__ ((__format_arg__ (2))) __attribute__
>((__format_arg__ (3)));
># 238 "/usr/include/libintl.h" 3 4
>extern char *dcngettext (const char *__domainname,
>    const char *__msgid1, const char *__msgid2,
>    unsigned long int __n, int __category)
>       __asm__ ("_" "libintl_dcngettext")
>       __attribute__ ((__format_arg__ (2))) __attribute__
>((__format_arg__ (3)));
># 260 "/usr/include/libintl.h" 3 4
>extern char *textdomain (const char *__domainname)
>       __asm__ ("_" "libintl_textdomain");
># 278 "/usr/include/libintl.h" 3 4
>extern char *bindtextdomain (const char *__domainname, const char *__dirname)
>       __asm__ ("_" "libintl_bindtextdomain");
># 296 "/usr/include/libintl.h" 3 4
>extern char *bind_textdomain_codeset (const char *__domainname,
>          const char *__codeset)
>       __asm__ ("_" "libintl_bind_textdomain_codeset");
># 408 "/usr/include/libintl.h" 3 4
>extern void
>       libintl_set_relocation_prefix (const char *orig_prefix,
>          const char *curr_prefix);
># 24 "C:/mono/Mono-1.2.4/include/glib-2.0/glib/gi18n.h" 2
># 36 "dbus-binding-tool-glib.c" 2
># 1 "/usr/include/stdio.h" 1 3 4
># 34 "/usr/include/stdio.h" 3 4
># 1 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/stddef.h" 1 3 4
># 35 "/usr/include/stdio.h" 2 3 4
># 48 "/usr/include/stdio.h" 3 4
>
>
>typedef __FILE FILE;
>
>
>
>typedef _fpos64_t fpos_t;
># 65 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/sys/stdio.h" 1 3 4
># 29 "/usr/include/sys/stdio.h" 3 4
>
>
>
>
>
>
>
>
># 66 "/usr/include/stdio.h" 2 3 4
># 170 "/usr/include/stdio.h" 3 4
>FILE * __attribute__((__cdecl__)) tmpfile (void);
>char * __attribute__((__cdecl__)) tmpnam (char *);
>int __attribute__((__cdecl__)) fclose (FILE *);
>int __attribute__((__cdecl__)) fflush (FILE *);
>FILE * __attribute__((__cdecl__)) freopen (const char *, const char *, FILE *);
>void __attribute__((__cdecl__)) setbuf (FILE *, char *);
>int __attribute__((__cdecl__)) setvbuf (FILE *, char *, int, size_t);
>int __attribute__((__cdecl__)) fprintf (FILE *, const char *, ...);
>int __attribute__((__cdecl__)) fscanf (FILE *, const char *, ...);
>int __attribute__((__cdecl__)) printf (const char *, ...);
>int __attribute__((__cdecl__)) scanf (const char *, ...);
>int __attribute__((__cdecl__)) sscanf (const char *, const char *, ...);
>int __attribute__((__cdecl__)) vfprintf (FILE *, const char *, __gnuc_va_list);
>int __attribute__((__cdecl__)) vprintf (const char *, __gnuc_va_list);
>int __attribute__((__cdecl__)) vsprintf (char *, const char *, __gnuc_va_list);
>int __attribute__((__cdecl__)) fgetc (FILE *);
>char * __attribute__((__cdecl__)) fgets (char *, int, FILE *);
>int __attribute__((__cdecl__)) fputc (int, FILE *);
>int __attribute__((__cdecl__)) fputs (const char *, FILE *);
>int __attribute__((__cdecl__)) getc (FILE *);
>int __attribute__((__cdecl__)) getchar (void);
>char * __attribute__((__cdecl__)) gets (char *);
>int __attribute__((__cdecl__)) putc (int, FILE *);
>int __attribute__((__cdecl__)) putchar (int);
>int __attribute__((__cdecl__)) puts (const char *);
>int __attribute__((__cdecl__)) ungetc (int, FILE *);
>size_t __attribute__((__cdecl__)) fread (void *, size_t _size, size_t
>_n, FILE *);
>size_t __attribute__((__cdecl__)) fwrite (const void * , size_t _size,
>size_t _n, FILE *);
>
>
>
>int __attribute__((__cdecl__)) fgetpos (FILE *, fpos_t *);
>
>int __attribute__((__cdecl__)) fseek (FILE *, long, int);
>
>
>
>int __attribute__((__cdecl__)) fsetpos (FILE *, const fpos_t *);
>
>long __attribute__((__cdecl__)) ftell ( FILE *);
>void __attribute__((__cdecl__)) rewind (FILE *);
>void __attribute__((__cdecl__)) clearerr (FILE *);
>int __attribute__((__cdecl__)) feof (FILE *);
>int __attribute__((__cdecl__)) ferror (FILE *);
>void __attribute__((__cdecl__)) perror (const char *);
>
>FILE * __attribute__((__cdecl__)) fopen (const char *_name, const char *_type);
>int __attribute__((__cdecl__)) sprintf (char *, const char *, ...);
>int __attribute__((__cdecl__)) remove (const char *);
>int __attribute__((__cdecl__)) rename (const char *, const char *);
>
>
>
>
>
>
>int __attribute__((__cdecl__)) fseeko (FILE *, off_t, int);
>off_t __attribute__((__cdecl__)) ftello ( FILE *);
>
>
>int __attribute__((__cdecl__)) asiprintf (char **, const char *, ...);
>int __attribute__((__cdecl__)) asprintf (char **, const char *, ...);
>
>int __attribute__((__cdecl__)) dprintf (int, const char *, ...);
>
>int __attribute__((__cdecl__)) fcloseall (void);
>int __attribute__((__cdecl__)) fiprintf (FILE *, const char *, ...);
>int __attribute__((__cdecl__)) fiscanf (FILE *, const char *, ...);
>int __attribute__((__cdecl__)) iprintf (const char *, ...);
>int __attribute__((__cdecl__)) iscanf (const char *, ...);
>int __attribute__((__cdecl__)) siprintf (char *, const char *, ...);
>int __attribute__((__cdecl__)) siscanf (const char *, const char *, ...);
>int __attribute__((__cdecl__)) snprintf (char *, size_t, const char *, ...);
>int __attribute__((__cdecl__)) sniprintf (char *, size_t, const char *, ...);
>char * __attribute__((__cdecl__)) tempnam (const char *, const char *);
>int __attribute__((__cdecl__)) vasiprintf (char **, const char *,
>__gnuc_va_list);
>int __attribute__((__cdecl__)) vasprintf (char **, const char *,
>__gnuc_va_list);
>int __attribute__((__cdecl__)) vdprintf (int, const char *, __gnuc_va_list);
>int __attribute__((__cdecl__)) vsniprintf (char *, size_t, const char
>*, __gnuc_va_list);
>int __attribute__((__cdecl__)) vsnprintf (char *, size_t, const char
>*, __gnuc_va_list);
>int __attribute__((__cdecl__)) vfiprintf (FILE *, const char *, __gnuc_va_list);
>int __attribute__((__cdecl__)) vfiscanf (FILE *, const char *, __gnuc_va_list);
>int __attribute__((__cdecl__)) vfscanf (FILE *, const char *, __gnuc_va_list);
>int __attribute__((__cdecl__)) viprintf (const char *, __gnuc_va_list);
>int __attribute__((__cdecl__)) viscanf (const char *, __gnuc_va_list);
>int __attribute__((__cdecl__)) vscanf (const char *, __gnuc_va_list);
>int __attribute__((__cdecl__)) vsiscanf (const char *, const char *,
>__gnuc_va_list);
>int __attribute__((__cdecl__)) vsscanf (const char *, const char *,
>__gnuc_va_list);
># 267 "/usr/include/stdio.h" 3 4
>FILE * __attribute__((__cdecl__)) fdopen (int, const char *);
>
>int __attribute__((__cdecl__)) fileno (FILE *);
>int __attribute__((__cdecl__)) getw (FILE *);
>int __attribute__((__cdecl__)) pclose (FILE *);
>FILE * __attribute__((__cdecl__)) popen (const char *, const char *);
>int __attribute__((__cdecl__)) putw (int, FILE *);
>void __attribute__((__cdecl__)) setbuffer (FILE *, char *, int);
>int __attribute__((__cdecl__)) setlinebuf (FILE *);
>int __attribute__((__cdecl__)) getc_unlocked (FILE *);
>int __attribute__((__cdecl__)) getchar_unlocked (void);
>void __attribute__((__cdecl__)) flockfile (FILE *);
>int __attribute__((__cdecl__)) ftrylockfile (FILE *);
>void __attribute__((__cdecl__)) funlockfile (FILE *);
>int __attribute__((__cdecl__)) putc_unlocked (int, FILE *);
>int __attribute__((__cdecl__)) putchar_unlocked (int);
>
>
>
>
>
>
>int __attribute__((__cdecl__)) _asiprintf_r (struct _reent *, char **,
>const char *, ...);
>int __attribute__((__cdecl__)) _asprintf_r (struct _reent *, char **,
>const char *, ...);
>int __attribute__((__cdecl__)) _dprintf_r (struct _reent *, int, const
>char *, ...);
>int __attribute__((__cdecl__)) _fcloseall_r (struct _reent *);
>FILE * __attribute__((__cdecl__)) _fdopen_r (struct _reent *, int,
>const char *);
>FILE * __attribute__((__cdecl__)) _fopen_r (struct _reent *, const
>char *, const char *);
>int __attribute__((__cdecl__)) _fclose_r (struct _reent *, FILE *);
>char * __attribute__((__cdecl__)) _fgets_r (struct _reent *, char *,
>int, FILE *);
>int __attribute__((__cdecl__)) _fiscanf_r (struct _reent *, FILE *,
>const char *, ...);
>int __attribute__((__cdecl__)) _fputc_r (struct _reent *, int, FILE *);
>int __attribute__((__cdecl__)) _fputs_r (struct _reent *, const char *, FILE *);
>size_t __attribute__((__cdecl__)) _fread_r (struct _reent *, void *,
>size_t _size, size_t _n, FILE *);
>int __attribute__((__cdecl__)) _fscanf_r (struct _reent *, FILE *,
>const char *, ...);
>int __attribute__((__cdecl__)) _fseek_r (struct _reent *, FILE *, long, int);
>long __attribute__((__cdecl__)) _ftell_r (struct _reent *, FILE *);
>size_t __attribute__((__cdecl__)) _fwrite_r (struct _reent *, const
>void * , size_t _size, size_t _n, FILE *);
>int __attribute__((__cdecl__)) _getc_r (struct _reent *, FILE *);
>int __attribute__((__cdecl__)) _getc_unlocked_r (struct _reent *, FILE *);
>int __attribute__((__cdecl__)) _getchar_r (struct _reent *);
>int __attribute__((__cdecl__)) _getchar_unlocked_r (struct _reent *);
>char * __attribute__((__cdecl__)) _gets_r (struct _reent *, char *);
>int __attribute__((__cdecl__)) _iprintf_r (struct _reent *, const char *, ...);
>int __attribute__((__cdecl__)) _iscanf_r (struct _reent *, const char *, ...);
>int __attribute__((__cdecl__)) _mkstemp_r (struct _reent *, char *);
>char * __attribute__((__cdecl__)) _mktemp_r (struct _reent *, char *);
>void __attribute__((__cdecl__)) _perror_r (struct _reent *, const char *);
>int __attribute__((__cdecl__)) _printf_r (struct _reent *, const char *, ...);
>int __attribute__((__cdecl__)) _putc_r (struct _reent *, int, FILE *);
>int __attribute__((__cdecl__)) _putc_unlocked_r (struct _reent *, int, FILE *);
>int __attribute__((__cdecl__)) _putchar_unlocked_r (struct _reent *, int);
>int __attribute__((__cdecl__)) _putchar_r (struct _reent *, int);
>int __attribute__((__cdecl__)) _puts_r (struct _reent *, const char *);
>int __attribute__((__cdecl__)) _remove_r (struct _reent *, const char *);
>int __attribute__((__cdecl__)) _rename_r (struct _reent *, const char
>*_old, const char *_new);
>
>int __attribute__((__cdecl__)) _scanf_r (struct _reent *, const char *, ...);
>int __attribute__((__cdecl__)) _siprintf_r (struct _reent *, char *,
>const char *, ...);
>int __attribute__((__cdecl__)) _siscanf_r (struct _reent *, const char
>*, const char *, ...);
>int __attribute__((__cdecl__)) _sniprintf_r (struct _reent *, char *,
>size_t, const char *, ...);
>int __attribute__((__cdecl__)) _snprintf_r (struct _reent *, char *,
>size_t, const char *, ...);
>int __attribute__((__cdecl__)) _sprintf_r (struct _reent *, char *,
>const char *, ...);
>int __attribute__((__cdecl__)) _sscanf_r (struct _reent *, const char
>*, const char *, ...);
>char * __attribute__((__cdecl__)) _tempnam_r (struct _reent *, const
>char *, const char *);
>FILE * __attribute__((__cdecl__)) _tmpfile_r (struct _reent *);
>char * __attribute__((__cdecl__)) _tmpnam_r (struct _reent *, char *);
>int __attribute__((__cdecl__)) _ungetc_r (struct _reent *, int, FILE *);
>int __attribute__((__cdecl__)) _vasiprintf_r (struct _reent *, char
>**, const char *, __gnuc_va_list);
>int __attribute__((__cdecl__)) _vasprintf_r (struct _reent *, char **,
>const char *, __gnuc_va_list);
>int __attribute__((__cdecl__)) _vdprintf_r (struct _reent *, int,
>const char *, __gnuc_va_list);
>int __attribute__((__cdecl__)) _vfiprintf_r (struct _reent *, FILE *,
>const char *, __gnuc_va_list);
>int __attribute__((__cdecl__)) _vfprintf_r (struct _reent *, FILE *,
>const char *, __gnuc_va_list);
>int __attribute__((__cdecl__)) _viprintf_r (struct _reent *, const
>char *, __gnuc_va_list);
>int __attribute__((__cdecl__)) _vprintf_r (struct _reent *, const char
>*, __gnuc_va_list);
>int __attribute__((__cdecl__)) _vsiprintf_r (struct _reent *, char *,
>const char *, __gnuc_va_list);
>int __attribute__((__cdecl__)) _vsprintf_r (struct _reent *, char *,
>const char *, __gnuc_va_list);
>int __attribute__((__cdecl__)) _vsniprintf_r (struct _reent *, char *,
>size_t, const char *, __gnuc_va_list);
>int __attribute__((__cdecl__)) _vsnprintf_r (struct _reent *, char *,
>size_t, const char *, __gnuc_va_list);
>int __attribute__((__cdecl__)) _vfiscanf_r (struct _reent *, FILE *,
>const char *, __gnuc_va_list);
>int __attribute__((__cdecl__)) _vfscanf_r (struct _reent *, FILE *,
>const char *, __gnuc_va_list);
>int __attribute__((__cdecl__)) _viscanf_r (struct _reent *, const char
>*, __gnuc_va_list);
>int __attribute__((__cdecl__)) _vscanf_r (struct _reent *, const char
>*, __gnuc_va_list);
>int __attribute__((__cdecl__)) _vsscanf_r (struct _reent *, const char
>*, const char *, __gnuc_va_list);
>int __attribute__((__cdecl__)) _vsiscanf_r (struct _reent *, const
>char *, const char *, __gnuc_va_list);
>
>ssize_t __attribute__((__cdecl__)) __getdelim (char **, size_t *, int, FILE *);
>ssize_t __attribute__((__cdecl__)) __getline (char **, size_t *, FILE *);
># 380 "/usr/include/stdio.h" 3 4
>int __attribute__((__cdecl__)) __srget_r (struct _reent *, FILE *);
>int __attribute__((__cdecl__)) __swbuf_r (struct _reent *, int, FILE *);
>
>
>
>
>
>
>FILE *__attribute__((__cdecl__)) funopen (const void * _cookie, int
>(*readfn)(void * _cookie, char *_buf, int _n), int (*writefn)(void *
>_cookie, const char *_buf, int _n), fpos_t (*seekfn)(void * _cookie,
>fpos_t _off, int _whence), int (*closefn)(void * _cookie));
># 405 "/usr/include/stdio.h" 3 4
>static __inline__ int __sgetc_r(struct _reent *__ptr, FILE *__p)
>  {
>    int __c = (--(__p)->_r < 0 ? __srget_r(__ptr, __p) : (int)(*(__p)->_p++));
>    if ((__p->_flags & 0x4000) && (__c == '\r'))
>      {
>      int __c2 = (--(__p)->_r < 0 ? __srget_r(__ptr, __p) :
>(int)(*(__p)->_p++));
>      if (__c2 == '\n')
>        __c = __c2;
>      else
>        ungetc(__c2, __p);
>      }
>    return __c;
>  }
># 487 "/usr/include/stdio.h" 3 4
>
># 37 "dbus-binding-tool-glib.c" 2
># 1 "/usr/include/stdlib.h" 1 3 4
># 14 "/usr/include/stdlib.h" 3 4
># 1 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/stddef.h" 1 3 4
># 15 "/usr/include/stdlib.h" 2 3 4
>
>
># 1 "/usr/include/machine/stdlib.h" 1 3 4
># 17 "/usr/include/machine/stdlib.h" 3 4
>char *mkdtemp (char *);
># 18 "/usr/include/stdlib.h" 2 3 4
>
># 1 "/usr/include/alloca.h" 1 3 4
># 20 "/usr/include/stdlib.h" 2 3 4
>
>
>
># 1 "/usr/include/cygwin/stdlib.h" 1 3 4
># 14 "/usr/include/cygwin/stdlib.h" 3 4
># 1 "/usr/include/cygwin/wait.h" 1 3 4
># 15 "/usr/include/cygwin/stdlib.h" 2 3 4
>
>
>
>
>
>
>const char *getprogname (void);
>void setprogname (const char *);
>
>
>char *realpath (const char *, char *);
>int unsetenv (const char *);
>int random (void);
>long srandom (unsigned);
>char *ptsname (int);
>int grantpt (int);
>int unlockpt (int);
># 24 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>typedef struct
>{
>  int quot;
>  int rem;
>} div_t;
>
>typedef struct
>{
>  long quot;
>  long rem;
>} ldiv_t;
>
>
>typedef struct
>{
>  long long int quot;
>  long long int rem;
>} lldiv_t;
># 57 "/usr/include/stdlib.h" 3 4
>extern __attribute__((dllimport)) int __mb_cur_max;
>
>
>
>void __attribute__((__cdecl__)) abort (void) __attribute__ ((noreturn));
>int __attribute__((__cdecl__)) abs (int);
>int __attribute__((__cdecl__)) atexit (void (*__func)(void));
>double __attribute__((__cdecl__)) atof (const char *__nptr);
>
>float __attribute__((__cdecl__)) atoff (const char *__nptr);
>
>int __attribute__((__cdecl__)) atoi (const char *__nptr);
>int __attribute__((__cdecl__)) _atoi_r (struct _reent *, const char *__nptr);
>long __attribute__((__cdecl__)) atol (const char *__nptr);
>long __attribute__((__cdecl__)) _atol_r (struct _reent *, const char *__nptr);
>void * __attribute__((__cdecl__)) bsearch (const void * __key, const
>void * __base, size_t __nmemb, size_t __size, int (*
>__attribute__((__cdecl__)) _compar) (const void *, const void *));
>
>
>
>
>void * __attribute__((__cdecl__)) calloc (size_t __nmemb, size_t __size);
>div_t __attribute__((__cdecl__)) div (int __numer, int __denom);
>void __attribute__((__cdecl__)) exit (int __status) __attribute__ ((noreturn));
>void __attribute__((__cdecl__)) free (void *);
>char * __attribute__((__cdecl__)) getenv (const char *__string);
>char * __attribute__((__cdecl__)) _getenv_r (struct _reent *, const
>char *__string);
>char * __attribute__((__cdecl__)) _findenv (const char *, int *);
>char * __attribute__((__cdecl__)) _findenv_r (struct _reent *, const
>char *, int *);
>long __attribute__((__cdecl__)) labs (long);
>ldiv_t __attribute__((__cdecl__)) ldiv (long __numer, long __denom);
>void * __attribute__((__cdecl__)) malloc (size_t __size);
>int __attribute__((__cdecl__)) mblen (const char *, size_t);
>int __attribute__((__cdecl__)) _mblen_r (struct _reent *, const char
>*, size_t, _mbstate_t *);
>int __attribute__((__cdecl__)) mbtowc (wchar_t *, const char *, size_t);
>int __attribute__((__cdecl__)) _mbtowc_r (struct _reent *, wchar_t *,
>const char *, size_t, _mbstate_t *);
>int __attribute__((__cdecl__)) wctomb (char *, wchar_t);
>int __attribute__((__cdecl__)) _wctomb_r (struct _reent *, char *,
>wchar_t, _mbstate_t *);
>size_t __attribute__((__cdecl__)) mbstowcs (wchar_t *, const char *, size_t);
>size_t __attribute__((__cdecl__)) _mbstowcs_r (struct _reent *,
>wchar_t *, const char *, size_t, _mbstate_t *);
>size_t __attribute__((__cdecl__)) wcstombs (char *, const wchar_t *, size_t);
>size_t __attribute__((__cdecl__)) _wcstombs_r (struct _reent *, char
>*, const wchar_t *, size_t, _mbstate_t *);
>
>
>int __attribute__((__cdecl__)) mkstemp (char *);
>char * __attribute__((__cdecl__)) mktemp (char *);
>
>
>void __attribute__((__cdecl__)) qsort (void * __base, size_t __nmemb,
>size_t __size, int(*_compar)(const void *, const void *));
>int __attribute__((__cdecl__)) rand (void);
>void * __attribute__((__cdecl__)) realloc (void * __r, size_t __size);
>void __attribute__((__cdecl__)) srand (unsigned __seed);
>double __attribute__((__cdecl__)) strtod (const char *__n, char **__end_PTR);
>double __attribute__((__cdecl__)) _strtod_r (struct _reent *,const
>char *__n, char **__end_PTR);
>float __attribute__((__cdecl__)) strtof (const char *__n, char **__end_PTR);
>
>
>
>
>
>
>long __attribute__((__cdecl__)) strtol (const char *__n, char
>**__end_PTR, int __base);
>long __attribute__((__cdecl__)) _strtol_r (struct _reent *,const char
>*__n, char **__end_PTR, int __base);
>unsigned long __attribute__((__cdecl__)) strtoul (const char *__n,
>char **__end_PTR, int __base);
>unsigned long __attribute__((__cdecl__)) _strtoul_r (struct _reent
>*,const char *__n, char **__end_PTR, int __base);
>
>int __attribute__((__cdecl__)) system (const char *__string);
>
>
>long __attribute__((__cdecl__)) a64l (const char *__input);
>char * __attribute__((__cdecl__)) l64a (long __input);
>char * __attribute__((__cdecl__)) _l64a_r (struct _reent *,long __input);
>int __attribute__((__cdecl__)) on_exit (void (*__func)(int, void
>*),void * __arg);
>void __attribute__((__cdecl__)) _Exit (int __status) __attribute__ ((noreturn));
>int __attribute__((__cdecl__)) putenv (char *__string);
>int __attribute__((__cdecl__)) _putenv_r (struct _reent *, char *__string);
>int __attribute__((__cdecl__)) setenv (const char *__string, const
>char *__value, int __overwrite);
>int __attribute__((__cdecl__)) _setenv_r (struct _reent *, const char
>*__string, const char *__value, int __overwrite);
>
>char * __attribute__((__cdecl__)) gcvt (double,int,char *);
>char * __attribute__((__cdecl__)) gcvtf (float,int,char *);
>char * __attribute__((__cdecl__)) fcvt (double,int,int *,int *);
>char * __attribute__((__cdecl__)) fcvtf (float,int,int *,int *);
>char * __attribute__((__cdecl__)) ecvt (double,int,int *,int *);
>char * __attribute__((__cdecl__)) ecvtbuf (double, int, int*, int*, char *);
>char * __attribute__((__cdecl__)) fcvtbuf (double, int, int*, int*, char *);
>char * __attribute__((__cdecl__)) ecvtf (float,int,int *,int *);
>char * __attribute__((__cdecl__)) dtoa (double, int, int, int *, int*, char**);
>int __attribute__((__cdecl__)) rand_r (unsigned *__seed);
>
>double __attribute__((__cdecl__)) drand48 (void);
>double __attribute__((__cdecl__)) _drand48_r (struct _reent *);
>double __attribute__((__cdecl__)) erand48 (unsigned short [3]);
>double __attribute__((__cdecl__)) _erand48_r (struct _reent *,
>unsigned short [3]);
>long __attribute__((__cdecl__)) jrand48 (unsigned short [3]);
>long __attribute__((__cdecl__)) _jrand48_r (struct _reent *, unsigned
>short [3]);
>void __attribute__((__cdecl__)) lcong48 (unsigned short [7]);
>void __attribute__((__cdecl__)) _lcong48_r (struct _reent *, unsigned
>short [7]);
>long __attribute__((__cdecl__)) lrand48 (void);
>long __attribute__((__cdecl__)) _lrand48_r (struct _reent *);
>long __attribute__((__cdecl__)) mrand48 (void);
>long __attribute__((__cdecl__)) _mrand48_r (struct _reent *);
>long __attribute__((__cdecl__)) nrand48 (unsigned short [3]);
>long __attribute__((__cdecl__)) _nrand48_r (struct _reent *, unsigned
>short [3]);
>unsigned short *
>       __attribute__((__cdecl__)) seed48 (unsigned short [3]);
>unsigned short *
>       __attribute__((__cdecl__)) _seed48_r (struct _reent *, unsigned
>short [3]);
>void __attribute__((__cdecl__)) srand48 (long);
>void __attribute__((__cdecl__)) _srand48_r (struct _reent *, long);
>long long __attribute__((__cdecl__)) atoll (const char *__nptr);
>long long __attribute__((__cdecl__)) _atoll_r (struct _reent *, const
>char *__nptr);
>long long __attribute__((__cdecl__)) llabs (long long);
>lldiv_t __attribute__((__cdecl__)) lldiv (long long __numer, long long __denom);
>long long __attribute__((__cdecl__)) strtoll (const char *__n, char
>**__end_PTR, int __base);
>long long __attribute__((__cdecl__)) _strtoll_r (struct _reent *,
>const char *__n, char **__end_PTR, int __base);
>unsigned long long __attribute__((__cdecl__)) strtoull (const char
>*__n, char **__end_PTR, int __base);
>unsigned long long __attribute__((__cdecl__)) _strtoull_r (struct
>_reent *, const char *__n, char **__end_PTR, int __base);
># 183 "/usr/include/stdlib.h" 3 4
>char * __attribute__((__cdecl__)) _dtoa_r (struct _reent *, double,
>int, int, int *, int*, char**);
>
>
>
>
>
>
>
>int __attribute__((__cdecl__)) _system_r (struct _reent *, const char *);
>
>void __attribute__((__cdecl__)) __eprintf (const char *, const char *,
>unsigned int, const char *);
>
>
># 38 "dbus-binding-tool-glib.c" 2
># 1 "/usr/include/string.h" 1 3 4
># 14 "/usr/include/string.h" 3 4
># 1 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/stddef.h" 1 3 4
># 15 "/usr/include/string.h" 2 3 4
>
>
>
>
>
>
>
>void * __attribute__((__cdecl__)) memchr (const void *, int, size_t);
>int __attribute__((__cdecl__)) memcmp (const void *, const void *, size_t);
>void * __attribute__((__cdecl__)) memcpy (void *, const void *, size_t);
>void * __attribute__((__cdecl__)) memmove (void *, const void *, size_t);
>void * __attribute__((__cdecl__)) memset (void *, int, size_t);
>char *__attribute__((__cdecl__)) strcat (char *, const char *);
>char *__attribute__((__cdecl__)) strchr (const char *, int);
>int __attribute__((__cdecl__)) strcmp (const char *, const char *);
>int __attribute__((__cdecl__)) strcoll (const char *, const char *);
>char *__attribute__((__cdecl__)) strcpy (char *, const char *);
>size_t __attribute__((__cdecl__)) strcspn (const char *, const char *);
>char *__attribute__((__cdecl__)) strerror (int);
>size_t __attribute__((__cdecl__)) strlen (const char *);
>char *__attribute__((__cdecl__)) strncat (char *, const char *, size_t);
>int __attribute__((__cdecl__)) strncmp (const char *, const char *, size_t);
>char *__attribute__((__cdecl__)) strncpy (char *, const char *, size_t);
>char *__attribute__((__cdecl__)) strpbrk (const char *, const char *);
>char *__attribute__((__cdecl__)) strrchr (const char *, int);
>size_t __attribute__((__cdecl__)) strspn (const char *, const char *);
>char *__attribute__((__cdecl__)) strstr (const char *, const char *);
>
>
>char *__attribute__((__cdecl__)) strtok (char *, const char *);
>
>
>size_t __attribute__((__cdecl__)) strxfrm (char *, const char *, size_t);
>
>
>char *__attribute__((__cdecl__)) strtok_r (char *, const char *, char **);
>
>int __attribute__((__cdecl__)) bcmp (const void *, const void *, size_t);
>void __attribute__((__cdecl__)) bcopy (const void *, void *, size_t);
>void __attribute__((__cdecl__)) bzero (void *, size_t);
>int __attribute__((__cdecl__)) ffs (int);
>char *__attribute__((__cdecl__)) index (const char *, int);
>void * __attribute__((__cdecl__)) memccpy (void *, const void *, int, size_t);
>void * __attribute__((__cdecl__)) mempcpy (void *, const void *, size_t);
>
>extern void *memmem (__const void *, size_t, __const void *, size_t);
>
>char *__attribute__((__cdecl__)) rindex (const char *, int);
>int __attribute__((__cdecl__)) strcasecmp (const char *, const char *);
>char *__attribute__((__cdecl__)) strdup (const char *);
>char *__attribute__((__cdecl__)) _strdup_r (struct _reent *, const char *);
>char *__attribute__((__cdecl__)) strndup (const char *, size_t);
>char *__attribute__((__cdecl__)) _strndup_r (struct _reent *, const
>char *, size_t);
>char *__attribute__((__cdecl__)) strerror_r (int, char *, size_t);
>size_t __attribute__((__cdecl__)) strlcat (char *, const char *, size_t);
>size_t __attribute__((__cdecl__)) strlcpy (char *, const char *, size_t);
>int __attribute__((__cdecl__)) strncasecmp (const char *, const char *, size_t);
>size_t __attribute__((__cdecl__)) strnlen (const char *, size_t);
>char *__attribute__((__cdecl__)) strsep (char **, const char *);
>char *__attribute__((__cdecl__)) strlwr (char *);
>char *__attribute__((__cdecl__)) strupr (char *);
>
>
>const char *__attribute__((__cdecl__)) strsignal (int __signo);
>
>int __attribute__((__cdecl__)) strtosigno (const char *__name);
># 99 "/usr/include/string.h" 3 4
># 1 "/usr/include/sys/string.h" 1 3 4
># 100 "/usr/include/string.h" 2 3 4
>
>
># 39 "dbus-binding-tool-glib.c" 2
># 1 "/usr/include/unistd.h" 1 3 4
>
>
>
># 1 "/usr/include/sys/unistd.h" 1 3 4
># 13 "/usr/include/sys/unistd.h" 3 4
># 1 "/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/stddef.h" 1 3 4
># 14 "/usr/include/sys/unistd.h" 2 3 4
>
>extern char **environ;
>
>void __attribute__((__cdecl__)) _exit (int __status ) __attribute__
>((noreturn));
>
>int __attribute__((__cdecl__)) access (const char *__path, int __amode );
>unsigned __attribute__((__cdecl__)) alarm (unsigned __secs );
>int __attribute__((__cdecl__)) chdir (const char *__path );
>int __attribute__((__cdecl__)) chmod (const char *__path, mode_t __mode );
>
>int __attribute__((__cdecl__)) chown (const char *__path, uid_t
>__owner, gid_t __group );
>
>
>int __attribute__((__cdecl__)) chroot (const char *__path );
>
>int __attribute__((__cdecl__)) close (int __fildes );
>char __attribute__((__cdecl__)) *ctermid (char *__s );
>char __attribute__((__cdecl__)) *cuserid (char *__s );
>
>int __attribute__((__cdecl__)) daemon (int nochdir, int noclose);
>
>int __attribute__((__cdecl__)) dup (int __fildes );
>int __attribute__((__cdecl__)) dup2 (int __fildes, int __fildes2 );
>
>void __attribute__((__cdecl__)) endusershell (void);
>
>int __attribute__((__cdecl__)) execl (const char *__path, const char *, ... );
>int __attribute__((__cdecl__)) execle (const char *__path, const char *, ... );
>int __attribute__((__cdecl__)) execlp (const char *__file, const char *, ... );
>int __attribute__((__cdecl__)) execv (const char *__path, char * const
>__argv[] );
>int __attribute__((__cdecl__)) execve (const char *__path, char *
>const __argv[], char * const __envp[] );
>int __attribute__((__cdecl__)) execvp (const char *__file, char *
>const __argv[] );
>
>int __attribute__((__cdecl__)) fchdir (int __fildes);
>
>int __attribute__((__cdecl__)) fchmod (int __fildes, mode_t __mode );
>
>int __attribute__((__cdecl__)) fchown (int __fildes, uid_t __owner,
>gid_t __group );
>
>pid_t __attribute__((__cdecl__)) fork (void );
>long __attribute__((__cdecl__)) fpathconf (int __fd, int __name );
>int __attribute__((__cdecl__)) fsync (int __fd);
>int __attribute__((__cdecl__)) fdatasync (int __fd);
>char __attribute__((__cdecl__)) *getcwd (char *__buf, size_t __size );
>
>int __attribute__((__cdecl__)) getdomainname (char *__name, size_t __len);
>
>
>gid_t __attribute__((__cdecl__)) getegid (void );
>uid_t __attribute__((__cdecl__)) geteuid (void );
>gid_t __attribute__((__cdecl__)) getgid (void );
>
>int __attribute__((__cdecl__)) getgroups (int __gidsetsize, gid_t
>__grouplist[] );
>
>long __attribute__((__cdecl__)) gethostid (void);
>
>char __attribute__((__cdecl__)) *getlogin (void );
>
>int __attribute__((__cdecl__)) getlogin_r (char *name, size_t namesize);
>
>char __attribute__((__cdecl__)) *getpass (const char *__prompt);
>size_t __attribute__((__cdecl__)) getpagesize (void);
>
>int __attribute__((__cdecl__)) getpeereid (int, uid_t *, gid_t *);
>
>pid_t __attribute__((__cdecl__)) getpgid (pid_t);
>pid_t __attribute__((__cdecl__)) getpgrp (void );
>pid_t __attribute__((__cdecl__)) getpid (void );
>pid_t __attribute__((__cdecl__)) getppid (void );
>
>pid_t __attribute__((__cdecl__)) getsid (pid_t);
>
>
>uid_t __attribute__((__cdecl__)) getuid (void );
>
>
>char * __attribute__((__cdecl__)) getusershell (void);
>char __attribute__((__cdecl__)) *getwd (char *__buf );
>int __attribute__((__cdecl__)) iruserok (unsigned long raddr, int
>superuser, const char *ruser, const char *luser);
>
>int __attribute__((__cdecl__)) isatty (int __fildes );
>
>int __attribute__((__cdecl__)) lchown (const char *__path, uid_t
>__owner, gid_t __group );
>
>int __attribute__((__cdecl__)) link (const char *__path1, const char *__path2 );
>int __attribute__((__cdecl__)) nice (int __nice_value );
>
>off_t __attribute__((__cdecl__)) lseek (int __fildes, off_t __offset,
>int __whence );
>
>long __attribute__((__cdecl__)) pathconf (const char *__path, int __name );
>int __attribute__((__cdecl__)) pause (void );
>
>int __attribute__((__cdecl__)) pthread_atfork (void (*)(void), void
>(*)(void), void (*)(void));
>
>int __attribute__((__cdecl__)) _pipe (int __fildes[2], 4096, _O_BINARY);
>ssize_t __attribute__((__cdecl__)) pread (int __fd, void *__buf,
>size_t __nbytes, off_t __offset);
>ssize_t __attribute__((__cdecl__)) pwrite (int __fd, const void
>*__buf, size_t __nbytes, off_t __offset);
>_ssize_t __attribute__((__cdecl__)) read (int __fd, void *__buf,
>size_t __nbyte );
>
>int __attribute__((__cdecl__)) rresvport (int *__alport);
>int __attribute__((__cdecl__)) revoke (char *__path);
>
>int __attribute__((__cdecl__)) rmdir (const char *__path );
>
>int __attribute__((__cdecl__)) ruserok (const char *rhost, int
>superuser, const char *ruser, const char *luser);
>
>void * __attribute__((__cdecl__)) sbrk (ptrdiff_t __incr);
>
>
>int __attribute__((__cdecl__)) setegid (gid_t __gid );
>int __attribute__((__cdecl__)) seteuid (uid_t __uid );
>
>int __attribute__((__cdecl__)) setgid (gid_t __gid );
>
>
>int __attribute__((__cdecl__)) setgroups (int ngroups, const gid_t *grouplist );
>
>int __attribute__((__cdecl__)) setpgid (pid_t __pid, pid_t __pgid );
>int __attribute__((__cdecl__)) setpgrp (void );
>
>int __attribute__((__cdecl__)) setregid (gid_t __rgid, gid_t __egid);
>int __attribute__((__cdecl__)) setreuid (uid_t __ruid, uid_t __euid);
>
>pid_t __attribute__((__cdecl__)) setsid (void );
>
>int __attribute__((__cdecl__)) setuid (uid_t __uid );
>
>
>void __attribute__((__cdecl__)) setusershell (void);
>
>unsigned __attribute__((__cdecl__)) sleep (unsigned int __seconds );
>void __attribute__((__cdecl__)) swab (const void *, void *, ssize_t);
>long __attribute__((__cdecl__)) sysconf (int __name );
>pid_t __attribute__((__cdecl__)) tcgetpgrp (int __fildes );
>int __attribute__((__cdecl__)) tcsetpgrp (int __fildes, pid_t __pgrp_id );
>char __attribute__((__cdecl__)) *ttyname (int __fildes );
>
>int __attribute__((__cdecl__)) ttyname_r (int, char *, size_t);
>
>int __attribute__((__cdecl__)) unlink (const char *__path );
>int __attribute__((__cdecl__)) vhangup (void );
>_ssize_t __attribute__((__cdecl__)) write (int __fd, const void
>*__buf, size_t __nbyte );
>
>
>
># 1 "/usr/include/getopt.h" 1 3 4
># 45 "/usr/include/getopt.h" 3 4
>extern int __attribute__((dllimport)) opterr;
>extern int __attribute__((dllimport)) optind;
>extern int __attribute__((dllimport)) optopt;
>extern int __attribute__((dllimport)) optreset;
>extern char __attribute__((dllimport)) *optarg;
>
>
>int getopt (int, char * const *, const char *);
># 160 "/usr/include/sys/unistd.h" 2 3 4
># 169 "/usr/include/sys/unistd.h" 3 4
>pid_t __attribute__((__cdecl__)) vfork (void );
>
>extern char *suboptarg;
>int getsubopt(char **, char * const *, char **);
># 195 "/usr/include/sys/unistd.h" 3 4
>int __attribute__((__cdecl__)) ftruncate (int __fd, off_t __length);
>int __attribute__((__cdecl__)) truncate (const char *, off_t __length);
>
>
>
>int __attribute__((__cdecl__)) getdtablesize (void);
>int __attribute__((__cdecl__)) setdtablesize (int);
>useconds_t __attribute__((__cdecl__)) ualarm (useconds_t __useconds,
>useconds_t __interval);
>unsigned __attribute__((__cdecl__)) usleep (unsigned int __useconds);
>
>
> int __attribute__((__cdecl__)) gethostname (char *__name, size_t __len);
>
>char * __attribute__((__cdecl__)) mktemp (char *);
>
>void __attribute__((__cdecl__)) sync (void);
>
>
>
>
>int __attribute__((__cdecl__)) readlink (const char *__path, char
>*__buf, int __buflen);
>int __attribute__((__cdecl__)) symlink (const char *__name1, const
>char *__name2);
># 5 "/usr/include/unistd.h" 2 3 4
># 40 "dbus-binding-tool-glib.c" 2
>
>
>
>typedef struct
>{
>  gboolean ignore_unsupported;
>  const char* prefix;
>  GIOChannel *channel;
>
>  GError **error;
>
>  GHashTable *generated;
>  GString *blob;
>  GString *signal_blob;
>  GString *property_blob;
>  guint count;
>} DBusBindingToolCData;
>
>static gboolean gather_marshallers (BaseInfo *base,
>DBusBindingToolCData *data, GError **error);
>static gboolean generate_glue (BaseInfo *base, DBusBindingToolCData
>*data, GError **error);
>static gboolean generate_client_glue (BaseInfo *base,
>DBusBindingToolCData *data, GError **error);
>
>static const char *
>dbus_g_type_get_marshal_name (GType gtype)
>{
>  switch ((g_type_fundamental (gtype)))
>    {
>    case ((GType) ((1) << (2))):
>      return "NONE";
>    case ((GType) ((5) << (2))):
>      return "BOOLEAN";
>    case ((GType) ((4) << (2))):
>      return "UCHAR";
>    case ((GType) ((6) << (2))):
>      return "INT";
>    case ((GType) ((7) << (2))):
>      return "UINT";
>    case ((GType) ((10) << (2))):
>      return "INT64";
>    case ((GType) ((11) << (2))):
>      return "UINT64";
>    case ((GType) ((15) << (2))):
>      return "DOUBLE";
>    case ((GType) ((16) << (2))):
>      return "STRING";
>    case ((GType) ((17) << (2))):
>      return "POINTER";
>    case ((GType) ((18) << (2))):
>      return "BOXED";
>    case ((GType) ((20) << (2))):
>      return "OBJECT";
>    default:
>      return ((void *)0);
>    }
>}
>
>
>static const char *
>dbus_g_type_get_c_name (GType gtype)
>{
>  GType subtype;
>  if (dbus_g_type_is_struct (gtype))
>    {
>      return "GValueArray";
>    }
>  if (dbus_g_type_is_collection (gtype))
>    {
>      subtype = dbus_g_type_get_collection_specialization(gtype);
>      if (_dbus_g_type_is_fixed (subtype))
>        return "GArray";
>      else
>        return "GPtrArray";
>    }
>
>  if (dbus_g_type_is_map (gtype))
>    return "GHashTable";
>
>  if (g_type_is_a (gtype, ((GType) ((16) << (2)))))
>    return "char *";
>
>
>
>
>  if (g_type_is_a (gtype, (g_strv_get_type ())))
>    return "char *";
>
>  if (g_type_is_a (gtype, (dbus_g_object_path_get_g_type ())))
>    return "char";
>
>  return g_type_name (gtype);
>}
>
>static gboolean
>compute_gsignature (MethodInfo *method, GType *rettype, GArray
>**params, GError **error)
>{
>  GSList *elt;
>  GType retval_type;
>  GArray *ret;
>  gboolean is_async;
>  const char *arg_type;
>  gboolean retval_signals_error;
>
>  is_async = method_info_get_annotation (method,
>"org.freedesktop.DBus.GLib.Async") != ((void *)0);
>  retval_signals_error = (0);
>
>  ret = g_array_new ((!(0)), (!(0)), sizeof (GType));
>
>  if (is_async)
>    retval_type = ((GType) ((1) << (2)));
>  else
>    {
>      gboolean found_retval;
>
>
>      found_retval = (0);
>      for (elt = method_info_get_args (method); elt; elt = elt->next)
> {
>   ArgInfo *arg = elt->data;
>   const char *returnval_annotation;
>
>   returnval_annotation = arg_info_get_annotation (arg,
>"org.freedesktop.DBus.GLib.ReturnVal");
>   if (returnval_annotation != ((void *)0))
>     {
>       arg_type = arg_info_get_type (arg);
>       retval_type = _dbus_gtype_from_signature (arg_type, (0));
>       if (retval_type == ((GType) ((0) << (2))))
>  goto invalid_type;
>       found_retval = (!(0));
>       if (!strcmp (returnval_annotation, "error"))
>  retval_signals_error = (!(0));
>       break;
>     }
> }
>      if (!found_retval)
> {
>   retval_type = ((GType) ((5) << (2)));
>   retval_signals_error = (!(0));
> }
>    }
>
>  *rettype = retval_type;
>
>
>  for (elt = method_info_get_args (method); elt; elt = elt->next)
>    {
>      ArgInfo *arg = elt->data;
>      if (arg_info_get_direction (arg) == ARG_IN)
> {
>   GType gtype;
>
>   arg_type = arg_info_get_type (arg);
>   gtype = _dbus_gtype_from_signature (arg_type, (0));
>   if (gtype == ((GType) ((0) << (2))))
>     goto invalid_type;
>
>   g_array_append_vals (ret, &(gtype), 1);
> }
>    }
>
>  if (!is_async)
>    {
>
>      for (elt = method_info_get_args (method); elt; elt = elt->next)
> {
>   ArgInfo *arg = elt->data;
>
>
>   if (arg_info_get_annotation (arg,
>"org.freedesktop.DBus.GLib.ReturnVal") != ((void *)0))
>     continue;
>
>   if (arg_info_get_direction (arg) == ARG_OUT)
>     {
>       GType gtype;
>       arg_type = arg_info_get_type (arg);
>       gtype = _dbus_gtype_from_signature (arg_type, (0));
>       if (gtype == ((GType) ((0) << (2))))
>  goto invalid_type;
>
>
>       gtype = ((GType) ((17) << (2)));
>       g_array_append_vals (ret, &(gtype), 1);
>     }
> }
>
>      if (retval_signals_error)
> {
>
>   GType gtype = ((GType) ((17) << (2)));
>   g_array_append_vals (ret, &(gtype), 1);
> }
>    }
>  else
>    {
>
>      GType gtype = ((GType) ((17) << (2)));
>      g_array_append_vals (ret, &(gtype), 1);
>    }
>
>  *params = ret;
>  return (!(0));
>
> invalid_type:
>  g_set_error (error,
>        dbus_binding_tool_error_quark (),
>        DBUS_BINDING_TOOL_ERROR_UNSUPPORTED_CONVERSION,
>        gettext ("Unsupported conversion from D-BUS type %s to
>glib-genmarshal type"),
>        arg_type);
>  return (0);
>}
>
>
>static char *
>compute_marshaller (MethodInfo *method, GError **error)
>{
>  GArray *signature;
>  GType rettype;
>  const char *marshal_name;
>  GString *ret;
>  guint i;
>
>  if (!compute_gsignature (method, &rettype, &signature, error))
>    return ((void *)0);
>
>  ret = g_string_new ("");
>  marshal_name = dbus_g_type_get_marshal_name (rettype);
>  (void) __extension__ ({ (void)0; });
>  g_string_append (ret, marshal_name);
>  g_string_append_c_inline (ret, ':');
>  for (i = 0; i < signature->len; i++)
>    {
>      marshal_name = dbus_g_type_get_marshal_name ((((GType*)
>(signature)->data) [(i)]));
>      (void) __extension__ ({ (void)0; });
>      g_string_append (ret, marshal_name);
>      if (i < signature->len - 1)
> g_string_append_c_inline (ret, ',');
>    }
>  if (signature->len == 0)
>    {
>      marshal_name = dbus_g_type_get_marshal_name (((GType) ((1) << (2))));
>      (void) __extension__ ({ (void)0; });
>      g_string_append (ret, marshal_name);
>    }
>  g_array_free (signature, (!(0)));
>  return g_string_free (ret, (0));
>}
>
>static char *
>compute_marshaller_name (MethodInfo *method, const char *prefix, GError **error)
>{
>  GString *ret;
>  GArray *signature;
>  GType rettype;
>  const char *marshal_name;
>  guint i;
>
>  if (!compute_gsignature (method, &rettype, &signature, error))
>    return ((void *)0);
>
>  ret = g_string_new ("dbus_glib_marshal_");
>  g_string_append (ret, prefix);
>  g_string_append_c_inline (ret, '_');
>
>  marshal_name = dbus_g_type_get_marshal_name (rettype);
>  (void) __extension__ ({ (void)0; });
>  g_string_append (ret, marshal_name);
>  g_string_append (ret, "__");
>  for (i = 0; i < signature->len; i++)
>    {
>      marshal_name = dbus_g_type_get_marshal_name ((((GType*)
>(signature)->data) [(i)]));
>      (void) __extension__ ({ (void)0; });
>      g_string_append (ret, marshal_name);
>      if (i < signature->len - 1)
> g_string_append_c_inline (ret, '_');
>    }
>  if (signature->len == 0)
>    {
>      marshal_name = dbus_g_type_get_marshal_name (((GType) ((1) << (2))));
>      (void) __extension__ ({ (void)0; });
>      g_string_append (ret, marshal_name);
>    }
>  g_array_free (signature, (!(0)));
>  return g_string_free (ret, (0));
>}
>
>static gboolean
>gather_marshallers_list (GSList *list, DBusBindingToolCData *data,
>GError **error)
>{
>  GSList *tmp;
>
>  tmp = list;
>  while (tmp != ((void *)0))
>    {
>      if (!gather_marshallers (tmp->data, data, error))
> return (0);
>      tmp = tmp->next;
>    }
>  return (!(0));
>}
>
>static gboolean
>gather_marshallers (BaseInfo *base, DBusBindingToolCData *data, GError **error)
>{
>  if (base_info_get_type (base) == INFO_TYPE_NODE)
>    {
>      if (!gather_marshallers_list (node_info_get_nodes ((NodeInfo *) base),
>        data, error))
> return (0);
>      if (!gather_marshallers_list (node_info_get_interfaces
>((NodeInfo *) base),
>        data, error))
> return (0);
>    }
>  else
>    {
>      InterfaceInfo *interface;
>      GSList *methods;
>      GSList *tmp;
>      const char *interface_c_name;
>
>      interface = (InterfaceInfo *) base;
>      interface_c_name = interface_info_get_annotation (interface,
>"org.freedesktop.DBus.GLib.CSymbol");
>      if (interface_c_name == ((void *)0))
>        {
>   if (!data->prefix)
>     return (!(0));
>        }
>
>      methods = interface_info_get_methods (interface);
>
>
>
>      for (tmp = methods; tmp != ((void *)0); tmp = ((tmp) ? (((GSList
>*)(tmp))->next) : ((void *)0)))
>        {
>          MethodInfo *method;
>          char *marshaller_name;
>
>          method = (MethodInfo *) tmp->data;
>
>          marshaller_name = compute_marshaller (method, error);
>   if (!marshaller_name)
>     return (0);
>
>   if (g_hash_table_lookup (data->generated, marshaller_name))
>     {
>       g_free (marshaller_name);
>       continue;
>     }
>
>   g_hash_table_insert (data->generated, marshaller_name, ((void *)0));
>        }
>
>    }
>  return (!(0));
>}
>
>static gboolean
>generate_glue_list (GSList *list, DBusBindingToolCData *data, GError **error)
>{
>  GSList *tmp;
>
>  tmp = list;
>  while (tmp != ((void *)0))
>    {
>      if (!generate_glue (tmp->data, data, error))
> return (0);
>      tmp = tmp->next;
>    }
>  return (!(0));
>}
>
>
>
>static gboolean
>write_printf_to_iochannel (const char *fmt, GIOChannel *channel,
>GError **error, ...)
>{
>  char *str;
>  va_list args;
>  GIOStatus status;
>  gsize written;
>  gboolean ret;
>
>  __builtin_va_start(args,error);
>
>  str = g_strdup_vprintf (fmt, args);
>  if ((status = g_io_channel_write_chars (channel, str, -1, &written,
>error)) == G_IO_STATUS_NORMAL)
>    ret = (!(0));
>  else
>    ret = (0);
>
>  g_free (str);
>
>  __builtin_va_end(args);
>
>  return ret;
>}
>
>static gboolean
>write_quoted_string (GIOChannel *channel, GString *string, GError **error)
>{
>  guint i;
>
>  do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>"\"", -1, &bytes_written, error)) goto io_lose; } while (0);
>  for (i = 0; i < string->len; i++)
>    {
>      if (string->str[i] != '\0')
> {
>   if (!g_io_channel_write_chars (channel, string->str + i, 1, ((void
>*)0), error))
>     return (0);
> }
>      else
> {
>   if (!g_io_channel_write_chars (channel, "\\0", -1, ((void *)0), error))
>     return (0);
> }
>    }
>  do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>"\\0\"", -1, &bytes_written, error)) goto io_lose; } while (0);
>  return (!(0));
> io_lose:
>  return (0);
>}
>
>static gboolean
>generate_glue (BaseInfo *base, DBusBindingToolCData *data, GError **error)
>{
>  if (base_info_get_type (base) == INFO_TYPE_NODE)
>    {
>      GString *object_introspection_data_blob;
>      GIOChannel *channel;
>
>      channel = data->channel;
>
>      object_introspection_data_blob = g_string_new_len ("", 0);
>
>      data->blob = object_introspection_data_blob;
>      data->count = 0;
>
>      data->signal_blob = g_string_new_len ("", 0);
>      data->property_blob = g_string_new_len ("", 0);
>
>      if (!write_printf_to_iochannel ("static const DBusGMethodInfo
>dbus_glib_%s_methods[] = {\n", channel, error, data->prefix))
> goto io_lose;
>
>      if (!generate_glue_list (node_info_get_nodes ((NodeInfo *) base),
>          data, error))
> return (0);
>      if (!generate_glue_list (node_info_get_interfaces ((NodeInfo *) base),
>          data, error))
> return (0);
>
>      do { gsize bytes_written; if (!g_io_channel_write_chars
>(channel, "};\n\n", -1, &bytes_written, error)) goto io_lose; } while
>(0);
>
>
>
>      if (!write_printf_to_iochannel ("const DBusGObjectInfo
>dbus_glib_%s_object_info = {\n",
>          channel, error, data->prefix))
> goto io_lose;
>      do { gsize bytes_written; if (!g_io_channel_write_chars
>(channel, "  0,\n", -1, &bytes_written, error)) goto io_lose; } while
>(0);
>      if (!write_printf_to_iochannel ("  dbus_glib_%s_methods,\n",
>channel, error, data->prefix))
> goto io_lose;
>      if (!write_printf_to_iochannel ("  %d,\n", channel, error, data->count))
> goto io_lose;
>
>      if (!write_quoted_string (channel, object_introspection_data_blob, error))
> goto io_lose;
>      do { gsize bytes_written; if (!g_io_channel_write_chars
>(channel, ",\n", -1, &bytes_written, error)) goto io_lose; } while
>(0);
>      if (!write_quoted_string (channel, data->signal_blob, error))
> goto io_lose;
>      do { gsize bytes_written; if (!g_io_channel_write_chars
>(channel, ",\n", -1, &bytes_written, error)) goto io_lose; } while
>(0);
>      if (!write_quoted_string (channel, data->property_blob, error))
> goto io_lose;
>      do { gsize bytes_written; if (!g_io_channel_write_chars
>(channel, "\n};\n\n", -1, &bytes_written, error)) goto io_lose; }
>while (0);
>
>      g_string_free (object_introspection_data_blob, (!(0)));
>      g_string_free (data->signal_blob, (!(0)));
>      g_string_free (data->property_blob, (!(0)));
>    }
>  else
>    {
>      GIOChannel *channel;
>      InterfaceInfo *interface;
>      GSList *methods;
>      GSList *signals;
>      GSList *properties;
>      GSList *tmp;
>      const char *interface_c_name;
>      GString *object_introspection_data_blob;
>
>      channel = data->channel;
>      object_introspection_data_blob = data->blob;
>
>      interface = (InterfaceInfo *) base;
>      interface_c_name = interface_info_get_annotation (interface,
>"org.freedesktop.DBus.GLib.CSymbol");
>      if (interface_c_name == ((void *)0))
>        {
>   if (data->prefix == ((void *)0))
>     return (!(0));
>   interface_c_name = data->prefix;
>        }
>
>      methods = interface_info_get_methods (interface);
>
>
>
>      for (tmp = methods; tmp != ((void *)0); tmp = ((tmp) ? (((GSList
>*)(tmp))->next) : ((void *)0)))
>        {
>          MethodInfo *method;
>          char *marshaller_name;
>   char *method_c_name;
>          gboolean async = (0);
>   GSList *args;
>   gboolean found_retval = (0);
>
>          method = (MethodInfo *) tmp->data;
>   method_c_name = g_strdup (method_info_get_annotation (method,
>"org.freedesktop.DBus.GLib.CSymbol"));
>          if (method_c_name == ((void *)0))
>     {
>       char *method_name_uscored;
>       method_name_uscored = _dbus_gutils_wincaps_to_uscore
>(method_info_get_name (method));
>              method_c_name = g_strdup_printf ("%s_%s",
>            interface_c_name,
>            method_name_uscored);
>       g_free (method_name_uscored);
>            }
>
>          if (!write_printf_to_iochannel ("  { (GCallback) %s, ",
>channel, error,
>       method_c_name))
>     goto io_lose;
>
>          marshaller_name = compute_marshaller_name (method,
>data->prefix, error);
>   if (!marshaller_name)
>     goto io_lose;
>
>          if (!write_printf_to_iochannel ("%s, %d },\n", channel, error,
>       marshaller_name,
>       object_introspection_data_blob->len))
>     {
>       g_free (marshaller_name);
>       goto io_lose;
>     }
>
>          if (method_info_get_annotation (method,
>"org.freedesktop.DBus.GLib.Async") != ((void *)0))
>            async = (!(0));
>
>
>
>
>
>   g_string_append (object_introspection_data_blob,
>interface_info_get_name (interface));
>   g_string_append_c_inline (object_introspection_data_blob, '\0');
>
>   g_string_append (object_introspection_data_blob,
>method_info_get_name (method));
>   g_string_append_c_inline (object_introspection_data_blob, '\0');
>
>   g_string_append_c_inline (object_introspection_data_blob, async ? 'A' : 'S');
>   g_string_append_c_inline (object_introspection_data_blob, '\0');
>
>   for (args = method_info_get_args (method); args; args = args->next)
>     {
>       ArgInfo *arg;
>       char direction;
>       const char *returnval_annotation;
>
>       arg = args->data;
>
>       g_string_append (object_introspection_data_blob,
>arg_info_get_name (arg));
>       g_string_append_c_inline (object_introspection_data_blob, '\0');
>
>       switch (arg_info_get_direction (arg))
>  {
>  case ARG_IN:
>    direction = 'I';
>    break;
>  case ARG_OUT:
>    direction = 'O';
>    break;
>  case ARG_INVALID:
>                default:
>                  (void) __extension__ ({ (void)0; });
>                  direction = 0;
>    break;
>  }
>       g_string_append_c_inline (object_introspection_data_blob, direction);
>       g_string_append_c_inline (object_introspection_data_blob, '\0');
>
>       if (arg_info_get_annotation (arg,
>"org.freedesktop.DBus.GLib.Const") != ((void *)0))
>  {
>    if (arg_info_get_direction (arg) == ARG_IN)
>      {
>        g_set_error (error,
>       dbus_binding_tool_error_quark (),
>       DBUS_BINDING_TOOL_ERROR_INVALID_ANNOTATION,
>       "Input argument \"%s\" cannot have const annotation in method
>\"%s\" of interface \"%s\"\n",
>       arg_info_get_name (arg),
>       method_info_get_name (method),
>       interface_info_get_name (interface));
>        return (0);
>      }
>    g_string_append_c_inline (object_introspection_data_blob, 'C');
>    g_string_append_c_inline (object_introspection_data_blob, '\0');
>  }
>       else if (arg_info_get_direction (arg) == ARG_OUT)
>  {
>    g_string_append_c_inline (object_introspection_data_blob, 'F');
>    g_string_append_c_inline (object_introspection_data_blob, '\0');
>  }
>
>       returnval_annotation = arg_info_get_annotation (arg,
>"org.freedesktop.DBus.GLib.ReturnVal");
>       if (returnval_annotation != ((void *)0))
>  {
>    GType gtype;
>
>    if (found_retval)
>      {
>        g_set_error (error,
>       dbus_binding_tool_error_quark (),
>       DBUS_BINDING_TOOL_ERROR_INVALID_ANNOTATION,
>       "Multiple arguments with return value annotation in method
>\"%s\" of interface \"%s\"\n",
>       method_info_get_name (method),
>       interface_info_get_name (interface));
>        return (0);
>      }
>    found_retval = (!(0));
>    if (arg_info_get_direction (arg) == ARG_IN)
>      {
>        g_set_error (error,
>       dbus_binding_tool_error_quark (),
>       DBUS_BINDING_TOOL_ERROR_INVALID_ANNOTATION,
>       "Input argument \"%s\" cannot have return value annotation in
>method \"%s\" of interface \"%s\"\n",
>       arg_info_get_name (arg),
>       method_info_get_name (method),
>       interface_info_get_name (interface));
>        return (0);
>      }
>    if (!strcmp ("", returnval_annotation))
>      g_string_append_c_inline (object_introspection_data_blob, 'R');
>    else if (!strcmp ("error", returnval_annotation))
>      {
>        gtype = _dbus_gtype_from_signature (arg_info_get_type (arg), (!(0)));
>        if (!_dbus_gtype_can_signal_error (gtype))
>   {
>     g_set_error (error,
>           dbus_binding_tool_error_quark (),
>           DBUS_BINDING_TOOL_ERROR_INVALID_ANNOTATION,
>           "Output argument \"%s\" cannot signal error with type
>\"%s\" in method \"%s\" of interface \"%s\"\n",
>           arg_info_get_name (arg),
>           g_type_name (gtype),
>           method_info_get_name (method),
>           interface_info_get_name (interface));
>     return (0);
>   }
>        g_string_append_c_inline (object_introspection_data_blob, 'E');
>      }
>    else
>      {
>        g_set_error (error,
>       dbus_binding_tool_error_quark (),
>       DBUS_BINDING_TOOL_ERROR_INVALID_ANNOTATION,
>       "Invalid ReturnVal annotation for argument \"%s\" in method
>\"%s\" of interface \"%s\"\n",
>       arg_info_get_name (arg),
>       method_info_get_name (method),
>       interface_info_get_name (interface));
>        return (0);
>      }
>
>    g_string_append_c_inline (object_introspection_data_blob, '\0');
>  }
>       else if (arg_info_get_direction (arg) == ARG_OUT)
>  {
>    g_string_append_c_inline (object_introspection_data_blob, 'N');
>    g_string_append_c_inline (object_introspection_data_blob, '\0');
>  }
>
>       g_string_append (object_introspection_data_blob,
>arg_info_get_type (arg));
>       g_string_append_c_inline (object_introspection_data_blob, '\0');
>     }
>
>   g_string_append_c_inline (object_introspection_data_blob, '\0');
>
>          data->count++;
>        }
>
>      signals = interface_info_get_signals (interface);
>
>      for (tmp = signals; tmp != ((void *)0); tmp = ((tmp) ? (((GSList
>*)(tmp))->next) : ((void *)0)))
>        {
>          SignalInfo *sig;
>
>   sig = tmp->data;
>
>   g_string_append (data->signal_blob, interface_info_get_name (interface));
>   g_string_append_c_inline (data->signal_blob, '\0');
>   g_string_append (data->signal_blob, signal_info_get_name (sig));
>   g_string_append_c_inline (data->signal_blob, '\0');
> }
>
>      properties = interface_info_get_properties (interface);
>
>      for (tmp = properties; tmp != ((void *)0); tmp = ((tmp) ?
>(((GSList *)(tmp))->next) : ((void *)0)))
>        {
>          PropertyInfo *prop;
>
>   prop = tmp->data;
>
>   g_string_append (data->property_blob, interface_info_get_name (interface));
>   g_string_append_c_inline (data->property_blob, '\0');
>   g_string_append (data->property_blob, property_info_get_name (prop));
>   g_string_append_c_inline (data->property_blob, '\0');
> }
>    }
>  return (!(0));
> io_lose:
>  return (0);
>}
>
>static void
>write_marshaller (gpointer key, gpointer value, gpointer user_data)
>{
>  DBusBindingToolCData *data;
>  const char *marshaller;
>  gsize bytes_written;
>
>  data = user_data;
>  marshaller = key;
>
>  if (data->error && *data->error)
>    return;
>
>  if (g_io_channel_write_chars (data->channel, marshaller, -1,
>&bytes_written, data->error) == G_IO_STATUS_NORMAL)
>    g_io_channel_write_chars (data->channel, "\n", -1, &bytes_written,
>data->error);
>}
>
>gboolean
>dbus_binding_tool_output_glib_server (BaseInfo *info, GIOChannel
>*channel, const char *prefix, GError **error)
>{
>  gboolean ret;
>  GPtrArray *argv;
>  gint child_stdout;
>  GIOChannel *genmarshal_stdout;
>  GPid child_pid;
>  DBusBindingToolCData data;
>  char *tempfile_name;
>  gint tempfile_fd;
>  GIOStatus iostatus;
>  char buf[4096];
>  gsize bytes_read, bytes_written;
>
>  memset (&data, 0, sizeof (data));
>
>  dbus_g_type_specialized_init ();
>  _dbus_g_type_specialized_builtins_init ();
>
>  data.prefix = prefix;
>  data.generated = g_hash_table_new_full (g_str_hash, g_str_equal,
>(GDestroyNotify) g_free, ((void *)0));
>  data.error = error;
>  genmarshal_stdout = ((void *)0);
>  tempfile_name = ((void *)0);
>
>  if (!gather_marshallers (info, &data, error))
>    goto io_lose;
>
>  tempfile_fd = g_file_open_tmp_utf8 ("dbus-binding-tool-c-marshallers.XXXXXX",
>     &tempfile_name, error);
>  if (tempfile_fd < 0)
>    goto io_lose;
>
>  data.channel = g_io_channel_unix_new (tempfile_fd);
>  if (!g_io_channel_set_encoding (data.channel, ((void *)0), error))
>    goto io_lose;
>  g_hash_table_foreach (data.generated, write_marshaller, &data);
>  if (error && *error != ((void *)0))
>    {
>      ret = (0);
>      g_io_channel_close (data.channel);
>      g_io_channel_unref (data.channel);
>      goto io_lose;
>    }
>
>  g_io_channel_close (data.channel);
>  g_io_channel_unref (data.channel);
>
>
>  argv = g_ptr_array_new ();
>  g_ptr_array_add (argv, "glib-genmarshal");
>  g_ptr_array_add (argv, "--header");
>  g_ptr_array_add (argv, "--body");
>  g_ptr_array_add (argv, g_strdup_printf ("--prefix=%s%s",
>"dbus_glib_marshal_", prefix));
>  g_ptr_array_add (argv, tempfile_name);
>  g_ptr_array_add (argv, ((void *)0));
>  if (!g_spawn_async_with_pipes_utf8 (((void *)0),
>(char**)argv->pdata, ((void *)0),
>     G_SPAWN_SEARCH_PATH,
>     ((void *)0), ((void *)0),
>     &child_pid,
>     ((void *)0),
>     &child_stdout, ((void *)0), error))
>    {
>      g_ptr_array_free (argv, (!(0)));
>      goto io_lose;
>    }
>  g_ptr_array_free (argv, (!(0)));
>
>  genmarshal_stdout = g_io_channel_unix_new (child_stdout);
>  if (!g_io_channel_set_encoding (genmarshal_stdout, ((void *)0), error))
>    goto io_lose;
>
>  do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>"/* Generated by dbus-binding-tool; do not edit! */\n\n", -1,
>&bytes_written, error)) goto io_lose; } while (0);
>
>  while ((iostatus = g_io_channel_read_chars (genmarshal_stdout, buf,
>sizeof (buf),
>           &bytes_read, error)) == G_IO_STATUS_NORMAL)
>    if (g_io_channel_write_chars (channel, buf, bytes_read,
>&bytes_written, error) != G_IO_STATUS_NORMAL)
>      goto io_lose;
>  if (iostatus != G_IO_STATUS_EOF)
>    goto io_lose;
>
>  g_io_channel_close (genmarshal_stdout);
>
>  do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>"#include <dbus/dbus-glib.h>\n", -1, &bytes_written, error)) goto
>io_lose; } while (0);
>
>  data.channel = channel;
>  g_io_channel_ref (data.channel);
>  if (!generate_glue (info, &data, error))
>    goto io_lose;
>
>  ret = (!(0));
> cleanup:
>  if (tempfile_name)
>    unlink (tempfile_name);
>  g_free (tempfile_name);
>  if (genmarshal_stdout)
>    g_io_channel_unref (genmarshal_stdout);
>  if (data.channel)
>    g_io_channel_unref (data.channel);
>  g_hash_table_destroy (data.generated);
>
>  return ret;
> io_lose:
>  ret = (0);
>  goto cleanup;
>}
>
>static char *
>iface_to_c_prefix (const char *iface)
>{
>  char **components;
>  char **component;
>  GString *ret;
>  gboolean first;
>
>  components = g_strsplit (iface, ".", 0);
>
>  first = (!(0));
>  ret = g_string_new ("");
>  for (component = components; *component; component++)
>    {
>      if (!first)
> g_string_append_c_inline (ret, '_');
>      else
> first = (0);
>      g_string_append (ret, *component);
>    }
>  g_strfreev (components);
>  return g_string_free (ret, (0));
>}
>
>static char *
>compute_client_method_name (const char *iface_prefix, MethodInfo *method)
>{
>  char *method_name_uscored, *ret;
>
>  method_name_uscored = _dbus_gutils_wincaps_to_uscore
>(method_info_get_name (method));
>  ret = g_strdup_printf ("%s_%s", iface_prefix, method_name_uscored);
>  g_free (method_name_uscored);
>
>  return ret;
>}
>
>static gboolean
>write_formal_parameters (InterfaceInfo *iface, MethodInfo *method,
>GIOChannel *channel, GError **error)
>{
>  GSList *args;
>
>  for (args = method_info_get_args (method); args; args = args->next)
>    {
>      ArgInfo *arg;
>      const char *type_str;
>      const char *type_suffix;
>      GType gtype;
>      int direction;
>
>      arg = args->data;
>
>      do { gsize bytes_written; if (!g_io_channel_write_chars
>(channel, ", ", -1, &bytes_written, error)) goto io_lose; } while (0);
>
>      direction = arg_info_get_direction (arg);
>
>      gtype = _dbus_gtype_from_signature (arg_info_get_type (arg), (!(0)));
>      if (gtype == ((GType) ((0) << (2))))
> {
>   g_set_error (error,
>         dbus_binding_tool_error_quark (),
>         DBUS_BINDING_TOOL_ERROR_UNSUPPORTED_CONVERSION,
>         gettext ("Unsupported conversion from D-BUS type signature
>\"%s\" to glib C type in method \"%s\" of interface \"%s\""),
>         arg_info_get_type (arg),
>         method_info_get_name (method),
>         interface_info_get_name (iface));
>   return (0);
> }
>      type_str = dbus_g_type_get_c_name (gtype);
>      (void) __extension__ ({ (void)0; });
>
>      if (gtype == (g_value_get_type ()))
> {
>   if (direction == ARG_IN)
>     type_suffix = "*";
>   else
>     type_suffix = "";
> }
>      else if ((g_type_is_a (gtype, ((GType) ((18) << (2))))
>       || g_type_is_a (gtype, ((GType) ((20) << (2))))
>    || g_type_is_a (gtype, ((GType) ((17) << (2))))))
> type_suffix = "*";
>      else
> type_suffix = "";
>
>
>      switch (direction)
> {
> case ARG_IN:
>   if (!write_printf_to_iochannel ("const %s%s IN_%s", channel, error,
>       type_str,
>       type_suffix,
>       arg_info_get_name (arg)))
>     goto io_lose;
>   break;
> case ARG_OUT:
>   if (!write_printf_to_iochannel ("%s%s* OUT_%s", channel, error,
>       type_str,
>       type_suffix,
>       arg_info_get_name (arg)))
>     goto io_lose;
>   break;
> case ARG_INVALID:
>   break;
> }
>    }
>
>  return (!(0));
> io_lose:
>  return (0);
>}
>
>
>
>
>
>
>
>static char *
>dbus_g_type_get_lookup_function (GType gtype)
>{
>  char *type_lookup;
>  switch (gtype)
>    {
>      case ((GType) ((3) << (2))): return g_strdup ("G_TYPE_" "CHAR");;
>      case ((GType) ((4) << (2))): return g_strdup ("G_TYPE_" "UCHAR");;
>      case ((GType) ((5) << (2))): return g_strdup ("G_TYPE_" "BOOLEAN");;
>      case ((GType) ((8) << (2))): return g_strdup ("G_TYPE_" "LONG");;
>      case ((GType) ((9) << (2))): return g_strdup ("G_TYPE_" "ULONG");;
>      case ((GType) ((6) << (2))): return g_strdup ("G_TYPE_" "INT");;
>      case ((GType) ((7) << (2))): return g_strdup ("G_TYPE_" "UINT");;
>      case ((GType) ((10) << (2))): return g_strdup ("G_TYPE_" "INT64");;
>      case ((GType) ((11) << (2))): return g_strdup ("G_TYPE_" "UINT64");;
>      case ((GType) ((14) << (2))): return g_strdup ("G_TYPE_" "FLOAT");;
>      case ((GType) ((15) << (2))): return g_strdup ("G_TYPE_" "DOUBLE");;
>      case ((GType) ((16) << (2))): return g_strdup ("G_TYPE_" "STRING");;
>    }
>  if (dbus_g_type_is_collection (gtype))
>    {
>      GType elt_gtype;
>      char *sublookup;
>
>      elt_gtype = dbus_g_type_get_collection_specialization (gtype);
>      sublookup = dbus_g_type_get_lookup_function (elt_gtype);
>      (void) __extension__ ({ (void)0; });
>
>      if (_dbus_g_type_is_fixed (elt_gtype))
>        {
>          type_lookup = g_strdup_printf ("dbus_g_type_get_collection "
>              "(\"GArray\", %s)", sublookup);
>        }
>      else
>        {
>          type_lookup = g_strdup_printf ("dbus_g_type_get_collection "
>              "(\"GPtrArray\", %s)", sublookup);
>        }
>
>      g_free (sublookup);
>
>      return type_lookup;
>    }
>  else if (dbus_g_type_is_map (gtype))
>    {
>      GType key_gtype;
>      char *key_lookup;
>      GType value_gtype;
>      char *value_lookup;
>
>      key_gtype = dbus_g_type_get_map_key_specialization (gtype);
>      value_gtype = dbus_g_type_get_map_value_specialization (gtype);
>      key_lookup = dbus_g_type_get_lookup_function (key_gtype);
>      (void) __extension__ ({ (void)0; });
>      value_lookup = dbus_g_type_get_lookup_function (value_gtype);
>      (void) __extension__ ({ (void)0; });
>      type_lookup = g_strdup_printf ("dbus_g_type_get_map
>(\"GHashTable\", %s, %s)",
>         key_lookup, value_lookup);
>      g_free (key_lookup);
>      g_free (value_lookup);
>      return type_lookup;
>    }
>  else if (dbus_g_type_is_struct (gtype))
>    {
>      GType value_gtype;
>      GString *string;
>      char *value_lookup = ((void *)0);
>      guint size, i;
>
>      string = g_string_new ("dbus_g_type_get_struct (\"GValueArray\"");
>
>      size = dbus_g_type_get_struct_size (gtype);
>      for (i=0; i < size; i++)
>        {
>          value_gtype = dbus_g_type_get_struct_member_type(gtype, i);
>          value_lookup = dbus_g_type_get_lookup_function (value_gtype);
>          (void) __extension__ ({ (void)0; });
>          g_string_append_printf (string, ", %s", value_lookup);
>          g_free (value_lookup);
>        }
>      g_string_append (string, ", G_TYPE_INVALID)");
>      return g_string_free (string, (0));
>    }
>
>  if (gtype == (g_value_get_type ())) return g_strdup ("G_TYPE_VALUE");
>  if (gtype == (g_strv_get_type ())) return g_strdup ("G_TYPE_STRV");
>  if (gtype == (g_value_array_get_type ())) return g_strdup
>("G_TYPE_VALUE_ARRAY");
>  if (gtype == (dbus_g_proxy_get_type ())) return g_strdup
>("DBUS_TYPE_G_PROXY");
>  if (gtype == (dbus_g_object_path_get_g_type ())) return g_strdup
>("DBUS_TYPE_G_OBJECT_PATH");
>  return ((void *)0);
>}
>
>
>
>static gboolean
>write_args_for_direction (InterfaceInfo *iface, MethodInfo *method,
>GIOChannel *channel, int direction, GError **error)
>{
>  GSList *args;
>
>  for (args = method_info_get_args (method); args; args = args->next)
>    {
>      ArgInfo *arg;
>      GType gtype;
>      char *type_lookup;
>
>      arg = args->data;
>
>      if (direction != arg_info_get_direction (arg))
> continue;
>
>      gtype = _dbus_gtype_from_signature (arg_info_get_type (arg), (!(0)));
>      (void) __extension__ ({ (void)0; });
>      type_lookup = dbus_g_type_get_lookup_function (gtype);
>      (void) __extension__ ({ (void)0; });
>
>      switch (direction)
> {
>
> case ARG_IN:
>   if (!write_printf_to_iochannel ("%s, IN_%s, ", channel, error,
>       type_lookup,
>       arg_info_get_name (arg)))
>     goto io_lose;
>   break;
> case ARG_OUT:
>   if (!write_printf_to_iochannel ("%s, OUT_%s, ", channel, error,
>       type_lookup,
>       arg_info_get_name (arg)))
>     goto io_lose;
>   break;
> case ARG_INVALID:
>   break;
> }
>      g_free (type_lookup);
>    }
>
>  return (!(0));
> io_lose:
>  return (0);
>}
>
>static gboolean
>check_supported_parameters (MethodInfo *method)
>{
>  GSList *args;
>
>  for (args = method_info_get_args (method); args; args = args->next)
>    {
>      ArgInfo *arg;
>      GType gtype;
>
>      arg = args->data;
>      gtype = _dbus_gtype_from_signature (arg_info_get_type (arg), (!(0)));
>      if (gtype == ((GType) ((0) << (2))))
> return (0);
>    }
>  return (!(0));
>}
>
>static gboolean
>write_untyped_out_args (InterfaceInfo *iface, MethodInfo *method,
>GIOChannel *channel, GError **error)
>{
>  GSList *args;
>
>  for (args = method_info_get_args (method); args; args = args->next)
>    {
>      ArgInfo *arg;
>
>      arg = args->data;
>      if (arg_info_get_direction (arg) != ARG_OUT)
>        continue;
>
>      if (!write_printf_to_iochannel ("OUT_%s, ", channel, error,
>                                      arg_info_get_name (arg)))
>        goto io_lose;
>     }
>
>   return (!(0));
> io_lose:
>  return (0);
>}
>
>static gboolean
>write_formal_declarations_for_direction (InterfaceInfo *iface,
>MethodInfo *method, GIOChannel *channel, const int direction, GError
>**error)
> {
>   GSList *args;
>
>   for (args = method_info_get_args (method); args; args = args->next)
>     {
>       ArgInfo *arg;
>      GType gtype;
>      const char *type_str, *type_suffix;
>      int dir;
>
>       arg = args->data;
>
>      dir = arg_info_get_direction (arg);
>
>      gtype = _dbus_gtype_from_signature (arg_info_get_type (arg), (!(0)));
>      type_str = dbus_g_type_get_c_name (gtype);
>
>      if (!type_str)
>       {
>         g_set_error (error,
>                      dbus_binding_tool_error_quark (),
>                      DBUS_BINDING_TOOL_ERROR_UNSUPPORTED_CONVERSION,
>                      gettext ("Unsupported conversion from D-BUS type
>signature \"%s\" to glib C type in method \"%s\" of interface
>\"%s\""),
>                      arg_info_get_type (arg),
>                      method_info_get_name (method),
>                      interface_info_get_name (iface));
>         return (0);
>       }
>
>
>      if (gtype == (g_value_get_type ()))
> {
>   if (direction == ARG_IN)
>     type_suffix = "*";
>   else
>     type_suffix = "";
> }
>      else if ((g_type_is_a (gtype, ((GType) ((18) << (2))))
>       || g_type_is_a (gtype, ((GType) ((20) << (2))))
>    || g_type_is_a (gtype, ((GType) ((17) << (2))))))
> type_suffix = "*";
>      else
> type_suffix = "";
>
>      if (direction != dir)
>        continue;
>
>          switch (dir)
>       {
>       case ARG_IN:
>         if (!write_printf_to_iochannel ("  %s%s IN_%s;\n", channel, error,
>                                         type_str, type_suffix,
>                                         arg_info_get_name (arg)))
>           goto io_lose;
>         break;
>       case ARG_OUT:
>         if (!write_printf_to_iochannel ("  %s%s OUT_%s;\n", channel, error,
>                                         type_str, type_suffix,
>                                         arg_info_get_name (arg)))
>           goto io_lose;
>         break;
>       case ARG_INVALID:
>         break;
>       }
>     }
>   return (!(0));
> io_lose:
>  return (0);
> }
>
>static gboolean
>write_formal_parameters_for_direction (InterfaceInfo *iface,
>MethodInfo *method, int dir, GIOChannel *channel, GError **error)
>{
>  GSList *args;
>
>  for (args = method_info_get_args (method); args; args = args->next)
>    {
>      ArgInfo *arg;
>      const char *type_str;
>      const char *type_suffix;
>      GType gtype;
>      int direction;
>
>      arg = args->data;
>
>      direction = arg_info_get_direction (arg);
>      if (dir != direction) continue;
>
>      do { gsize bytes_written; if (!g_io_channel_write_chars
>(channel, ", ", -1, &bytes_written, error)) goto io_lose; } while (0);
>
>      gtype = _dbus_gtype_from_signature (arg_info_get_type (arg), (!(0)));
>      type_str = dbus_g_type_get_c_name (gtype);
>
>      if (gtype == (g_value_get_type ()))
> {
>   if (direction == ARG_IN)
>     type_suffix = "*";
>   else
>     type_suffix = "";
> }
>      else if ((g_type_is_a (gtype, ((GType) ((18) << (2))))
>       || g_type_is_a (gtype, ((GType) ((20) << (2))))
>    || g_type_is_a (gtype, ((GType) ((17) << (2))))))
> type_suffix = "*";
>      else
> type_suffix = "";
>
>      if (!type_str)
> {
>   g_set_error (error,
>         dbus_binding_tool_error_quark (),
>         DBUS_BINDING_TOOL_ERROR_UNSUPPORTED_CONVERSION,
>         gettext ("Unsupported conversion from D-BUS type signature
>\"%s\" to glib C type in method \"%s\" of interface \"%s\""),
>         arg_info_get_type (arg),
>         method_info_get_name (method),
>         interface_info_get_name (iface));
>   return (0);
> }
>
>       switch (direction)
>  {
>  case ARG_IN:
>   if (!write_printf_to_iochannel ("const %s%s IN_%s", channel, error,
>       type_str,
>       type_suffix,
>       arg_info_get_name (arg)))
>      goto io_lose;
>    break;
>  case ARG_OUT:
>   if (!write_printf_to_iochannel ("%s%s* OUT_%s", channel, error,
>       type_str,
>       type_suffix,
>       arg_info_get_name (arg)))
>      goto io_lose;
>    break;
>  case ARG_INVALID:
>   break;
> }
>    }
>  return (!(0));
> io_lose:
>  return (0);
>}
>
>static gboolean
>write_typed_args_for_direction (InterfaceInfo *iface, MethodInfo
>*method, GIOChannel *channel, const int direction, GError **error)
> {
>  GSList *args;
>
>  for (args = method_info_get_args (method); args; args = args->next)
>    {
>      ArgInfo *arg;
>      int dir;
>      GType gtype;
>      const char *type_lookup;
>
>      arg = args->data;
>
>      dir = arg_info_get_direction (arg);
>
>      if (dir != direction)
>        continue;
>
>      gtype = _dbus_gtype_from_signature (arg_info_get_type (arg), (!(0)));
>      type_lookup = dbus_g_type_get_lookup_function (gtype);
>
>      if (!write_printf_to_iochannel ("%s, &%s_%s, ", channel, error,
>type_lookup, direction == ARG_IN ? "IN" : "OUT", arg_info_get_name
>(arg)))
>          goto io_lose;
>    }
>  return (!(0));
> io_lose:
>  return (0);
>}
>
>static gboolean
>write_async_method_client (GIOChannel *channel, InterfaceInfo
>*interface, MethodInfo *method, GError **error)
>{
>  char *method_name, *iface_prefix;
>  const char *interface_c_name;
>
>  iface_prefix = iface_to_c_prefix (interface_info_get_name (interface));
>  interface_c_name = interface_info_get_annotation (interface,
>"org.freedesktop.DBus.GLib.ClientCSymbol");
>  if (interface_c_name == ((void *)0))
>    {
>      interface_c_name = (const char *) iface_prefix;
>    }
>
>  method_name = g_strdup (method_info_get_annotation (method,
>"org.freedesktop.DBus.GLib.ClientCSymbol"));
>  if (method_name == ((void *)0))
>    {
>      method_name = compute_client_method_name (interface_c_name, method);
>    }
>  g_free(iface_prefix);
>
>
>  if (!write_printf_to_iochannel ("typedef void (*%s_reply)
>(DBusGProxy *proxy, ", channel, error, method_name))
>    goto io_lose;
>  {
>    GSList *args;
>    for (args = method_info_get_args (method); args; args = args->next)
>      {
> ArgInfo *arg;
> const char *type_suffix, *type_str;
> GType gtype;
>
> arg = args->data;
>
> if (arg_info_get_direction (arg) != ARG_OUT)
>   continue;
> gtype = _dbus_gtype_from_signature (arg_info_get_type (arg), (!(0)));
> if (gtype != (g_value_get_type ()) && (g_type_is_a (gtype, ((GType)
>((18) << (2))))
>      || g_type_is_a (gtype, ((GType) ((20) << (2))))
>      || g_type_is_a (gtype, ((GType) ((17) << (2))))))
>   type_suffix = "*";
> else
>   type_suffix = "";
> type_str = dbus_g_type_get_c_name (_dbus_gtype_from_signature
>(arg_info_get_type (arg), (!(0))));
> if (!write_printf_to_iochannel ("%s %sOUT_%s, ", channel, error,
>type_str, type_suffix, arg_info_get_name (arg)))
>   goto io_lose;
>      }
>  }
>  do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>"GError *error, gpointer userdata);\n\n", -1, &bytes_written, error))
>goto io_lose; } while (0);
>
>
>
>  do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>"static void\n", -1, &bytes_written, error)) goto io_lose; } while
>(0);
>  if (!write_printf_to_iochannel ("%s_async_callback (DBusGProxy
>*proxy, DBusGProxyCall *call, void *user_data)\n", channel, error,
>method_name))
>    goto io_lose;
>  do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>"{\n", -1, &bytes_written, error)) goto io_lose; } while (0);
>  do { gsize bytes_written; if (!g_io_channel_write_chars (channel, "
>DBusGAsyncData *data = (DBusGAsyncData*) user_data;\n  GError *error =
>NULL;\n", -1, &bytes_written, error)) goto io_lose; } while (0);
>  if (!write_formal_declarations_for_direction (interface, method,
>channel, ARG_OUT, error))
>    goto io_lose;
>
>  do { gsize bytes_written; if (!g_io_channel_write_chars (channel, "
>dbus_g_proxy_end_call (proxy, call, &error, ", -1, &bytes_written,
>error)) goto io_lose; } while (0);
>  if (!write_typed_args_for_direction (interface, method, channel,
>ARG_OUT, error))
>    goto io_lose;
>  do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>"G_TYPE_INVALID);\n", -1, &bytes_written, error)) goto io_lose; }
>while (0);
>  if (!write_printf_to_iochannel ("  (*(%s_reply)data->cb) (proxy, ",
>channel, error, method_name))
>    goto io_lose;
>  if (!write_untyped_out_args (interface, method, channel, error))
>    goto io_lose;
>  do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>"error, data->userdata);\n", -1, &bytes_written, error)) goto io_lose;
>} while (0);
>  do { gsize bytes_written; if (!g_io_channel_write_chars (channel, "
>return;\n}\n\n", -1, &bytes_written, error)) goto io_lose; } while
>(0);
>
>
>
>  do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>"static\n#ifdef G_HAVE_INLINE\ninline\n#endif\nDBusGProxyCall*\n", -1,
>&bytes_written, error)) goto io_lose; } while (0);
>  if (!write_printf_to_iochannel ("%s_async (DBusGProxy *proxy", channel, error,
>                                  method_name))
>    goto io_lose;
>  if (!write_formal_parameters_for_direction (interface, method,
>ARG_IN, channel, error))
>    goto io_lose;
>
>  if (!write_printf_to_iochannel (", %s_reply callback, gpointer
>userdata)\n\n", channel, error, method_name))
>    goto io_lose;
>
>  do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>"{\n", -1, &bytes_written, error)) goto io_lose; } while (0);
>  do { gsize bytes_written; if (!g_io_channel_write_chars (channel, "
>DBusGAsyncData *stuff;\n  stuff = g_new (DBusGAsyncData, 1);\n
>stuff->cb = G_CALLBACK (callback);\n  stuff->userdata = userdata;\n",
>-1, &bytes_written, error)) goto io_lose; } while (0);
>  if (!write_printf_to_iochannel ("  return dbus_g_proxy_begin_call
>(proxy, \"%s\", %s_async_callback, stuff, g_free, ", channel, error,
>method_info_get_name (method), method_name))
>    goto io_lose;
>  if (!write_args_for_direction (interface, method, channel, ARG_IN, error))
>    goto io_lose;
>  do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>"G_TYPE_INVALID);\n}\n", -1, &bytes_written, error)) goto io_lose; }
>while (0);
>
>  g_free (method_name);
>  return (!(0));
> io_lose:
>  g_free (method_name);
>  return (0);
> }
>
>static gboolean
>generate_client_glue_list (GSList *list, DBusBindingToolCData *data,
>GError **error)
>{
>  GSList *tmp;
>
>  tmp = list;
>  while (tmp != ((void *)0))
>    {
>      if (!generate_client_glue (tmp->data, data, error))
> return (0);
>      tmp = tmp->next;
>    }
>  return (!(0));
>}
>
>static gboolean
>generate_client_glue (BaseInfo *base, DBusBindingToolCData *data,
>GError **error)
>{
>  if (base_info_get_type (base) == INFO_TYPE_NODE)
>    {
>      if (!generate_client_glue_list (node_info_get_nodes ((NodeInfo *) base),
>          data, error))
> return (0);
>      if (!generate_client_glue_list (node_info_get_interfaces
>((NodeInfo *) base),
>          data, error))
> return (0);
>    }
>  else
>    {
>      GIOChannel *channel;
>      InterfaceInfo *interface;
>      GSList *methods;
>      GSList *tmp;
>      char *iface_prefix;
>      const char *interface_c_name;
>
>      channel = data->channel;
>
>      interface = (InterfaceInfo *) base;
>
>      methods = interface_info_get_methods (interface);
>
>      iface_prefix = iface_to_c_prefix (interface_info_get_name (interface));
>      interface_c_name = interface_info_get_annotation (interface,
>"org.freedesktop.DBus.GLib.ClientCSymbol");
>      if (interface_c_name == ((void *)0))
>      {
>          interface_c_name = (const char *) iface_prefix;
>      }
>
>      if (!write_printf_to_iochannel ("#ifndef DBUS_GLIB_CLIENT_WRAPPERS_%s\n"
>          "#define DBUS_GLIB_CLIENT_WRAPPERS_%s\n\n",
>          channel, error,
>          iface_prefix, iface_prefix))
> {
>   g_free (iface_prefix);
>   goto io_lose;
> }
>
>      for (tmp = methods; tmp != ((void *)0); tmp = ((tmp) ? (((GSList
>*)(tmp))->next) : ((void *)0)))
>        {
>   MethodInfo *method;
>   char *method_c_name;
>   gboolean is_noreply;
>
>          method = (MethodInfo *) tmp->data;
>   method_c_name = g_strdup (method_info_get_annotation (method,
>"org.freedesktop.DBus.GLib.ClientCSymbol"));
>          if (method_c_name == ((void *)0))
>     {
>              method_c_name = compute_client_method_name
>(interface_c_name, method);
>            }
>
>   is_noreply = method_info_get_annotation (method,
>"org.freedesktop.DBus.Method.NoReply") != ((void *)0);
>
>   if (data->ignore_unsupported && !check_supported_parameters (method))
>     {
>       g_log (((gchar*) 0), G_LOG_LEVEL_WARNING, "Ignoring unsupported
>signature in method \"%s\" of interface \"%s\"\n",
>method_info_get_name (method), interface_info_get_name (interface));
>
>
>       continue;
>     }
>
>
>   do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>"static\n#ifdef G_HAVE_INLINE\ninline\n#endif\ngboolean\n", -1,
>&bytes_written, error)) goto io_lose; } while (0);
>   if (!write_printf_to_iochannel ("%s (DBusGProxy *proxy", channel, error,
>       method_c_name))
>     goto io_lose;
>   g_free (method_c_name);
>
>   if (!write_formal_parameters (interface, method, channel, error))
>     goto io_lose;
>
>   do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>", GError **error)\n\n", -1, &bytes_written, error)) goto io_lose; }
>while (0);
>
>   do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>"{\n", -1, &bytes_written, error)) goto io_lose; } while (0);
>
>   if (is_noreply) {
>     if (!write_printf_to_iochannel ("  dbus_g_proxy_call_no_reply
>(proxy, \"%s\", ", channel, error,
>         method_info_get_name (method)))
>       goto io_lose;
>
>     if (!write_args_for_direction (interface, method, channel, ARG_IN, error))
>       goto io_lose;
>
>     do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>"G_TYPE_INVALID, ", -1, &bytes_written, error)) goto io_lose; } while
>(0);
>
>     if (!write_args_for_direction (interface, method, channel, ARG_OUT, error))
>       goto io_lose;
>
>     do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>"G_TYPE_INVALID);\n", -1, &bytes_written, error)) goto io_lose; }
>while (0);
>
>     do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>"  return TRUE;\n}\n\n", -1, &bytes_written, error)) goto io_lose; }
>while (0);
>   } else {
>     if (!write_printf_to_iochannel ("  return dbus_g_proxy_call
>(proxy, \"%s\", ", channel, error,
>         method_info_get_name (method)))
>       goto io_lose;
>
>     do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>"error, ", -1, &bytes_written, error)) goto io_lose; } while (0);
>
>     if (!write_args_for_direction (interface, method, channel, ARG_IN, error))
>       goto io_lose;
>
>     do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>"G_TYPE_INVALID, ", -1, &bytes_written, error)) goto io_lose; } while
>(0);
>
>     if (!write_args_for_direction (interface, method, channel, ARG_OUT, error))
>       goto io_lose;
>
>     do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>"G_TYPE_INVALID);\n}\n\n", -1, &bytes_written, error)) goto io_lose; }
>while (0);
>   }
>
>   write_async_method_client (channel, interface, method, error);
> }
>
>      if (!write_printf_to_iochannel ("#endif /* defined
>DBUS_GLIB_CLIENT_WRAPPERS_%s */\n\n", channel, error, iface_prefix))
> {
>   g_free (iface_prefix);
>   goto io_lose;
> }
>
>      g_free (iface_prefix);
>    }
>  return (!(0));
> io_lose:
>  return (0);
>}
>
>
>gboolean
>dbus_binding_tool_output_glib_client (BaseInfo *info, GIOChannel
>*channel, gboolean ignore_unsupported, GError **error)
>{
>  DBusBindingToolCData data;
>  gboolean ret;
>
>  memset (&data, 0, sizeof (data));
>
>  data.channel = channel;
>  data.ignore_unsupported = ignore_unsupported;
>
>  dbus_g_type_specialized_init ();
>  _dbus_g_type_specialized_builtins_init ();
>
>  do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>"/* Generated by dbus-binding-tool; do not edit! */\n\n", -1,
>&bytes_written, error)) goto io_lose; } while (0);
>  do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>"#include <glib/gtypes.h>\n", -1, &bytes_written, error)) goto
>io_lose; } while (0);
>  do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>"#include <glib/gerror.h>\n", -1, &bytes_written, error)) goto
>io_lose; } while (0);
>  do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>"#include <dbus/dbus-glib.h>\n\n", -1, &bytes_written, error)) goto
>io_lose; } while (0);
>  do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>"G_BEGIN_DECLS\n\n", -1, &bytes_written, error)) goto io_lose; } while
>(0);
>
>  ret = generate_client_glue (info, &data, error);
>  if (!ret)
>    goto io_lose;
>
>  do { gsize bytes_written; if (!g_io_channel_write_chars (channel,
>"G_END_DECLS\n", -1, &bytes_written, error)) goto io_lose; } while
>(0);
>
>  return ret;
> io_lose:
>  return (0);
>}
>
>
>On 5/29/07, Ralf Habacker <ralf.habacker@freenet.de> wrote:
>> Thiago Macieira schrieb:
>> > Scott Peterson wrote:
>> >
>> >> I'm trying to build dbus-glib on cygwin and I'm getting this error when
>> >> I make:
>> >>
>> >> In file included from /usr/include/unistd.h:4,
>> >>                 from dbus-binding-tool-glib.c:39:
>> >> /usr/include/sys/unistd.h:108: error: parse error before numeric
>> >> constant
>> >>
>> >> Ideas?
>> >>
>> >
>> > There's something in that line of sys/unistd.h that is being #define'd to
>> > something else.
>> >
>> > What's on that line?
>> >
>> > sys/unistd.h has 1 line here.
>> >
>> in cygwin 1.5.21-2 unistd.h version line  108 contains
>>
>>    int     _EXFUN(pipe, (int __fildes[2] ));
>>
>> Probably __fildes is being redefined. You may compile with make CC="gcc
>> -save-temps" and take a look into dbus-binding-tool-glib.i then to see
>> what's going wrong.
>>
>> Ralf
>>
>>
>
>
>-- 
>Scott.
>_______________________________________________
>dbus mailing list
>dbus@lists.freedesktop.org
>http://lists.freedesktop.org/mailman/listinfo/dbus

Actions: View

Attachments on bug 247332: 158713 | 158714