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

6 files changed, 6247 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 0000000000..bbbf5df985
--- /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 0000000000..1ab6e379c2
--- /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 0000000000..4b9c234e21
--- /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 0000000000..7cea8b037b
--- /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);