diff options
Diffstat (limited to 'recipes/glib-2.0/files/visibility.patch')
| -rw-r--r-- | recipes/glib-2.0/files/visibility.patch | 6123 |
1 files changed, 6123 insertions, 0 deletions
diff --git a/recipes/glib-2.0/files/visibility.patch b/recipes/glib-2.0/files/visibility.patch new file mode 100644 index 0000000000..7cea8b037b --- /dev/null +++ b/recipes/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 \ |