summaryrefslogtreecommitdiff
path: root/meta/packages/glib-2.0/files
diff options
context:
space:
mode:
authorRichard Purdie <richard@openedhand.com>2007-02-04 17:56:48 +0000
committerRichard Purdie <richard@openedhand.com>2007-02-04 17:56:48 +0000
commit9a667a82979eb85b0b5204e3d969b9859cd54be3 (patch)
tree3a1b0a5f1754c59191e250106941072fe8fc9e6a /meta/packages/glib-2.0/files
parenta0394cd0b1613dcad2f3a705048d352d044f7865 (diff)
downloadopenembedded-core-9a667a82979eb85b0b5204e3d969b9859cd54be3.tar.gz
openembedded-core-9a667a82979eb85b0b5204e3d969b9859cd54be3.tar.bz2
openembedded-core-9a667a82979eb85b0b5204e3d969b9859cd54be3.tar.xz
openembedded-core-9a667a82979eb85b0b5204e3d969b9859cd54be3.zip
glib: Add 2.12.6 from OE.dev
git-svn-id: https://svn.o-hand.com/repos/poky/trunk@1254 311d38ba-8fff-0310-9ca6-ca027cbcb966
Diffstat (limited to 'meta/packages/glib-2.0/files')
-rw-r--r--meta/packages/glib-2.0/files/configure-libtool.patch11
-rw-r--r--meta/packages/glib-2.0/files/glib-mkenums-nowarn.patch8
-rw-r--r--meta/packages/glib-2.0/files/gtk-doc.patch59
-rw-r--r--meta/packages/glib-2.0/files/visibility.patch6123
4 files changed, 6201 insertions, 0 deletions
diff --git a/meta/packages/glib-2.0/files/configure-libtool.patch b/meta/packages/glib-2.0/files/configure-libtool.patch
new file mode 100644
index 000000000..bbbf5df98
--- /dev/null
+++ b/meta/packages/glib-2.0/files/configure-libtool.patch
@@ -0,0 +1,11 @@
+--- glib-2.8.4/configure.in.orig 2006-06-05 13:34:08.000000000 +0100
++++ glib-2.8.4/configure.in 2006-06-05 13:34:36.000000000 +0100
+@@ -1106,7 +1106,7 @@
+ dnl No use for this on Win32
+ G_MODULE_LDFLAGS=
+ else
+- G_MODULE_LDFLAGS=`(./libtool --config; echo eval echo \\$export_dynamic_flag_spec) | sh`
++ G_MODULE_LDFLAGS=`(./$host_alias-libtool --config; echo eval echo \\$export_dynamic_flag_spec) | sh`
+ fi
+ dnl G_MODULE_IMPL= don't reset, so cmd-line can override
+ G_MODULE_NEED_USCORE=0
diff --git a/meta/packages/glib-2.0/files/glib-mkenums-nowarn.patch b/meta/packages/glib-2.0/files/glib-mkenums-nowarn.patch
new file mode 100644
index 000000000..1ab6e379c
--- /dev/null
+++ b/meta/packages/glib-2.0/files/glib-mkenums-nowarn.patch
@@ -0,0 +1,8 @@
+--- glib-2.6.5/gobject/glib-mkenums.in.orig 2006-06-15 21:28:23.436946024 -0600
++++ glib-2.6.5/gobject/glib-mkenums.in 2006-06-15 21:28:35.417124760 -0600
+@@ -1,4 +1,4 @@
+-#!@PERL_PATH@ -w
++#!@PERL_PATH@
+
+ # glib-mkenums.pl
+ # Information about the current enumeration
diff --git a/meta/packages/glib-2.0/files/gtk-doc.patch b/meta/packages/glib-2.0/files/gtk-doc.patch
new file mode 100644
index 000000000..4b9c234e2
--- /dev/null
+++ b/meta/packages/glib-2.0/files/gtk-doc.patch
@@ -0,0 +1,59 @@
+--- glib/acinclude.m4 2004-05-08 11:14:46.000000000 +0100
++++ glib/acinclude.m4 2004-05-08 11:14:55.000000000 +0100
+@@ -446,3 +446,56 @@
+ ])
+
+
++dnl -*- mode: autoconf -*-
++
++# serial 1
++
++dnl Usage:
++dnl GTK_DOC_CHECK([minimum-gtk-doc-version])
++AC_DEFUN([GTK_DOC_CHECK],
++[
++ AC_BEFORE([AC_PROG_LIBTOOL],[$0])dnl setup libtool first
++ AC_BEFORE([AM_PROG_LIBTOOL],[$0])dnl setup libtool first
++ dnl for overriding the documentation installation directory
++ AC_ARG_WITH(html-dir,
++ AC_HELP_STRING([--with-html-dir=PATH], [path to installed docs]),,
++ [with_html_dir='${datadir}/gtk-doc/html'])
++ HTML_DIR="$with_html_dir"
++ AC_SUBST(HTML_DIR)
++
++ dnl enable/disable documentation building
++ AC_ARG_ENABLE(gtk-doc,
++ AC_HELP_STRING([--enable-gtk-doc],
++ [use gtk-doc to build documentation [default=no]]),,
++ enable_gtk_doc=no)
++
++ have_gtk_doc=no
++ if test -z "$PKG_CONFIG"; then
++ AC_PATH_PROG(PKG_CONFIG, pkg-config, no)
++ fi
++ if test "$PKG_CONFIG" != "no" && $PKG_CONFIG --exists gtk-doc; then
++ have_gtk_doc=yes
++ fi
++
++ dnl do we want to do a version check?
++ifelse([$1],[],,
++ [gtk_doc_min_version=$1
++ if test "$have_gtk_doc" = yes; then
++ AC_MSG_CHECKING([gtk-doc version >= $gtk_doc_min_version])
++ if $PKG_CONFIG --atleast-version $gtk_doc_min_version gtk-doc; then
++ AC_MSG_RESULT(yes)
++ else
++ AC_MSG_RESULT(no)
++ have_gtk_doc=no
++ fi
++ fi
++])
++ if test x$enable_gtk_doc = xyes; then
++ if test "$have_gtk_doc" != yes; then
++ enable_gtk_doc=no
++ fi
++ fi
++
++ AM_CONDITIONAL(ENABLE_GTK_DOC, test x$enable_gtk_doc = xyes)
++ AM_CONDITIONAL(GTK_DOC_USE_LIBTOOL, test -n "$LIBTOOL")
++])
diff --git a/meta/packages/glib-2.0/files/visibility.patch b/meta/packages/glib-2.0/files/visibility.patch
new file mode 100644
index 000000000..7cea8b037
--- /dev/null
+++ b/meta/packages/glib-2.0/files/visibility.patch
@@ -0,0 +1,6123 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- glib-2.4.6/glib/garray.h~visibility.patch
++++ glib-2.4.6/glib/garray.h
+@@ -63,102 +63,102 @@
+ #define g_array_insert_val(a,i,v) g_array_insert_vals (a, i, &(v), 1)
+ #define g_array_index(a,t,i) (((t*) (a)->data) [(i)])
+
+-GArray* g_array_new (gboolean zero_terminated,
++GLIB_FUNC GArray* g_array_new (gboolean zero_terminated,
+ gboolean clear_,
+- guint element_size);
+-GArray* g_array_sized_new (gboolean zero_terminated,
++ guint element_size);;
++GLIB_FUNC 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,
++ guint reserved_size);;
++GLIB_FUNC gchar* g_array_free (GArray *array,
++ gboolean free_segment);;
++GLIB_FUNC GArray* g_array_append_vals (GArray *array,
+ gconstpointer data,
+- guint len);
+-GArray* g_array_prepend_vals (GArray *array,
++ guint len);;
++GLIB_FUNC GArray* g_array_prepend_vals (GArray *array,
+ gconstpointer data,
+- guint len);
+-GArray* g_array_insert_vals (GArray *array,
++ guint len);;
++GLIB_FUNC 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 len);;
++GLIB_FUNC GArray* g_array_set_size (GArray *array,
++ guint length);;
++GLIB_FUNC GArray* g_array_remove_index (GArray *array,
++ guint index_);;
++GLIB_FUNC GArray* g_array_remove_index_fast (GArray *array,
++ guint index_);;
++GLIB_FUNC 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,
++ guint length);;
++GLIB_FUNC void g_array_sort (GArray *array,
++ GCompareFunc compare_func);;
++GLIB_FUNC void g_array_sort_with_data (GArray *array,
+ GCompareDataFunc compare_func,
+- gpointer user_data);
++ gpointer user_data);;
+
+ /* Resizable pointer array. This interface is much less complicated
+ * than the above. Add appends a pointer. Remove fills any cleared
+ * spot and shortens the array. remove_fast will again distort order.
+ */
+ #define g_ptr_array_index(array,index_) ((array)->pdata)[index_]
+-GPtrArray* g_ptr_array_new (void);
+-GPtrArray* g_ptr_array_sized_new (guint reserved_size);
+-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,
++GLIB_FUNC GPtrArray* g_ptr_array_new (void);
++GLIB_FUNC GPtrArray* g_ptr_array_sized_new (guint reserved_size);
++GLIB_FUNC gpointer* g_ptr_array_free (GPtrArray *array,
++ gboolean free_seg);;
++GLIB_FUNC void g_ptr_array_set_size (GPtrArray *array,
++ gint length);;
++GLIB_FUNC gpointer g_ptr_array_remove_index (GPtrArray *array,
++ guint index_);;
++GLIB_FUNC gpointer g_ptr_array_remove_index_fast (GPtrArray *array,
++ guint index_);;
++GLIB_FUNC gboolean g_ptr_array_remove (GPtrArray *array,
++ gpointer data);;
++GLIB_FUNC gboolean g_ptr_array_remove_fast (GPtrArray *array,
++ gpointer data);;
++GLIB_FUNC 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,
++ guint length);;
++GLIB_FUNC void g_ptr_array_add (GPtrArray *array,
++ gpointer data);;
++GLIB_FUNC void g_ptr_array_sort (GPtrArray *array,
++ GCompareFunc compare_func);;
++GLIB_FUNC void g_ptr_array_sort_with_data (GPtrArray *array,
+ GCompareDataFunc compare_func,
+- gpointer user_data);
+-void g_ptr_array_foreach (GPtrArray *array,
++ gpointer user_data);;
++GLIB_FUNC void g_ptr_array_foreach (GPtrArray *array,
+ GFunc func,
+- gpointer user_data);
++ gpointer user_data);;
+
+
+ /* Byte arrays, an array of guint8. Implemented as a GArray,
+ * but type-safe.
+ */
+
+-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,
++GLIB_FUNC GByteArray* g_byte_array_new (void);
++GLIB_FUNC GByteArray* g_byte_array_sized_new (guint reserved_size);
++GLIB_FUNC guint8* g_byte_array_free (GByteArray *array,
++ gboolean free_segment);;
++GLIB_FUNC GByteArray* g_byte_array_append (GByteArray *array,
+ const guint8 *data,
+- guint len);
+-GByteArray* g_byte_array_prepend (GByteArray *array,
++ guint len);;
++GLIB_FUNC 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 len);;
++GLIB_FUNC GByteArray* g_byte_array_set_size (GByteArray *array,
++ guint length);;
++GLIB_FUNC GByteArray* g_byte_array_remove_index (GByteArray *array,
++ guint index_);;
++GLIB_FUNC GByteArray* g_byte_array_remove_index_fast (GByteArray *array,
++ guint index_);;
++GLIB_FUNC 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,
++ guint length);;
++GLIB_FUNC void g_byte_array_sort (GByteArray *array,
++ GCompareFunc compare_func);;
++GLIB_FUNC void g_byte_array_sort_with_data (GByteArray *array,
+ GCompareDataFunc compare_func,
+- gpointer user_data);
++ gpointer user_data);;
+
+
+ G_END_DECLS
+--- glib-2.4.6/glib/gasyncqueue.h~visibility.patch
++++ glib-2.4.6/glib/gasyncqueue.h
+@@ -37,45 +37,45 @@
+ */
+
+ /* Get a new GAsyncQueue with the ref_count 1 */
+-GAsyncQueue* g_async_queue_new (void);
++GLIB_FUNC GAsyncQueue* g_async_queue_new (void);
+
+ /* Lock and unlock a GAsyncQueue. All functions lock the queue for
+ * themselves, but in certain cirumstances you want to hold the lock longer,
+ * thus you lock the queue, call the *_unlocked functions and unlock it again.
+ */
+-void g_async_queue_lock (GAsyncQueue *queue);
+-void g_async_queue_unlock (GAsyncQueue *queue);
++GLIB_FUNC void g_async_queue_lock (GAsyncQueue *queue);
++GLIB_FUNC void g_async_queue_unlock (GAsyncQueue *queue);
+
+ /* Ref and unref the GAsyncQueue. */
+-void g_async_queue_ref (GAsyncQueue *queue);
+-void g_async_queue_unref (GAsyncQueue *queue);
++GLIB_FUNC void g_async_queue_ref (GAsyncQueue *queue);
++GLIB_FUNC void g_async_queue_unref (GAsyncQueue *queue);
+ #ifndef G_DISABLE_DEPRECATED
+ /* You don't have to hold the lock for calling *_ref and *_unref anymore. */
+-void g_async_queue_ref_unlocked (GAsyncQueue *queue);
+-void g_async_queue_unref_and_unlock (GAsyncQueue *queue);
++GLIB_FUNC void g_async_queue_ref_unlocked (GAsyncQueue *queue);
++GLIB_FUNC void g_async_queue_unref_and_unlock (GAsyncQueue *queue);
+ #endif /* !G_DISABLE_DEPRECATED */
+
+ /* Push data into the async queue. Must not be NULL. */
+-void g_async_queue_push (GAsyncQueue *queue,
+- gpointer data);
+-void g_async_queue_push_unlocked (GAsyncQueue *queue,
+- gpointer data);
++GLIB_FUNC void g_async_queue_push (GAsyncQueue *queue,
++ gpointer data);;
++GLIB_FUNC void g_async_queue_push_unlocked (GAsyncQueue *queue,
++ gpointer data);;
+
+ /* Pop data from the async queue. When no data is there, the thread is blocked
+ * until data arrives. */
+-gpointer g_async_queue_pop (GAsyncQueue *queue);
+-gpointer g_async_queue_pop_unlocked (GAsyncQueue *queue);
++GLIB_FUNC gpointer g_async_queue_pop (GAsyncQueue *queue);
++GLIB_FUNC gpointer g_async_queue_pop_unlocked (GAsyncQueue *queue);
+
+ /* Try to pop data. NULL is returned in case of empty queue. */
+-gpointer g_async_queue_try_pop (GAsyncQueue *queue);
+-gpointer g_async_queue_try_pop_unlocked (GAsyncQueue *queue);
++GLIB_FUNC gpointer g_async_queue_try_pop (GAsyncQueue *queue);
++GLIB_FUNC gpointer g_async_queue_try_pop_unlocked (GAsyncQueue *queue);
+
+ /* Wait for data until at maximum until end_time is reached. NULL is returned
+ * in case of empty queue. */
+-gpointer g_async_queue_timed_pop (GAsyncQueue *queue,
+- GTimeVal *end_time);
+-gpointer g_async_queue_timed_pop_unlocked (GAsyncQueue *queue,
+- GTimeVal *end_time);
++GLIB_FUNC gpointer g_async_queue_timed_pop (GAsyncQueue *queue,
++ GTimeVal *end_time);;
++GLIB_FUNC gpointer g_async_queue_timed_pop_unlocked (GAsyncQueue *queue,
++ GTimeVal *end_time);;
+
+ /* Return the length of the queue. Negative values mean that threads
+ * are waiting, positve values mean that there are entries in the
+@@ -83,8 +83,8 @@
+ * the number of waiting threads, g_async_queue_length == 0 could also
+ * mean 'n' entries in the queue and 'n' thread waiting. Such can
+ * happen due to locking of the queue or due to scheduling. */
+-gint g_async_queue_length (GAsyncQueue *queue);
+-gint g_async_queue_length_unlocked (GAsyncQueue *queue);
++GLIB_FUNC gint g_async_queue_length (GAsyncQueue *queue);
++GLIB_FUNC gint g_async_queue_length_unlocked (GAsyncQueue *queue);
+
+ G_END_DECLS
+
+--- glib-2.4.6/glib/gatomic.h~visibility.patch
++++ glib-2.4.6/glib/gatomic.h
+@@ -34,20 +34,20 @@
+
+ G_BEGIN_DECLS
+
+-gint g_atomic_int_exchange_and_add (gint *atomic,
+- gint val);
+-void g_atomic_int_add (gint *atomic,
+- gint val);
+-gboolean g_atomic_int_compare_and_exchange (gint *atomic,
++GLIB_FUNC gint g_atomic_int_exchange_and_add (gint *atomic,
++ gint val);;
++GLIB_FUNC void g_atomic_int_add (gint *atomic,
++ gint val);;
++GLIB_FUNC gboolean g_atomic_int_compare_and_exchange (gint *atomic,
+ gint oldval,
+- gint newval);
+-gboolean g_atomic_pointer_compare_and_exchange (gpointer *atomic,
++ gint newval);;
++GLIB_FUNC gboolean g_atomic_pointer_compare_and_exchange (gpointer *atomic,
+ gpointer oldval,
+- gpointer newval);
++ gpointer newval);;
+
+ #ifdef G_ATOMIC_OP_MEMORY_BARRIER_NEEDED
+-gint g_atomic_int_get (gint *atomic);
+-gpointer g_atomic_pointer_get (gpointer *atomic);
++GLIB_FUNC gint g_atomic_int_get (gint *atomic);
++GLIB_FUNC gpointer g_atomic_pointer_get (gpointer *atomic);
+ #else /* !G_ATOMIC_OP_MEMORY_BARRIER_NEEDED */
+ # define g_atomic_int_get(atomic) (*(atomic))
+ # define g_atomic_pointer_get(atomic) (*(atomic))
+--- glib-2.4.6/glib/gbacktrace.h~visibility.patch
++++ glib-2.4.6/glib/gbacktrace.h
+@@ -40,8 +40,8 @@
+ * The prg_name arg is required by gdb to find the executable, if it is
+ * passed as NULL, g_on_error_query() will try g_get_prgname().
+ */
+-void g_on_error_query (const gchar *prg_name);
+-void g_on_error_stack_trace (const gchar *prg_name);
++GLIB_FUNC void g_on_error_query (const gchar *prg_name);
++GLIB_FUNC void g_on_error_stack_trace (const gchar *prg_name);
+
+ /* Hacker macro to place breakpoints for selected machines.
+ * Actual use is strongly discouraged of course ;)
+--- glib-2.4.6/glib/gcache.h~visibility.patch
++++ glib-2.4.6/glib/gcache.h
+@@ -39,24 +39,24 @@
+
+ /* Caches
+ */
+-GCache* g_cache_new (GCacheNewFunc value_new_func,
++GLIB_FUNC 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,
++ GEqualFunc key_equal_func);;
++GLIB_FUNC void g_cache_destroy (GCache *cache);
++GLIB_FUNC gpointer g_cache_insert (GCache *cache,
++ gpointer key);;
++GLIB_FUNC void g_cache_remove (GCache *cache,
++ gconstpointer value);;
++GLIB_FUNC void g_cache_key_foreach (GCache *cache,
+ GHFunc func,
+- gpointer user_data);
+-void g_cache_value_foreach (GCache *cache,
++ gpointer user_data);;
++GLIB_FUNC void g_cache_value_foreach (GCache *cache,
+ GHFunc func,
+- gpointer user_data);
++ gpointer user_data);;
+
+ G_END_DECLS
+
+--- glib-2.4.6/glib/gcompletion.h~visibility.patch
++++ glib-2.4.6/glib/gcompletion.h
+@@ -52,21 +52,21 @@
+ 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,
++GLIB_FUNC GCompletion* g_completion_new (GCompletionFunc func);
++GLIB_FUNC void g_completion_add_items (GCompletion* cmp,
++ GList* items);;
++GLIB_FUNC void g_completion_remove_items (GCompletion* cmp,
++ GList* items);;
++GLIB_FUNC void g_completion_clear_items (GCompletion* cmp);
++GLIB_FUNC GList* g_completion_complete (GCompletion* cmp,
+ const gchar* prefix,
+- gchar** new_prefix);
+-GList* g_completion_complete_utf8 (GCompletion *cmp,
++ gchar** new_prefix);;
++GLIB_FUNC 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);
++ gchar** new_prefix);;
++GLIB_FUNC void g_completion_set_compare (GCompletion *cmp,
++ GCompletionStrncmpFunc strncmp_func);;
++GLIB_FUNC void g_completion_free (GCompletion* cmp);
+
+ G_END_DECLS
+
+--- glib-2.4.6/glib/gconvert.h~visibility.patch
++++ glib-2.4.6/glib/gconvert.h
+@@ -43,79 +43,79 @@
+ } GConvertError;
+
+ #define G_CONVERT_ERROR g_convert_error_quark()
+-GQuark g_convert_error_quark (void);
++GLIB_FUNC GQuark g_convert_error_quark (void);
+
+ /* Thin wrappers around iconv
+ */
+ typedef struct _GIConv *GIConv;
+
+-GIConv g_iconv_open (const gchar *to_codeset,
+- const gchar *from_codeset);
+-size_t g_iconv (GIConv converter,
++GLIB_FUNC GIConv g_iconv_open (const gchar *to_codeset,
++ const gchar *from_codeset);;
++GLIB_FUNC size_t g_iconv (GIConv converter,
+ gchar **inbuf,
+ gsize *inbytes_left,
+ gchar **outbuf,
+- gsize *outbytes_left);
+-gint g_iconv_close (GIConv converter);
++ gsize *outbytes_left);;
++GLIB_FUNC gint g_iconv_close (GIConv converter);
+
+
+-gchar* g_convert (const gchar *str,
++GLIB_FUNC gchar* g_convert (const gchar *str,
+ gssize len,
+ const gchar *to_codeset,
+ const gchar *from_codeset,
+ gsize *bytes_read,
+ gsize *bytes_written,
+- GError **error);
+-gchar* g_convert_with_iconv (const gchar *str,
++ GError **error);;
++GLIB_FUNC gchar* g_convert_with_iconv (const gchar *str,
+ gssize len,
+ GIConv converter,
+ gsize *bytes_read,
+ gsize *bytes_written,
+- GError **error);
+-gchar* g_convert_with_fallback (const gchar *str,
++ GError **error);;
++GLIB_FUNC 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);
++ GError **error);;
+
+
+ /* Convert between libc's idea of strings and UTF-8.
+ */
+-gchar* g_locale_to_utf8 (const gchar *opsysstring,
++GLIB_FUNC gchar* g_locale_to_utf8 (const gchar *opsysstring,
+ gssize len,
+ gsize *bytes_read,
+ gsize *bytes_written,
+- GError **error);
+-gchar* g_locale_from_utf8 (const gchar *utf8string,
++ GError **error);;
++GLIB_FUNC gchar* g_locale_from_utf8 (const gchar *utf8string,
+ gssize len,
+ gsize *bytes_read,
+ gsize *bytes_written,
+- GError **error);
++ GError **error);;
+
+ /* Convert between the operating system (or C runtime)
+ * representation of file names and UTF-8.
+ */
+-gchar* g_filename_to_utf8 (const gchar *opsysstring,
++GLIB_FUNC gchar* g_filename_to_utf8 (const gchar *opsysstring,
+ gssize len,
+ gsize *bytes_read,
+ gsize *bytes_written,
+- GError **error);
+-gchar* g_filename_from_utf8 (const gchar *utf8string,
++ GError **error);;
++GLIB_FUNC gchar* g_filename_from_utf8 (const gchar *utf8string,
+ gssize len,
+ gsize *bytes_read,
+ gsize *bytes_written,
+- GError **error);
++ GError **error);;
+
+-gchar *g_filename_from_uri (const gchar *uri,
++GLIB_FUNC gchar *g_filename_from_uri (const gchar *uri,
+ gchar **hostname,
+- GError **error);
++ GError **error);;
+
+-gchar *g_filename_to_uri (const gchar *filename,
++GLIB_FUNC gchar *g_filename_to_uri (const gchar *filename,
+ const gchar *hostname,
+- GError **error);
++ GError **error);;
+
+
+ G_END_DECLS
+--- glib-2.4.6/glib/gdataset.h~visibility.patch
++++ glib-2.4.6/glib/gdataset.h
+@@ -39,19 +39,19 @@
+
+ /* Keyed Data List
+ */
+-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,
++GLIB_FUNC void g_datalist_init (GData **datalist);
++GLIB_FUNC void g_datalist_clear (GData **datalist);
++GLIB_FUNC gpointer g_datalist_id_get_data (GData **datalist,
++ GQuark key_id);;
++GLIB_FUNC 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,
++ GDestroyNotify destroy_func);;
++GLIB_FUNC gpointer g_datalist_id_remove_no_notify (GData **datalist,
++ GQuark key_id);;
++GLIB_FUNC void g_datalist_foreach (GData **datalist,
+ GDataForeachFunc func,
+- gpointer user_data);
++ gpointer user_data);;
+ #define g_datalist_id_set_data(dl, q, d) \
+ g_datalist_id_set_data_full ((dl), (q), (d), NULL)
+ #define g_datalist_id_remove_data(dl, q) \
+@@ -70,18 +70,18 @@
+
+ /* Location Associated Keyed Data
+ */
+-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,
++GLIB_FUNC void g_dataset_destroy (gconstpointer dataset_location);
++GLIB_FUNC gpointer g_dataset_id_get_data (gconstpointer dataset_location,
++ GQuark key_id);;
++GLIB_FUNC 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,
++ GDestroyNotify destroy_func);;
++GLIB_FUNC gpointer g_dataset_id_remove_no_notify (gconstpointer dataset_location,
++ GQuark key_id);;
++GLIB_FUNC void g_dataset_foreach (gconstpointer dataset_location,
+ GDataForeachFunc func,
+- gpointer user_data);
++ gpointer user_data);;
+ #define g_dataset_id_set_data(l, k, d) \
+ g_dataset_id_set_data_full ((l), (k), (d), NULL)
+ #define g_dataset_id_remove_data(l, k) \
+--- glib-2.4.6/glib/gdate.h~visibility.patch
++++ glib-2.4.6/glib/gdate.h
+@@ -114,121 +114,121 @@
+ * to get a usable object. You can also allocate a GDate statically,
+ * then call g_date_clear() to initialize.
+ */
+-GDate* g_date_new (void);
+-GDate* g_date_new_dmy (GDateDay day,
++GLIB_FUNC GDate* g_date_new (void);
++GLIB_FUNC 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);
++ GDateYear year);;
++GLIB_FUNC GDate* g_date_new_julian (guint32 julian_day);
++GLIB_FUNC void g_date_free (GDate *date);
+
+ /* check g_date_valid() after doing an operation that might fail, like
+ * _parse. Almost all g_date operations are undefined on invalid
+ * dates (the exceptions are the mutators, since you need those to
+ * return to validity).
+ */
+-gboolean g_date_valid (const GDate *date);
+-gboolean g_date_valid_day (GDateDay day) G_GNUC_CONST;
+-gboolean g_date_valid_month (GDateMonth month) G_GNUC_CONST;
+-gboolean g_date_valid_year (GDateYear year) G_GNUC_CONST;
+-gboolean g_date_valid_weekday (GDateWeekday weekday) G_GNUC_CONST;
+-gboolean g_date_valid_julian (guint32 julian_date) G_GNUC_CONST;
+-gboolean g_date_valid_dmy (GDateDay day,
++GLIB_FUNC gboolean g_date_valid (const GDate *date);
++GLIB_FUNC gboolean g_date_valid_day (GDateDay day) G_GNUC_CONST;;
++GLIB_FUNC gboolean g_date_valid_month (GDateMonth month) G_GNUC_CONST;;
++GLIB_FUNC gboolean g_date_valid_year (GDateYear year) G_GNUC_CONST;;
++GLIB_FUNC gboolean g_date_valid_weekday (GDateWeekday weekday) G_GNUC_CONST;;
++GLIB_FUNC gboolean g_date_valid_julian (guint32 julian_date) G_GNUC_CONST;;
++GLIB_FUNC gboolean g_date_valid_dmy (GDateDay day,
+ GDateMonth month,
+- GDateYear year) G_GNUC_CONST;
++ GDateYear year) G_GNUC_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);
++GLIB_FUNC GDateWeekday g_date_get_weekday (const GDate *date);
++GLIB_FUNC GDateMonth g_date_get_month (const GDate *date);
++GLIB_FUNC GDateYear g_date_get_year (const GDate *date);
++GLIB_FUNC GDateDay g_date_get_day (const GDate *date);
++GLIB_FUNC guint32 g_date_get_julian (const GDate *date);
++GLIB_FUNC guint g_date_get_day_of_year (const GDate *date);
+ /* First monday/sunday is the start of week 1; if we haven't reached
+ * that day, return 0. These are not ISO weeks of the year; that
+ * routine needs to be added.
+ * these functions return the number of weeks, starting on the
+ * corrsponding day
+ */
+-guint g_date_get_monday_week_of_year (const GDate *date);
+-guint g_date_get_sunday_week_of_year (const GDate *date);
++GLIB_FUNC guint g_date_get_monday_week_of_year (const GDate *date);
++GLIB_FUNC guint g_date_get_sunday_week_of_year (const GDate *date);
+
+ /* If you create a static date struct you need to clear it to get it
+ * in a sane state before use. You can clear a whole array at
+ * once with the ndates argument.
+ */
+-void g_date_clear (GDate *date,
+- guint n_dates);
++GLIB_FUNC void g_date_clear (GDate *date,
++ guint n_dates);;
+
+ /* The parse routine is meant for dates typed in by a user, so it
+ * permits many formats but tries to catch common typos. If your data
+ * needs to be strictly validated, it is not an appropriate function.
+ */
+-void g_date_set_parse (GDate *date,
+- const gchar *str);
+-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,
++GLIB_FUNC void g_date_set_parse (GDate *date,
++ const gchar *str);;
++GLIB_FUNC void g_date_set_time (GDate *date,
++ GTime time_);;
++GLIB_FUNC void g_date_set_month (GDate *date,
++ GDateMonth month);;
++GLIB_FUNC void g_date_set_day (GDate *date,
++ GDateDay day);;
++GLIB_FUNC void g_date_set_year (GDate *date,
++ GDateYear year);;
++GLIB_FUNC 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);
++ GDateYear y);;
++GLIB_FUNC void g_date_set_julian (GDate *date,
++ guint32 julian_date);;
++GLIB_FUNC gboolean g_date_is_first_of_month (const GDate *date);
++GLIB_FUNC gboolean g_date_is_last_of_month (const GDate *date);
+
+ /* To go forward by some number of weeks just go forward weeks*7 days */
+-void g_date_add_days (GDate *date,
+- guint n_days);
+-void g_date_subtract_days (GDate *date,
+- guint n_days);
++GLIB_FUNC void g_date_add_days (GDate *date,
++ guint n_days);;
++GLIB_FUNC void g_date_subtract_days (GDate *date,
++ guint n_days);;
+
+ /* If you add/sub months while day > 28, the day might change */
+-void g_date_add_months (GDate *date,
+- guint n_months);
+-void g_date_subtract_months (GDate *date,
+- guint n_months);
++GLIB_FUNC void g_date_add_months (GDate *date,
++ guint n_months);;
++GLIB_FUNC void g_date_subtract_months (GDate *date,
++ guint n_months);;
+
+ /* If it's feb 29, changing years can move you to the 28th */
+-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) G_GNUC_CONST;
+-guint8 g_date_get_days_in_month (GDateMonth month,
+- GDateYear year) G_GNUC_CONST;
+-guint8 g_date_get_monday_weeks_in_year (GDateYear year) G_GNUC_CONST;
+-guint8 g_date_get_sunday_weeks_in_year (GDateYear year) G_GNUC_CONST;
++GLIB_FUNC void g_date_add_years (GDate *date,
++ guint n_years);;
++GLIB_FUNC void g_date_subtract_years (GDate *date,
++ guint n_years);;
++GLIB_FUNC gboolean g_date_is_leap_year (GDateYear year) G_GNUC_CONST;;
++GLIB_FUNC guint8 g_date_get_days_in_month (GDateMonth month,
++ GDateYear year) G_GNUC_CONST;;
++GLIB_FUNC guint8 g_date_get_monday_weeks_in_year (GDateYear year) G_GNUC_CONST;;
++GLIB_FUNC guint8 g_date_get_sunday_weeks_in_year (GDateYear year) G_GNUC_CONST;;
+
+ /* Returns the number of days between the two dates. If date2 comes
+ before date1, a negative value is return. */
+-gint g_date_days_between (const GDate *date1,
+- const GDate *date2);
++GLIB_FUNC gint g_date_days_between (const GDate *date1,
++ const GDate *date2);;
+
+ /* qsort-friendly (with a cast...) */
+-gint g_date_compare (const GDate *lhs,
+- const GDate *rhs);
+-void g_date_to_struct_tm (const GDate *date,
+- struct tm *tm);
++GLIB_FUNC gint g_date_compare (const GDate *lhs,
++ const GDate *rhs);;
++GLIB_FUNC void g_date_to_struct_tm (const GDate *date,
++ struct tm *tm);;
+
+-void g_date_clamp (GDate *date,
++GLIB_FUNC void g_date_clamp (GDate *date,
+ const GDate *min_date,
+- const GDate *max_date);
++ const GDate *max_date);;
+
+ /* Swap date1 and date2's values if date1 > date2. */
+-void g_date_order (GDate *date1, GDate *date2);
++GLIB_FUNC void g_date_order (GDate *date1, GDate *date2);
+
+ /* Just like strftime() except you can only use date-related formats.
+ * Using a time format is undefined.
+ */
+-gsize g_date_strftime (gchar *s,
++GLIB_FUNC gsize g_date_strftime (gchar *s,
+ gsize slen,
+ const gchar *format,
+- const GDate *date);
++ const GDate *date);;
+
+ #ifndef G_DISABLE_DEPRECATED
+
+--- glib-2.4.6/glib/gdir.h~visibility.patch
++++ glib-2.4.6/glib/gdir.h
+@@ -29,12 +29,12 @@
+
+ typedef struct _GDir GDir;
+
+-GDir * g_dir_open (const gchar *path,
++GLIB_FUNC GDir * g_dir_open (const gchar *path,
+ guint flags,
+- GError **error);
+-G_CONST_RETURN gchar *g_dir_read_name (GDir *dir);
+-void g_dir_rewind (GDir *dir);
+-void g_dir_close (GDir *dir);
++ GError **error);;
++GLIB_FUNC G_CONST_RETURN gchar *g_dir_read_name (GDir *dir);
++GLIB_FUNC void g_dir_rewind (GDir *dir);
++GLIB_FUNC void g_dir_close (GDir *dir);
+
+ G_END_DECLS
+
+--- glib-2.4.6/glib/gerror.h~visibility.patch
++++ glib-2.4.6/glib/gerror.h
+@@ -34,38 +34,38 @@
+ gchar *message;
+ };
+
+-GError* g_error_new (GQuark domain,
++GLIB_FUNC GError* g_error_new (GQuark domain,
+ gint code,
+ const gchar *format,
+- ...) G_GNUC_PRINTF (3, 4);
++ ...) G_GNUC_PRINTF (3, 4);;
+
+-GError* g_error_new_literal (GQuark domain,
++GLIB_FUNC GError* g_error_new_literal (GQuark domain,
+ gint code,
+- const gchar *message);
++ const gchar *message);;
+
+-void g_error_free (GError *error);
+-GError* g_error_copy (const GError *error);
++GLIB_FUNC void g_error_free (GError *error);
++GLIB_FUNC GError* g_error_copy (const GError *error);
+
+-gboolean g_error_matches (const GError *error,
++GLIB_FUNC gboolean g_error_matches (const GError *error,
+ GQuark domain,
+- gint code);
++ gint code);;
+
+ /* if (err) *err = g_error_new(domain, code, format, ...), also has
+ * some sanity checks.
+ */
+-void g_set_error (GError **err,
++GLIB_FUNC void g_set_error (GError **err,
+ GQuark domain,
+ gint code,
+ const gchar *format,
+- ...) G_GNUC_PRINTF (4, 5);
++ ...) G_GNUC_PRINTF (4, 5);;
+
+ /* if (dest) *dest = src; also has some sanity checks.
+ */
+-void g_propagate_error (GError **dest,
+- GError *src);
++GLIB_FUNC void g_propagate_error (GError **dest,
++ GError *src);;
+
+ /* if (err && *err) { g_error_free(*err); *err = NULL; } */
+-void g_clear_error (GError **err);
++GLIB_FUNC void g_clear_error (GError **err);
+
+
+ G_END_DECLS
+--- glib-2.4.6/glib/gfileutils.h~visibility.patch
++++ glib-2.4.6/glib/gfileutils.h
+@@ -68,32 +68,32 @@
+ G_FILE_TEST_EXISTS = 1 << 4
+ } GFileTest;
+
+-GQuark g_file_error_quark (void);
++GLIB_FUNC GQuark g_file_error_quark (void);
+ /* So other code can generate a GFileError */
+-GFileError g_file_error_from_errno (gint err_no);
++GLIB_FUNC GFileError g_file_error_from_errno (gint err_no);
+
+-gboolean g_file_test (const gchar *filename,
+- GFileTest test);
+-gboolean g_file_get_contents (const gchar *filename,
++GLIB_FUNC gboolean g_file_test (const gchar *filename,
++ GFileTest test);;
++GLIB_FUNC gboolean g_file_get_contents (const gchar *filename,
+ gchar **contents,
+ gsize *length,
+- GError **error);
+-gchar *g_file_read_link (const gchar *filename,
+- GError **error);
++ GError **error);;
++GLIB_FUNC gchar *g_file_read_link (const gchar *filename,
++ GError **error);;
+
+ /* Wrapper / workalike for mkstemp() */
+-gint g_mkstemp (gchar *tmpl);
++GLIB_FUNC gint g_mkstemp (gchar *tmpl);
+
+ /* Wrapper for g_mkstemp */
+-gint g_file_open_tmp (const gchar *tmpl,
++GLIB_FUNC gint g_file_open_tmp (const gchar *tmpl,
+ gchar **name_used,
+- GError **error);
++ GError **error);;
+
+-gchar *g_build_path (const gchar *separator,
++GLIB_FUNC gchar *g_build_path (const gchar *separator,
+ const gchar *first_element,
+- ...);
+-gchar *g_build_filename (const gchar *first_element,
+- ...);
++ ...);;
++GLIB_FUNC gchar *g_build_filename (const gchar *first_element,
++ ...);;
+
+ G_END_DECLS
+
+--- glib-2.4.6/glib/ghash.h~visibility.patch
++++ glib-2.4.6/glib/ghash.h
+@@ -39,42 +39,42 @@
+
+ /* Hash tables
+ */
+-GHashTable* g_hash_table_new (GHashFunc hash_func,
+- GEqualFunc key_equal_func);
+-GHashTable* g_hash_table_new_full (GHashFunc hash_func,
++GLIB_FUNC GHashTable* g_hash_table_new (GHashFunc hash_func,
++ GEqualFunc key_equal_func);;
++GLIB_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,
++ GDestroyNotify value_destroy_func);;
++GLIB_FUNC void g_hash_table_destroy (GHashTable *hash_table);
++GLIB_FUNC void g_hash_table_insert (GHashTable *hash_table,
+ gpointer key,
+- gpointer value);
+-void g_hash_table_replace (GHashTable *hash_table,
++ gpointer value);;
++GLIB_FUNC void g_hash_table_replace (GHashTable *hash_table,
+ gpointer key,
+- gpointer value);
+-gboolean g_hash_table_remove (GHashTable *hash_table,
+- gconstpointer key);
+-gboolean g_hash_table_steal (GHashTable *hash_table,
+- gconstpointer key);
+-gpointer g_hash_table_lookup (GHashTable *hash_table,
+- gconstpointer key);
+-gboolean g_hash_table_lookup_extended (GHashTable *hash_table,
++ gpointer value);;
++GLIB_FUNC gboolean g_hash_table_remove (GHashTable *hash_table,
++ gconstpointer key);;
++GLIB_FUNC gboolean g_hash_table_steal (GHashTable *hash_table,
++ gconstpointer key);;
++GLIB_FUNC gpointer g_hash_table_lookup (GHashTable *hash_table,
++ gconstpointer key);;
++GLIB_FUNC 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,
++ gpointer *value);;
++GLIB_FUNC void g_hash_table_foreach (GHashTable *hash_table,
+ GHFunc func,
+- gpointer user_data);
+-gpointer g_hash_table_find (GHashTable *hash_table,
++ gpointer user_data);;
++GLIB_FUNC gpointer g_hash_table_find (GHashTable *hash_table,
+ GHRFunc predicate,
+- gpointer user_data);
+-guint g_hash_table_foreach_remove (GHashTable *hash_table,
++ gpointer user_data);;
++GLIB_FUNC guint g_hash_table_foreach_remove (GHashTable *hash_table,
+ GHRFunc func,
+- gpointer user_data);
+-guint g_hash_table_foreach_steal (GHashTable *hash_table,
++ gpointer user_data);;
++GLIB_FUNC guint g_hash_table_foreach_steal (GHashTable *hash_table,
+ GHRFunc func,
+- gpointer user_data);
+-guint g_hash_table_size (GHashTable *hash_table);
++ gpointer user_data);;
++GLIB_FUNC guint g_hash_table_size (GHashTable *hash_table);
+
+ #ifndef G_DISABLE_DEPRECATED
+
+@@ -87,13 +87,13 @@
+
+ /* Hash Functions
+ */
+-gboolean g_str_equal (gconstpointer v,
+- gconstpointer v2);
+-guint g_str_hash (gconstpointer v);
++GLIB_FUNC gboolean g_str_equal (gconstpointer v,
++ gconstpointer v2);;
++GLIB_FUNC guint g_str_hash (gconstpointer v);
+
+-gboolean g_int_equal (gconstpointer v,
+- gconstpointer v2);
+-guint g_int_hash (gconstpointer v);
++GLIB_FUNC gboolean g_int_equal (gconstpointer v,
++ gconstpointer v2);;
++GLIB_FUNC guint g_int_hash (gconstpointer v);
+
+ /* This "hash" function will just return the key's address as an
+ * unsigned integer. Useful for hashing on plain addresses or
+@@ -101,8 +101,8 @@
+ * Passing NULL into g_hash_table_new() as GHashFunc has the
+ * same effect as passing g_direct_hash().
+ */
+-guint g_direct_hash (gconstpointer v) G_GNUC_CONST;
+-gboolean g_direct_equal (gconstpointer v,
++GLIB_FUNC guint g_direct_hash (gconstpointer v) G_GNUC_CONST;
++GLIB_FUNC gboolean g_direct_equal (gconstpointer v,
+ gconstpointer v2) G_GNUC_CONST;
+
+ G_END_DECLS
+--- glib-2.4.6/glib/ghook.h~visibility.patch
++++ glib-2.4.6/glib/ghook.h
+@@ -99,78 +99,78 @@
+
+ /* --- prototypes --- */
+ /* callback maintenance functions */
+-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);
+-void 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,
++GLIB_FUNC void g_hook_list_init (GHookList *hook_list,
++ guint hook_size);;
++GLIB_FUNC void g_hook_list_clear (GHookList *hook_list);
++GLIB_FUNC GHook* g_hook_alloc (GHookList *hook_list);
++GLIB_FUNC void g_hook_free (GHookList *hook_list,
++ GHook *hook);;
++GLIB_FUNC void g_hook_ref (GHookList *hook_list,
++ GHook *hook);;
++GLIB_FUNC void g_hook_unref (GHookList *hook_list,
++ GHook *hook);;
++GLIB_FUNC gboolean g_hook_destroy (GHookList *hook_list,
++ gulong hook_id);;
++GLIB_FUNC void g_hook_destroy_link (GHookList *hook_list,
++ GHook *hook);;
++GLIB_FUNC void g_hook_prepend (GHookList *hook_list,
++ GHook *hook);;
++GLIB_FUNC void g_hook_insert_before (GHookList *hook_list,
+ GHook *sibling,
+- GHook *hook);
+-void g_hook_insert_sorted (GHookList *hook_list,
++ GHook *hook);;
++GLIB_FUNC 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,
++ GHookCompareFunc func);;
++GLIB_FUNC GHook* g_hook_get (GHookList *hook_list,
++ gulong hook_id);;
++GLIB_FUNC GHook* g_hook_find (GHookList *hook_list,
+ gboolean need_valids,
+ GHookFindFunc func,
+- gpointer data);
+-GHook* g_hook_find_data (GHookList *hook_list,
++ gpointer data);;
++GLIB_FUNC GHook* g_hook_find_data (GHookList *hook_list,
+ gboolean need_valids,
+- gpointer data);
+-GHook* g_hook_find_func (GHookList *hook_list,
++ gpointer data);;
++GLIB_FUNC GHook* g_hook_find_func (GHookList *hook_list,
+ gboolean need_valids,
+- gpointer func);
+-GHook* g_hook_find_func_data (GHookList *hook_list,
++ gpointer func);;
++GLIB_FUNC GHook* g_hook_find_func_data (GHookList *hook_list,
+ gboolean need_valids,
+ gpointer func,
+- gpointer data);
++ gpointer data);;
+ /* return the first valid hook, and increment its reference count */
+-GHook* g_hook_first_valid (GHookList *hook_list,
+- gboolean may_be_in_call);
++GLIB_FUNC GHook* g_hook_first_valid (GHookList *hook_list,
++ gboolean may_be_in_call);;
+ /* return the next valid hook with incremented reference count, and
+ * decrement the reference count of the original hook
+ */
+-GHook* g_hook_next_valid (GHookList *hook_list,
++GLIB_FUNC GHook* g_hook_next_valid (GHookList *hook_list,
+ GHook *hook,
+- gboolean may_be_in_call);
++ gboolean may_be_in_call);;
+ /* GHookCompareFunc implementation to insert hooks sorted by their id */
+-gint g_hook_compare_ids (GHook *new_hook,
+- GHook *sibling);
++GLIB_FUNC gint g_hook_compare_ids (GHook *new_hook,
++ GHook *sibling);;
+ /* convenience macros */
+ #define g_hook_append( hook_list, hook ) \
+ g_hook_insert_before ((hook_list), NULL, (hook))
+ /* invoke all valid hooks with the (*GHookFunc) signature.
+ */
+-void g_hook_list_invoke (GHookList *hook_list,
+- gboolean may_recurse);
++GLIB_FUNC void g_hook_list_invoke (GHookList *hook_list,
++ gboolean may_recurse);;
+ /* invoke all valid hooks with the (*GHookCheckFunc) signature,
+ * and destroy the hook if FALSE is returned.
+ */
+-void g_hook_list_invoke_check (GHookList *hook_list,
+- gboolean may_recurse);
++GLIB_FUNC void g_hook_list_invoke_check (GHookList *hook_list,
++ gboolean may_recurse);;
+ /* invoke a marshaller on all valid hooks.
+ */
+-void g_hook_list_marshal (GHookList *hook_list,
++GLIB_FUNC 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,
++ gpointer marshal_data);;
++GLIB_FUNC void g_hook_list_marshal_check (GHookList *hook_list,
+ gboolean may_recurse,
+ GHookCheckMarshaller marshaller,
+- gpointer marshal_data);
++ gpointer marshal_data);;
+
+ G_END_DECLS
+
+--- glib-2.4.6/glib/giochannel.h~visibility.patch
++++ glib-2.4.6/glib/giochannel.h
+@@ -162,112 +162,112 @@
+ GIOFlags (*io_get_flags) (GIOChannel *channel);
+ };
+
+-void g_io_channel_init (GIOChannel *channel);
+-void g_io_channel_ref (GIOChannel *channel);
+-void g_io_channel_unref (GIOChannel *channel);
++GLIB_FUNC void g_io_channel_init (GIOChannel *channel);
++GLIB_FUNC void g_io_channel_ref (GIOChannel *channel);
++GLIB_FUNC void g_io_channel_unref (GIOChannel *channel);
+
+ #ifndef G_DISABLE_DEPRECATED
+-GIOError g_io_channel_read (GIOChannel *channel,
++GLIB_FUNC GIOError g_io_channel_read (GIOChannel *channel,
+ gchar *buf,
+ gsize count,
+- gsize *bytes_read);
+-GIOError g_io_channel_write (GIOChannel *channel,
++ gsize *bytes_read);;
++GLIB_FUNC GIOError g_io_channel_write (GIOChannel *channel,
+ const gchar *buf,
+ gsize count,
+- gsize *bytes_written);
+-GIOError g_io_channel_seek (GIOChannel *channel,
++ gsize *bytes_written);;
++GLIB_FUNC GIOError g_io_channel_seek (GIOChannel *channel,
+ gint64 offset,
+- GSeekType type);
+-void g_io_channel_close (GIOChannel *channel);
++ GSeekType type);;
++GLIB_FUNC void g_io_channel_close (GIOChannel *channel);
+ #endif /* G_DISABLE_DEPRECATED */
+
+-GIOStatus g_io_channel_shutdown (GIOChannel *channel,
++GLIB_FUNC GIOStatus g_io_channel_shutdown (GIOChannel *channel,
+ gboolean flush,
+- GError **err);
+-guint g_io_add_watch_full (GIOChannel *channel,
++ GError **err);;
++GLIB_FUNC 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,
++ GDestroyNotify notify);;
++GLIB_FUNC GSource * g_io_create_watch (GIOChannel *channel,
++ GIOCondition condition);;
++GLIB_FUNC guint g_io_add_watch (GIOChannel *channel,
+ GIOCondition condition,
+ GIOFunc func,
+- gpointer user_data);
++ gpointer user_data);;
+
+ /* character encoding conversion involved functions.
+ */
+
+-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,
++GLIB_FUNC void g_io_channel_set_buffer_size (GIOChannel *channel,
++ gsize size);;
++GLIB_FUNC gsize g_io_channel_get_buffer_size (GIOChannel *channel);
++GLIB_FUNC GIOCondition g_io_channel_get_buffer_condition (GIOChannel *channel);
++GLIB_FUNC 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,
++ GError **error);;
++GLIB_FUNC GIOFlags g_io_channel_get_flags (GIOChannel *channel);
++GLIB_FUNC void g_io_channel_set_line_term (GIOChannel *channel,
+ const gchar *line_term,
+- gint length);
+-G_CONST_RETURN 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,
++ gint length);;
++GLIB_FUNC G_CONST_RETURN gchar* g_io_channel_get_line_term (GIOChannel *channel,
++ gint *length);;
++GLIB_FUNC void g_io_channel_set_buffered (GIOChannel *channel,
++ gboolean buffered);;
++GLIB_FUNC gboolean g_io_channel_get_buffered (GIOChannel *channel);
++GLIB_FUNC GIOStatus g_io_channel_set_encoding (GIOChannel *channel,
+ const gchar *encoding,
+- GError **error);
+-G_CONST_RETURN 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);
++ GError **error);;
++GLIB_FUNC G_CONST_RETURN gchar* g_io_channel_get_encoding (GIOChannel *channel);
++GLIB_FUNC void g_io_channel_set_close_on_unref (GIOChannel *channel,
++ gboolean do_close);;
++GLIB_FUNC 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,
++GLIB_FUNC GIOStatus g_io_channel_flush (GIOChannel *channel,
++ GError **error);;
++GLIB_FUNC 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,
++ GError **error);;
++GLIB_FUNC 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,
++ GError **error);;
++GLIB_FUNC GIOStatus g_io_channel_read_to_end (GIOChannel *channel,
+ gchar **str_return,
+ gsize *length,
+- GError **error);
+-GIOStatus g_io_channel_read_chars (GIOChannel *channel,
++ GError **error);;
++GLIB_FUNC 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,
++ GError **error);;
++GLIB_FUNC GIOStatus g_io_channel_read_unichar (GIOChannel *channel,
+ gunichar *thechar,
+- GError **error);
+-GIOStatus g_io_channel_write_chars (GIOChannel *channel,
++ GError **error);;
++GLIB_FUNC 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,
++ GError **error);;
++GLIB_FUNC GIOStatus g_io_channel_write_unichar (GIOChannel *channel,
+ gunichar thechar,
+- GError **error);
+-GIOStatus g_io_channel_seek_position (GIOChannel *channel,
++ GError **error);;
++GLIB_FUNC GIOStatus g_io_channel_seek_position (GIOChannel *channel,
+ gint64 offset,
+ GSeekType type,
+- GError **error);
+-GIOChannel* g_io_channel_new_file (const gchar *filename,
++ GError **error);;
++GLIB_FUNC GIOChannel* g_io_channel_new_file (const gchar *filename,
+ const gchar *mode,
+- GError **error);
++ GError **error);;
+
+ /* Error handling */
+
+-GQuark g_io_channel_error_quark (void);
+-GIOChannelError g_io_channel_error_from_errno (gint en);
++GLIB_FUNC GQuark g_io_channel_error_quark (void);
++GLIB_FUNC GIOChannelError g_io_channel_error_from_errno (gint en);
+
+ /* On Unix, IO channels created with this function for any file
+ * descriptor or socket.
+@@ -287,8 +287,8 @@
+ * corresponding concept is file HANDLE. There isn't as of yet a way to
+ * get GIOChannels for Win32 file HANDLEs.
+ */
+-GIOChannel* g_io_channel_unix_new (int fd);
+-gint g_io_channel_unix_get_fd (GIOChannel *channel);
++GLIB_FUNC GIOChannel* g_io_channel_unix_new (int fd);
++GLIB_FUNC gint g_io_channel_unix_get_fd (GIOChannel *channel);
+
+
+ /* Hook for GClosure / GSource integration. Don't touch */
+@@ -308,19 +308,19 @@
+ * from the underlying file descriptor. For SOCKETs, it is possible to call
+ * recv().
+ */
+-void g_io_channel_win32_make_pollfd (GIOChannel *channel,
++GLIB_FUNC void g_io_channel_win32_make_pollfd (GIOChannel *channel,
+ GIOCondition condition,
+- GPollFD *fd);
++ GPollFD *fd);;
+
+ /* This can be used to wait a until at least one of the channels is readable.
+ * On Unix you would do a select() on the file descriptors of the channels.
+ */
+-gint g_io_channel_win32_poll (GPollFD *fds,
++GLIB_FUNC gint g_io_channel_win32_poll (GPollFD *fds,
+ gint n_fds,
+- gint timeout_);
++ gint timeout_);;
+
+ /* Create an IO channel for Windows messages for window handle hwnd. */
+-GIOChannel *g_io_channel_win32_new_messages (guint hwnd);
++GLIB_FUNC GIOChannel *g_io_channel_win32_new_messages (guint hwnd);;
+
+ /* Create an IO channel for C runtime (emulated Unix-like) file
+ * descriptors. After calling g_io_add_watch() on a IO channel
+@@ -331,17 +331,17 @@
+ * the file descriptor should be done by this internal GLib
+ * thread. Your code should call only g_io_channel_read().
+ */
+-GIOChannel* g_io_channel_win32_new_fd (gint fd);
++GLIB_FUNC GIOChannel* g_io_channel_win32_new_fd (gint fd);
+
+ /* Get the C runtime file descriptor of a channel. */
+-gint g_io_channel_win32_get_fd (GIOChannel *channel);
++GLIB_FUNC gint g_io_channel_win32_get_fd (GIOChannel *channel);
+
+ /* Create an IO channel for a winsock socket. The parameter should be
+ * a SOCKET. Contrary to IO channels for file descriptors (on *Win32),
+ * you can use normal recv() or recvfrom() on sockets even if GLib
+ * is polling them.
+ */
+-GIOChannel *g_io_channel_win32_new_socket (gint socket);
++GLIB_FUNC GIOChannel *g_io_channel_win32_new_socket (gint socket);;
+
+ #endif
+
+--- glib-2.4.6/glib/glib.def~visibility.patch
++++ glib-2.4.6/glib/glib.def
+@@ -1,4 +1,3 @@
+-EXPORTS
+ g_allocator_free
+ g_allocator_new
+ g_array_append_vals
+@@ -47,9 +46,7 @@
+ g_atomic_int_add
+ g_atomic_int_compare_and_exchange
+ g_atomic_int_exchange_and_add
+-; g_atomic_int_get
+ g_atomic_pointer_compare_and_exchange
+-; g_atomic_pointer_get
+ g_basename
+ g_bit_nth_lsf
+ g_bit_nth_msf
+--- glib-2.4.6/glib/glist.h~visibility.patch
++++ glib-2.4.6/glib/glist.h
+@@ -42,62 +42,62 @@
+
+ /* Doubly linked lists
+ */
+-void g_list_push_allocator (GAllocator *allocator);
+-void g_list_pop_allocator (void);
+-GList* g_list_alloc (void);
+-void g_list_free (GList *list);
+-void g_list_free_1 (GList *list);
+-GList* g_list_append (GList *list,
+- gpointer data);
+-GList* g_list_prepend (GList *list,
+- gpointer data);
+-GList* g_list_insert (GList *list,
++GLIB_FUNC void g_list_push_allocator (GAllocator *allocator);
++GLIB_FUNC void g_list_pop_allocator (void);
++GLIB_FUNC GList* g_list_alloc (void);
++GLIB_FUNC void g_list_free (GList *list);
++GLIB_FUNC void g_list_free_1 (GList *list);
++GLIB_FUNC GList* g_list_append (GList *list,
++ gpointer data);;
++GLIB_FUNC GList* g_list_prepend (GList *list,
++ gpointer data);;
++GLIB_FUNC GList* g_list_insert (GList *list,
+ gpointer data,
+- gint position);
+-GList* g_list_insert_sorted (GList *list,
++ gint position);;
++GLIB_FUNC GList* g_list_insert_sorted (GList *list,
+ gpointer data,
+- GCompareFunc func);
+-GList* g_list_insert_before (GList *list,
++ GCompareFunc func);;
++GLIB_FUNC GList* g_list_insert_before (GList *list,
+ GList *sibling,
+- gpointer data);
+-GList* g_list_concat (GList *list1,
+- GList *list2);
+-GList* g_list_remove (GList *list,
+- gconstpointer data);
+-GList* g_list_remove_all (GList *list,
+- gconstpointer data);
+-GList* g_list_remove_link (GList *list,
+- GList *llink);
+-GList* g_list_delete_link (GList *list,
+- GList *link_);
+-GList* g_list_reverse (GList *list);
+-GList* g_list_copy (GList *list);
+-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,
++ gpointer data);;
++GLIB_FUNC GList* g_list_concat (GList *list1,
++ GList *list2);;
++GLIB_FUNC GList* g_list_remove (GList *list,
++ gconstpointer data);;
++GLIB_FUNC GList* g_list_remove_all (GList *list,
++ gconstpointer data);;
++GLIB_FUNC GList* g_list_remove_link (GList *list,
++ GList *llink);;
++GLIB_FUNC GList* g_list_delete_link (GList *list,
++ GList *link_);;
++GLIB_FUNC GList* g_list_reverse (GList *list);
++GLIB_FUNC GList* g_list_copy (GList *list);
++GLIB_FUNC GList* g_list_nth (GList *list,
++ guint n);;
++GLIB_FUNC GList* g_list_nth_prev (GList *list,
++ guint n);;
++GLIB_FUNC GList* g_list_find (GList *list,
++ gconstpointer data);;
++GLIB_FUNC 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,
++ GCompareFunc func);;
++GLIB_FUNC gint g_list_position (GList *list,
++ GList *llink);;
++GLIB_FUNC gint g_list_index (GList *list,
++ gconstpointer data);;
++GLIB_FUNC GList* g_list_last (GList *list);
++GLIB_FUNC GList* g_list_first (GList *list);
++GLIB_FUNC guint g_list_length (GList *list);
++GLIB_FUNC void g_list_foreach (GList *list,
+ GFunc func,
+- gpointer user_data);
+-GList* g_list_sort (GList *list,
+- GCompareFunc compare_func);
+-GList* g_list_sort_with_data (GList *list,
++ gpointer user_data);;
++GLIB_FUNC GList* g_list_sort (GList *list,
++ GCompareFunc compare_func);;
++GLIB_FUNC GList* g_list_sort_with_data (GList *list,
+ GCompareDataFunc compare_func,
+- gpointer user_data);
+-gpointer g_list_nth_data (GList *list,
+- guint n);
++ gpointer user_data);;
++GLIB_FUNC gpointer g_list_nth_data (GList *list,
++ guint n);;
+
+ #define g_list_previous(list) ((list) ? (((GList *)(list))->prev) : NULL)
+ #define g_list_next(list) ((list) ? (((GList *)(list))->next) : NULL)
+--- glib-2.4.6/glib/gmain.h~visibility.patch
++++ glib-2.4.6/glib/gmain.h
+@@ -135,111 +135,111 @@
+
+ /* GMainContext: */
+
+-GMainContext *g_main_context_new (void);
+-void g_main_context_ref (GMainContext *context);
+-void g_main_context_unref (GMainContext *context);
+-GMainContext *g_main_context_default (void);
++GLIB_FUNC GMainContext *g_main_context_new (void);;
++GLIB_FUNC void g_main_context_ref (GMainContext *context);
++GLIB_FUNC void g_main_context_unref (GMainContext *context);
++GLIB_FUNC GMainContext *g_main_context_default (void);;
+
+-gboolean g_main_context_iteration (GMainContext *context,
+- gboolean may_block);
+-gboolean g_main_context_pending (GMainContext *context);
++GLIB_FUNC gboolean g_main_context_iteration (GMainContext *context,
++ gboolean may_block);;
++GLIB_FUNC gboolean g_main_context_pending (GMainContext *context);
+
+ /* For implementation of legacy interfaces
+ */
+-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,
++GLIB_FUNC GSource *g_main_context_find_source_by_id (GMainContext *context,
++ guint source_id);;
++GLIB_FUNC GSource *g_main_context_find_source_by_user_data (GMainContext *context,
++ gpointer user_data);;
++GLIB_FUNC GSource *g_main_context_find_source_by_funcs_user_data (GMainContext *context,
+ GSourceFuncs *funcs,
+- gpointer user_data);
++ gpointer user_data);;
+
+ /* Low level functions for implementing custom main loops.
+ */
+-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_wait (GMainContext *context,
++GLIB_FUNC void g_main_context_wakeup (GMainContext *context);
++GLIB_FUNC gboolean g_main_context_acquire (GMainContext *context);
++GLIB_FUNC void g_main_context_release (GMainContext *context);
++GLIB_FUNC gboolean g_main_context_wait (GMainContext *context,
+ GCond *cond,
+- GMutex *mutex);
++ GMutex *mutex);;
+
+-gboolean g_main_context_prepare (GMainContext *context,
+- gint *priority);
+-gint g_main_context_query (GMainContext *context,
++GLIB_FUNC gboolean g_main_context_prepare (GMainContext *context,
++ gint *priority);;
++GLIB_FUNC 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 n_fds);;
++GLIB_FUNC gint g_main_context_check (GMainContext *context,
+ gint max_priority,
+ GPollFD *fds,
+- gint n_fds);
+-void g_main_context_dispatch (GMainContext *context);
++ gint n_fds);;
++GLIB_FUNC 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);
++GLIB_FUNC void g_main_context_set_poll_func (GMainContext *context,
++ GPollFunc func);;
++GLIB_FUNC GPollFunc g_main_context_get_poll_func (GMainContext *context);
+
+ /* Low level functions for use by source implementations
+ */
+-void g_main_context_add_poll (GMainContext *context,
++GLIB_FUNC void g_main_context_add_poll (GMainContext *context,
+ GPollFD *fd,
+- gint priority);
+-void g_main_context_remove_poll (GMainContext *context,
+- GPollFD *fd);
++ gint priority);;
++GLIB_FUNC void g_main_context_remove_poll (GMainContext *context,
++ GPollFD *fd);;
+
+-int g_main_depth (void);
++GLIB_FUNC int g_main_depth (void);
+
+ /* GMainLoop: */
+
+-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);
++GLIB_FUNC GMainLoop *g_main_loop_new (GMainContext *context,
++ gboolean is_running);;
++GLIB_FUNC void g_main_loop_run (GMainLoop *loop);
++GLIB_FUNC void g_main_loop_quit (GMainLoop *loop);
++GLIB_FUNC GMainLoop *g_main_loop_ref (GMainLoop *loop);;
++GLIB_FUNC void g_main_loop_unref (GMainLoop *loop);
++GLIB_FUNC gboolean g_main_loop_is_running (GMainLoop *loop);
++GLIB_FUNC GMainContext *g_main_loop_get_context (GMainLoop *loop);;
+
+ /* GSource: */
+
+-GSource *g_source_new (GSourceFuncs *source_funcs,
+- guint struct_size);
+-GSource *g_source_ref (GSource *source);
+-void g_source_unref (GSource *source);
++GLIB_FUNC GSource *g_source_new (GSourceFuncs *source_funcs,
++ guint struct_size);;
++GLIB_FUNC GSource *g_source_ref (GSource *source);;
++GLIB_FUNC void g_source_unref (GSource *source);
+
+-guint g_source_attach (GSource *source,
+- GMainContext *context);
+-void g_source_destroy (GSource *source);
++GLIB_FUNC guint g_source_attach (GSource *source,
++ GMainContext *context);;
++GLIB_FUNC 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);
++GLIB_FUNC void g_source_set_priority (GSource *source,
++ gint priority);;
++GLIB_FUNC gint g_source_get_priority (GSource *source);
++GLIB_FUNC void g_source_set_can_recurse (GSource *source,
++ gboolean can_recurse);;
++GLIB_FUNC gboolean g_source_get_can_recurse (GSource *source);
++GLIB_FUNC guint g_source_get_id (GSource *source);
+
+-GMainContext *g_source_get_context (GSource *source);
++GLIB_FUNC GMainContext *g_source_get_context (GSource *source);;
+
+-void g_source_set_callback (GSource *source,
++GLIB_FUNC void g_source_set_callback (GSource *source,
+ GSourceFunc func,
+ gpointer data,
+- GDestroyNotify notify);
++ GDestroyNotify notify);;
+
+
+ /* Used to implement g_source_connect_closure and internally*/
+-void g_source_set_callback_indirect (GSource *source,
++GLIB_FUNC void g_source_set_callback_indirect (GSource *source,
+ gpointer callback_data,
+- GSourceCallbackFuncs *callback_funcs);
++ GSourceCallbackFuncs *callback_funcs);;
+
+-void g_source_add_poll (GSource *source,
+- GPollFD *fd);
+-void g_source_remove_poll (GSource *source,
+- GPollFD *fd);
++GLIB_FUNC void g_source_add_poll (GSource *source,
++ GPollFD *fd);;
++GLIB_FUNC void g_source_remove_poll (GSource *source,
++ GPollFD *fd);;
+
+-void g_source_get_current_time (GSource *source,
+- GTimeVal *timeval);
++GLIB_FUNC void g_source_get_current_time (GSource *source,
++ GTimeVal *timeval);;
+
+ /* void g_source_connect_closure (GSource *source,
+ GClosure *closure);
+@@ -247,13 +247,13 @@
+
+ /* Specific source types
+ */
+-GSource *g_idle_source_new (void);
+-GSource *g_child_watch_source_new (GPid pid);
+-GSource *g_timeout_source_new (guint interval);
++GLIB_FUNC GSource *g_idle_source_new (void);;
++GLIB_FUNC GSource *g_child_watch_source_new (GPid pid);;
++GLIB_FUNC GSource *g_timeout_source_new (guint interval);;
+
+ /* Miscellaneous functions
+ */
+-void g_get_current_time (GTimeVal *result);
++GLIB_FUNC void g_get_current_time (GTimeVal *result);
+
+ /* ============== Compat main loop stuff ================== */
+
+@@ -278,35 +278,35 @@
+ #endif /* G_DISABLE_DEPRECATED */
+
+ /* Source manipulation by ID */
+-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);
++GLIB_FUNC gboolean g_source_remove (guint tag);
++GLIB_FUNC gboolean g_source_remove_by_user_data (gpointer user_data);
++GLIB_FUNC gboolean g_source_remove_by_funcs_user_data (GSourceFuncs *funcs,
++ gpointer user_data);;
+
+ /* Idles, child watchers and timeouts */
+-guint g_timeout_add_full (gint priority,
++GLIB_FUNC guint g_timeout_add_full (gint priority,
+ guint interval,
+ GSourceFunc function,
+ gpointer data,
+- GDestroyNotify notify);
+-guint g_timeout_add (guint interval,
++ GDestroyNotify notify);;
++GLIB_FUNC guint g_timeout_add (guint interval,
+ GSourceFunc function,
+- gpointer data);
+-guint g_child_watch_add_full (gint priority,
++ gpointer data);;
++GLIB_FUNC guint g_child_watch_add_full (gint priority,
+ GPid pid,
+ GChildWatchFunc function,
+ gpointer data,
+- GDestroyNotify notify);
+-guint g_child_watch_add (GPid pid,
++ GDestroyNotify notify);;
++GLIB_FUNC 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,
++ gpointer data);;
++GLIB_FUNC guint g_idle_add (GSourceFunc function,
++ gpointer data);;
++GLIB_FUNC guint g_idle_add_full (gint priority,
+ GSourceFunc function,
+ gpointer data,
+- GDestroyNotify notify);
+-gboolean g_idle_remove_by_data (gpointer data);
++ GDestroyNotify notify);;
++GLIB_FUNC gboolean g_idle_remove_by_data (gpointer data);
+
+ /* Hook for GClosure / GSource integration. Don't touch */
+ GLIB_VAR GSourceFuncs g_timeout_funcs;
+--- glib-2.4.6/glib/gmarkup.h~visibility.patch
++++ glib-2.4.6/glib/gmarkup.h
+@@ -42,7 +42,7 @@
+
+ #define G_MARKUP_ERROR g_markup_error_quark ()
+
+-GQuark g_markup_error_quark (void);
++GLIB_FUNC GQuark g_markup_error_quark (void);
+
+ typedef enum
+ {
+@@ -97,33 +97,33 @@
+ gpointer user_data);
+ };
+
+-GMarkupParseContext *g_markup_parse_context_new (const GMarkupParser *parser,
++GLIB_FUNC 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,
++ GDestroyNotify user_data_dnotify);;
++GLIB_FUNC void g_markup_parse_context_free (GMarkupParseContext *context);
++GLIB_FUNC gboolean g_markup_parse_context_parse (GMarkupParseContext *context,
+ const gchar *text,
+ gssize text_len,
+- GError **error);
++ GError **error);;
+
+-gboolean g_markup_parse_context_end_parse (GMarkupParseContext *context,
+- GError **error);
+-G_CONST_RETURN gchar *g_markup_parse_context_get_element (GMarkupParseContext *context);
++GLIB_FUNC gboolean g_markup_parse_context_end_parse (GMarkupParseContext *context,
++ GError **error);;
++GLIB_FUNC G_CONST_RETURN gchar *g_markup_parse_context_get_element (GMarkupParseContext *context);
+
+ /* For user-constructed error messages, has no precise semantics */
+-void g_markup_parse_context_get_position (GMarkupParseContext *context,
++GLIB_FUNC void g_markup_parse_context_get_position (GMarkupParseContext *context,
+ gint *line_number,
+- gint *char_number);
++ gint *char_number);;
+
+ /* useful when saving */
+-gchar* g_markup_escape_text (const gchar *text,
+- gssize length);
++GLIB_FUNC gchar* g_markup_escape_text (const gchar *text,
++ gssize length);;
+
+-gchar *g_markup_printf_escaped (const char *format,
+- ...) G_GNUC_PRINTF (1, 2);
+-gchar *g_markup_vprintf_escaped (const char *format,
+- va_list args);
++GLIB_FUNC gchar *g_markup_printf_escaped (const char *format,
++ ...) G_GNUC_PRINTF (1, 2);;
++GLIB_FUNC gchar *g_markup_vprintf_escaped (const char *format,
++ va_list args);;
+
+ G_END_DECLS
+
+--- glib-2.4.6/glib/gmem.h~visibility.patch
++++ glib-2.4.6/glib/gmem.h
+@@ -45,14 +45,14 @@
+
+ /* Memory allocation functions
+ */
+-gpointer g_malloc (gulong n_bytes);
+-gpointer g_malloc0 (gulong n_bytes);
+-gpointer g_realloc (gpointer mem,
+- gulong n_bytes);
+-void g_free (gpointer mem);
+-gpointer g_try_malloc (gulong n_bytes);
+-gpointer g_try_realloc (gpointer mem,
+- gulong n_bytes);
++GLIB_FUNC gpointer g_malloc (gulong n_bytes);
++GLIB_FUNC gpointer g_malloc0 (gulong n_bytes);
++GLIB_FUNC gpointer g_realloc (gpointer mem,
++ gulong n_bytes);;
++GLIB_FUNC void g_free (gpointer mem);
++GLIB_FUNC gpointer g_try_malloc (gulong n_bytes);
++GLIB_FUNC gpointer g_try_realloc (gpointer mem,
++ gulong n_bytes);;
+
+
+ /* Convenience memory allocators
+@@ -82,13 +82,13 @@
+ gpointer (*try_realloc) (gpointer mem,
+ gsize n_bytes);
+ };
+-void g_mem_set_vtable (GMemVTable *vtable);
+-gboolean g_mem_is_system_malloc (void);
++GLIB_FUNC void g_mem_set_vtable (GMemVTable *vtable);
++GLIB_FUNC gboolean g_mem_is_system_malloc (void);
+
+ /* Memory profiler and checker, has to be enabled via g_mem_set_vtable()
+ */
+ GLIB_VAR GMemVTable *glib_mem_profiler_table;
+-void g_mem_profile (void);
++GLIB_FUNC void g_mem_profile (void);
+
+
+ /* Memchunk convenience functions
+@@ -132,19 +132,19 @@
+ #define G_ALLOC_ONLY 1
+ #define G_ALLOC_AND_FREE 2
+
+-GMemChunk* g_mem_chunk_new (const gchar *name,
++GLIB_FUNC 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);
++ gint type);;
++GLIB_FUNC void g_mem_chunk_destroy (GMemChunk *mem_chunk);
++GLIB_FUNC gpointer g_mem_chunk_alloc (GMemChunk *mem_chunk);
++GLIB_FUNC gpointer g_mem_chunk_alloc0 (GMemChunk *mem_chunk);
++GLIB_FUNC void g_mem_chunk_free (GMemChunk *mem_chunk,
++ gpointer mem);;
++GLIB_FUNC void g_mem_chunk_clean (GMemChunk *mem_chunk);
++GLIB_FUNC void g_mem_chunk_reset (GMemChunk *mem_chunk);
++GLIB_FUNC void g_mem_chunk_print (GMemChunk *mem_chunk);
++GLIB_FUNC void g_mem_chunk_info (void);
+
+ /* Ah yes...we have a "g_blow_chunks" function.
+ * "g_blow_chunks" simply compresses all the chunks. This operation
+@@ -154,14 +154,14 @@
+ * much better name than "g_mem_chunk_clean_all" or something
+ * similar.
+ */
+-void g_blow_chunks (void);
++GLIB_FUNC void g_blow_chunks (void);
+
+
+ /* Generic allocators
+ */
+-GAllocator* g_allocator_new (const gchar *name,
+- guint n_preallocs);
+-void g_allocator_free (GAllocator *allocator);
++GLIB_FUNC GAllocator* g_allocator_new (const gchar *name,
++ guint n_preallocs);;
++GLIB_FUNC void g_allocator_free (GAllocator *allocator);
+
+ /* internal */
+ #define G_ALLOCATOR_LIST (1)
+--- glib-2.4.6/glib/gmessages.h~visibility.patch
++++ glib-2.4.6/glib/gmessages.h
+@@ -41,8 +41,8 @@
+
+ /* calculate a string size, guaranteed to fit format + args.
+ */
+-gsize g_printf_string_upper_bound (const gchar* format,
+- va_list args);
++GLIB_FUNC gsize g_printf_string_upper_bound (const gchar* format,
++ va_list args);;
+
+ /* Log level shift offset for user defined
+ * log levels (0-7 are used by GLib).
+@@ -78,27 +78,27 @@
+
+ /* Logging mechanism
+ */
+-guint g_log_set_handler (const gchar *log_domain,
++GLIB_FUNC 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,
++ gpointer user_data);;
++GLIB_FUNC void g_log_remove_handler (const gchar *log_domain,
++ guint handler_id);;
++GLIB_FUNC void g_log_default_handler (const gchar *log_domain,
+ GLogLevelFlags log_level,
+ const gchar *message,
+- gpointer unused_data);
+-void g_log (const gchar *log_domain,
++ gpointer unused_data);;
++GLIB_FUNC void g_log (const gchar *log_domain,
+ GLogLevelFlags log_level,
+ const gchar *format,
+- ...) G_GNUC_PRINTF (3, 4);
+-void g_logv (const gchar *log_domain,
++ ...) G_GNUC_PRINTF (3, 4);;
++GLIB_FUNC 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);
++ va_list args);;
++GLIB_FUNC GLogLevelFlags g_log_set_fatal_mask (const gchar *log_domain,
++ GLogLevelFlags fatal_mask);;
++GLIB_FUNC GLogLevelFlags g_log_set_always_fatal (GLogLevelFlags fatal_mask);
+
+ /* internal */
+ void _g_log_fallback_handler (const gchar *log_domain,
+@@ -176,12 +176,12 @@
+ #endif /* !__GNUC__ */
+
+ typedef void (*GPrintFunc) (const gchar *string);
+-void g_print (const gchar *format,
+- ...) G_GNUC_PRINTF (1, 2);
+-GPrintFunc g_set_print_handler (GPrintFunc func);
+-void g_printerr (const gchar *format,
+- ...) G_GNUC_PRINTF (1, 2);
+-GPrintFunc g_set_printerr_handler (GPrintFunc func);
++GLIB_FUNC void g_print (const gchar *format,
++ ...) G_GNUC_PRINTF (1, 2);;
++GLIB_FUNC GPrintFunc g_set_print_handler (GPrintFunc func);
++GLIB_FUNC void g_printerr (const gchar *format,
++ ...) G_GNUC_PRINTF (1, 2);;
++GLIB_FUNC GPrintFunc g_set_printerr_handler (GPrintFunc func);
+
+
+ /* Provide macros for error handling. The "assert" macros will
+--- glib-2.4.6/glib/gnode.h~visibility.patch
++++ glib-2.4.6/glib/gnode.h
+@@ -74,36 +74,36 @@
+ ((GNode*) (node))->next == NULL)
+ #define G_NODE_IS_LEAF(node) (((GNode*) (node))->children == NULL)
+
+-void g_node_push_allocator (GAllocator *allocator);
+-void g_node_pop_allocator (void);
+-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,
++GLIB_FUNC void g_node_push_allocator (GAllocator *allocator);
++GLIB_FUNC void g_node_pop_allocator (void);
++GLIB_FUNC GNode* g_node_new (gpointer data);
++GLIB_FUNC void g_node_destroy (GNode *root);
++GLIB_FUNC void g_node_unlink (GNode *node);
++GLIB_FUNC GNode* g_node_copy_deep (GNode *node,
+ GCopyFunc copy_func,
+- gpointer data);
+-GNode* g_node_copy (GNode *node);
+-GNode* g_node_insert (GNode *parent,
++ gpointer data);;
++GLIB_FUNC GNode* g_node_copy (GNode *node);
++GLIB_FUNC GNode* g_node_insert (GNode *parent,
+ gint position,
+- GNode *node);
+-GNode* g_node_insert_before (GNode *parent,
++ GNode *node);;
++GLIB_FUNC GNode* g_node_insert_before (GNode *parent,
+ GNode *sibling,
+- GNode *node);
+-GNode* g_node_insert_after (GNode *parent,
++ GNode *node);;
++GLIB_FUNC 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,
++ GNode *node);;
++GLIB_FUNC GNode* g_node_prepend (GNode *parent,
++ GNode *node);;
++GLIB_FUNC guint g_node_n_nodes (GNode *root,
++ GTraverseFlags flags);;
++GLIB_FUNC GNode* g_node_get_root (GNode *node);
++GLIB_FUNC gboolean g_node_is_ancestor (GNode *node,
++ GNode *descendant);;
++GLIB_FUNC guint g_node_depth (GNode *node);
++GLIB_FUNC GNode* g_node_find (GNode *root,
+ GTraverseType order,
+ GTraverseFlags flags,
+- gpointer data);
++ gpointer data);;
+
+ /* convenience macros */
+ #define g_node_append(parent, node) \
+@@ -122,39 +122,39 @@
+ * this function is just a high level interface to
+ * low level traversal functions, optimized for speed.
+ */
+-void g_node_traverse (GNode *root,
++GLIB_FUNC void g_node_traverse (GNode *root,
+ GTraverseType order,
+ GTraverseFlags flags,
+ gint max_depth,
+ GNodeTraverseFunc func,
+- gpointer data);
++ gpointer data);;
+
+ /* return the maximum tree height starting with `node', this is an expensive
+ * operation, since we need to visit all nodes. this could be shortened by
+ * adding `guint height' to struct _GNode, but then again, this is not very
+ * often needed, and would make g_node_insert() more time consuming.
+ */
+-guint g_node_max_height (GNode *root);
++GLIB_FUNC guint g_node_max_height (GNode *root);
+
+-void g_node_children_foreach (GNode *node,
++GLIB_FUNC 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,
++ gpointer data);;
++GLIB_FUNC void g_node_reverse_children (GNode *node);
++GLIB_FUNC guint g_node_n_children (GNode *node);
++GLIB_FUNC GNode* g_node_nth_child (GNode *node,
++ guint n);;
++GLIB_FUNC GNode* g_node_last_child (GNode *node);
++GLIB_FUNC 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);
++ gpointer data);;
++GLIB_FUNC gint g_node_child_position (GNode *node,
++ GNode *child);;
++GLIB_FUNC gint g_node_child_index (GNode *node,
++ gpointer data);;
+
+-GNode* g_node_first_sibling (GNode *node);
+-GNode* g_node_last_sibling (GNode *node);
++GLIB_FUNC GNode* g_node_first_sibling (GNode *node);
++GLIB_FUNC GNode* g_node_last_sibling (GNode *node);
+
+ #define g_node_prev_sibling(node) ((node) ? \
+ ((GNode*) (node))->prev : NULL)
+--- glib-2.4.6/glib/gpattern.h~visibility.patch
++++ glib-2.4.6/glib/gpattern.h
+@@ -26,18 +26,18 @@
+
+ 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,
++GLIB_FUNC GPatternSpec* g_pattern_spec_new (const gchar *pattern);
++GLIB_FUNC void g_pattern_spec_free (GPatternSpec *pspec);
++GLIB_FUNC gboolean g_pattern_spec_equal (GPatternSpec *pspec1,
++ GPatternSpec *pspec2);;
++GLIB_FUNC 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);
++ const gchar *string_reversed);;
++GLIB_FUNC gboolean g_pattern_match_string (GPatternSpec *pspec,
++ const gchar *string);;
++GLIB_FUNC gboolean g_pattern_match_simple (const gchar *pattern,
++ const gchar *string);;
+
+ G_END_DECLS
+
+--- glib-2.4.6/glib/gprimes.h~visibility.patch
++++ glib-2.4.6/glib/gprimes.h
+@@ -40,7 +40,7 @@
+ * next largest prime, or the highest it knows about which is about
+ * MAXINT/4.
+ */
+-guint g_spaced_primes_closest (guint num) G_GNUC_CONST;
++GLIB_FUNC guint g_spaced_primes_closest (guint num) G_GNUC_CONST;;
+
+ G_END_DECLS
+
+--- glib-2.4.6/glib/gprintf.h~visibility.patch
++++ glib-2.4.6/glib/gprintf.h
+@@ -25,34 +25,34 @@
+
+ G_BEGIN_DECLS
+
+-gint g_printf (gchar const *format,
+- ...) G_GNUC_PRINTF (1, 2);
+-gint g_fprintf (FILE *file,
++GLIB_FUNC gint g_printf (gchar const *format,
++ ...) G_GNUC_PRINTF (1, 2);;
++GLIB_FUNC gint g_fprintf (FILE *file,
+ gchar const *format,
+- ...) G_GNUC_PRINTF (2, 3);
+-gint g_sprintf (gchar *string,
++ ...) G_GNUC_PRINTF (2, 3);;
++GLIB_FUNC gint g_sprintf (gchar *string,
+ gchar const *format,
+- ...) G_GNUC_PRINTF (2, 3);
+-gint g_snprintf (gchar *string,
++ ...) G_GNUC_PRINTF (2, 3);;
++GLIB_FUNC gint g_snprintf (gchar *string,
+ gulong n,
+ gchar const *format,
+- ...) G_GNUC_PRINTF (3, 4);
++ ...) G_GNUC_PRINTF (3, 4);;
+
+-gint g_vprintf (gchar const *format,
+- va_list args);
+-gint g_vfprintf (FILE *file,
++GLIB_FUNC gint g_vprintf (gchar const *format,
++ va_list args);;
++GLIB_FUNC gint g_vfprintf (FILE *file,
+ gchar const *format,
+- va_list args);
+-gint g_vsprintf (gchar *string,
++ va_list args);;
++GLIB_FUNC gint g_vsprintf (gchar *string,
+ gchar const *format,
+- va_list args);
+-gint g_vsnprintf (gchar *string,
++ va_list args);;
++GLIB_FUNC gint g_vsnprintf (gchar *string,
+ gulong n,
+ gchar const *format,
+- va_list args);
+-gint g_vasprintf (gchar **string,
++ va_list args);;
++GLIB_FUNC gint g_vasprintf (gchar **string,
+ gchar const *format,
+- va_list args);
++ va_list args);;
+
+ G_END_DECLS
+
+--- glib-2.4.6/glib/gqsort.h~visibility.patch
++++ glib-2.4.6/glib/gqsort.h
+@@ -32,11 +32,11 @@
+
+ G_BEGIN_DECLS
+
+-void g_qsort_with_data (gconstpointer pbase,
++GLIB_FUNC void g_qsort_with_data (gconstpointer pbase,
+ gint total_elems,
+ gsize size,
+ GCompareDataFunc compare_func,
+- gpointer user_data);
++ gpointer user_data);;
+
+ G_END_DECLS
+
+--- glib-2.4.6/glib/gquark.h~visibility.patch
++++ glib-2.4.6/glib/gquark.h
+@@ -35,10 +35,10 @@
+
+ /* Quarks (string<->id association)
+ */
+-GQuark g_quark_try_string (const gchar *string);
+-GQuark g_quark_from_static_string (const gchar *string);
+-GQuark g_quark_from_string (const gchar *string);
+-G_CONST_RETURN gchar* g_quark_to_string (GQuark quark) G_GNUC_CONST;
++GLIB_FUNC GQuark g_quark_try_string (const gchar *string);
++GLIB_FUNC GQuark g_quark_from_static_string (const gchar *string);
++GLIB_FUNC GQuark g_quark_from_string (const gchar *string);
++GLIB_FUNC G_CONST_RETURN gchar* g_quark_to_string (GQuark quark) G_GNUC_CONST;
+
+ G_END_DECLS
+
+--- glib-2.4.6/glib/gqueue.h~visibility.patch
++++ glib-2.4.6/glib/gqueue.h
+@@ -42,77 +42,77 @@
+
+ /* Queues
+ */
+-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,
++GLIB_FUNC GQueue* g_queue_new (void);
++GLIB_FUNC void g_queue_free (GQueue *queue);
++GLIB_FUNC gboolean g_queue_is_empty (GQueue *queue);
++GLIB_FUNC guint g_queue_get_length (GQueue *queue);
++GLIB_FUNC void g_queue_reverse (GQueue *queue);
++GLIB_FUNC GQueue * g_queue_copy (GQueue *queue);
++GLIB_FUNC 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,
++ gpointer user_data);;
++GLIB_FUNC GList * g_queue_find (GQueue *queue,
++ gconstpointer data);;
++GLIB_FUNC GList * g_queue_find_custom (GQueue *queue,
+ gconstpointer data,
+- GCompareFunc func);
+-void g_queue_sort (GQueue *queue,
++ GCompareFunc func);;
++GLIB_FUNC void g_queue_sort (GQueue *queue,
+ GCompareDataFunc compare_func,
+- gpointer user_data);
++ 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,
++GLIB_FUNC void g_queue_push_head (GQueue *queue,
++ gpointer data);;
++GLIB_FUNC void g_queue_push_tail (GQueue *queue,
++ gpointer data);;
++GLIB_FUNC 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,
++ gint n);;
++GLIB_FUNC gpointer g_queue_pop_head (GQueue *queue);
++GLIB_FUNC gpointer g_queue_pop_tail (GQueue *queue);
++GLIB_FUNC gpointer g_queue_pop_nth (GQueue *queue,
++ guint n);;
++GLIB_FUNC gpointer g_queue_peek_head (GQueue *queue);
++GLIB_FUNC gpointer g_queue_peek_tail (GQueue *queue);
++GLIB_FUNC gpointer g_queue_peek_nth (GQueue *queue,
++ guint n);;
++GLIB_FUNC gint g_queue_index (GQueue *queue,
++ gconstpointer data);;
++GLIB_FUNC void g_queue_remove (GQueue *queue,
++ gconstpointer data);;
++GLIB_FUNC void g_queue_remove_all (GQueue *queue,
++ gconstpointer data);;
++GLIB_FUNC void g_queue_insert_before (GQueue *queue,
+ GList *sibling,
+- gpointer data);
+-void g_queue_insert_after (GQueue *queue,
++ gpointer data);;
++GLIB_FUNC void g_queue_insert_after (GQueue *queue,
+ GList *sibling,
+- gpointer data);
+-void g_queue_insert_sorted (GQueue *queue,
++ gpointer data);;
++GLIB_FUNC void g_queue_insert_sorted (GQueue *queue,
+ gpointer data,
+ GCompareDataFunc func,
+- gpointer user_data);
++ 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,
++GLIB_FUNC void g_queue_push_head_link (GQueue *queue,
++ GList *link_);;
++GLIB_FUNC void g_queue_push_tail_link (GQueue *queue,
++ GList *link_);;
++GLIB_FUNC 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_);
++ GList *link_);;
++GLIB_FUNC GList* g_queue_pop_head_link (GQueue *queue);
++GLIB_FUNC GList* g_queue_pop_tail_link (GQueue *queue);
++GLIB_FUNC GList* g_queue_pop_nth_link (GQueue *queue,
++ guint n);;
++GLIB_FUNC GList* g_queue_peek_head_link (GQueue *queue);
++GLIB_FUNC GList* g_queue_peek_tail_link (GQueue *queue);
++GLIB_FUNC GList* g_queue_peek_nth_link (GQueue *queue,
++ guint n);;
++GLIB_FUNC gint g_queue_link_index (GQueue *queue,
++ GList *link_);;
++GLIB_FUNC void g_queue_unlink (GQueue *queue,
++ GList *link_);;
++GLIB_FUNC void g_queue_delete_link (GQueue *queue,
++ GList *link_);;
+
+ G_END_DECLS
+
+--- glib-2.4.6/glib/grand.h~visibility.patch
++++ glib-2.4.6/glib/grand.h
+@@ -42,38 +42,38 @@
+ * double_range -> [begin..end)
+ */
+
+-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_,
++GLIB_FUNC GRand* g_rand_new_with_seed (guint32 seed);
++GLIB_FUNC GRand* g_rand_new_with_seed_array (const guint32 *seed,
++ guint seed_length);;
++GLIB_FUNC GRand* g_rand_new (void);
++GLIB_FUNC void g_rand_free (GRand *rand_);
++GLIB_FUNC GRand* g_rand_copy (GRand *rand_);
++GLIB_FUNC void g_rand_set_seed (GRand *rand_,
++ guint32 seed);;
++GLIB_FUNC void g_rand_set_seed_array (GRand *rand_,
+ const guint32 *seed,
+- guint seed_length);
++ guint seed_length);;
+
+ #define g_rand_boolean(rand_) ((g_rand_int (rand_) & (1 << 15)) != 0)
+
+-guint32 g_rand_int (GRand *rand_);
+-gint32 g_rand_int_range (GRand *rand_,
++GLIB_FUNC guint32 g_rand_int (GRand *rand_);
++GLIB_FUNC gint32 g_rand_int_range (GRand *rand_,
+ gint32 begin,
+- gint32 end);
+-gdouble g_rand_double (GRand *rand_);
+-gdouble g_rand_double_range (GRand *rand_,
++ gint32 end);;
++GLIB_FUNC gdouble g_rand_double (GRand *rand_);
++GLIB_FUNC gdouble g_rand_double_range (GRand *rand_,
+ gdouble begin,
+- gdouble end);
+-void g_random_set_seed (guint32 seed);
++ gdouble end);;
++GLIB_FUNC void g_random_set_seed (guint32 seed);
+
+ #define g_random_boolean() ((g_random_int () & (1 << 15)) != 0)
+
+-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);
++GLIB_FUNC guint32 g_random_int (void);
++GLIB_FUNC gint32 g_random_int_range (gint32 begin,
++ gint32 end);;
++GLIB_FUNC gdouble g_random_double (void);
++GLIB_FUNC gdouble g_random_double_range (gdouble begin,
++ gdouble end);;
+
+
+ G_END_DECLS
+--- glib-2.4.6/glib/grel.h~visibility.patch
++++ glib-2.4.6/glib/grel.h
+@@ -62,31 +62,31 @@
+ * g_relation_count() counts ...
+ */
+
+-GRelation* g_relation_new (gint fields);
+-void g_relation_destroy (GRelation *relation);
+-void g_relation_index (GRelation *relation,
++GLIB_FUNC GRelation* g_relation_new (gint fields);
++GLIB_FUNC void g_relation_destroy (GRelation *relation);
++GLIB_FUNC 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,
++ GEqualFunc key_equal_func);;
++GLIB_FUNC void g_relation_insert (GRelation *relation,
++ ...);;
++GLIB_FUNC gint g_relation_delete (GRelation *relation,
+ gconstpointer key,
+- gint field);
+-GTuples* g_relation_select (GRelation *relation,
++ gint field);;
++GLIB_FUNC GTuples* g_relation_select (GRelation *relation,
+ gconstpointer key,
+- gint field);
+-gint g_relation_count (GRelation *relation,
++ gint field);;
++GLIB_FUNC gint g_relation_count (GRelation *relation,
+ gconstpointer key,
+- gint field);
+-gboolean g_relation_exists (GRelation *relation,
+- ...);
+-void g_relation_print (GRelation *relation);
++ gint field);;
++GLIB_FUNC gboolean g_relation_exists (GRelation *relation,
++ ...);;
++GLIB_FUNC void g_relation_print (GRelation *relation);
+
+-void g_tuples_destroy (GTuples *tuples);
+-gpointer g_tuples_index (GTuples *tuples,
++GLIB_FUNC void g_tuples_destroy (GTuples *tuples);
++GLIB_FUNC gpointer g_tuples_index (GTuples *tuples,
+ gint index_,
+- gint field);
++ gint field);;
+
+ G_END_DECLS
+
+--- glib-2.4.6/glib/gscanner.h~visibility.patch
++++ glib-2.4.6/glib/gscanner.h
+@@ -201,52 +201,52 @@
+ 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,
++GLIB_FUNC GScanner* g_scanner_new (const GScannerConfig *config_templ);
++GLIB_FUNC void g_scanner_destroy (GScanner *scanner);
++GLIB_FUNC void g_scanner_input_file (GScanner *scanner,
++ gint input_fd);;
++GLIB_FUNC void g_scanner_sync_file_offset (GScanner *scanner);
++GLIB_FUNC 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 text_len);;
++GLIB_FUNC GTokenType g_scanner_get_next_token (GScanner *scanner);
++GLIB_FUNC GTokenType g_scanner_peek_next_token (GScanner *scanner);
++GLIB_FUNC GTokenType g_scanner_cur_token (GScanner *scanner);
++GLIB_FUNC GTokenValue g_scanner_cur_value (GScanner *scanner);
++GLIB_FUNC guint g_scanner_cur_line (GScanner *scanner);
++GLIB_FUNC guint g_scanner_cur_position (GScanner *scanner);
++GLIB_FUNC gboolean g_scanner_eof (GScanner *scanner);
++GLIB_FUNC guint g_scanner_set_scope (GScanner *scanner,
++ guint scope_id);;
++GLIB_FUNC void g_scanner_scope_add_symbol (GScanner *scanner,
+ guint scope_id,
+ const gchar *symbol,
+- gpointer value);
+-void g_scanner_scope_remove_symbol (GScanner *scanner,
++ gpointer value);;
++GLIB_FUNC void g_scanner_scope_remove_symbol (GScanner *scanner,
+ guint scope_id,
+- const gchar *symbol);
+-gpointer g_scanner_scope_lookup_symbol (GScanner *scanner,
++ const gchar *symbol);;
++GLIB_FUNC gpointer g_scanner_scope_lookup_symbol (GScanner *scanner,
+ guint scope_id,
+- const gchar *symbol);
+-void g_scanner_scope_foreach_symbol (GScanner *scanner,
++ const gchar *symbol);;
++GLIB_FUNC 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,
++ gpointer user_data);;
++GLIB_FUNC gpointer g_scanner_lookup_symbol (GScanner *scanner,
++ const gchar *symbol);;
++GLIB_FUNC 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,
++ gint is_error);;
++GLIB_FUNC void g_scanner_error (GScanner *scanner,
+ const gchar *format,
+- ...) G_GNUC_PRINTF (2,3);
+-void g_scanner_warn (GScanner *scanner,
++ ...) G_GNUC_PRINTF (2,3);;
++GLIB_FUNC void g_scanner_warn (GScanner *scanner,
+ const gchar *format,
+- ...) G_GNUC_PRINTF (2,3);
++ ...) G_GNUC_PRINTF (2,3);;
+
+ #ifndef G_DISABLE_DEPRECATED
+
+--- glib-2.4.6/glib/gshell.h~visibility.patch
++++ glib-2.4.6/glib/gshell.h
+@@ -36,15 +36,15 @@
+ G_SHELL_ERROR_FAILED
+ } GShellError;
+
+-GQuark g_shell_error_quark (void);
++GLIB_FUNC 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,
++GLIB_FUNC gchar* g_shell_quote (const gchar *unquoted_string);
++GLIB_FUNC gchar* g_shell_unquote (const gchar *quoted_string,
++ GError **error);;
++GLIB_FUNC gboolean g_shell_parse_argv (const gchar *command_line,
+ gint *argcp,
+ gchar ***argvp,
+- GError **error);
++ GError **error);;
+
+ G_END_DECLS
+
+--- glib-2.4.6/glib/gslist.h~visibility.patch
++++ glib-2.4.6/glib/gslist.h
+@@ -41,59 +41,59 @@
+
+ /* Singly linked lists
+ */
+-void g_slist_push_allocator (GAllocator *allocator);
+-void g_slist_pop_allocator (void);
+-GSList* g_slist_alloc (void);
+-void g_slist_free (GSList *list);
+-void g_slist_free_1 (GSList *list);
+-GSList* g_slist_append (GSList *list,
+- gpointer data);
+-GSList* g_slist_prepend (GSList *list,
+- gpointer data);
+-GSList* g_slist_insert (GSList *list,
++GLIB_FUNC void g_slist_push_allocator (GAllocator *allocator);
++GLIB_FUNC void g_slist_pop_allocator (void);
++GLIB_FUNC GSList* g_slist_alloc (void);
++GLIB_FUNC void g_slist_free (GSList *list);
++GLIB_FUNC void g_slist_free_1 (GSList *list);
++GLIB_FUNC GSList* g_slist_append (GSList *list,
++ gpointer data);;
++GLIB_FUNC GSList* g_slist_prepend (GSList *list,
++ gpointer data);;
++GLIB_FUNC GSList* g_slist_insert (GSList *list,
+ gpointer data,
+- gint position);
+-GSList* g_slist_insert_sorted (GSList *list,
++ gint position);;
++GLIB_FUNC GSList* g_slist_insert_sorted (GSList *list,
+ gpointer data,
+- GCompareFunc func);
+-GSList* g_slist_insert_before (GSList *slist,
++ GCompareFunc func);;
++GLIB_FUNC GSList* g_slist_insert_before (GSList *slist,
+ GSList *sibling,
+- gpointer data);
+-GSList* g_slist_concat (GSList *list1,
+- GSList *list2);
+-GSList* g_slist_remove (GSList *list,
+- gconstpointer data);
+-GSList* g_slist_remove_all (GSList *list,
+- gconstpointer data);
+-GSList* g_slist_remove_link (GSList *list,
+- GSList *link_);
+-GSList* g_slist_delete_link (GSList *list,
+- GSList *link_);
+-GSList* g_slist_reverse (GSList *list);
+-GSList* g_slist_copy (GSList *list);
+-GSList* g_slist_nth (GSList *list,
+- guint n);
+-GSList* g_slist_find (GSList *list,
+- gconstpointer data);
+-GSList* g_slist_find_custom (GSList *list,
++ gpointer data);;
++GLIB_FUNC GSList* g_slist_concat (GSList *list1,
++ GSList *list2);;
++GLIB_FUNC GSList* g_slist_remove (GSList *list,
++ gconstpointer data);;
++GLIB_FUNC GSList* g_slist_remove_all (GSList *list,
++ gconstpointer data);;
++GLIB_FUNC GSList* g_slist_remove_link (GSList *list,
++ GSList *link_);;
++GLIB_FUNC GSList* g_slist_delete_link (GSList *list,
++ GSList *link_);;
++GLIB_FUNC GSList* g_slist_reverse (GSList *list);
++GLIB_FUNC GSList* g_slist_copy (GSList *list);
++GLIB_FUNC GSList* g_slist_nth (GSList *list,
++ guint n);;
++GLIB_FUNC GSList* g_slist_find (GSList *list,
++ gconstpointer data);;
++GLIB_FUNC 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,
++ GCompareFunc func);;
++GLIB_FUNC gint g_slist_position (GSList *list,
++ GSList *llink);;
++GLIB_FUNC gint g_slist_index (GSList *list,
++ gconstpointer data);;
++GLIB_FUNC GSList* g_slist_last (GSList *list);
++GLIB_FUNC guint g_slist_length (GSList *list);
++GLIB_FUNC void g_slist_foreach (GSList *list,
+ GFunc func,
+- gpointer user_data);
+-GSList* g_slist_sort (GSList *list,
+- GCompareFunc compare_func);
+-GSList* g_slist_sort_with_data (GSList *list,
++ gpointer user_data);;
++GLIB_FUNC GSList* g_slist_sort (GSList *list,
++ GCompareFunc compare_func);;
++GLIB_FUNC GSList* g_slist_sort_with_data (GSList *list,
+ GCompareDataFunc compare_func,
+- gpointer user_data);
+-gpointer g_slist_nth_data (GSList *list,
+- guint n);
++ gpointer user_data);;
++GLIB_FUNC gpointer g_slist_nth_data (GSList *list,
++ guint n);;
+ #define g_slist_next(slist) ((slist) ? (((GSList *)(slist))->next) : NULL)
+
+ G_END_DECLS
+--- glib-2.4.6/glib/gspawn.h~visibility.patch
++++ glib-2.4.6/glib/gspawn.h
+@@ -69,22 +69,22 @@
+ G_SPAWN_FILE_AND_ARGV_ZERO = 1 << 6
+ } GSpawnFlags;
+
+-GQuark g_spawn_error_quark (void);
++GLIB_FUNC GQuark g_spawn_error_quark (void);
+
+-gboolean g_spawn_async (const gchar *working_directory,
++GLIB_FUNC gboolean g_spawn_async (const gchar *working_directory,
+ gchar **argv,
+ gchar **envp,
+ GSpawnFlags flags,
+ GSpawnChildSetupFunc child_setup,
+ gpointer user_data,
+ GPid *child_pid,
+- GError **error);
++ GError **error);;
+
+
+ /* Opens pipes for non-NULL standard_output, standard_input, standard_error,
+ * and returns the parent's end of the pipes.
+ */
+-gboolean g_spawn_async_with_pipes (const gchar *working_directory,
++GLIB_FUNC gboolean g_spawn_async_with_pipes (const gchar *working_directory,
+ gchar **argv,
+ gchar **envp,
+ GSpawnFlags flags,
+@@ -94,14 +94,14 @@
+ gint *standard_input,
+ gint *standard_output,
+ gint *standard_error,
+- GError **error);
++ GError **error);;
+
+
+ /* If standard_output or standard_error are non-NULL, the full
+ * standard output or error of the command will be placed there.
+ */
+
+-gboolean g_spawn_sync (const gchar *working_directory,
++GLIB_FUNC gboolean g_spawn_sync (const gchar *working_directory,
+ gchar **argv,
+ gchar **envp,
+ GSpawnFlags flags,
+@@ -110,17 +110,17 @@
+ gchar **standard_output,
+ gchar **standard_error,
+ gint *exit_status,
+- GError **error);
++ GError **error);;
+
+-gboolean g_spawn_command_line_sync (const gchar *command_line,
++GLIB_FUNC gboolean g_spawn_command_line_sync (const gchar *command_line,
+ gchar **standard_output,
+ gchar **standard_error,
+ gint *exit_status,
+- GError **error);
+-gboolean g_spawn_command_line_async (const gchar *command_line,
+- GError **error);
++ GError **error);;
++GLIB_FUNC gboolean g_spawn_command_line_async (const gchar *command_line,
++ GError **error);;
+
+-void g_spawn_close_pid (GPid pid);
++GLIB_FUNC void g_spawn_close_pid (GPid pid);
+
+
+ G_END_DECLS
+--- glib-2.4.6/glib/gstrfuncs.h~visibility.patch
++++ glib-2.4.6/glib/gstrfuncs.h
+@@ -82,82 +82,82 @@
+ #define g_ascii_isxdigit(c) \
+ ((g_ascii_table[(guchar) (c)] & G_ASCII_XDIGIT) != 0)
+
+-gchar g_ascii_tolower (gchar c) G_GNUC_CONST;
+-gchar g_ascii_toupper (gchar c) G_GNUC_CONST;
++GLIB_FUNC gchar g_ascii_tolower (gchar c) G_GNUC_CONST;;
++GLIB_FUNC gchar g_ascii_toupper (gchar c) G_GNUC_CONST;;
+
+-gint g_ascii_digit_value (gchar c) G_GNUC_CONST;
+-gint g_ascii_xdigit_value (gchar c) G_GNUC_CONST;
++GLIB_FUNC gint g_ascii_digit_value (gchar c) G_GNUC_CONST;;
++GLIB_FUNC gint g_ascii_xdigit_value (gchar c) G_GNUC_CONST;;
+
+ /* String utility functions that modify a string argument or
+ * return a constant string that must not be freed.
+ */
+ #define G_STR_DELIMITERS "_-|> <."
+-gchar* g_strdelimit (gchar *string,
++GLIB_FUNC gchar* g_strdelimit (gchar *string,
+ const gchar *delimiters,
+- gchar new_delimiter);
+-gchar* g_strcanon (gchar *string,
++ gchar new_delimiter);;
++GLIB_FUNC gchar* g_strcanon (gchar *string,
+ const gchar *valid_chars,
+- gchar substitutor);
+-G_CONST_RETURN gchar* g_strerror (gint errnum) G_GNUC_CONST;
+-G_CONST_RETURN gchar* g_strsignal (gint signum) G_GNUC_CONST;
+-gchar* g_strreverse (gchar *string);
+-gsize g_strlcpy (gchar *dest,
++ gchar substitutor);;
++GLIB_FUNC G_CONST_RETURN gchar* g_strerror (gint errnum) G_GNUC_CONST;
++GLIB_FUNC G_CONST_RETURN gchar* g_strsignal (gint signum) G_GNUC_CONST;
++GLIB_FUNC gchar* g_strreverse (gchar *string);
++GLIB_FUNC gsize g_strlcpy (gchar *dest,
+ const gchar *src,
+- gsize dest_size);
+-gsize g_strlcat (gchar *dest,
++ gsize dest_size);;
++GLIB_FUNC gsize g_strlcat (gchar *dest,
+ const gchar *src,
+- gsize dest_size);
+-gchar * g_strstr_len (const gchar *haystack,
++ gsize dest_size);;
++GLIB_FUNC 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,
++ const gchar *needle);;
++GLIB_FUNC gchar * g_strrstr (const gchar *haystack,
++ const gchar *needle);;
++GLIB_FUNC gchar * g_strrstr_len (const gchar *haystack,
+ gssize haystack_len,
+- const gchar *needle);
++ 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);
++GLIB_FUNC gboolean g_str_has_suffix (const gchar *str,
++ const gchar *suffix);;
++GLIB_FUNC gboolean g_str_has_prefix (const gchar *str,
++ const gchar *prefix);;
+
+ /* String to/from double conversion functions */
+
+-gdouble g_strtod (const gchar *nptr,
+- gchar **endptr);
+-gdouble g_ascii_strtod (const gchar *nptr,
+- gchar **endptr);
+-guint64 g_ascii_strtoull (const gchar *nptr,
++GLIB_FUNC gdouble g_strtod (const gchar *nptr,
++ gchar **endptr);;
++GLIB_FUNC gdouble g_ascii_strtod (const gchar *nptr,
++ gchar **endptr);;
++GLIB_FUNC guint64 g_ascii_strtoull (const gchar *nptr,
+ gchar **endptr,
+- guint base);
++ guint base);;
+ /* 29 bytes should enough for all possible values that
+ * g_ascii_dtostr can produce.
+ * Then add 10 for good measure */
+ #define G_ASCII_DTOSTR_BUF_SIZE (29 + 10)
+-gchar * g_ascii_dtostr (gchar *buffer,
++GLIB_FUNC gchar * g_ascii_dtostr (gchar *buffer,
+ gint buf_len,
+- gdouble d);
+-gchar * g_ascii_formatd (gchar *buffer,
++ gdouble d);;
++GLIB_FUNC gchar * g_ascii_formatd (gchar *buffer,
+ gint buf_len,
+ const gchar *format,
+- gdouble d);
++ gdouble d);;
+
+ /* removes leading spaces */
+-gchar* g_strchug (gchar *string);
++GLIB_FUNC gchar* g_strchug (gchar *string);
+ /* removes trailing spaces */
+-gchar* g_strchomp (gchar *string);
++GLIB_FUNC gchar* g_strchomp (gchar *string);
+ /* removes leading & trailing spaces */
+ #define g_strstrip( string ) g_strchomp (g_strchug (string))
+
+-gint g_ascii_strcasecmp (const gchar *s1,
+- const gchar *s2);
+-gint g_ascii_strncasecmp (const gchar *s1,
++GLIB_FUNC gint g_ascii_strcasecmp (const gchar *s1,
++ const gchar *s2);;
++GLIB_FUNC gint g_ascii_strncasecmp (const gchar *s1,
+ const gchar *s2,
+- gsize n);
+-gchar* g_ascii_strdown (const gchar *str,
+- gssize len);
+-gchar* g_ascii_strup (const gchar *str,
+- gssize len);
++ gsize n);;
++GLIB_FUNC gchar* g_ascii_strdown (const gchar *str,
++ gssize len);;
++GLIB_FUNC gchar* g_ascii_strup (const gchar *str,
++ gssize len);;
+
+ #ifndef G_DISABLE_DEPRECATED
+
+@@ -166,37 +166,37 @@
+ * toupper, which is almost never the right thing.
+ */
+
+-gint g_strcasecmp (const gchar *s1,
+- const gchar *s2);
+-gint g_strncasecmp (const gchar *s1,
++GLIB_FUNC gint g_strcasecmp (const gchar *s1,
++ const gchar *s2);;
++GLIB_FUNC gint g_strncasecmp (const gchar *s1,
+ const gchar *s2,
+- guint n);
+-gchar* g_strdown (gchar *string);
+-gchar* g_strup (gchar *string);
++ guint n);;
++GLIB_FUNC gchar* g_strdown (gchar *string);
++GLIB_FUNC gchar* g_strup (gchar *string);
+
+ #endif /* G_DISABLE_DEPRECATED */
+
+ /* String utility functions that return a newly allocated string which
+ * ought to be freed with g_free from the caller at some point.
+ */
+-gchar* g_strdup (const gchar *str);
+-gchar* g_strdup_printf (const gchar *format,
+- ...) G_GNUC_PRINTF (1, 2);
+-gchar* g_strdup_vprintf (const gchar *format,
+- va_list args);
+-gchar* g_strndup (const gchar *str,
+- gsize n);
+-gchar* g_strnfill (gsize length,
+- gchar fill_char);
+-gchar* g_strconcat (const gchar *string1,
+- ...); /* NULL terminated */
+-gchar* g_strjoin (const gchar *separator,
+- ...); /* NULL terminated */
++GLIB_FUNC gchar* g_strdup (const gchar *str);
++GLIB_FUNC gchar* g_strdup_printf (const gchar *format,
++ ...) G_GNUC_PRINTF (1, 2);;
++GLIB_FUNC gchar* g_strdup_vprintf (const gchar *format,
++ va_list args);;
++GLIB_FUNC gchar* g_strndup (const gchar *str,
++ gsize n);;
++GLIB_FUNC gchar* g_strnfill (gsize length,
++ gchar fill_char);;
++GLIB_FUNC gchar* g_strconcat (const gchar *string1,
++ ...);; /* NULL terminated */
++GLIB_FUNC gchar* g_strjoin (const gchar *separator,
++ ...);; /* NULL terminated */
+ /* Make a copy of a string interpreting C string -style escape
+ * sequences. Inverse of g_strescape. The recognized sequences are \b
+ * \f \n \r \t \\ \" and the octal format.
+ */
+-gchar* g_strcompress (const gchar *source);
++GLIB_FUNC gchar* g_strcompress (const gchar *source);
+
+ /* Copy a string escaping nonprintable characters like in C strings.
+ * Inverse of g_strcompress. The exceptions parameter, if non-NULL, points
+@@ -206,11 +206,11 @@
+ * Luckily this function wasn't used much, using NULL as second parameter
+ * provides mostly identical semantics.
+ */
+-gchar* g_strescape (const gchar *source,
+- const gchar *exceptions);
++GLIB_FUNC gchar* g_strescape (const gchar *source,
++ const gchar *exceptions);;
+
+-gpointer g_memdup (gconstpointer mem,
+- guint byte_size);
++GLIB_FUNC gpointer g_memdup (gconstpointer mem,
++ guint byte_size);;
+
+ /* NULL terminated string arrays.
+ * g_strsplit(), g_strsplit_set() split up string into max_tokens tokens
+@@ -220,21 +220,21 @@
+ * g_strfreev() frees the array itself and all of its strings.
+ * g_strdupv() copies a NULL-terminated array of strings
+ */
+-gchar** g_strsplit (const gchar *string,
++GLIB_FUNC gchar** g_strsplit (const gchar *string,
+ const gchar *delimiter,
+- gint max_tokens);
+-gchar ** g_strsplit_set (const gchar *string,
++ gint max_tokens);;
++GLIB_FUNC gchar ** g_strsplit_set (const gchar *string,
+ const gchar *delimiters,
+- gint max_tokens);
+-gchar* g_strjoinv (const gchar *separator,
+- gchar **str_array);
+-void g_strfreev (gchar **str_array);
+-gchar** g_strdupv (gchar **str_array);
++ gint max_tokens);;
++GLIB_FUNC gchar* g_strjoinv (const gchar *separator,
++ gchar **str_array);;
++GLIB_FUNC void g_strfreev (gchar **str_array);
++GLIB_FUNC gchar** g_strdupv (gchar **str_array);
+
+-gchar* g_stpcpy (gchar *dest,
+- const char *src);
++GLIB_FUNC gchar* g_stpcpy (gchar *dest,
++ const char *src);;
+
+-G_CONST_RETURN gchar *g_strip_context (const gchar *msgid,
++GLIB_FUNC G_CONST_RETURN gchar *g_strip_context (const gchar *msgid,
+ const gchar *msgval);
+
+ G_END_DECLS
+--- glib-2.4.6/glib/gstring.h~visibility.patch
++++ glib-2.4.6/glib/gstring.h
+@@ -45,76 +45,76 @@
+
+ /* String Chunks
+ */
+-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,
++GLIB_FUNC GStringChunk* g_string_chunk_new (gsize size);
++GLIB_FUNC void g_string_chunk_free (GStringChunk *chunk);
++GLIB_FUNC gchar* g_string_chunk_insert (GStringChunk *chunk,
++ const gchar *string);;
++GLIB_FUNC gchar* g_string_chunk_insert_len (GStringChunk *chunk,
+ const gchar *string,
+- gssize len);
+-gchar* g_string_chunk_insert_const (GStringChunk *chunk,
+- const gchar *string);
++ gssize len);;
++GLIB_FUNC gchar* g_string_chunk_insert_const (GStringChunk *chunk,
++ const gchar *string);;
+
+
+ /* Strings
+ */
+-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,
++GLIB_FUNC GString* g_string_new (const gchar *init);
++GLIB_FUNC GString* g_string_new_len (const gchar *init,
++ gssize len);;
++GLIB_FUNC GString* g_string_sized_new (gsize dfl_size);
++GLIB_FUNC gchar* g_string_free (GString *string,
++ gboolean free_segment);;
++GLIB_FUNC gboolean g_string_equal (const GString *v,
++ const GString *v2);;
++GLIB_FUNC guint g_string_hash (const GString *str);
++GLIB_FUNC GString* g_string_assign (GString *string,
++ const gchar *rval);;
++GLIB_FUNC GString* g_string_truncate (GString *string,
++ gsize len);;
++GLIB_FUNC GString* g_string_set_size (GString *string,
++ gsize len);;
++GLIB_FUNC 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,
++ gssize len);;
++GLIB_FUNC GString* g_string_append (GString *string,
++ const gchar *val);;
++GLIB_FUNC 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,
++ gssize len);;
++GLIB_FUNC GString* g_string_append_c (GString *string,
++ gchar c);;
++GLIB_FUNC GString* g_string_append_unichar (GString *string,
++ gunichar wc);;
++GLIB_FUNC GString* g_string_prepend (GString *string,
++ const gchar *val);;
++GLIB_FUNC GString* g_string_prepend_c (GString *string,
++ gchar c);;
++GLIB_FUNC GString* g_string_prepend_unichar (GString *string,
++ gunichar wc);;
++GLIB_FUNC GString* g_string_prepend_len (GString *string,
+ const gchar *val,
+- gssize len);
+-GString* g_string_insert (GString *string,
++ gssize len);;
++GLIB_FUNC GString* g_string_insert (GString *string,
+ gssize pos,
+- const gchar *val);
+-GString* g_string_insert_c (GString *string,
++ const gchar *val);;
++GLIB_FUNC GString* g_string_insert_c (GString *string,
+ gssize pos,
+- gchar c);
+-GString* g_string_insert_unichar (GString *string,
++ gchar c);;
++GLIB_FUNC GString* g_string_insert_unichar (GString *string,
+ gssize pos,
+- gunichar wc);
+-GString* g_string_erase (GString *string,
++ gunichar wc);;
++GLIB_FUNC 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,
++ gssize len);;
++GLIB_FUNC GString* g_string_ascii_down (GString *string);
++GLIB_FUNC GString* g_string_ascii_up (GString *string);
++GLIB_FUNC void g_string_printf (GString *string,
+ const gchar *format,
+- ...) G_GNUC_PRINTF (2, 3);
+-void g_string_append_printf (GString *string,
++ ...) G_GNUC_PRINTF (2, 3);;
++GLIB_FUNC void g_string_append_printf (GString *string,
+ const gchar *format,
+- ...) G_GNUC_PRINTF (2, 3);
++ ...) G_GNUC_PRINTF (2, 3);;
+
+ /* -- optimize g_strig_append_c --- */
+ #ifdef G_CAN_INLINE
+@@ -127,8 +127,8 @@
+ gstring->str[gstring->len++] = c;
+ gstring->str[gstring->len] = 0;
+ }
+- else
+- g_string_insert_c (gstring, -1, c);
++else
++ g_string_insert_c (gstring, -1, c);;;;
+ return gstring;
+ }
+ #define g_string_append_c(gstr,c) g_string_append_c_inline (gstr, c)
+@@ -142,8 +142,8 @@
+ * toupper, which is almost never the right thing.
+ */
+
+-GString* g_string_down (GString *string);
+-GString* g_string_up (GString *string);
++GLIB_FUNC GString* g_string_down (GString *string);
++GLIB_FUNC GString* g_string_up (GString *string);
+
+ /* These aliases are included for compatibility. */
+ #define g_string_sprintf g_string_printf
+--- glib-2.4.6/glib/gthread.h~visibility.patch
++++ glib-2.4.6/glib/gthread.h
+@@ -36,7 +36,7 @@
+ /* GLib Thread support
+ */
+
+-extern GQuark g_thread_error_quark (void);
++GLIB_FUNC extern GQuark g_thread_error_quark (void);
+ #define G_THREAD_ERROR g_thread_error_quark ()
+
+ typedef enum
+@@ -116,7 +116,7 @@
+ * only be called once, and must not be called directly or indirectly
+ * from another glib-function, e.g. as a callback.
+ */
+-void g_thread_init (GThreadFunctions *vtable);
++GLIB_FUNC void g_thread_init (GThreadFunctions *vtable);
+
+ /* Errorcheck mutexes. If you define G_ERRORCHECK_MUTEXES, then all
+ * mutexes will check for re-locking and re-unlocking */
+@@ -125,7 +125,7 @@
+ * NULL. Do not call directly. Use #define G_ERRORCHECK_MUTEXES
+ * instead.
+ */
+-void g_thread_init_with_errorcheck_mutexes (GThreadFunctions* vtable);
++GLIB_FUNC void g_thread_init_with_errorcheck_mutexes (GThreadFunctions* vtable);
+
+ /* A random number to recognize debug calls to g_mutex_... */
+ #define G_MUTEX_DEBUG_MAGIC 0xf8e18ad7
+@@ -135,7 +135,7 @@
+ #endif
+
+ /* internal function for fallback static mutex implementation */
+-GMutex* g_static_mutex_get_mutex_impl (GMutex **mutex);
++GLIB_FUNC GMutex* g_static_mutex_get_mutex_impl (GMutex **mutex);
+
+ #define g_static_mutex_get_mutex_impl_shortcut(mutex) \
+ (g_atomic_pointer_get ((gpointer*)mutex) ? *(mutex) : \
+@@ -205,19 +205,19 @@
+ (g_thread_create_full (func, data, 0, joinable, FALSE, \
+ G_THREAD_PRIORITY_NORMAL, error))
+
+-GThread* g_thread_create_full (GThreadFunc func,
++GLIB_FUNC 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);
++ GError **error);;
++GLIB_FUNC GThread* g_thread_self (void);
++GLIB_FUNC void g_thread_exit (gpointer retval);
++GLIB_FUNC gpointer g_thread_join (GThread *thread);
+
+-void g_thread_set_priority (GThread *thread,
+- GThreadPriority priority);
++GLIB_FUNC void g_thread_set_priority (GThread *thread,
++ GThreadPriority priority);;
+
+ /* GStaticMutexes can be statically initialized with the value
+ * G_STATIC_MUTEX_INIT, and then they can directly be used, that is
+@@ -230,8 +230,8 @@
+ g_mutex_trylock (g_static_mutex_get_mutex (mutex))
+ #define g_static_mutex_unlock(mutex) \
+ g_mutex_unlock (g_static_mutex_get_mutex (mutex))
+-void g_static_mutex_init (GStaticMutex *mutex);
+-void g_static_mutex_free (GStaticMutex *mutex);
++GLIB_FUNC void g_static_mutex_init (GStaticMutex *mutex);
++GLIB_FUNC void g_static_mutex_free (GStaticMutex *mutex);
+
+ struct _GStaticPrivate
+ {
+@@ -239,12 +239,12 @@
+ guint index;
+ };
+ #define G_STATIC_PRIVATE_INIT { 0 }
+-void g_static_private_init (GStaticPrivate *private_key);
+-gpointer g_static_private_get (GStaticPrivate *private_key);
+-void g_static_private_set (GStaticPrivate *private_key,
++GLIB_FUNC void g_static_private_init (GStaticPrivate *private_key);
++GLIB_FUNC gpointer g_static_private_get (GStaticPrivate *private_key);
++GLIB_FUNC void g_static_private_set (GStaticPrivate *private_key,
+ gpointer data,
+- GDestroyNotify notify);
+-void g_static_private_free (GStaticPrivate *private_key);
++ GDestroyNotify notify);;
++GLIB_FUNC void g_static_private_free (GStaticPrivate *private_key);
+
+ typedef struct _GStaticRecMutex GStaticRecMutex;
+ struct _GStaticRecMutex
+@@ -256,14 +256,14 @@
+ };
+
+ #define G_STATIC_REC_MUTEX_INIT { G_STATIC_MUTEX_INIT }
+-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);
++GLIB_FUNC void g_static_rec_mutex_init (GStaticRecMutex *mutex);
++GLIB_FUNC void g_static_rec_mutex_lock (GStaticRecMutex *mutex);
++GLIB_FUNC gboolean g_static_rec_mutex_trylock (GStaticRecMutex *mutex);
++GLIB_FUNC void g_static_rec_mutex_unlock (GStaticRecMutex *mutex);
++GLIB_FUNC void g_static_rec_mutex_lock_full (GStaticRecMutex *mutex,
++ guint depth);;
++GLIB_FUNC guint g_static_rec_mutex_unlock_full (GStaticRecMutex *mutex);
++GLIB_FUNC void g_static_rec_mutex_free (GStaticRecMutex *mutex);
+
+ typedef struct _GStaticRWLock GStaticRWLock;
+ struct _GStaticRWLock
+@@ -280,14 +280,14 @@
+
+ #define G_STATIC_RW_LOCK_INIT { G_STATIC_MUTEX_INIT, NULL, NULL, 0, FALSE, 0, 0 }
+
+-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);
++GLIB_FUNC void g_static_rw_lock_init (GStaticRWLock* lock);
++GLIB_FUNC void g_static_rw_lock_reader_lock (GStaticRWLock* lock);
++GLIB_FUNC gboolean g_static_rw_lock_reader_trylock (GStaticRWLock* lock);
++GLIB_FUNC void g_static_rw_lock_reader_unlock (GStaticRWLock* lock);
++GLIB_FUNC void g_static_rw_lock_writer_lock (GStaticRWLock* lock);
++GLIB_FUNC gboolean g_static_rw_lock_writer_trylock (GStaticRWLock* lock);
++GLIB_FUNC void g_static_rw_lock_writer_unlock (GStaticRWLock* lock);
++GLIB_FUNC void g_static_rw_lock_free (GStaticRWLock* lock);
+
+ typedef enum
+ {
+@@ -305,7 +305,7 @@
+
+ #define G_ONCE_INIT { G_ONCE_STATUS_NOTCALLED, NULL }
+
+-gpointer g_once_impl (GOnce *once, GThreadFunc func, gpointer arg);
++GLIB_FUNC gpointer g_once_impl (GOnce *once, GThreadFunc func, gpointer arg);
+
+ #ifdef G_ATOMIC_OP_MEMORY_BARRIER_NEEDED
+ # define g_once(once, func, arg) g_once_impl ((once), (func), (arg))
+--- glib-2.4.6/glib/gthreadinit.h~visibility.patch
++++ glib-2.4.6/glib/gthreadinit.h
+@@ -24,7 +24,7 @@
+ G_BEGIN_DECLS
+
+ /* Is called from gthread/gthread-impl.c */
+-void g_thread_init_glib (void);
++GLIB_FUNC void g_thread_init_glib (void);
+
+ /* Are called from glib/gthread.c. May not contain g_private_new calls */
+ void _g_mem_thread_init (void);
+--- glib-2.4.6/glib/gthreadpool.h~visibility.patch
++++ glib-2.4.6/glib/gthreadpool.h
+@@ -50,51 +50,51 @@
+ * means, that the threads shouldn't be shared and that they will be
+ * prestarted (otherwise they are started as needed) user_data is the
+ * 2nd argument to the func */
+-GThreadPool* g_thread_pool_new (GFunc func,
++GLIB_FUNC GThreadPool* g_thread_pool_new (GFunc func,
+ gpointer user_data,
+ gint max_threads,
+ gboolean exclusive,
+- GError **error);
++ GError **error);;
+
+ /* Push new data into the thread pool. This task is assigned to a thread later
+ * (when the maximal number of threads is reached for that pool) or now
+ * (otherwise). If necessary a new thread will be started. The function
+ * returns immediatly */
+-void g_thread_pool_push (GThreadPool *pool,
++GLIB_FUNC void g_thread_pool_push (GThreadPool *pool,
+ gpointer data,
+- GError **error);
++ GError **error);;
+
+ /* Set the number of threads, which can run concurrently for that pool, -1
+ * means no limit. 0 means has the effect, that the pool won't process
+ * requests until the limit is set higher again */
+-void g_thread_pool_set_max_threads (GThreadPool *pool,
++GLIB_FUNC void g_thread_pool_set_max_threads (GThreadPool *pool,
+ gint max_threads,
+- GError **error);
+-gint g_thread_pool_get_max_threads (GThreadPool *pool);
++ GError **error);;
++GLIB_FUNC gint g_thread_pool_get_max_threads (GThreadPool *pool);
+
+ /* Get the number of threads assigned to that pool. This number doesn't
+ * necessarily represent the number of working threads in that pool */
+-guint g_thread_pool_get_num_threads (GThreadPool *pool);
++GLIB_FUNC guint g_thread_pool_get_num_threads (GThreadPool *pool);
+
+ /* Get the number of unprocessed items in the pool */
+-guint g_thread_pool_unprocessed (GThreadPool *pool);
++GLIB_FUNC guint g_thread_pool_unprocessed (GThreadPool *pool);
+
+ /* Free the pool, immediate means, that all unprocessed items in the queue
+ * wont be processed, wait means, that the function doesn't return immediatly,
+ * but after all threads in the pool are ready processing items. immediate
+ * does however not mean, that threads are killed. */
+-void g_thread_pool_free (GThreadPool *pool,
++GLIB_FUNC void g_thread_pool_free (GThreadPool *pool,
+ gboolean immediate,
+- gboolean wait);
++ gboolean wait);;
+
+ /* Set the maximal number of unused threads before threads will be stopped by
+ * GLib, -1 means no limit */
+-void g_thread_pool_set_max_unused_threads (gint max_threads);
+-gint g_thread_pool_get_max_unused_threads (void);
+-guint g_thread_pool_get_num_unused_threads (void);
++GLIB_FUNC void g_thread_pool_set_max_unused_threads (gint max_threads);
++GLIB_FUNC gint g_thread_pool_get_max_unused_threads (void);
++GLIB_FUNC guint g_thread_pool_get_num_unused_threads (void);
+
+ /* Stop all currently unused threads, but leave the limit untouched */
+-void g_thread_pool_stop_unused_threads (void);
++GLIB_FUNC void g_thread_pool_stop_unused_threads (void);
+
+ G_END_DECLS
+
+--- glib-2.4.6/glib/gtimer.h~visibility.patch
++++ glib-2.4.6/glib/gtimer.h
+@@ -39,19 +39,19 @@
+
+ #define G_USEC_PER_SEC 1000000
+
+-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);
++GLIB_FUNC GTimer* g_timer_new (void);
++GLIB_FUNC void g_timer_destroy (GTimer *timer);
++GLIB_FUNC void g_timer_start (GTimer *timer);
++GLIB_FUNC void g_timer_stop (GTimer *timer);
++GLIB_FUNC void g_timer_reset (GTimer *timer);
++GLIB_FUNC void g_timer_continue (GTimer *timer);
++GLIB_FUNC gdouble g_timer_elapsed (GTimer *timer,
++ gulong *microseconds);;
+
+-void g_usleep (gulong microseconds);
++GLIB_FUNC void g_usleep (gulong microseconds);
+
+-void g_time_val_add (GTimeVal *time_,
+- glong microseconds);
++GLIB_FUNC void g_time_val_add (GTimeVal *time_,
++ glong microseconds);;
+
+ G_END_DECLS
+
+--- glib-2.4.6/glib/gtree.h~visibility.patch
++++ glib-2.4.6/glib/gtree.h
+@@ -39,46 +39,46 @@
+
+ /* Balanced binary trees
+ */
+-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,
++GLIB_FUNC GTree* g_tree_new (GCompareFunc key_compare_func);
++GLIB_FUNC GTree* g_tree_new_with_data (GCompareDataFunc key_compare_func,
++ gpointer key_compare_data);;
++GLIB_FUNC 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,
++ GDestroyNotify value_destroy_func);;
++GLIB_FUNC void g_tree_destroy (GTree *tree);
++GLIB_FUNC void g_tree_insert (GTree *tree,
+ gpointer key,
+- gpointer value);
+-void g_tree_replace (GTree *tree,
++ gpointer value);;
++GLIB_FUNC void g_tree_replace (GTree *tree,
+ gpointer key,
+- gpointer value);
+-void g_tree_remove (GTree *tree,
+- gconstpointer key);
+-void g_tree_steal (GTree *tree,
+- gconstpointer key);
+-gpointer g_tree_lookup (GTree *tree,
+- gconstpointer key);
+-gboolean g_tree_lookup_extended (GTree *tree,
++ gpointer value);;
++GLIB_FUNC void g_tree_remove (GTree *tree,
++ gconstpointer key);;
++GLIB_FUNC void g_tree_steal (GTree *tree,
++ gconstpointer key);;
++GLIB_FUNC gpointer g_tree_lookup (GTree *tree,
++ gconstpointer key);;
++GLIB_FUNC gboolean g_tree_lookup_extended (GTree *tree,
+ gconstpointer lookup_key,
+ gpointer *orig_key,
+- gpointer *value);
+-void g_tree_foreach (GTree *tree,
++ gpointer *value);;
++GLIB_FUNC void g_tree_foreach (GTree *tree,
+ GTraverseFunc func,
+- gpointer user_data);
++ gpointer user_data);;
+
+ #ifndef G_DISABLE_DEPRECATED
+-void g_tree_traverse (GTree *tree,
++GLIB_FUNC void g_tree_traverse (GTree *tree,
+ GTraverseFunc traverse_func,
+ GTraverseType traverse_type,
+- gpointer user_data);
++ gpointer user_data);;
+ #endif /* G_DISABLE_DEPRECATED */
+
+-gpointer g_tree_search (GTree *tree,
++GLIB_FUNC gpointer g_tree_search (GTree *tree,
+ GCompareFunc search_func,
+- gconstpointer user_data);
+-gint g_tree_height (GTree *tree);
+-gint g_tree_nnodes (GTree *tree);
++ gconstpointer user_data);;
++GLIB_FUNC gint g_tree_height (GTree *tree);
++GLIB_FUNC gint g_tree_nnodes (GTree *tree);
+
+
+
+--- glib-2.4.6/glib/gtypes.h~visibility.patch
++++ glib-2.4.6/glib/gtypes.h
+@@ -411,9 +411,42 @@
+ # endif /* !GLIB_COMPILATION */
+ # endif /* !GLIB_STATIC_COMPILATION */
+ # else /* !G_PLATFORM_WIN32 */
+-# define GLIB_VAR extern
++# ifdef GLIB_STATIC_COMPILATION
++# define GLIB_VAR extern
++# else /* !GLIB_STATIC_COMPILATION */
++# ifdef GLIB_COMPILATION
++# ifdef GCC_HASCLASSVISIBILITY
++# define GLIB_VAR __attribute__ ((visibility("default")))
++# endif /* !GCC_HASCLASSVISIBILITY */
++# endif /* !GLIB_COMPILATION */
++# endif /* !GLIB_STATIC_COMPILATION */
++# ifndef GLIB_VAR
++# define GLIB_VAR extern
++# endif /* !GLIB_VAR */
+ # endif /* !G_PLATFORM_WIN32 */
+ #endif /* GLIB_VAR */
++#ifndef GLIB_FUNC
++# ifdef G_PLATFORM_WIN32
++# ifndef GLIB_STATIC_COMPILATION
++# ifdef GLIB_COMPILATION
++# define GLIB_FUNC __declspec(dllexport)
++# else /* !GLIB_COMPILATION */
++# define GLIB_FUNC __declspec(dllimport)
++# endif /* !GLIB_COMPILATION */
++# endif /* !GLIB_STATIC_COMPILATION */
++# else /* !G_PLATFORM_WIN32 */
++# ifndef GLIB_STATIC_COMPILATION
++# ifdef GLIB_COMPILATION
++# ifdef GCC_HASCLASSVISIBILITY
++# define GLIB_FUNC __attribute__ ((visibility("default")))
++# endif /* !GCC_HASCLASSVISIBILITY */
++# endif /* !GLIB_COMPILATION */
++# endif /* !GLIB_STATIC_COMPILATION */
++# ifndef GLIB_FUNC
++# define GLIB_FUNC
++# endif /* !GLIB_FUNC */
++# endif /* !G_PLATFORM_WIN32 */
++#endif /* GLIB_FUNC */
+
+ #endif /* __G_TYPES_H__ */
+
+--- glib-2.4.6/glib/gunicode.h~visibility.patch
++++ glib-2.4.6/glib/gunicode.h
+@@ -111,55 +111,55 @@
+ * in case the locale's charset will be changed later using setlocale()
+ * or in some other way.
+ */
+-gboolean g_get_charset (G_CONST_RETURN char **charset);
++GLIB_FUNC gboolean g_get_charset (G_CONST_RETURN char **charset);
+
+ /* These are all analogs of the <ctype.h> functions.
+ */
+-gboolean g_unichar_isalnum (gunichar c) G_GNUC_CONST;
+-gboolean g_unichar_isalpha (gunichar c) G_GNUC_CONST;
+-gboolean g_unichar_iscntrl (gunichar c) G_GNUC_CONST;
+-gboolean g_unichar_isdigit (gunichar c) G_GNUC_CONST;
+-gboolean g_unichar_isgraph (gunichar c) G_GNUC_CONST;
+-gboolean g_unichar_islower (gunichar c) G_GNUC_CONST;
+-gboolean g_unichar_isprint (gunichar c) G_GNUC_CONST;
+-gboolean g_unichar_ispunct (gunichar c) G_GNUC_CONST;
+-gboolean g_unichar_isspace (gunichar c) G_GNUC_CONST;
+-gboolean g_unichar_isupper (gunichar c) G_GNUC_CONST;
+-gboolean g_unichar_isxdigit (gunichar c) G_GNUC_CONST;
+-gboolean g_unichar_istitle (gunichar c) G_GNUC_CONST;
+-gboolean g_unichar_isdefined (gunichar c) G_GNUC_CONST;
+-gboolean g_unichar_iswide (gunichar c) G_GNUC_CONST;
++GLIB_FUNC gboolean g_unichar_isalnum (gunichar c) G_GNUC_CONST;;
++GLIB_FUNC gboolean g_unichar_isalpha (gunichar c) G_GNUC_CONST;;
++GLIB_FUNC gboolean g_unichar_iscntrl (gunichar c) G_GNUC_CONST;;
++GLIB_FUNC gboolean g_unichar_isdigit (gunichar c) G_GNUC_CONST;;
++GLIB_FUNC gboolean g_unichar_isgraph (gunichar c) G_GNUC_CONST;;
++GLIB_FUNC gboolean g_unichar_islower (gunichar c) G_GNUC_CONST;;
++GLIB_FUNC gboolean g_unichar_isprint (gunichar c) G_GNUC_CONST;;
++GLIB_FUNC gboolean g_unichar_ispunct (gunichar c) G_GNUC_CONST;;
++GLIB_FUNC gboolean g_unichar_isspace (gunichar c) G_GNUC_CONST;;
++GLIB_FUNC gboolean g_unichar_isupper (gunichar c) G_GNUC_CONST;;
++GLIB_FUNC gboolean g_unichar_isxdigit (gunichar c) G_GNUC_CONST;;
++GLIB_FUNC gboolean g_unichar_istitle (gunichar c) G_GNUC_CONST;;
++GLIB_FUNC gboolean g_unichar_isdefined (gunichar c) G_GNUC_CONST;;
++GLIB_FUNC gboolean g_unichar_iswide (gunichar c) G_GNUC_CONST;;
+
+ /* More <ctype.h> functions. These convert between the three cases.
+ * See the Unicode book to understand title case. */
+-gunichar g_unichar_toupper (gunichar c) G_GNUC_CONST;
+-gunichar g_unichar_tolower (gunichar c) G_GNUC_CONST;
+-gunichar g_unichar_totitle (gunichar c) G_GNUC_CONST;
++GLIB_FUNC gunichar g_unichar_toupper (gunichar c) G_GNUC_CONST;;
++GLIB_FUNC gunichar g_unichar_tolower (gunichar c) G_GNUC_CONST;;
++GLIB_FUNC gunichar g_unichar_totitle (gunichar c) G_GNUC_CONST;;
+
+ /* If C is a digit (according to `g_unichar_isdigit'), then return its
+ numeric value. Otherwise return -1. */
+-gint g_unichar_digit_value (gunichar c) G_GNUC_CONST;
++GLIB_FUNC gint g_unichar_digit_value (gunichar c) G_GNUC_CONST;;
+
+-gint g_unichar_xdigit_value (gunichar c) G_GNUC_CONST;
++GLIB_FUNC gint g_unichar_xdigit_value (gunichar c) G_GNUC_CONST;;
+
+ /* Return the Unicode character type of a given character. */
+-GUnicodeType g_unichar_type (gunichar c) G_GNUC_CONST;
++GLIB_FUNC GUnicodeType g_unichar_type (gunichar c) G_GNUC_CONST;;
+
+ /* Return the line break property for a given character */
+-GUnicodeBreakType g_unichar_break_type (gunichar c) G_GNUC_CONST;
++GLIB_FUNC GUnicodeBreakType g_unichar_break_type (gunichar c) G_GNUC_CONST;;
+
+
+ /* Compute canonical ordering of a string in-place. This rearranges
+ decomposed characters in the string according to their combining
+ classes. See the Unicode manual for more information. */
+-void g_unicode_canonical_ordering (gunichar *string,
+- gsize len);
++GLIB_FUNC void g_unicode_canonical_ordering (gunichar *string,
++ gsize len);;
+
+ /* Compute canonical decomposition of a character. Returns g_malloc()d
+ string of Unicode characters. RESULT_LEN is set to the resulting
+ length of the string. */
+-gunichar *g_unicode_canonical_decomposition (gunichar ch,
+- gsize *result_len);
++GLIB_FUNC gunichar *g_unicode_canonical_decomposition (gunichar ch,
++ gsize *result_len);;
+
+ /* Array of skip-bytes-per-initial character.
+ */
+@@ -167,97 +167,97 @@
+
+ #define g_utf8_next_char(p) (char *)((p) + g_utf8_skip[*(guchar *)(p)])
+
+-gunichar g_utf8_get_char (const gchar *p);
+-gunichar g_utf8_get_char_validated (const gchar *p,
+- gssize max_len);
++GLIB_FUNC gunichar g_utf8_get_char (const gchar *p);
++GLIB_FUNC 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);
++GLIB_FUNC gchar* g_utf8_offset_to_pointer (const gchar *str,
++ glong offset);;
++GLIB_FUNC glong g_utf8_pointer_to_offset (const gchar *str,
++ const gchar *pos);;
++GLIB_FUNC gchar* g_utf8_prev_char (const gchar *p);
++GLIB_FUNC gchar* g_utf8_find_next_char (const gchar *p,
++ const gchar *end);;
++GLIB_FUNC gchar* g_utf8_find_prev_char (const gchar *str,
++ const gchar *p);;
+
+-glong g_utf8_strlen (const gchar *p,
+- gssize max);
++GLIB_FUNC glong g_utf8_strlen (const gchar *p,
++ gssize max);;
+
+ /* Copies n characters from src to dest */
+-gchar* g_utf8_strncpy (gchar *dest,
++GLIB_FUNC gchar* g_utf8_strncpy (gchar *dest,
+ const gchar *src,
+- gsize n);
++ gsize n);;
+
+ /* Find the UTF-8 character corresponding to ch, in string p. These
+ functions are equivalants to strchr and strrchr */
+-gchar* g_utf8_strchr (const gchar *p,
++GLIB_FUNC gchar* g_utf8_strchr (const gchar *p,
+ gssize len,
+- gunichar c);
+-gchar* g_utf8_strrchr (const gchar *p,
++ gunichar c);;
++GLIB_FUNC gchar* g_utf8_strrchr (const gchar *p,
+ gssize len,
+- gunichar c);
+-gchar* g_utf8_strreverse (const gchar *str,
+- gssize len);
++ gunichar c);;
++GLIB_FUNC gchar* g_utf8_strreverse (const gchar *str,
++ gssize len);;
+
+-gunichar2 *g_utf8_to_utf16 (const gchar *str,
++GLIB_FUNC gunichar2 *g_utf8_to_utf16 (const gchar *str,
+ glong len,
+ glong *items_read,
+ glong *items_written,
+- GError **error);
+-gunichar * g_utf8_to_ucs4 (const gchar *str,
++ GError **error);;
++GLIB_FUNC gunichar * g_utf8_to_ucs4 (const gchar *str,
+ glong len,
+ glong *items_read,
+ glong *items_written,
+- GError **error);
+-gunichar * g_utf8_to_ucs4_fast (const gchar *str,
++ GError **error);;
++GLIB_FUNC gunichar * g_utf8_to_ucs4_fast (const gchar *str,
+ glong len,
+- glong *items_written);
+-gunichar * g_utf16_to_ucs4 (const gunichar2 *str,
++ glong *items_written);;
++GLIB_FUNC gunichar * g_utf16_to_ucs4 (const gunichar2 *str,
+ glong len,
+ glong *items_read,
+ glong *items_written,
+- GError **error);
+-gchar* g_utf16_to_utf8 (const gunichar2 *str,
++ GError **error);;
++GLIB_FUNC gchar* g_utf16_to_utf8 (const gunichar2 *str,
+ glong len,
+ glong *items_read,
+ glong *items_written,
+- GError **error);
+-gunichar2 *g_ucs4_to_utf16 (const gunichar *str,
++ GError **error);;
++GLIB_FUNC gunichar2 *g_ucs4_to_utf16 (const gunichar *str,
+ glong len,
+ glong *items_read,
+ glong *items_written,
+- GError **error);
+-gchar* g_ucs4_to_utf8 (const gunichar *str,
++ GError **error);;
++GLIB_FUNC gchar* g_ucs4_to_utf8 (const gunichar *str,
+ glong len,
+ glong *items_read,
+ glong *items_written,
+- GError **error);
++ GError **error);;
+
+ /* Convert a single character into UTF-8. outbuf must have at
+ * least 6 bytes of space. Returns the number of bytes in the
+ * result.
+ */
+-gint g_unichar_to_utf8 (gunichar c,
+- gchar *outbuf);
++GLIB_FUNC gint g_unichar_to_utf8 (gunichar c,
++ gchar *outbuf);;
+
+ /* Validate a UTF8 string, return TRUE if valid, put pointer to
+ * first invalid char in **end
+ */
+
+-gboolean g_utf8_validate (const gchar *str,
++GLIB_FUNC gboolean g_utf8_validate (const gchar *str,
+ gssize max_len,
+- const gchar **end);
++ const gchar **end);;
+
+ /* Validate a Unicode character */
+-gboolean g_unichar_validate (gunichar ch);
++GLIB_FUNC gboolean g_unichar_validate (gunichar ch);
+
+-gchar *g_utf8_strup (const gchar *str,
+- gssize len);
+-gchar *g_utf8_strdown (const gchar *str,
+- gssize len);
+-gchar *g_utf8_casefold (const gchar *str,
+- gssize len);
++GLIB_FUNC gchar *g_utf8_strup (const gchar *str,
++ gssize len);;
++GLIB_FUNC gchar *g_utf8_strdown (const gchar *str,
++ gssize len);;
++GLIB_FUNC gchar *g_utf8_casefold (const gchar *str,
++ gssize len);;
+
+ typedef enum {
+ G_NORMALIZE_DEFAULT,
+@@ -270,17 +270,17 @@
+ G_NORMALIZE_NFKC = G_NORMALIZE_ALL_COMPOSE
+ } GNormalizeMode;
+
+-gchar *g_utf8_normalize (const gchar *str,
++GLIB_FUNC gchar *g_utf8_normalize (const gchar *str,
+ gssize len,
+- GNormalizeMode mode);
++ GNormalizeMode mode);;
+
+-gint g_utf8_collate (const gchar *str1,
+- const gchar *str2);
+-gchar *g_utf8_collate_key (const gchar *str,
+- gssize len);
++GLIB_FUNC gint g_utf8_collate (const gchar *str1,
++ const gchar *str2);;
++GLIB_FUNC gchar *g_utf8_collate_key (const gchar *str,
++ gssize len);;
+
+-gboolean g_unichar_get_mirror_char (gunichar ch,
+- gunichar *mirrored_ch);
++GLIB_FUNC gboolean g_unichar_get_mirror_char (gunichar ch,
++ gunichar *mirrored_ch);;
+
+ G_END_DECLS
+
+--- glib-2.4.6/glib/gutils.h~visibility.patch
++++ glib-2.4.6/glib/gutils.h
+@@ -113,14 +113,14 @@
+
+ /* Retrive static string info
+ */
+-G_CONST_RETURN gchar* g_get_user_name (void);
+-G_CONST_RETURN gchar* g_get_real_name (void);
+-G_CONST_RETURN gchar* g_get_home_dir (void);
+-G_CONST_RETURN gchar* g_get_tmp_dir (void);
+-gchar* g_get_prgname (void);
+-void g_set_prgname (const gchar *prgname);
+-G_CONST_RETURN gchar* g_get_application_name (void);
+-void g_set_application_name (const gchar *application_name);
++GLIB_FUNC G_CONST_RETURN gchar* g_get_user_name (void);
++GLIB_FUNC G_CONST_RETURN gchar* g_get_real_name (void);
++GLIB_FUNC G_CONST_RETURN gchar* g_get_home_dir (void);
++GLIB_FUNC G_CONST_RETURN gchar* g_get_tmp_dir (void);
++GLIB_FUNC gchar* g_get_prgname (void);
++GLIB_FUNC void g_set_prgname (const gchar *prgname);
++GLIB_FUNC G_CONST_RETURN gchar* g_get_application_name (void);
++GLIB_FUNC void g_set_application_name (const gchar *application_name);
+
+
+ typedef struct _GDebugKey GDebugKey;
+@@ -132,24 +132,24 @@
+
+ /* Miscellaneous utility functions
+ */
+-guint g_parse_debug_string (const gchar *string,
++GLIB_FUNC guint g_parse_debug_string (const gchar *string,
+ const GDebugKey *keys,
+- guint nkeys);
++ guint nkeys);;
+
+-gint g_snprintf (gchar *string,
++GLIB_FUNC gint g_snprintf (gchar *string,
+ gulong n,
+ gchar const *format,
+- ...) G_GNUC_PRINTF (3, 4);
+-gint g_vsnprintf (gchar *string,
++ ...) G_GNUC_PRINTF (3, 4);;
++GLIB_FUNC gint g_vsnprintf (gchar *string,
+ gulong n,
+ gchar const *format,
+- va_list args);
++ va_list args);;
+
+ /* Check if a file name is an absolute path */
+-gboolean g_path_is_absolute (const gchar *file_name);
++GLIB_FUNC gboolean g_path_is_absolute (const gchar *file_name);
+
+ /* In case of absolute paths, skip the root part */
+-G_CONST_RETURN gchar* g_path_skip_root (const gchar *file_name);
++GLIB_FUNC G_CONST_RETURN gchar* g_path_skip_root (const gchar *file_name);
+
+ #ifndef G_DISABLE_DEPRECATED
+
+@@ -157,27 +157,27 @@
+ * major release of GLib. Use g_path_get_dirname/g_path_get_basename
+ * instead. Whatch out! The string returned by g_path_get_basename
+ * must be g_freed, while the string returned by g_basename must not.*/
+-G_CONST_RETURN gchar* g_basename (const gchar *file_name);
++GLIB_FUNC G_CONST_RETURN gchar* g_basename (const gchar *file_name);
+ #define g_dirname g_path_get_dirname
+
+ #endif /* G_DISABLE_DEPRECATED */
+
+ /* The returned strings are newly allocated with g_malloc() */
+-gchar* g_get_current_dir (void);
+-gchar* g_path_get_basename (const gchar *file_name);
+-gchar* g_path_get_dirname (const gchar *file_name);
++GLIB_FUNC gchar* g_get_current_dir (void);
++GLIB_FUNC gchar* g_path_get_basename (const gchar *file_name);
++GLIB_FUNC gchar* g_path_get_dirname (const gchar *file_name);
+
+
+ /* Set the pointer at the specified location to NULL */
+-void g_nullify_pointer (gpointer *nullify_location);
++GLIB_FUNC void g_nullify_pointer (gpointer *nullify_location);
+
+ /* return the environment string for the variable. The returned memory
+ * must not be freed. */
+-G_CONST_RETURN gchar* g_getenv (const gchar *variable);
+-gboolean g_setenv (const gchar *variable,
++GLIB_FUNC G_CONST_RETURN gchar* g_getenv (const gchar *variable);
++GLIB_FUNC gboolean g_setenv (const gchar *variable,
+ const gchar *value,
+- gboolean overwrite);
+-void g_unsetenv (const gchar *variable);
++ gboolean overwrite);;
++GLIB_FUNC void g_unsetenv (const gchar *variable);
+
+
+ /* we try to provide a usefull equivalent for ATEXIT if it is
+@@ -195,18 +195,18 @@
+ * (if there is any in the implementation) and doesn't encounter
+ * missing include files.
+ */
+-void g_atexit (GVoidFunc func);
++GLIB_FUNC void g_atexit (GVoidFunc func);
+
+ /* Look for an executable in PATH, following execvp() rules */
+-gchar* g_find_program_in_path (const gchar *program);
++GLIB_FUNC gchar* g_find_program_in_path (const gchar *program);
+
+ /* Bit tests
+ */
+-G_INLINE_FUNC gint g_bit_nth_lsf (gulong mask,
+- gint nth_bit);
+-G_INLINE_FUNC gint g_bit_nth_msf (gulong mask,
+- gint nth_bit);
+-G_INLINE_FUNC guint g_bit_storage (gulong number);
++GLIB_FUNC G_INLINE_FUNC gint g_bit_nth_lsf (gulong mask,
++ gint nth_bit);;
++GLIB_FUNC G_INLINE_FUNC gint g_bit_nth_msf (gulong mask,
++ gint nth_bit);;
++GLIB_FUNC G_INLINE_FUNC guint g_bit_storage (gulong number);
+
+ /* Trash Stacks
+ * elements need to be >= sizeof (gpointer)
+@@ -217,11 +217,11 @@
+ GTrashStack *next;
+ };
+
+-G_INLINE_FUNC void g_trash_stack_push (GTrashStack **stack_p,
+- gpointer data_p);
+-G_INLINE_FUNC gpointer g_trash_stack_pop (GTrashStack **stack_p);
+-G_INLINE_FUNC gpointer g_trash_stack_peek (GTrashStack **stack_p);
+-G_INLINE_FUNC guint g_trash_stack_height (GTrashStack **stack_p);
++GLIB_FUNC G_INLINE_FUNC void g_trash_stack_push (GTrashStack **stack_p,
++ gpointer data_p);;
++GLIB_FUNC G_INLINE_FUNC gpointer g_trash_stack_pop (GTrashStack **stack_p);
++GLIB_FUNC G_INLINE_FUNC gpointer g_trash_stack_peek (GTrashStack **stack_p);
++GLIB_FUNC G_INLINE_FUNC guint g_trash_stack_height (GTrashStack **stack_p);
+
+ /* inline function implementations
+ */
+--- glib-2.4.6/glib/gwin32.h~visibility.patch
++++ glib-2.4.6/glib/gwin32.h
+@@ -68,8 +68,8 @@
+ */
+ # define ftruncate(fd, size) g_win32_ftruncate (fd, size)
+
+-gint g_win32_ftruncate (gint f,
+- guint size);
++GLIB_FUNC gint g_win32_ftruncate (gint f,
++ guint size);;
+ #endif /* G_OS_WIN32 */
+
+ /* The MS setlocale uses locale names of the form "English_United
+@@ -78,20 +78,20 @@
+ * returns it as a string of the above form for use in forming file
+ * names etc. The returned string should be deallocated with g_free().
+ */
+-gchar* g_win32_getlocale (void);
++GLIB_FUNC gchar* g_win32_getlocale (void);
+
+ /* Translate a Win32 error code (as returned by GetLastError()) into
+ * the corresponding message. The returned string should be deallocated
+ * with g_free().
+ */
+-gchar* g_win32_error_message (gint error);
++GLIB_FUNC gchar* g_win32_error_message (gint error);
+
+-gchar* g_win32_get_package_installation_directory (gchar *package,
+- gchar *dll_name);
++GLIB_FUNC gchar* g_win32_get_package_installation_directory (gchar *package,
++ gchar *dll_name);;
+
+-gchar* g_win32_get_package_installation_subdirectory (gchar *package,
++GLIB_FUNC gchar* g_win32_get_package_installation_subdirectory (gchar *package,
+ gchar *dll_name,
+- gchar *subdir);
++ gchar *subdir);;
+
+ G_END_DECLS
+
+--- glib-2.4.6/gmodule/gmodule.def~visibility.patch
++++ glib-2.4.6/gmodule/gmodule.def
+@@ -1,4 +1,3 @@
+-EXPORTS
+ g_module_build_path
+ g_module_close
+ g_module_error
+--- glib-2.4.6/gmodule/gmodule.h~visibility.patch
++++ glib-2.4.6/gmodule/gmodule.h
+@@ -38,9 +38,35 @@
+ #ifdef G_PLATFORM_WIN32
+ # define G_MODULE_EXPORT __declspec(dllexport)
+ #else /* !G_PLATFORM_WIN32 */
+-# define G_MODULE_EXPORT
++# ifdef GCC_HASCLASSVISIBILITY
++# define G_MODULE_EXPORT __attribute__ ((visibility("default")))
++# else /* !GCC_HASCLASSVISIBILITY */
++# define G_MODULE_EXPORT
++# endif /* !GCC_HASCLASSVISIBILITY */
+ #endif /* !G_PLATFORM_WIN32 */
+
++#ifndef GMODULE_FUNC
++# ifdef G_PLATFORM_WIN32
++# ifndef GMODULE_STATIC_COMPILATION
++# ifdef GMODULE_COMPILATION
++# define GMODULE_FUNC __declspec(dllexport)
++# else /* !GMODULE_COMPILATION */
++# define GMODULE_FUNC __declspec(dllimport)
++# endif /* !GMODULE_COMPILATION */
++# endif /* !GMODULE_STATIC_COMPILATION */
++# else /* !G_PLATFORM_WIN32 */
++# ifndef GMODULE_STATIC_COMPILATION
++# ifdef GMODULE_COMPILATION
++# ifdef GCC_HASCLASSVISIBILITY
++# define GMODULE_FUNC __attribute__ ((visibility("default")))
++# endif
++# endif /* !GMODULE_COMPILATION */
++# endif /* !GMODULE_STATIC_COMPILATION */
++# ifndef GMODULE_FUNC
++# define GMODULE_FUNC
++# endif /* !GMODULE_FUNC */
++# endif /* !G_PLATFORM_WIN32 */
++#endif /* GMODULE_FUNC */
+ typedef enum
+ {
+ G_MODULE_BIND_LAZY = 1 << 0,
+@@ -53,28 +79,28 @@
+ typedef void (*GModuleUnload) (GModule *module);
+
+ /* return TRUE if dynamic module loading is supported */
+-gboolean g_module_supported (void) G_GNUC_CONST;
++GMODULE_FUNC gboolean g_module_supported (void) G_GNUC_CONST;
+
+ /* open a module `file_name' and return handle, which is NULL on error */
+-GModule* g_module_open (const gchar *file_name,
++GMODULE_FUNC GModule* g_module_open (const gchar *file_name,
+ GModuleFlags flags);
+
+ /* close a previously opened module, returns TRUE on success */
+-gboolean g_module_close (GModule *module);
++GMODULE_FUNC gboolean g_module_close (GModule *module);
+
+ /* make a module resident so g_module_close on it will be ignored */
+-void g_module_make_resident (GModule *module);
++GMODULE_FUNC void g_module_make_resident (GModule *module);
+
+ /* query the last module error as a string */
+-G_CONST_RETURN gchar* g_module_error (void);
++GMODULE_FUNC G_CONST_RETURN gchar* g_module_error (void);
+
+ /* retrieve a symbol pointer from `module', returns TRUE on success */
+-gboolean g_module_symbol (GModule *module,
++GMODULE_FUNC gboolean g_module_symbol (GModule *module,
+ const gchar *symbol_name,
+ gpointer *symbol);
+
+ /* retrieve the file name from an existing module */
+-G_CONST_RETURN gchar* g_module_name (GModule *module);
++GMODULE_FUNC G_CONST_RETURN gchar* g_module_name (GModule *module);
+
+ /* Build the actual file name containing a module. `directory' is the
+ * directory where the module file is supposed to be, or NULL or empty
+@@ -87,7 +113,7 @@
+ *
+ * No checks are made that the file exists, or is of correct type.
+ */
+-gchar* g_module_build_path (const gchar *directory,
++GMODULE_FUNC gchar* g_module_build_path (const gchar *directory,
+ const gchar *module_name);
+
+
+--- glib-2.4.6/gmodule/Makefile.am~visibility.patch
++++ glib-2.4.6/gmodule/Makefile.am
+@@ -1,7 +1,9 @@
+ ## Process this file with automake to produce Makefile.in
+
+ INCLUDES = -I$(top_srcdir) -I$(top_srcdir)/glib -I$(top_srcdir)/gmodule \
+- -DG_LOG_DOMAIN=\"GModule\" @GLIB_DEBUG_FLAGS@ -DG_DISABLE_DEPRECATED
++ -DG_LOG_DOMAIN=\"GModule\" @GLIB_DEBUG_FLAGS@ \
++ -DG_DISABLE_DEPRECATED \
++ -DGMODULE_COMPILATION
+
+ EXTRA_DIST = \
+ makefile.msc.in \
+--- glib-2.4.6/gobject/gboxed.h~visibility.patch
++++ glib-2.4.6/gobject/gboxed.h
+@@ -38,22 +38,22 @@
+
+
+ /* --- prototypes --- */
+-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);
++GOBJECT_FUNC gpointer g_boxed_copy (GType boxed_type,
++ gconstpointer src_boxed);;
++GOBJECT_FUNC void g_boxed_free (GType boxed_type,
++ gpointer boxed);;
++GOBJECT_FUNC void g_value_set_boxed (GValue *value,
++ gconstpointer v_boxed);;
++GOBJECT_FUNC void g_value_set_static_boxed (GValue *value,
++ gconstpointer v_boxed);;
++GOBJECT_FUNC gpointer g_value_get_boxed (const GValue *value);;
++GOBJECT_FUNC gpointer g_value_dup_boxed (const GValue *value);;
+
+
+ /* --- convenience --- */
+-GType g_boxed_type_register_static (const gchar *name,
++GOBJECT_FUNC GType g_boxed_type_register_static (const gchar *name,
+ GBoxedCopyFunc boxed_copy,
+- GBoxedFreeFunc boxed_free);
++ GBoxedFreeFunc boxed_free);;
+
+
+ /* --- GLib boxed types --- */
+@@ -64,17 +64,17 @@
+ #define G_TYPE_GSTRING (g_gstring_get_type ())
+
+
+-void g_value_take_boxed (GValue *value,
+- gconstpointer v_boxed);
++GOBJECT_FUNC void g_value_take_boxed (GValue *value,
++ gconstpointer v_boxed);;
+ #ifndef G_DISABLE_DEPRECATED
+-void g_value_set_boxed_take_ownership (GValue *value,
+- gconstpointer v_boxed);
++GOBJECT_FUNC void g_value_set_boxed_take_ownership (GValue *value,
++ gconstpointer v_boxed);;
+ #endif
+-GType g_closure_get_type (void) G_GNUC_CONST;
+-GType g_value_get_type (void) G_GNUC_CONST;
+-GType g_value_array_get_type (void) G_GNUC_CONST;
+-GType g_strv_get_type (void) G_GNUC_CONST;
+-GType g_gstring_get_type (void) G_GNUC_CONST;
++GOBJECT_FUNC GType g_closure_get_type (void) G_GNUC_CONST;
++GOBJECT_FUNC GType g_value_get_type (void) G_GNUC_CONST;
++GOBJECT_FUNC GType g_value_array_get_type (void) G_GNUC_CONST;
++GOBJECT_FUNC GType g_strv_get_type (void) G_GNUC_CONST;
++GOBJECT_FUNC GType g_gstring_get_type (void) G_GNUC_CONST;
+
+ typedef gchar** GStrv;
+
+--- glib-2.4.6/gobject/gclosure.h~visibility.patch
++++ glib-2.4.6/gobject/gclosure.h
+@@ -100,51 +100,51 @@
+
+
+ /* --- prototypes --- */
+-GClosure* g_cclosure_new (GCallback callback_func,
++GOBJECT_FUNC GClosure* g_cclosure_new (GCallback callback_func,
+ gpointer user_data,
+- GClosureNotify destroy_data);
+-GClosure* g_cclosure_new_swap (GCallback callback_func,
++ GClosureNotify destroy_data);;
++GOBJECT_FUNC 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);
++ GClosureNotify destroy_data);;
++GOBJECT_FUNC GClosure* g_signal_type_cclosure_new (GType itype,
++ guint struct_offset);;
+
+
+ /* --- prototypes --- */
+-GClosure* g_closure_ref (GClosure *closure);
+-void g_closure_sink (GClosure *closure);
+-void g_closure_unref (GClosure *closure);
++GOBJECT_FUNC GClosure* g_closure_ref (GClosure *closure);;
++GOBJECT_FUNC void g_closure_sink (GClosure *closure);;
++GOBJECT_FUNC void g_closure_unref (GClosure *closure);;
+ /* intimidating */
+-GClosure* g_closure_new_simple (guint sizeof_closure,
+- gpointer data);
+-void g_closure_add_finalize_notifier (GClosure *closure,
++GOBJECT_FUNC GClosure* g_closure_new_simple (guint sizeof_closure,
++ gpointer data);;
++GOBJECT_FUNC void g_closure_add_finalize_notifier (GClosure *closure,
+ gpointer notify_data,
+- GClosureNotify notify_func);
+-void g_closure_remove_finalize_notifier (GClosure *closure,
++ GClosureNotify notify_func);;
++GOBJECT_FUNC void g_closure_remove_finalize_notifier (GClosure *closure,
+ gpointer notify_data,
+- GClosureNotify notify_func);
+-void g_closure_add_invalidate_notifier (GClosure *closure,
++ GClosureNotify notify_func);;
++GOBJECT_FUNC void g_closure_add_invalidate_notifier (GClosure *closure,
+ gpointer notify_data,
+- GClosureNotify notify_func);
+-void g_closure_remove_invalidate_notifier (GClosure *closure,
++ GClosureNotify notify_func);;
++GOBJECT_FUNC void g_closure_remove_invalidate_notifier (GClosure *closure,
+ gpointer notify_data,
+- GClosureNotify notify_func);
+-void g_closure_add_marshal_guards (GClosure *closure,
++ GClosureNotify notify_func);;
++GOBJECT_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,
++ GClosureNotify post_marshal_notify);;
++GOBJECT_FUNC void g_closure_set_marshal (GClosure *closure,
++ GClosureMarshal marshal);;
++GOBJECT_FUNC 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,
++ GClosureMarshal meta_marshal);;
++GOBJECT_FUNC void g_closure_invalidate (GClosure *closure);;
++GOBJECT_FUNC void g_closure_invoke (GClosure *closure,
+ GValue /*out*/ *return_value,
+ guint n_param_values,
+ const GValue *param_values,
+- gpointer invocation_hint);
++ gpointer invocation_hint);;
+
+ /* FIXME:
+ OK: data_object::destroy -> closure_invalidate();
+--- glib-2.4.6/gobject/genums.h~visibility.patch
++++ glib-2.4.6/gobject/genums.h
+@@ -81,24 +81,24 @@
+
+
+ /* --- prototypes --- */
+-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);
++GOBJECT_FUNC GEnumValue* g_enum_get_value (GEnumClass *enum_class,
++ gint value);;
++GOBJECT_FUNC GEnumValue* g_enum_get_value_by_name (GEnumClass *enum_class,
++ const gchar *name);;
++GOBJECT_FUNC GEnumValue* g_enum_get_value_by_nick (GEnumClass *enum_class,
++ const gchar *nick);;
++GOBJECT_FUNC GFlagsValue* g_flags_get_first_value (GFlagsClass *flags_class,
++ guint value);;
++GOBJECT_FUNC GFlagsValue* g_flags_get_value_by_name (GFlagsClass *flags_class,
++ const gchar *name);;
++GOBJECT_FUNC GFlagsValue* g_flags_get_value_by_nick (GFlagsClass *flags_class,
++ const gchar *nick);;
++GOBJECT_FUNC void g_value_set_enum (GValue *value,
++ gint v_enum);;
++GOBJECT_FUNC gint g_value_get_enum (const GValue *value);;
++GOBJECT_FUNC void g_value_set_flags (GValue *value,
++ guint v_flags);;
++GOBJECT_FUNC guint g_value_get_flags (const GValue *value);;
+
+
+
+@@ -106,19 +106,19 @@
+ /* const_static_values is a NULL terminated array of enum/flags
+ * values that is taken over!
+ */
+-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);
++GOBJECT_FUNC GType g_enum_register_static (const gchar *name,
++ const GEnumValue *const_static_values);;
++GOBJECT_FUNC GType g_flags_register_static (const gchar *name,
++ const GFlagsValue *const_static_values);;
+ /* functions to complete the type information
+ * for enums/flags implemented by plugins
+ */
+-void g_enum_complete_type_info (GType g_enum_type,
++GOBJECT_FUNC 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,
++ const GEnumValue *const_values);;
++GOBJECT_FUNC void g_flags_complete_type_info (GType g_flags_type,
+ GTypeInfo *info,
+- const GFlagsValue *const_values);
++ const GFlagsValue *const_values);;
+
+ G_END_DECLS
+
+--- glib-2.4.6/gobject/glib-genmarshal.c~visibility.patch
++++ glib-2.4.6/gobject/glib-genmarshal.c
+@@ -356,7 +356,7 @@
+ }
+ if (gen_cheader && !have_std_marshaller)
+ {
+- ind = g_fprintf (fout, "extern void ");
++ ind = g_fprintf (fout, "GOBJECT_FUNC extern void ");
+ ind += g_fprintf (fout, "%s_%s (", marshaller_prefix, signame);
+ g_fprintf (fout, "GClosure *closure,\n");
+ g_fprintf (fout, "%sGValue *return_value,\n", indent (ind));
+--- glib-2.4.6/gobject/gmarshal.c~visibility.patch
++++ glib-2.4.6/gobject/gmarshal.c
+@@ -45,7 +45,7 @@
+ #endif /* !G_ENABLE_DEBUG */
+
+
+-/* VOID:VOID (./gmarshal.list:26) */
++/* VOID:VOID (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:26) */
+ void
+ g_cclosure_marshal_VOID__VOID (GClosure *closure,
+ GValue *return_value,
+@@ -78,7 +78,7 @@
+ data2);
+ }
+
+-/* VOID:BOOLEAN (./gmarshal.list:27) */
++/* VOID:BOOLEAN (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:27) */
+ void
+ g_cclosure_marshal_VOID__BOOLEAN (GClosure *closure,
+ GValue *return_value,
+@@ -113,7 +113,7 @@
+ data2);
+ }
+
+-/* VOID:CHAR (./gmarshal.list:28) */
++/* VOID:CHAR (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:28) */
+ void
+ g_cclosure_marshal_VOID__CHAR (GClosure *closure,
+ GValue *return_value,
+@@ -148,7 +148,7 @@
+ data2);
+ }
+
+-/* VOID:UCHAR (./gmarshal.list:29) */
++/* VOID:UCHAR (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:29) */
+ void
+ g_cclosure_marshal_VOID__UCHAR (GClosure *closure,
+ GValue *return_value,
+@@ -183,7 +183,7 @@
+ data2);
+ }
+
+-/* VOID:INT (./gmarshal.list:30) */
++/* VOID:INT (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:30) */
+ void
+ g_cclosure_marshal_VOID__INT (GClosure *closure,
+ GValue *return_value,
+@@ -218,7 +218,7 @@
+ data2);
+ }
+
+-/* VOID:UINT (./gmarshal.list:31) */
++/* VOID:UINT (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:31) */
+ void
+ g_cclosure_marshal_VOID__UINT (GClosure *closure,
+ GValue *return_value,
+@@ -253,7 +253,7 @@
+ data2);
+ }
+
+-/* VOID:LONG (./gmarshal.list:32) */
++/* VOID:LONG (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:32) */
+ void
+ g_cclosure_marshal_VOID__LONG (GClosure *closure,
+ GValue *return_value,
+@@ -288,7 +288,7 @@
+ data2);
+ }
+
+-/* VOID:ULONG (./gmarshal.list:33) */
++/* VOID:ULONG (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:33) */
+ void
+ g_cclosure_marshal_VOID__ULONG (GClosure *closure,
+ GValue *return_value,
+@@ -323,7 +323,7 @@
+ data2);
+ }
+
+-/* VOID:ENUM (./gmarshal.list:34) */
++/* VOID:ENUM (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:34) */
+ void
+ g_cclosure_marshal_VOID__ENUM (GClosure *closure,
+ GValue *return_value,
+@@ -358,7 +358,7 @@
+ data2);
+ }
+
+-/* VOID:FLAGS (./gmarshal.list:35) */
++/* VOID:FLAGS (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:35) */
+ void
+ g_cclosure_marshal_VOID__FLAGS (GClosure *closure,
+ GValue *return_value,
+@@ -393,7 +393,7 @@
+ data2);
+ }
+
+-/* VOID:FLOAT (./gmarshal.list:36) */
++/* VOID:FLOAT (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:36) */
+ void
+ g_cclosure_marshal_VOID__FLOAT (GClosure *closure,
+ GValue *return_value,
+@@ -428,7 +428,7 @@
+ data2);
+ }
+
+-/* VOID:DOUBLE (./gmarshal.list:37) */
++/* VOID:DOUBLE (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:37) */
+ void
+ g_cclosure_marshal_VOID__DOUBLE (GClosure *closure,
+ GValue *return_value,
+@@ -463,7 +463,7 @@
+ data2);
+ }
+
+-/* VOID:STRING (./gmarshal.list:38) */
++/* VOID:STRING (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:38) */
+ void
+ g_cclosure_marshal_VOID__STRING (GClosure *closure,
+ GValue *return_value,
+@@ -498,7 +498,7 @@
+ data2);
+ }
+
+-/* VOID:PARAM (./gmarshal.list:39) */
++/* VOID:PARAM (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:39) */
+ void
+ g_cclosure_marshal_VOID__PARAM (GClosure *closure,
+ GValue *return_value,
+@@ -533,7 +533,7 @@
+ data2);
+ }
+
+-/* VOID:BOXED (./gmarshal.list:40) */
++/* VOID:BOXED (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:40) */
+ void
+ g_cclosure_marshal_VOID__BOXED (GClosure *closure,
+ GValue *return_value,
+@@ -568,7 +568,7 @@
+ data2);
+ }
+
+-/* VOID:POINTER (./gmarshal.list:41) */
++/* VOID:POINTER (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:41) */
+ void
+ g_cclosure_marshal_VOID__POINTER (GClosure *closure,
+ GValue *return_value,
+@@ -603,7 +603,7 @@
+ data2);
+ }
+
+-/* VOID:OBJECT (./gmarshal.list:42) */
++/* VOID:OBJECT (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:42) */
+ void
+ g_cclosure_marshal_VOID__OBJECT (GClosure *closure,
+ GValue *return_value,
+@@ -638,7 +638,7 @@
+ data2);
+ }
+
+-/* VOID:UINT,POINTER (./gmarshal.list:45) */
++/* VOID:UINT,POINTER (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:45) */
+ void
+ g_cclosure_marshal_VOID__UINT_POINTER (GClosure *closure,
+ GValue *return_value,
+@@ -675,7 +675,7 @@
+ data2);
+ }
+
+-/* BOOL:FLAGS (./gmarshal.list:46) */
++/* BOOL:FLAGS (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:46) */
+ void
+ g_cclosure_marshal_BOOLEAN__FLAGS (GClosure *closure,
+ GValue *return_value,
+@@ -714,7 +714,7 @@
+ g_value_set_boolean (return_value, v_return);
+ }
+
+-/* STRING:OBJECT,POINTER (./gmarshal.list:47) */
++/* STRING:OBJECT,POINTER (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:47) */
+ void
+ g_cclosure_marshal_STRING__OBJECT_POINTER (GClosure *closure,
+ GValue *return_value,
+--- glib-2.4.6/gobject/gmarshal.h~visibility.patch
++++ glib-2.4.6/gobject/gmarshal.h
+@@ -3,166 +3,166 @@
+
+ G_BEGIN_DECLS
+
+-/* VOID:VOID (./gmarshal.list:26) */
+-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);
++/* VOID:VOID (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:26) */
++GOBJECT_FUNC 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);
+
+-/* VOID:BOOLEAN (./gmarshal.list:27) */
+-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);
++/* VOID:BOOLEAN (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:27) */
++GOBJECT_FUNC 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);
+
+-/* VOID:CHAR (./gmarshal.list:28) */
+-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);
++/* VOID:CHAR (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:28) */
++GOBJECT_FUNC 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);
+
+-/* VOID:UCHAR (./gmarshal.list:29) */
+-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);
++/* VOID:UCHAR (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:29) */
++GOBJECT_FUNC 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);
+
+-/* VOID:INT (./gmarshal.list:30) */
+-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);
++/* VOID:INT (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:30) */
++GOBJECT_FUNC 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);
+
+-/* VOID:UINT (./gmarshal.list:31) */
+-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);
++/* VOID:UINT (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:31) */
++GOBJECT_FUNC 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);
+
+-/* VOID:LONG (./gmarshal.list:32) */
+-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);
++/* VOID:LONG (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:32) */
++GOBJECT_FUNC 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);
+
+-/* VOID:ULONG (./gmarshal.list:33) */
+-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);
++/* VOID:ULONG (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:33) */
++GOBJECT_FUNC 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);
+
+-/* VOID:ENUM (./gmarshal.list:34) */
+-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);
++/* VOID:ENUM (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:34) */
++GOBJECT_FUNC 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);
+
+-/* VOID:FLAGS (./gmarshal.list:35) */
+-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);
++/* VOID:FLAGS (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:35) */
++GOBJECT_FUNC 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);
+
+-/* VOID:FLOAT (./gmarshal.list:36) */
+-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);
++/* VOID:FLOAT (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:36) */
++GOBJECT_FUNC 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);
+
+-/* VOID:DOUBLE (./gmarshal.list:37) */
+-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);
++/* VOID:DOUBLE (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:37) */
++GOBJECT_FUNC 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);
+
+-/* VOID:STRING (./gmarshal.list:38) */
+-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);
++/* VOID:STRING (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:38) */
++GOBJECT_FUNC 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);
+
+-/* VOID:PARAM (./gmarshal.list:39) */
+-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);
++/* VOID:PARAM (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:39) */
++GOBJECT_FUNC 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);
+
+-/* VOID:BOXED (./gmarshal.list:40) */
+-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);
++/* VOID:BOXED (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:40) */
++GOBJECT_FUNC 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);
+
+-/* VOID:POINTER (./gmarshal.list:41) */
+-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);
++/* VOID:POINTER (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:41) */
++GOBJECT_FUNC 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);
+
+-/* VOID:OBJECT (./gmarshal.list:42) */
+-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);
++/* VOID:OBJECT (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:42) */
++GOBJECT_FUNC 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);
+
+-/* VOID:UINT,POINTER (./gmarshal.list:45) */
+-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);
++/* VOID:UINT,POINTER (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:45) */
++GOBJECT_FUNC 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);
+
+-/* BOOL:FLAGS (./gmarshal.list:46) */
+-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);
++/* BOOL:FLAGS (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:46) */
++GOBJECT_FUNC 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);
+ #define g_cclosure_marshal_BOOL__FLAGS g_cclosure_marshal_BOOLEAN__FLAGS
+
+-/* STRING:OBJECT,POINTER (./gmarshal.list:47) */
+-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);
++/* STRING:OBJECT,POINTER (/home/kergoth/code/build-z/tmp/work/arm-linux/glib-2.0-2.4.6-r2/glib-2.4.6/gobject/gmarshal.list:47) */
++GOBJECT_FUNC 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);
+
+ G_END_DECLS
+
+--- glib-2.4.6/gobject/gobject.def~visibility.patch
++++ glib-2.4.6/gobject/gobject.def
+@@ -1,4 +1,3 @@
+-EXPORTS
+ g_boxed_copy
+ g_boxed_free
+ g_boxed_type_register_static
+--- glib-2.4.6/gobject/gobject.h~visibility.patch
++++ glib-2.4.6/gobject/gobject.h
+@@ -28,6 +28,7 @@
+ #include <gobject/gparam.h>
+ #include <gobject/gclosure.h>
+ #include <gobject/gsignal.h>
++#include <gobject/gparamspecs.h>
+
+ G_BEGIN_DECLS
+
+@@ -111,123 +112,123 @@
+
+
+ /* --- prototypes --- */
+-void g_object_class_install_property (GObjectClass *oclass,
++GOBJECT_FUNC 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,
++ GParamSpec *pspec);;
++GOBJECT_FUNC GParamSpec* g_object_class_find_property (GObjectClass *oclass,
++ const gchar *property_name);;
++GOBJECT_FUNC GParamSpec**g_object_class_list_properties (GObjectClass *oclass,
+ guint *n_properties);
+-void g_object_class_override_property (GObjectClass *oclass,
++GOBJECT_FUNC void g_object_class_override_property (GObjectClass *oclass,
+ guint property_id,
+- const gchar *name);
++ 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,
++GOBJECT_FUNC void g_object_interface_install_property (gpointer g_iface,
++ GParamSpec *pspec);;
++GOBJECT_FUNC GParamSpec* g_object_interface_find_property (gpointer g_iface,
++ const gchar *property_name);;
++GOBJECT_FUNC GParamSpec**g_object_interface_list_properties (gpointer g_iface,
+ guint *n_properties_p);
+
+-gpointer g_object_new (GType object_type,
++GOBJECT_FUNC gpointer g_object_new (GType object_type,
+ const gchar *first_property_name,
+- ...);
+-gpointer g_object_newv (GType object_type,
++ ...);;
++GOBJECT_FUNC gpointer g_object_newv (GType object_type,
+ guint n_parameters,
+- GParameter *parameters);
+-GObject* g_object_new_valist (GType object_type,
++ GParameter *parameters);;
++GOBJECT_FUNC GObject* g_object_new_valist (GType object_type,
+ const gchar *first_property_name,
+- va_list var_args);
+-void g_object_set (gpointer object,
++ va_list var_args);;
++GOBJECT_FUNC void g_object_set (gpointer object,
+ const gchar *first_property_name,
+- ...);
+-void g_object_get (gpointer object,
++ ...);;
++GOBJECT_FUNC void g_object_get (gpointer object,
+ const gchar *first_property_name,
+- ...);
+-gpointer g_object_connect (gpointer object,
++ ...);;
++GOBJECT_FUNC gpointer g_object_connect (gpointer object,
+ const gchar *signal_spec,
+- ...);
+-void g_object_disconnect (gpointer object,
++ ...);;
++GOBJECT_FUNC void g_object_disconnect (gpointer object,
+ const gchar *signal_spec,
+- ...);
+-void g_object_set_valist (GObject *object,
++ ...);;
++GOBJECT_FUNC void g_object_set_valist (GObject *object,
+ const gchar *first_property_name,
+- va_list var_args);
+-void g_object_get_valist (GObject *object,
++ va_list var_args);;
++GOBJECT_FUNC void g_object_get_valist (GObject *object,
+ const gchar *first_property_name,
+- va_list var_args);
+-void g_object_set_property (GObject *object,
++ va_list var_args);;
++GOBJECT_FUNC void g_object_set_property (GObject *object,
+ const gchar *property_name,
+- const GValue *value);
+-void g_object_get_property (GObject *object,
++ const GValue *value);;
++GOBJECT_FUNC 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);
+-gpointer g_object_ref (gpointer object);
+-void g_object_unref (gpointer object);
+-void g_object_weak_ref (GObject *object,
++ GValue *value);;
++GOBJECT_FUNC void g_object_freeze_notify (GObject *object);;
++GOBJECT_FUNC void g_object_notify (GObject *object,
++ const gchar *property_name);;
++GOBJECT_FUNC void g_object_thaw_notify (GObject *object);;
++GOBJECT_FUNC gpointer g_object_ref (gpointer object);;
++GOBJECT_FUNC void g_object_unref (gpointer object);;
++GOBJECT_FUNC void g_object_weak_ref (GObject *object,
+ GWeakNotify notify,
+- gpointer data);
+-void g_object_weak_unref (GObject *object,
++ gpointer data);;
++GOBJECT_FUNC 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);
+-gpointer g_object_get_qdata (GObject *object,
+- GQuark quark);
+-void g_object_set_qdata (GObject *object,
++ gpointer data);;
++GOBJECT_FUNC void g_object_add_weak_pointer (GObject *object,
++ gpointer *weak_pointer_location);;
++GOBJECT_FUNC void g_object_remove_weak_pointer (GObject *object,
++ gpointer *weak_pointer_location);;
++GOBJECT_FUNC gpointer g_object_get_qdata (GObject *object,
++ GQuark quark);;
++GOBJECT_FUNC void g_object_set_qdata (GObject *object,
+ GQuark quark,
+- gpointer data);
+-void g_object_set_qdata_full (GObject *object,
++ gpointer data);;
++GOBJECT_FUNC 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,
++ GDestroyNotify destroy);;
++GOBJECT_FUNC gpointer g_object_steal_qdata (GObject *object,
++ GQuark quark);;
++GOBJECT_FUNC gpointer g_object_get_data (GObject *object,
++ const gchar *key);;
++GOBJECT_FUNC void g_object_set_data (GObject *object,
+ const gchar *key,
+- gpointer data);
+-void g_object_set_data_full (GObject *object,
++ gpointer data);;
++GOBJECT_FUNC 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,
++ GDestroyNotify destroy);;
++GOBJECT_FUNC gpointer g_object_steal_data (GObject *object,
++ const gchar *key);;
++GOBJECT_FUNC void g_object_watch_closure (GObject *object,
++ GClosure *closure);;
++GOBJECT_FUNC GClosure* g_cclosure_new_object (GCallback callback_func,
++ GObject *object);;
++GOBJECT_FUNC GClosure* g_cclosure_new_object_swap (GCallback callback_func,
++ GObject *object);;
++GOBJECT_FUNC GClosure* g_closure_new_object (guint sizeof_closure,
++ GObject *object);;
++GOBJECT_FUNC void g_value_set_object (GValue *value,
++ gpointer v_object);;
++GOBJECT_FUNC gpointer g_value_get_object (const GValue *value);;
++GOBJECT_FUNC GObject* g_value_dup_object (const GValue *value);;
++GOBJECT_FUNC gulong g_signal_connect_object (gpointer instance,
+ const gchar *detailed_signal,
+ GCallback c_handler,
+ gpointer gobject,
+- GConnectFlags connect_flags);
++ GConnectFlags connect_flags);;
+
+
+ /*< protected >*/
+-void g_object_run_dispose (GObject *object);
++GOBJECT_FUNC void g_object_run_dispose (GObject *object);;
+
+
+-void g_value_take_object (GValue *value,
+- gpointer v_object);
++GOBJECT_FUNC void g_value_take_object (GValue *value,
++ gpointer v_object);;
+ #ifndef G_DISABLE_DEPRECATED
+-void g_value_set_object_take_ownership (GValue *value,
+- gpointer v_object);
++GOBJECT_FUNC void g_value_set_object_take_ownership (GValue *value,
++ gpointer v_object);;
+ #endif
+
+ /* --- implementation macros --- */
+--- glib-2.4.6/gobject/gparam.h~visibility.patch
++++ glib-2.4.6/gobject/gparam.h
+@@ -109,49 +109,49 @@
+
+
+ /* --- prototypes --- */
+-GParamSpec* g_param_spec_ref (GParamSpec *pspec);
+-void g_param_spec_unref (GParamSpec *pspec);
+-void g_param_spec_sink (GParamSpec *pspec);
+-gpointer g_param_spec_get_qdata (GParamSpec *pspec,
+- GQuark quark);
+-void g_param_spec_set_qdata (GParamSpec *pspec,
++GOBJECT_FUNC GParamSpec* g_param_spec_ref (GParamSpec *pspec);;
++GOBJECT_FUNC void g_param_spec_unref (GParamSpec *pspec);;
++GOBJECT_FUNC void g_param_spec_sink (GParamSpec *pspec);;
++GOBJECT_FUNC gpointer g_param_spec_get_qdata (GParamSpec *pspec,
++ GQuark quark);;
++GOBJECT_FUNC void g_param_spec_set_qdata (GParamSpec *pspec,
+ GQuark quark,
+- gpointer data);
+-void g_param_spec_set_qdata_full (GParamSpec *pspec,
++ gpointer data);;
++GOBJECT_FUNC 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);
++ GDestroyNotify destroy);;
++GOBJECT_FUNC gpointer g_param_spec_steal_qdata (GParamSpec *pspec,
++ GQuark quark);;
++GOBJECT_FUNC 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,
++GOBJECT_FUNC void g_param_value_set_default (GParamSpec *pspec,
++ GValue *value);;
++GOBJECT_FUNC gboolean g_param_value_defaults (GParamSpec *pspec,
++ GValue *value);;
++GOBJECT_FUNC gboolean g_param_value_validate (GParamSpec *pspec,
++ GValue *value);;
++GOBJECT_FUNC gboolean g_param_value_convert (GParamSpec *pspec,
+ const GValue *src_value,
+ GValue *dest_value,
+- gboolean strict_validation);
+-gint g_param_values_cmp (GParamSpec *pspec,
++ gboolean strict_validation);;
++GOBJECT_FUNC gint g_param_values_cmp (GParamSpec *pspec,
+ const GValue *value1,
+- const GValue *value2);
+-G_CONST_RETURN gchar* g_param_spec_get_name (GParamSpec *pspec);
+-G_CONST_RETURN gchar* g_param_spec_get_nick (GParamSpec *pspec);
+-G_CONST_RETURN 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);
++ const GValue *value2);;
++GOBJECT_FUNC G_CONST_RETURN gchar* g_param_spec_get_name (GParamSpec *pspec);;
++GOBJECT_FUNC G_CONST_RETURN gchar* g_param_spec_get_nick (GParamSpec *pspec);;
++GOBJECT_FUNC G_CONST_RETURN gchar* g_param_spec_get_blurb (GParamSpec *pspec);;
++GOBJECT_FUNC void g_value_set_param (GValue *value,
++ GParamSpec *param);;
++GOBJECT_FUNC GParamSpec* g_value_get_param (const GValue *value);;
++GOBJECT_FUNC GParamSpec* g_value_dup_param (const GValue *value);;
+
+
+-void g_value_take_param (GValue *value,
+- GParamSpec *param);
++GOBJECT_FUNC void g_value_take_param (GValue *value,
++ GParamSpec *param);;
+ #ifndef G_DISABLE_DEPRECATED
+-void g_value_set_param_take_ownership (GValue *value,
+- GParamSpec *param);
++GOBJECT_FUNC void g_value_set_param_take_ownership (GValue *value,
++ GParamSpec *param);;
+ #endif
+
+ /* --- convenience functions --- */
+@@ -174,36 +174,36 @@
+ const GValue *value1,
+ const GValue *value2);
+ };
+-GType g_param_type_register_static (const gchar *name,
+- const GParamSpecTypeInfo *pspec_info);
++GOBJECT_FUNC GType g_param_type_register_static (const gchar *name,
++ const GParamSpecTypeInfo *pspec_info);;
+
+ /* For registering builting types */
+-GType _g_param_type_register_static_constant (const gchar *name,
++GOBJECT_FUNC GType _g_param_type_register_static_constant (const gchar *name,
+ const GParamSpecTypeInfo *pspec_info,
+ GType opt_type);
+
+
+ /* --- protected --- */
+-gpointer g_param_spec_internal (GType param_type,
++GOBJECT_FUNC 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,
++ GParamFlags flags);;
++GOBJECT_FUNC GParamSpecPool* g_param_spec_pool_new (gboolean type_prefixing);;
++GOBJECT_FUNC 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,
++ GType owner_type);;
++GOBJECT_FUNC void g_param_spec_pool_remove (GParamSpecPool *pool,
++ GParamSpec *pspec);;
++GOBJECT_FUNC 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,
++ gboolean walk_ancestors);;
++GOBJECT_FUNC GList* g_param_spec_pool_list_owned (GParamSpecPool *pool,
++ GType owner_type);;
++GOBJECT_FUNC GParamSpec** g_param_spec_pool_list (GParamSpecPool *pool,
+ GType owner_type,
+- guint *n_pspecs_p);
++ guint *n_pspecs_p);;
+
+
+
+--- glib-2.4.6/gobject/gparamspecs.h~visibility.patch
++++ glib-2.4.6/gobject/gparamspecs.h
+@@ -270,154 +270,130 @@
+ };
+
+ /* --- GParamSpec prototypes --- */
+-GParamSpec* g_param_spec_char (const gchar *name,
++GOBJECT_FUNC 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,
++ GParamFlags flags);;
++GOBJECT_FUNC 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,
++ GParamFlags flags);;
++GOBJECT_FUNC 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,
++ GParamFlags flags);;
++GOBJECT_FUNC 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,
++ GParamFlags flags);;
++GOBJECT_FUNC 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,
++ GParamFlags flags);;
++GOBJECT_FUNC 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,
++ GParamFlags flags);;
++GOBJECT_FUNC 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,
++ GParamFlags flags);;
++GOBJECT_FUNC 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,
++ GParamFlags flags);;
++GOBJECT_FUNC 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,
++ GParamFlags flags);;
++GOBJECT_FUNC 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,
++ GParamFlags flags);;
++GOBJECT_FUNC 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,
++ GParamFlags flags);;
++GOBJECT_FUNC 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,
++ GParamFlags flags);;
++GOBJECT_FUNC 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,
++ GParamFlags flags);;
++GOBJECT_FUNC 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,
++ GParamFlags flags);;
++GOBJECT_FUNC 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,
++ GParamFlags flags);;
++GOBJECT_FUNC 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,
++ GParamFlags flags);;
++GOBJECT_FUNC 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,
++ GParamFlags flags);;
++GOBJECT_FUNC 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,
++ GParamFlags flags);;
++GOBJECT_FUNC 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,
++ GParamFlags flags);;
++GOBJECT_FUNC 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);
++ GParamFlags flags);;
+
+-/* --- internal --- */
+-/* We prefix variable declarations so they can
+- * properly get exported in windows dlls.
+- */
+-#ifndef GOBJECT_VAR
+-# ifdef G_PLATFORM_WIN32
+-# ifdef GOBJECT_STATIC_COMPILATION
+-# define GOBJECT_VAR extern
+-# else /* !GOBJECT_STATIC_COMPILATION */
+-# ifdef GOBJECT_COMPILATION
+-# ifdef DLL_EXPORT
+-# define GOBJECT_VAR __declspec(dllexport)
+-# else /* !DLL_EXPORT */
+-# define GOBJECT_VAR extern
+-# endif /* !DLL_EXPORT */
+-# else /* !GOBJECT_COMPILATION */
+-# define GOBJECT_VAR extern __declspec(dllimport)
+-# endif /* !GOBJECT_COMPILATION */
+-# endif /* !GOBJECT_STATIC_COMPILATION */
+-# else /* !G_PLATFORM_WIN32 */
+-# define GOBJECT_VAR extern
+-# endif /* !G_PLATFORM_WIN32 */
+-#endif /* GOBJECT_VAR */
++GOBJECT_FUNC GParamSpec* g_param_spec_override (const gchar *name,
++ GParamSpec *overridden);;
+
+ GOBJECT_VAR GType *g_param_spec_types;
+
+--- glib-2.4.6/gobject/gsignal.h~visibility.patch
++++ glib-2.4.6/gobject/gsignal.h
+@@ -94,7 +94,7 @@
+
+
+ /* --- signals --- */
+-guint g_signal_newv (const gchar *signal_name,
++GOBJECT_FUNC guint g_signal_newv (const gchar *signal_name,
+ GType itype,
+ GSignalFlags signal_flags,
+ GClosure *class_closure,
+@@ -103,8 +103,8 @@
+ GSignalCMarshaller c_marshaller,
+ GType return_type,
+ guint n_params,
+- GType *param_types);
+-guint g_signal_new_valist (const gchar *signal_name,
++ GType *param_types);;
++GOBJECT_FUNC guint g_signal_new_valist (const gchar *signal_name,
+ GType itype,
+ GSignalFlags signal_flags,
+ GClosure *class_closure,
+@@ -113,8 +113,8 @@
+ GSignalCMarshaller c_marshaller,
+ GType return_type,
+ guint n_params,
+- va_list args);
+-guint g_signal_new (const gchar *signal_name,
++ va_list args);;
++GOBJECT_FUNC guint g_signal_new (const gchar *signal_name,
+ GType itype,
+ GSignalFlags signal_flags,
+ guint class_offset,
+@@ -123,116 +123,116 @@
+ GSignalCMarshaller c_marshaller,
+ GType return_type,
+ guint n_params,
+- ...);
+-void g_signal_emitv (const GValue *instance_and_params,
++ ...);;
++GOBJECT_FUNC void g_signal_emitv (const GValue *instance_and_params,
+ guint signal_id,
+ GQuark detail,
+- GValue *return_value);
+-void g_signal_emit_valist (gpointer instance,
++ GValue *return_value);;
++GOBJECT_FUNC void g_signal_emit_valist (gpointer instance,
+ guint signal_id,
+ GQuark detail,
+- va_list var_args);
+-void g_signal_emit (gpointer instance,
++ va_list var_args);;
++GOBJECT_FUNC void g_signal_emit (gpointer instance,
+ guint signal_id,
+ GQuark detail,
+- ...);
+-void g_signal_emit_by_name (gpointer instance,
++ ...);;
++GOBJECT_FUNC void g_signal_emit_by_name (gpointer instance,
+ const gchar *detailed_signal,
+- ...);
+-guint g_signal_lookup (const gchar *name,
+- GType itype);
+-G_CONST_RETURN 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,
++ ...);;
++GOBJECT_FUNC guint g_signal_lookup (const gchar *name,
++ GType itype);;
++GOBJECT_FUNC G_CONST_RETURN gchar* g_signal_name (guint signal_id);;
++GOBJECT_FUNC void g_signal_query (guint signal_id,
++ GSignalQuery *query);;
++GOBJECT_FUNC guint* g_signal_list_ids (GType itype,
++ guint *n_ids);;
++GOBJECT_FUNC 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);
++ gboolean force_detail_quark);;
++GOBJECT_FUNC GSignalInvocationHint* g_signal_get_invocation_hint (gpointer instance);;
+
+
+ /* --- signal emissions --- */
+-void g_signal_stop_emission (gpointer instance,
++GOBJECT_FUNC 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);;
++GOBJECT_FUNC void g_signal_stop_emission_by_name (gpointer instance,
++ const gchar *detailed_signal);;
++GOBJECT_FUNC 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);
++ GDestroyNotify data_destroy);;
++GOBJECT_FUNC void g_signal_remove_emission_hook (guint signal_id,
++ gulong hook_id);;
+
+
+ /* --- signal handlers --- */
+-gboolean g_signal_has_handler_pending (gpointer instance,
++GOBJECT_FUNC 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,
++ gboolean may_be_blocked);;
++GOBJECT_FUNC 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,
++ gboolean after);;
++GOBJECT_FUNC gulong g_signal_connect_closure (gpointer instance,
+ const gchar *detailed_signal,
+ GClosure *closure,
+- gboolean after);
+-gulong g_signal_connect_data (gpointer instance,
++ gboolean after);;
++GOBJECT_FUNC 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,
++ GConnectFlags connect_flags);;
++GOBJECT_FUNC void g_signal_handler_block (gpointer instance,
++ gulong handler_id);;
++GOBJECT_FUNC void g_signal_handler_unblock (gpointer instance,
++ gulong handler_id);;
++GOBJECT_FUNC void g_signal_handler_disconnect (gpointer instance,
++ gulong handler_id);;
++GOBJECT_FUNC gboolean g_signal_handler_is_connected (gpointer instance,
++ gulong handler_id);;
++GOBJECT_FUNC 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,
++ gpointer data);;
++GOBJECT_FUNC 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,
++ gpointer data);;
++GOBJECT_FUNC 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,
++ gpointer data);;
++GOBJECT_FUNC guint g_signal_handlers_disconnect_matched (gpointer instance,
+ GSignalMatchType mask,
+ guint signal_id,
+ GQuark detail,
+ GClosure *closure,
+ gpointer func,
+- gpointer data);
++ gpointer data);;
+
+
+ /* --- chaining for language bindings --- */
+-void g_signal_override_class_closure (guint signal_id,
++GOBJECT_FUNC 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);
++ GClosure *class_closure);;
++GOBJECT_FUNC void g_signal_chain_from_overridden (const GValue *instance_and_params,
++ GValue *return_value);;
+
+
+ /* --- convenience --- */
+@@ -256,13 +256,13 @@
+ 0, 0, NULL, (func), (data))
+
+
+-gboolean g_signal_accumulator_true_handled (GSignalInvocationHint *ihint,
++GOBJECT_FUNC gboolean g_signal_accumulator_true_handled (GSignalInvocationHint *ihint,
+ GValue *return_accu,
+ const GValue *handler_return,
+- gpointer dummy);
++ gpointer dummy);;
+
+ /*< private >*/
+-void g_signal_handlers_destroy (gpointer instance);
++GOBJECT_FUNC void g_signal_handlers_destroy (gpointer instance);;
+ void _g_signals_destroy (GType itype);
+
+ G_END_DECLS
+--- glib-2.4.6/gobject/gsourceclosure.h~visibility.patch
++++ glib-2.4.6/gobject/gsourceclosure.h
+@@ -27,11 +27,11 @@
+
+ G_BEGIN_DECLS
+
+-void g_source_set_closure (GSource *source,
+- GClosure *closure);
++GOBJECT_FUNC void g_source_set_closure (GSource *source,
++ GClosure *closure);;
+
+-GType g_io_channel_get_type (void);
+-GType g_io_condition_get_type (void);
++GOBJECT_FUNC GType g_io_channel_get_type (void);;
++GOBJECT_FUNC GType g_io_condition_get_type (void);;
+
+ #define G_TYPE_IO_CHANNEL (g_io_channel_get_type ())
+ #define G_TYPE_IO_CONDITION (g_io_condition_get_type ())
+--- glib-2.4.6/gobject/gtype.h~visibility.patch
++++ glib-2.4.6/gobject/gtype.h
+@@ -27,6 +27,63 @@
+
+ G_BEGIN_DECLS
+
++/* We prefix variable declarations so they can
++ * properly get exported in windows dlls.
++ */
++#ifndef GOBJECT_VAR
++# ifdef G_PLATFORM_WIN32
++# ifdef GOBJECT_STATIC_COMPILATION
++# define GOBJECT_VAR extern
++# else /* !GOBJECT_STATIC_COMPILATION */
++# ifdef GOBJECT_COMPILATION
++# ifdef DLL_EXPORT
++# define GOBJECT_VAR __declspec(dllexport)
++# else /* !DLL_EXPORT */
++# define GOBJECT_VAR extern
++# endif /* !DLL_EXPORT */
++# else /* !GOBJECT_COMPILATION */
++# define GOBJECT_VAR extern __declspec(dllimport)
++# endif /* !GOBJECT_COMPILATION */
++# endif /* !GOBJECT_STATIC_COMPILATION */
++# else /* !G_PLATFORM_WIN32 */
++# ifdef GOBJECT_STATIC_COMPILATION
++# define GOBJECT_VAR extern
++# else /* !GOBJECT_STATIC_COMPILATION */
++# ifdef GOBJECT_COMPILATION
++# ifdef GCC_HASCLASSVISIBILITY
++# define GOBJECT_VAR __attribute__ ((visibility("default")))
++# endif
++# endif /* !GOBJECT_COMPILATION */
++# endif /* !GOBJECT_STATIC_COMPILATION */
++# ifndef GOBJECT_VAR
++# define GOBJECT_VAR extern
++# endif /* !GOBJECT_VAR */
++# endif /* !G_PLATFORM_WIN32 */
++#endif /* GOBJECT_VAR */
++
++#ifndef GOBJECT_FUNC
++# ifdef G_PLATFORM_WIN32
++# ifndef GOBJECT_STATIC_COMPILATION
++# ifdef GOBJECT_COMPILATION
++# define GOBJECT_FUNC __declspec(dllexport)
++# else /* !GOBJECT_COMPILATION */
++# define GOBJECT_FUNC __declspec(dllimport)
++# endif /* !GOBJECT_COMPILATION */
++# endif /* !GOBJECT_STATIC_COMPILATION */
++# else /* !G_PLATFORM_WIN32 */
++# ifndef GOBJECT_STATIC_COMPILATION
++# ifdef GOBJECT_COMPILATION
++# ifdef GCC_HASCLASSVISIBILITY
++# define GOBJECT_FUNC __attribute__ ((visibility("default")))
++# endif
++# endif /* !GOBJECT_COMPILATION */
++# endif /* !GOBJECT_STATIC_COMPILATION */
++# ifndef GOBJECT_FUNC
++# define GOBJECT_FUNC
++# endif /* !GOBJECT_FUNC */
++# endif /* !G_PLATFORM_WIN32 */
++#endif /* GOBJECT_FUNC */
++
+ /* Basic Type Macros
+ */
+ #define G_TYPE_FUNDAMENTAL(type) (g_type_fundamental (type))
+@@ -164,44 +221,44 @@
+
+
+ /* --- prototypes --- */
+-void g_type_init (void);
+-void g_type_init_with_debug_flags (GTypeDebugFlags debug_flags);
+-G_CONST_RETURN 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);
++GOBJECT_FUNC void g_type_init (void);;
++GOBJECT_FUNC void g_type_init_with_debug_flags (GTypeDebugFlags debug_flags);;
++GOBJECT_FUNC G_CONST_RETURN gchar* g_type_name (GType type);;
++GOBJECT_FUNC GQuark g_type_qname (GType type);;
++GOBJECT_FUNC GType g_type_from_name (const gchar *name);;
++GOBJECT_FUNC GType g_type_parent (GType type);;
++GOBJECT_FUNC guint g_type_depth (GType type);;
++GOBJECT_FUNC GType g_type_next_base (GType leaf_type,
++ GType root_type);;
++GOBJECT_FUNC gboolean g_type_is_a (GType type,
++ GType is_a_type);;
++GOBJECT_FUNC gpointer g_type_class_ref (GType type);;
++GOBJECT_FUNC gpointer g_type_class_peek (GType type);;
++GOBJECT_FUNC gpointer g_type_class_peek_static (GType type);;
++GOBJECT_FUNC void g_type_class_unref (gpointer g_class);;
++GOBJECT_FUNC gpointer g_type_class_peek_parent (gpointer g_class);;
++GOBJECT_FUNC gpointer g_type_interface_peek (gpointer instance_class,
++ GType iface_type);;
++GOBJECT_FUNC 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);
++GOBJECT_FUNC gpointer g_type_default_interface_ref (GType g_type);;
++GOBJECT_FUNC gpointer g_type_default_interface_peek (GType g_type);;
++GOBJECT_FUNC void g_type_default_interface_unref (gpointer g_iface);;
+
+ /* g_free() the returned arrays */
+-GType* g_type_children (GType type,
+- guint *n_children);
+-GType* g_type_interfaces (GType type,
+- guint *n_interfaces);
++GOBJECT_FUNC GType* g_type_children (GType type,
++ guint *n_children);;
++GOBJECT_FUNC GType* g_type_interfaces (GType type,
++ guint *n_interfaces);;
+
+ /* per-type _static_ data */
+-void g_type_set_qdata (GType type,
++GOBJECT_FUNC 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);
++ gpointer data);;
++GOBJECT_FUNC gpointer g_type_get_qdata (GType type,
++ GQuark quark);;
++GOBJECT_FUNC void g_type_query (GType type,
++ GTypeQuery *query);;
+
+
+ /* --- type registration --- */
+@@ -283,33 +340,33 @@
+ GTypeCValue *collect_values,
+ guint collect_flags);
+ };
+-GType g_type_register_static (GType parent_type,
++GOBJECT_FUNC GType g_type_register_static (GType parent_type,
+ const gchar *type_name,
+ const GTypeInfo *info,
+- GTypeFlags flags);
+-GType g_type_register_dynamic (GType parent_type,
++ GTypeFlags flags);;
++GOBJECT_FUNC GType g_type_register_dynamic (GType parent_type,
+ const gchar *type_name,
+ GTypePlugin *plugin,
+- GTypeFlags flags);
+-GType g_type_register_fundamental (GType type_id,
++ GTypeFlags flags);;
++GOBJECT_FUNC 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,
++ GTypeFlags flags);;
++GOBJECT_FUNC void g_type_add_interface_static (GType instance_type,
+ GType interface_type,
+- const GInterfaceInfo *info);
+-void g_type_add_interface_dynamic (GType instance_type,
++ const GInterfaceInfo *info);;
++GOBJECT_FUNC 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,
++ GTypePlugin *plugin);;
++GOBJECT_FUNC void g_type_interface_add_prerequisite (GType interface_type,
++ GType prerequisite_type);;
++GOBJECT_FUNC 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);
++GOBJECT_FUNC void g_type_class_add_private (gpointer g_class,
++ gsize private_size);;
++GOBJECT_FUNC gpointer g_type_instance_get_private (GTypeInstance *instance,
++ GType private_type);;
+
+
+ /* --- GType boilerplate --- */
+@@ -382,49 +439,49 @@
+
+
+ /* --- protected (for fundamental type implementations) --- */
+-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);
++GOBJECT_FUNC GTypePlugin* g_type_get_plugin (GType type);;
++GOBJECT_FUNC GTypePlugin* g_type_interface_get_plugin (GType instance_type,
++ GType interface_type);;
++GOBJECT_FUNC GType g_type_fundamental_next (void);;
++GOBJECT_FUNC GType g_type_fundamental (GType type_id);;
++GOBJECT_FUNC GTypeInstance* g_type_create_instance (GType type);;
++GOBJECT_FUNC 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);
++GOBJECT_FUNC void g_type_add_class_cache_func (gpointer cache_data,
++ GTypeClassCacheFunc cache_func);;
++GOBJECT_FUNC void g_type_remove_class_cache_func (gpointer cache_data,
++ GTypeClassCacheFunc cache_func);;
++GOBJECT_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 chec_func);
++GOBJECT_FUNC void g_type_add_interface_check (gpointer check_data,
++ GTypeInterfaceCheckFunc check_func);;
++GOBJECT_FUNC void g_type_remove_interface_check (gpointer check_data,
++ GTypeInterfaceCheckFunc chec_func);;
+
+-GTypeValueTable* g_type_value_table_peek (GType type);
++GOBJECT_FUNC GTypeValueTable* g_type_value_table_peek (GType type);;
+
+
+ /*< private >*/
+-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);
++GOBJECT_FUNC gboolean g_type_check_instance (GTypeInstance *instance);;
++GOBJECT_FUNC GTypeInstance* g_type_check_instance_cast (GTypeInstance *instance,
++ GType iface_type);;
++GOBJECT_FUNC gboolean g_type_check_instance_is_a (GTypeInstance *instance,
++ GType iface_type);;
++GOBJECT_FUNC GTypeClass* g_type_check_class_cast (GTypeClass *g_class,
++ GType is_a_type);;
++GOBJECT_FUNC gboolean g_type_check_class_is_a (GTypeClass *g_class,
++ GType is_a_type);;
++GOBJECT_FUNC gboolean g_type_check_is_value_type (GType type);;
++GOBJECT_FUNC gboolean g_type_check_value (GValue *value);;
++GOBJECT_FUNC gboolean g_type_check_value_holds (GValue *value,
++ GType type);;
++GOBJECT_FUNC gboolean g_type_test_flags (GType type,
++ guint flags);;
+
+
+ /* --- debugging functions --- */
+-G_CONST_RETURN gchar* g_type_name_from_instance (GTypeInstance *instance);
+-G_CONST_RETURN gchar* g_type_name_from_class (GTypeClass *g_class);
++GOBJECT_FUNC G_CONST_RETURN gchar* g_type_name_from_instance (GTypeInstance *instance);;
++GOBJECT_FUNC G_CONST_RETURN gchar* g_type_name_from_class (GTypeClass *g_class);;
+
+
+ /* --- implementation bits --- */
+--- glib-2.4.6/gobject/gtypemodule.h~visibility.patch
++++ glib-2.4.6/gobject/gtypemodule.h
+@@ -65,20 +65,20 @@
+ void (*reserved4) (void);
+ };
+
+-GType g_type_module_get_type (void);
+-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,
++GOBJECT_FUNC GType g_type_module_get_type (void);;
++GOBJECT_FUNC gboolean g_type_module_use (GTypeModule *module);;
++GOBJECT_FUNC void g_type_module_unuse (GTypeModule *module);;
++GOBJECT_FUNC void g_type_module_set_name (GTypeModule *module,
++ const gchar *name);;
++GOBJECT_FUNC 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,
++ GTypeFlags flags);;
++GOBJECT_FUNC void g_type_module_add_interface (GTypeModule *module,
+ GType instance_type,
+ GType interface_type,
+- const GInterfaceInfo *interface_info);
++ const GInterfaceInfo *interface_info);;
+
+ G_END_DECLS
+
+--- glib-2.4.6/gobject/gtypeplugin.h~visibility.patch
++++ glib-2.4.6/gobject/gtypeplugin.h
+@@ -62,17 +62,17 @@
+
+
+ /* --- prototypes --- */
+-GType g_type_plugin_get_type (void) G_GNUC_CONST;
+-void g_type_plugin_use (GTypePlugin *plugin);
+-void g_type_plugin_unuse (GTypePlugin *plugin);
+-void g_type_plugin_complete_type_info (GTypePlugin *plugin,
++GOBJECT_FUNC GType g_type_plugin_get_type (void) G_GNUC_CONST;
++GOBJECT_FUNC void g_type_plugin_use (GTypePlugin *plugin);;
++GOBJECT_FUNC void g_type_plugin_unuse (GTypePlugin *plugin);;
++GOBJECT_FUNC 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,
++ GTypeValueTable *value_table);;
++GOBJECT_FUNC void g_type_plugin_complete_interface_info (GTypePlugin *plugin,
+ GType instance_type,
+ GType interface_type,
+- GInterfaceInfo *info);
++ GInterfaceInfo *info);;
+
+ G_END_DECLS
+
+--- glib-2.4.6/gobject/gvaluearray.h~visibility.patch
++++ glib-2.4.6/gobject/gvaluearray.h
+@@ -46,25 +46,25 @@
+
+
+ /* --- prototypes --- */
+-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,
++GOBJECT_FUNC GValue* g_value_array_get_nth (GValueArray *value_array,
++ guint index_);;
++GOBJECT_FUNC GValueArray* g_value_array_new (guint n_prealloced);;
++GOBJECT_FUNC void g_value_array_free (GValueArray *value_array);;
++GOBJECT_FUNC GValueArray* g_value_array_copy (const GValueArray *value_array);;
++GOBJECT_FUNC GValueArray* g_value_array_prepend (GValueArray *value_array,
++ const GValue *value);;
++GOBJECT_FUNC GValueArray* g_value_array_append (GValueArray *value_array,
++ const GValue *value);;
++GOBJECT_FUNC 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,
++ const GValue *value);;
++GOBJECT_FUNC GValueArray* g_value_array_remove (GValueArray *value_array,
++ guint index_);;
++GOBJECT_FUNC GValueArray* g_value_array_sort (GValueArray *value_array,
++ GCompareFunc compare_func);;
++GOBJECT_FUNC GValueArray* g_value_array_sort_with_data (GValueArray *value_array,
+ GCompareDataFunc compare_func,
+- gpointer user_data);
++ gpointer user_data);;
+
+
+
+--- glib-2.4.6/gobject/gvalue.h~visibility.patch
++++ glib-2.4.6/gobject/gvalue.h
+@@ -61,31 +61,31 @@
+
+
+ /* --- prototypes --- */
+-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);
++GOBJECT_FUNC GValue* g_value_init (GValue *value,
++ GType g_type);;
++GOBJECT_FUNC void g_value_copy (const GValue *src_value,
++ GValue *dest_value);;
++GOBJECT_FUNC GValue* g_value_reset (GValue *value);;
++GOBJECT_FUNC void g_value_unset (GValue *value);;
++GOBJECT_FUNC void g_value_set_instance (GValue *value,
++ gpointer instance);;
+
+
+ /* --- private --- */
+-gboolean g_value_fits_pointer (const GValue *value);
+-gpointer g_value_peek_pointer (const GValue *value);
++GOBJECT_FUNC gboolean g_value_fits_pointer (const GValue *value);;
++GOBJECT_FUNC gpointer g_value_peek_pointer (const GValue *value);;
+
+
+ /* --- implementation details --- */
+-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,
++GOBJECT_FUNC gboolean g_value_type_compatible (GType src_type,
++ GType dest_type);;
++GOBJECT_FUNC gboolean g_value_type_transformable (GType src_type,
++ GType dest_type);;
++GOBJECT_FUNC gboolean g_value_transform (const GValue *src_value,
++ GValue *dest_value);;
++GOBJECT_FUNC void g_value_register_transform_func (GType src_type,
+ GType dest_type,
+- GValueTransform transform_func);
++ GValueTransform transform_func);;
+ #define G_VALUE_NOCOPY_CONTENTS (1 << 27)
+
+
+--- glib-2.4.6/gobject/gvaluetypes.h~visibility.patch
++++ glib-2.4.6/gobject/gvaluetypes.h
+@@ -46,62 +46,62 @@
+
+
+ /* --- prototypes --- */
+-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);
+-G_CONST_RETURN 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);
++GOBJECT_FUNC void g_value_set_char (GValue *value,
++ gchar v_char);;
++GOBJECT_FUNC gchar g_value_get_char (const GValue *value);;
++GOBJECT_FUNC void g_value_set_uchar (GValue *value,
++ guchar v_uchar);;
++GOBJECT_FUNC guchar g_value_get_uchar (const GValue *value);;
++GOBJECT_FUNC void g_value_set_boolean (GValue *value,
++ gboolean v_boolean);;
++GOBJECT_FUNC gboolean g_value_get_boolean (const GValue *value);;
++GOBJECT_FUNC void g_value_set_int (GValue *value,
++ gint v_int);;
++GOBJECT_FUNC gint g_value_get_int (const GValue *value);;
++GOBJECT_FUNC void g_value_set_uint (GValue *value,
++ guint v_uint);;
++GOBJECT_FUNC guint g_value_get_uint (const GValue *value);;
++GOBJECT_FUNC void g_value_set_long (GValue *value,
++ glong v_long);;
++GOBJECT_FUNC glong g_value_get_long (const GValue *value);;
++GOBJECT_FUNC void g_value_set_ulong (GValue *value,
++ gulong v_ulong);;
++GOBJECT_FUNC gulong g_value_get_ulong (const GValue *value);;
++GOBJECT_FUNC void g_value_set_int64 (GValue *value,
++ gint64 v_int64);;
++GOBJECT_FUNC gint64 g_value_get_int64 (const GValue *value);;
++GOBJECT_FUNC void g_value_set_uint64 (GValue *value,
++ guint64 v_uint64);;
++GOBJECT_FUNC guint64 g_value_get_uint64 (const GValue *value);;
++GOBJECT_FUNC void g_value_set_float (GValue *value,
++ gfloat v_float);;
++GOBJECT_FUNC gfloat g_value_get_float (const GValue *value);;
++GOBJECT_FUNC void g_value_set_double (GValue *value,
++ gdouble v_double);;
++GOBJECT_FUNC gdouble g_value_get_double (const GValue *value);;
++GOBJECT_FUNC void g_value_set_string (GValue *value,
++ const gchar *v_string);;
++GOBJECT_FUNC void g_value_set_static_string (GValue *value,
++ const gchar *v_string);;
++GOBJECT_FUNC G_CONST_RETURN gchar* g_value_get_string (const GValue *value);;
++GOBJECT_FUNC gchar* g_value_dup_string (const GValue *value);;
++GOBJECT_FUNC void g_value_set_pointer (GValue *value,
++ gpointer v_pointer);;
++GOBJECT_FUNC gpointer g_value_get_pointer (const GValue *value);;
+
+
+ /* Convenience for registering new pointer types */
+-GType g_pointer_type_register_static (const gchar *name);
++GOBJECT_FUNC GType g_pointer_type_register_static (const gchar *name);;
+
+ /* debugging aid, describe value contents as string */
+-gchar* g_strdup_value_contents (const GValue *value);
++GOBJECT_FUNC gchar* g_strdup_value_contents (const GValue *value);;
+
+
+-void g_value_take_string (GValue *value,
+- gchar *v_string);
++GOBJECT_FUNC void g_value_take_string (GValue *value,
++ gchar *v_string);;
+ #ifndef G_DISABLE_DEPRECATED
+-void g_value_set_string_take_ownership (GValue *value,
+- gchar *v_string);
++GOBJECT_FUNC void g_value_set_string_take_ownership (GValue *value,
++ gchar *v_string);;
+ #endif
+
+
+--- glib-2.4.6/gthread/gthread.def~visibility.patch
++++ glib-2.4.6/gthread/gthread.def
+@@ -1,3 +1,2 @@
+-EXPORTS
+ g_thread_init
+ g_thread_init_with_errorcheck_mutexes
+--- glib-2.4.6/gthread/Makefile.am~visibility.patch
++++ glib-2.4.6/gthread/Makefile.am
+@@ -2,7 +2,8 @@
+
+ INCLUDES = -I$(top_srcdir) -I$(top_srcdir)/glib -I$(top_srcdir)/gthread \
+ -DG_LOG_DOMAIN=\"GThread\" @GTHREAD_COMPILE_IMPL_DEFINES@ \
+- @GLIB_DEBUG_FLAGS@ -DG_DISABLE_DEPRECATED
++ @GLIB_DEBUG_FLAGS@ -DG_DISABLE_DEPRECATED \
++ -DGLIB_COMPILATION
+
+ EXTRA_DIST = \
+ makefile.msc.in \
generated by cgit v1.2.3 (git 2.46.0) at 2024-12-23 18:24:44 +0000