diff options
Diffstat (limited to 'glib/src/glib_functions.defs')
| -rw-r--r-- | glib/src/glib_functions.defs | 8168 |
1 files changed, 8065 insertions, 103 deletions
diff --git a/glib/src/glib_functions.defs b/glib/src/glib_functions.defs index 3d55e45d..87445f69 100644 --- a/glib/src/glib_functions.defs +++ b/glib/src/glib_functions.defs @@ -657,10 +657,49 @@ (return-type "none") ) -(define-method unref_to_array - (of-object "GBytes") - (c-name "g_bytes_unref_to_array") - (return-type "const-GByteArray*") +(define-method remove + (of-object "GAsyncQueue") + (c-name "g_async_queue_remove") + (return-type "gboolean") + (parameters + '("gpointer" "item") + ) +) + +(define-method remove_unlocked + (of-object "GAsyncQueue") + (c-name "g_async_queue_remove_unlocked") + (return-type "gboolean") + (parameters + '("gpointer" "item") + ) +) + +(define-method push_front + (of-object "GAsyncQueue") + (c-name "g_async_queue_push_front") + (return-type "none") + (parameters + '("gpointer" "item") + ) +) + +(define-method push_front_unlocked + (of-object "GAsyncQueue") + (c-name "g_async_queue_push_front_unlocked") + (return-type "none") + (parameters + '("gpointer" "item") + ) +) + +(define-method timed_pop + (of-object "GAsyncQueue") + (c-name "g_async_queue_timed_pop") + (return-type "gpointer") + (parameters + '("GTimeVal*" "end_time") + ) ) (define-method unref_to_data @@ -672,9 +711,13 @@ ) ) -(define-function new - (c-name "g_checksum_new") - (return-type "GChecksum*") + + +;; From gatomic.h + +(define-function g_atomic_int_get + (c-name "g_atomic_int_get") + (return-type "gint") (parameters '("GChecksumType" "checksum_type") ) @@ -1474,10 +1517,14 @@ ) ) -(define-method get_hash_table - (of-object "GHashTableIter") - (c-name "g_hash_table_iter_get_hash_table") - (return-type "GHashTable*") + + +;; From gchecksum.h + +(define-method get_length + (of-object "GChecksumType") + (c-name "g_checksum_type_get_length") + (return-type "gssize") ) (define-method init @@ -2058,10 +2105,19 @@ ) ) -(define-method get_locale_string - (of-object "GKeyFile") - (c-name "g_key_file_get_locale_string") - (return-type "gchar*") + + +;; From gdate.h + +(define-function g_date_new + (c-name "g_date_new") + (is-constructor-of "GDate") + (return-type "GDate*") +) + +(define-function g_date_new_dmy + (c-name "g_date_new_dmy") + (return-type "GDate*") (parameters '("const-gchar*" "group_name") '("const-gchar*" "key") @@ -2585,12 +2641,7935 @@ ) ) +(define-function g_date_time_new_from_timeval_local + (c-name "g_date_time_new_from_timeval_local") + (return-type "GDateTime*") + (parameters + '("const-GTimeVal*" "tv") + ) +) + +(define-function g_date_time_new_from_timeval_utc + (c-name "g_date_time_new_from_timeval_utc") + (return-type "GDateTime*") + (parameters + '("const-GTimeVal*" "tv") + ) +) + +(define-function g_date_time_new + (c-name "g_date_time_new") + (is-constructor-of "GDateTime") + (return-type "GDateTime*") + (parameters + '("GTimeZone*" "tz") + '("gint" "year") + '("gint" "month") + '("gint" "day") + '("gint" "hour") + '("gint" "minute") + '("gdouble" "seconds") + ) +) + +(define-function g_date_time_new_local + (c-name "g_date_time_new_local") + (return-type "GDateTime*") + (parameters + '("gint" "year") + '("gint" "month") + '("gint" "day") + '("gint" "hour") + '("gint" "minute") + '("gdouble" "seconds") + ) +) + +(define-function g_date_time_new_utc + (c-name "g_date_time_new_utc") + (return-type "GDateTime*") + (parameters + '("gint" "year") + '("gint" "month") + '("gint" "day") + '("gint" "hour") + '("gint" "minute") + '("gdouble" "seconds") + ) +) + +(define-method add + (of-object "GDateTime") + (c-name "g_date_time_add") + (return-type "GDateTime*") + (parameters + '("GTimeSpan" "timespan") + ) +) + +(define-method add_years + (of-object "GDateTime") + (c-name "g_date_time_add_years") + (return-type "GDateTime*") + (parameters + '("gint" "years") + ) +) + +(define-method add_months + (of-object "GDateTime") + (c-name "g_date_time_add_months") + (return-type "GDateTime*") + (parameters + '("gint" "months") + ) +) + +(define-method add_weeks + (of-object "GDateTime") + (c-name "g_date_time_add_weeks") + (return-type "GDateTime*") + (parameters + '("gint" "weeks") + ) +) + +(define-method add_days + (of-object "GDateTime") + (c-name "g_date_time_add_days") + (return-type "GDateTime*") + (parameters + '("gint" "days") + ) +) + +(define-method add_hours + (of-object "GDateTime") + (c-name "g_date_time_add_hours") + (return-type "GDateTime*") + (parameters + '("gint" "hours") + ) +) + +(define-method add_minutes + (of-object "GDateTime") + (c-name "g_date_time_add_minutes") + (return-type "GDateTime*") + (parameters + '("gint" "minutes") + ) +) + +(define-method add_seconds + (of-object "GDateTime") + (c-name "g_date_time_add_seconds") + (return-type "GDateTime*") + (parameters + '("gdouble" "seconds") + ) +) + +(define-method add_full + (of-object "GDateTime") + (c-name "g_date_time_add_full") + (return-type "GDateTime*") + (parameters + '("gint" "years") + '("gint" "months") + '("gint" "days") + '("gint" "hours") + '("gint" "minutes") + '("gdouble" "seconds") + ) +) + +(define-function g_date_time_compare + (c-name "g_date_time_compare") + (return-type "gint") + (parameters + '("gconstpointer" "dt1") + '("gconstpointer" "dt2") + ) +) + +(define-method difference + (of-object "GDateTime") + (c-name "g_date_time_difference") + (return-type "GTimeSpan") + (parameters + '("GDateTime*" "begin") + ) +) + +(define-function g_date_time_hash + (c-name "g_date_time_hash") + (return-type "guint") + (parameters + '("gconstpointer" "datetime") + ) +) + +(define-function g_date_time_equal + (c-name "g_date_time_equal") + (return-type "gboolean") + (parameters + '("gconstpointer" "dt1") + '("gconstpointer" "dt2") + ) +) + +(define-method get_ymd + (of-object "GDateTime") + (c-name "g_date_time_get_ymd") + (return-type "none") + (parameters + '("gint*" "year") + '("gint*" "month") + '("gint*" "day") + ) +) + +(define-method get_year + (of-object "GDateTime") + (c-name "g_date_time_get_year") + (return-type "gint") +) + +(define-method get_month + (of-object "GDateTime") + (c-name "g_date_time_get_month") + (return-type "gint") +) + +(define-method get_day_of_month + (of-object "GDateTime") + (c-name "g_date_time_get_day_of_month") + (return-type "gint") +) + +(define-method get_week_numbering_year + (of-object "GDateTime") + (c-name "g_date_time_get_week_numbering_year") + (return-type "gint") +) + +(define-method get_week_of_year + (of-object "GDateTime") + (c-name "g_date_time_get_week_of_year") + (return-type "gint") +) + +(define-method get_day_of_week + (of-object "GDateTime") + (c-name "g_date_time_get_day_of_week") + (return-type "gint") +) + +(define-method get_day_of_year + (of-object "GDateTime") + (c-name "g_date_time_get_day_of_year") + (return-type "gint") +) + +(define-method get_hour + (of-object "GDateTime") + (c-name "g_date_time_get_hour") + (return-type "gint") +) + +(define-method get_minute + (of-object "GDateTime") + (c-name "g_date_time_get_minute") + (return-type "gint") +) + +(define-method get_second + (of-object "GDateTime") + (c-name "g_date_time_get_second") + (return-type "gint") +) + +(define-method get_microsecond + (of-object "GDateTime") + (c-name "g_date_time_get_microsecond") + (return-type "gint") +) + +(define-method get_seconds + (of-object "GDateTime") + (c-name "g_date_time_get_seconds") + (return-type "gdouble") +) + +(define-method to_unix + (of-object "GDateTime") + (c-name "g_date_time_to_unix") + (return-type "gint64") +) + +(define-method to_timeval + (of-object "GDateTime") + (c-name "g_date_time_to_timeval") + (return-type "gboolean") + (parameters + '("GTimeVal*" "tv") + ) +) + +(define-method get_utc_offset + (of-object "GDateTime") + (c-name "g_date_time_get_utc_offset") + (return-type "GTimeSpan") +) + +(define-method get_timezone_abbreviation + (of-object "GDateTime") + (c-name "g_date_time_get_timezone_abbreviation") + (return-type "const-gchar*") +) + +(define-method is_daylight_savings + (of-object "GDateTime") + (c-name "g_date_time_is_daylight_savings") + (return-type "gboolean") +) + +(define-method to_timezone + (of-object "GDateTime") + (c-name "g_date_time_to_timezone") + (return-type "GDateTime*") + (parameters + '("GTimeZone*" "tz") + ) +) + +(define-method to_local + (of-object "GDateTime") + (c-name "g_date_time_to_local") + (return-type "GDateTime*") +) + +(define-method to_utc + (of-object "GDateTime") + (c-name "g_date_time_to_utc") + (return-type "GDateTime*") +) + +(define-method format + (of-object "GDateTime") + (c-name "g_date_time_format") + (return-type "gchar*") + (parameters + '("const-gchar*" "format") + ) +) + + + +;; From gdir.h + +(define-function g_dir_open + (c-name "g_dir_open") + (return-type "GDir*") + (parameters + '("const-gchar*" "path") + '("guint" "flags") + '("GError**" "error") + ) +) + +(define-method read_name + (of-object "GDir") + (c-name "g_dir_read_name") + (return-type "const-gchar*") +) + +(define-method rewind + (of-object "GDir") + (c-name "g_dir_rewind") + (return-type "none") +) + +(define-method close + (of-object "GDir") + (c-name "g_dir_close") + (return-type "none") +) + +(define-function g_dir_open_utf8 + (c-name "g_dir_open_utf8") + (return-type "GDir*") + (parameters + '("const-gchar*" "path") + '("guint" "flags") + '("GError**" "error") + ) +) + +(define-method read_name_utf8 + (of-object "GDir") + (c-name "g_dir_read_name_utf8") + (return-type "const-gchar*") +) + + + +;; From genviron.h + +(define-function g_getenv + (c-name "g_getenv") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "variable") + ) +) + +(define-function g_setenv + (c-name "g_setenv") + (return-type "gboolean") + (parameters + '("const-gchar*" "variable") + '("const-gchar*" "value") + '("gboolean" "overwrite") + ) +) + +(define-function g_unsetenv + (c-name "g_unsetenv") + (return-type "none") + (parameters + '("const-gchar*" "variable") + ) +) + +(define-function g_listenv + (c-name "g_listenv") + (return-type "gchar**") +) + +(define-function g_get_environ + (c-name "g_get_environ") + (return-type "gchar**") +) + +(define-function g_environ_getenv + (c-name "g_environ_getenv") + (return-type "const-gchar*") + (parameters + '("gchar**" "envp") + '("const-gchar*" "variable") + ) +) + +(define-function g_environ_setenv + (c-name "g_environ_setenv") + (return-type "gchar**") + (parameters + '("gchar**" "envp") + '("const-gchar*" "variable") + '("const-gchar*" "value") + '("gboolean" "overwrite") + ) +) + +(define-function g_environ_unsetenv + (c-name "g_environ_unsetenv") + (return-type "gchar**") + (parameters + '("gchar**" "envp") + '("const-gchar*" "variable") + ) +) + +(define-function g_getenv_utf8 + (c-name "g_getenv_utf8") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "variable") + ) +) + +(define-function g_setenv_utf8 + (c-name "g_setenv_utf8") + (return-type "gboolean") + (parameters + '("const-gchar*" "variable") + '("const-gchar*" "value") + '("gboolean" "overwrite") + ) +) + +(define-function g_unsetenv_utf8 + (c-name "g_unsetenv_utf8") + (return-type "none") + (parameters + '("const-gchar*" "variable") + ) +) + + + +;; From gerror.h + +(define-function g_error_new + (c-name "g_error_new") + (is-constructor-of "GError") + (return-type "GError*") + (parameters + '("GQuark" "domain") + '("gint" "code") + '("const-gchar*" "format") + ) + (varargs #t) +) + +(define-function g_error_new_literal + (c-name "g_error_new_literal") + (return-type "GError*") + (parameters + '("GQuark" "domain") + '("gint" "code") + '("const-gchar*" "message") + ) +) + +(define-function g_error_new_valist + (c-name "g_error_new_valist") + (return-type "GError*") + (parameters + '("GQuark" "domain") + '("gint" "code") + '("const-gchar*" "format") + '("va_list" "args") + ) +) + +(define-method free + (of-object "GError") + (c-name "g_error_free") + (return-type "none") +) + +(define-method copy + (of-object "GError") + (c-name "g_error_copy") + (return-type "GError*") +) + +(define-method matches + (of-object "GError") + (c-name "g_error_matches") + (return-type "gboolean") + (parameters + '("GQuark" "domain") + '("gint" "code") + ) +) + +(define-function g_set_error + (c-name "g_set_error") + (return-type "none") + (parameters + '("GError**" "err") + '("GQuark" "domain") + '("gint" "code") + '("const-gchar*" "format") + ) + (varargs #t) +) + +(define-function g_set_error_literal + (c-name "g_set_error_literal") + (return-type "none") + (parameters + '("GError**" "err") + '("GQuark" "domain") + '("gint" "code") + '("const-gchar*" "message") + ) +) + +(define-function g_propagate_error + (c-name "g_propagate_error") + (return-type "none") + (parameters + '("GError**" "dest") + '("GError*" "src") + ) +) + +(define-function g_clear_error + (c-name "g_clear_error") + (return-type "none") + (parameters + '("GError**" "err") + ) +) + +(define-function g_prefix_error + (c-name "g_prefix_error") + (return-type "none") + (parameters + '("GError**" "err") + '("const-gchar*" "format") + ) + (varargs #t) +) + +(define-function g_propagate_prefixed_error + (c-name "g_propagate_prefixed_error") + (return-type "none") + (parameters + '("GError**" "dest") + '("GError*" "src") + '("const-gchar*" "format") + ) + (varargs #t) +) + + + +;; From gfileutils.h + +(define-function g_file_error_quark + (c-name "g_file_error_quark") + (return-type "GQuark") +) + +(define-function g_file_error_from_errno + (c-name "g_file_error_from_errno") + (return-type "GFileError") + (parameters + '("gint" "err_no") + ) +) + +(define-function g_file_test + (c-name "g_file_test") + (return-type "gboolean") + (parameters + '("const-gchar*" "filename") + '("GFileTest" "test") + ) +) + +(define-function g_file_get_contents + (c-name "g_file_get_contents") + (return-type "gboolean") + (parameters + '("const-gchar*" "filename") + '("gchar**" "contents") + '("gsize*" "length") + '("GError**" "error") + ) +) + +(define-function g_file_set_contents + (c-name "g_file_set_contents") + (return-type "gboolean") + (parameters + '("const-gchar*" "filename") + '("const-gchar*" "contents") + '("gssize" "length") + '("GError**" "error") + ) +) + +(define-function g_file_read_link + (c-name "g_file_read_link") + (return-type "gchar*") + (parameters + '("const-gchar*" "filename") + '("GError**" "error") + ) +) + +(define-function g_mkdtemp + (c-name "g_mkdtemp") + (return-type "gchar*") + (parameters + '("gchar*" "tmpl") + ) +) + +(define-function g_mkdtemp_full + (c-name "g_mkdtemp_full") + (return-type "gchar*") + (parameters + '("gchar*" "tmpl") + '("gint" "mode") + ) +) + +(define-function g_mkstemp + (c-name "g_mkstemp") + (return-type "gint") + (parameters + '("gchar*" "tmpl") + ) +) + +(define-function g_mkstemp_full + (c-name "g_mkstemp_full") + (return-type "gint") + (parameters + '("gchar*" "tmpl") + '("gint" "flags") + '("gint" "mode") + ) +) + +(define-function g_file_open_tmp + (c-name "g_file_open_tmp") + (return-type "gint") + (parameters + '("const-gchar*" "tmpl") + '("gchar**" "name_used") + '("GError**" "error") + ) +) + +(define-function g_dir_make_tmp + (c-name "g_dir_make_tmp") + (return-type "gchar*") + (parameters + '("const-gchar*" "tmpl") + '("GError**" "error") + ) +) + +(define-function g_build_path + (c-name "g_build_path") + (return-type "gchar*") + (parameters + '("const-gchar*" "separator") + '("const-gchar*" "first_element") + ) + (varargs #t) +) + +(define-function g_build_pathv + (c-name "g_build_pathv") + (return-type "gchar*") + (parameters + '("const-gchar*" "separator") + '("gchar**" "args") + ) +) + +(define-function g_build_filename + (c-name "g_build_filename") + (return-type "gchar*") + (parameters + '("const-gchar*" "first_element") + ) + (varargs #t) +) + +(define-function g_build_filenamev + (c-name "g_build_filenamev") + (return-type "gchar*") + (parameters + '("gchar**" "args") + ) +) + +(define-function g_mkdir_with_parents + (c-name "g_mkdir_with_parents") + (return-type "gint") + (parameters + '("const-gchar*" "pathname") + '("gint" "mode") + ) +) + +(define-function g_path_is_absolute + (c-name "g_path_is_absolute") + (return-type "gboolean") + (parameters + '("const-gchar*" "file_name") + ) +) + +(define-function g_path_skip_root + (c-name "g_path_skip_root") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "file_name") + ) +) + +(define-function g_basename + (c-name "g_basename") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "file_name") + ) +) + +(define-function g_get_current_dir + (c-name "g_get_current_dir") + (return-type "gchar*") +) + +(define-function g_path_get_basename + (c-name "g_path_get_basename") + (return-type "gchar*") + (parameters + '("const-gchar*" "file_name") + ) +) + +(define-function g_path_get_dirname + (c-name "g_path_get_dirname") + (return-type "gchar*") + (parameters + '("const-gchar*" "file_name") + ) +) + +(define-function g_file_test_utf8 + (c-name "g_file_test_utf8") + (return-type "gboolean") + (parameters + '("const-gchar*" "filename") + '("GFileTest" "test") + ) +) + +(define-function g_file_get_contents_utf8 + (c-name "g_file_get_contents_utf8") + (return-type "gboolean") + (parameters + '("const-gchar*" "filename") + '("gchar**" "contents") + '("gsize*" "length") + '("GError**" "error") + ) +) + +(define-function g_mkstemp_utf8 + (c-name "g_mkstemp_utf8") + (return-type "gint") + (parameters + '("gchar*" "tmpl") + ) +) + +(define-function g_file_open_tmp_utf8 + (c-name "g_file_open_tmp_utf8") + (return-type "gint") + (parameters + '("const-gchar*" "tmpl") + '("gchar**" "name_used") + '("GError**" "error") + ) +) + +(define-function g_get_current_dir_utf8 + (c-name "g_get_current_dir_utf8") + (return-type "gchar*") +) + + + +;; From ggettext.h + +(define-function g_strip_context + (c-name "g_strip_context") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "msgid") + '("const-gchar*" "msgval") + ) +) + +(define-function g_dgettext + (c-name "g_dgettext") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "domain") + '("const-gchar*" "msgid") + ) +) + +(define-function g_dcgettext + (c-name "g_dcgettext") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "domain") + '("const-gchar*" "msgid") + '("gint" "category") + ) +) + +(define-function g_dngettext + (c-name "g_dngettext") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "domain") + '("const-gchar*" "msgid") + '("const-gchar*" "msgid_plural") + '("gulong" "n") + ) +) + +(define-function g_dpgettext + (c-name "g_dpgettext") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "domain") + '("const-gchar*" "msgctxtid") + '("gsize" "msgidoffset") + ) +) + +(define-function g_dpgettext2 + (c-name "g_dpgettext2") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "domain") + '("const-gchar*" "context") + '("const-gchar*" "msgid") + ) +) + + + +;; From ghash.h + +(define-function g_hash_table_new + (c-name "g_hash_table_new") + (is-constructor-of "GHashTable") + (return-type "GHashTable*") + (parameters + '("GHashFunc" "hash_func") + '("GEqualFunc" "key_equal_func") + ) +) + +(define-function g_hash_table_new_full + (c-name "g_hash_table_new_full") + (return-type "GHashTable*") + (parameters + '("GHashFunc" "hash_func") + '("GEqualFunc" "key_equal_func") + '("GDestroyNotify" "key_destroy_func") + '("GDestroyNotify" "value_destroy_func") + ) +) + +(define-method destroy + (of-object "GHashTable") + (c-name "g_hash_table_destroy") + (return-type "none") +) + +(define-method insert + (of-object "GHashTable") + (c-name "g_hash_table_insert") + (return-type "gboolean") + (parameters + '("gpointer" "key") + '("gpointer" "value") + ) +) + +(define-method replace + (of-object "GHashTable") + (c-name "g_hash_table_replace") + (return-type "gboolean") + (parameters + '("gpointer" "key") + '("gpointer" "value") + ) +) + +(define-method add + (of-object "GHashTable") + (c-name "g_hash_table_add") + (return-type "gboolean") + (parameters + '("gpointer" "key") + ) +) + +(define-method remove + (of-object "GHashTable") + (c-name "g_hash_table_remove") + (return-type "gboolean") + (parameters + '("gconstpointer" "key") + ) +) + +(define-method remove_all + (of-object "GHashTable") + (c-name "g_hash_table_remove_all") + (return-type "none") +) + +(define-method steal + (of-object "GHashTable") + (c-name "g_hash_table_steal") + (return-type "gboolean") + (parameters + '("gconstpointer" "key") + ) +) + +(define-method steal_all + (of-object "GHashTable") + (c-name "g_hash_table_steal_all") + (return-type "none") +) + +(define-method lookup + (of-object "GHashTable") + (c-name "g_hash_table_lookup") + (return-type "gpointer") + (parameters + '("gconstpointer" "key") + ) +) + +(define-method contains + (of-object "GHashTable") + (c-name "g_hash_table_contains") + (return-type "gboolean") + (parameters + '("gconstpointer" "key") + ) +) + +(define-method lookup_extended + (of-object "GHashTable") + (c-name "g_hash_table_lookup_extended") + (return-type "gboolean") + (parameters + '("gconstpointer" "lookup_key") + '("gpointer*" "orig_key") + '("gpointer*" "value") + ) +) + +(define-method foreach + (of-object "GHashTable") + (c-name "g_hash_table_foreach") + (return-type "none") + (parameters + '("GHFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-method find + (of-object "GHashTable") + (c-name "g_hash_table_find") + (return-type "gpointer") + (parameters + '("GHRFunc" "predicate") + '("gpointer" "user_data") + ) +) + +(define-method foreach_remove + (of-object "GHashTable") + (c-name "g_hash_table_foreach_remove") + (return-type "guint") + (parameters + '("GHRFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-method foreach_steal + (of-object "GHashTable") + (c-name "g_hash_table_foreach_steal") + (return-type "guint") + (parameters + '("GHRFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-method size + (of-object "GHashTable") + (c-name "g_hash_table_size") + (return-type "guint") +) + +(define-method get_keys + (of-object "GHashTable") + (c-name "g_hash_table_get_keys") + (return-type "GList*") +) + +(define-method get_values + (of-object "GHashTable") + (c-name "g_hash_table_get_values") + (return-type "GList*") +) + +(define-method get_keys_as_array + (of-object "GHashTable") + (c-name "g_hash_table_get_keys_as_array") + (return-type "gpointer*") + (parameters + '("guint*" "length") + ) +) + +(define-method init + (of-object "GHashTableIter") + (c-name "g_hash_table_iter_init") + (return-type "none") + (parameters + '("GHashTable*" "hash_table") + ) +) + +(define-method next + (of-object "GHashTableIter") + (c-name "g_hash_table_iter_next") + (return-type "gboolean") + (parameters + '("gpointer*" "key") + '("gpointer*" "value") + ) +) + +(define-method get_hash_table + (of-object "GHashTableIter") + (c-name "g_hash_table_iter_get_hash_table") + (return-type "GHashTable*") +) + +(define-method remove + (of-object "GHashTableIter") + (c-name "g_hash_table_iter_remove") + (return-type "none") +) + +(define-method replace + (of-object "GHashTableIter") + (c-name "g_hash_table_iter_replace") + (return-type "none") + (parameters + '("gpointer" "value") + ) +) + +(define-method steal + (of-object "GHashTableIter") + (c-name "g_hash_table_iter_steal") + (return-type "none") +) + +(define-method ref + (of-object "GHashTable") + (c-name "g_hash_table_ref") + (return-type "GHashTable*") +) + +(define-method unref + (of-object "GHashTable") + (c-name "g_hash_table_unref") + (return-type "none") +) + +(define-function g_str_equal + (c-name "g_str_equal") + (return-type "gboolean") + (parameters + '("gconstpointer" "v1") + '("gconstpointer" "v2") + ) +) + +(define-function g_str_hash + (c-name "g_str_hash") + (return-type "guint") + (parameters + '("gconstpointer" "v") + ) +) + +(define-function g_int_equal + (c-name "g_int_equal") + (return-type "gboolean") + (parameters + '("gconstpointer" "v1") + '("gconstpointer" "v2") + ) +) + +(define-function g_int_hash + (c-name "g_int_hash") + (return-type "guint") + (parameters + '("gconstpointer" "v") + ) +) + +(define-function g_int64_equal + (c-name "g_int64_equal") + (return-type "gboolean") + (parameters + '("gconstpointer" "v1") + '("gconstpointer" "v2") + ) +) + +(define-function g_int64_hash + (c-name "g_int64_hash") + (return-type "guint") + (parameters + '("gconstpointer" "v") + ) +) + +(define-function g_double_equal + (c-name "g_double_equal") + (return-type "gboolean") + (parameters + '("gconstpointer" "v1") + '("gconstpointer" "v2") + ) +) + +(define-function g_double_hash + (c-name "g_double_hash") + (return-type "guint") + (parameters + '("gconstpointer" "v") + ) +) + +(define-function g_direct_hash + (c-name "g_direct_hash") + (return-type "guint") + (parameters + '("gconstpointer" "v") + ) +) + +(define-function g_direct_equal + (c-name "g_direct_equal") + (return-type "gboolean") + (parameters + '("gconstpointer" "v1") + '("gconstpointer" "v2") + ) +) + + + +;; From ghmac.h + +(define-function g_hmac_new + (c-name "g_hmac_new") + (is-constructor-of "GHmac") + (return-type "GHmac*") + (parameters + '("GChecksumType" "digest_type") + '("const-guchar*" "key") + '("gsize" "key_len") + ) +) + +(define-method copy + (of-object "GHmac") + (c-name "g_hmac_copy") + (return-type "GHmac*") +) + +(define-method ref + (of-object "GHmac") + (c-name "g_hmac_ref") + (return-type "GHmac*") +) + +(define-method unref + (of-object "GHmac") + (c-name "g_hmac_unref") + (return-type "none") +) + +(define-method update + (of-object "GHmac") + (c-name "g_hmac_update") + (return-type "none") + (parameters + '("const-guchar*" "data") + '("gssize" "length") + ) +) + +(define-method get_string + (of-object "GHmac") + (c-name "g_hmac_get_string") + (return-type "const-gchar*") +) + +(define-method get_digest + (of-object "GHmac") + (c-name "g_hmac_get_digest") + (return-type "none") + (parameters + '("guint8*" "buffer") + '("gsize*" "digest_len") + ) +) + +(define-function g_compute_hmac_for_data + (c-name "g_compute_hmac_for_data") + (return-type "gchar*") + (parameters + '("GChecksumType" "digest_type") + '("const-guchar*" "key") + '("gsize" "key_len") + '("const-guchar*" "data") + '("gsize" "length") + ) +) + +(define-function g_compute_hmac_for_string + (c-name "g_compute_hmac_for_string") + (return-type "gchar*") + (parameters + '("GChecksumType" "digest_type") + '("const-guchar*" "key") + '("gsize" "key_len") + '("const-gchar*" "str") + '("gssize" "length") + ) +) + + + +;; From ghook.h + +(define-method init + (of-object "GHookList") + (c-name "g_hook_list_init") + (return-type "none") + (parameters + '("guint" "hook_size") + ) +) + +(define-method clear + (of-object "GHookList") + (c-name "g_hook_list_clear") + (return-type "none") +) + +(define-function g_hook_alloc + (c-name "g_hook_alloc") + (return-type "GHook*") + (parameters + '("GHookList*" "hook_list") + ) +) + +(define-function g_hook_free + (c-name "g_hook_free") + (return-type "none") + (parameters + '("GHookList*" "hook_list") + '("GHook*" "hook") + ) +) + +(define-function g_hook_ref + (c-name "g_hook_ref") + (return-type "GHook*") + (parameters + '("GHookList*" "hook_list") + '("GHook*" "hook") + ) +) + +(define-function g_hook_unref + (c-name "g_hook_unref") + (return-type "none") + (parameters + '("GHookList*" "hook_list") + '("GHook*" "hook") + ) +) + +(define-function g_hook_destroy + (c-name "g_hook_destroy") + (return-type "gboolean") + (parameters + '("GHookList*" "hook_list") + '("gulong" "hook_id") + ) +) + +(define-function g_hook_destroy_link + (c-name "g_hook_destroy_link") + (return-type "none") + (parameters + '("GHookList*" "hook_list") + '("GHook*" "hook") + ) +) + +(define-function g_hook_prepend + (c-name "g_hook_prepend") + (return-type "none") + (parameters + '("GHookList*" "hook_list") + '("GHook*" "hook") + ) +) + +(define-function g_hook_insert_before + (c-name "g_hook_insert_before") + (return-type "none") + (parameters + '("GHookList*" "hook_list") + '("GHook*" "sibling") + '("GHook*" "hook") + ) +) + +(define-function g_hook_insert_sorted + (c-name "g_hook_insert_sorted") + (return-type "none") + (parameters + '("GHookList*" "hook_list") + '("GHook*" "hook") + '("GHookCompareFunc" "func") + ) +) + +(define-function g_hook_get + (c-name "g_hook_get") + (return-type "GHook*") + (parameters + '("GHookList*" "hook_list") + '("gulong" "hook_id") + ) +) + +(define-function g_hook_find + (c-name "g_hook_find") + (return-type "GHook*") + (parameters + '("GHookList*" "hook_list") + '("gboolean" "need_valids") + '("GHookFindFunc" "func") + '("gpointer" "data") + ) +) + +(define-function g_hook_find_data + (c-name "g_hook_find_data") + (return-type "GHook*") + (parameters + '("GHookList*" "hook_list") + '("gboolean" "need_valids") + '("gpointer" "data") + ) +) + +(define-function g_hook_find_func + (c-name "g_hook_find_func") + (return-type "GHook*") + (parameters + '("GHookList*" "hook_list") + '("gboolean" "need_valids") + '("gpointer" "func") + ) +) + +(define-function g_hook_find_func_data + (c-name "g_hook_find_func_data") + (return-type "GHook*") + (parameters + '("GHookList*" "hook_list") + '("gboolean" "need_valids") + '("gpointer" "func") + '("gpointer" "data") + ) +) + +(define-function g_hook_first_valid + (c-name "g_hook_first_valid") + (return-type "GHook*") + (parameters + '("GHookList*" "hook_list") + '("gboolean" "may_be_in_call") + ) +) + +(define-function g_hook_next_valid + (c-name "g_hook_next_valid") + (return-type "GHook*") + (parameters + '("GHookList*" "hook_list") + '("GHook*" "hook") + '("gboolean" "may_be_in_call") + ) +) + +(define-method compare_ids + (of-object "GHook") + (c-name "g_hook_compare_ids") + (return-type "gint") + (parameters + '("GHook*" "sibling") + ) +) + +(define-method invoke + (of-object "GHookList") + (c-name "g_hook_list_invoke") + (return-type "none") + (parameters + '("gboolean" "may_recurse") + ) +) + +(define-method invoke_check + (of-object "GHookList") + (c-name "g_hook_list_invoke_check") + (return-type "none") + (parameters + '("gboolean" "may_recurse") + ) +) + +(define-method marshal + (of-object "GHookList") + (c-name "g_hook_list_marshal") + (return-type "none") + (parameters + '("gboolean" "may_recurse") + '("GHookMarshaller" "marshaller") + '("gpointer" "marshal_data") + ) +) + +(define-method marshal_check + (of-object "GHookList") + (c-name "g_hook_list_marshal_check") + (return-type "none") + (parameters + '("gboolean" "may_recurse") + '("GHookCheckMarshaller" "marshaller") + '("gpointer" "marshal_data") + ) +) + + + +;; From ghostutils.h + +(define-function g_hostname_is_non_ascii + (c-name "g_hostname_is_non_ascii") + (return-type "gboolean") + (parameters + '("const-gchar*" "hostname") + ) +) + +(define-function g_hostname_is_ascii_encoded + (c-name "g_hostname_is_ascii_encoded") + (return-type "gboolean") + (parameters + '("const-gchar*" "hostname") + ) +) + +(define-function g_hostname_is_ip_address + (c-name "g_hostname_is_ip_address") + (return-type "gboolean") + (parameters + '("const-gchar*" "hostname") + ) +) + +(define-function g_hostname_to_ascii + (c-name "g_hostname_to_ascii") + (return-type "gchar*") + (parameters + '("const-gchar*" "hostname") + ) +) + +(define-function g_hostname_to_unicode + (c-name "g_hostname_to_unicode") + (return-type "gchar*") + (parameters + '("const-gchar*" "hostname") + ) +) + + + +;; From gi18n.h + + + +;; From gi18n-lib.h + + + +;; From giochannel.h + +(define-method init + (of-object "GIOChannel") + (c-name "g_io_channel_init") + (return-type "none") +) + +(define-method ref + (of-object "GIOChannel") + (c-name "g_io_channel_ref") + (return-type "GIOChannel*") +) + +(define-method unref + (of-object "GIOChannel") + (c-name "g_io_channel_unref") + (return-type "none") +) + +(define-method read + (of-object "GIOChannel") + (c-name "g_io_channel_read") + (return-type "GIOError") + (parameters + '("gchar*" "buf") + '("gsize" "count") + '("gsize*" "bytes_read") + ) +) + +(define-method write + (of-object "GIOChannel") + (c-name "g_io_channel_write") + (return-type "GIOError") + (parameters + '("const-gchar*" "buf") + '("gsize" "count") + '("gsize*" "bytes_written") + ) +) + +(define-method seek + (of-object "GIOChannel") + (c-name "g_io_channel_seek") + (return-type "GIOError") + (parameters + '("gint64" "offset") + '("GSeekType" "type") + ) +) + +(define-method close + (of-object "GIOChannel") + (c-name "g_io_channel_close") + (return-type "none") +) + +(define-method shutdown + (of-object "GIOChannel") + (c-name "g_io_channel_shutdown") + (return-type "GIOStatus") + (parameters + '("gboolean" "flush") + '("GError**" "err") + ) +) + +(define-function g_io_add_watch_full + (c-name "g_io_add_watch_full") + (return-type "guint") + (parameters + '("GIOChannel*" "channel") + '("gint" "priority") + '("GIOCondition" "condition") + '("GIOFunc" "func") + '("gpointer" "user_data") + '("GDestroyNotify" "notify") + ) +) + +(define-function g_io_create_watch + (c-name "g_io_create_watch") + (return-type "GSource*") + (parameters + '("GIOChannel*" "channel") + '("GIOCondition" "condition") + ) +) + +(define-function g_io_add_watch + (c-name "g_io_add_watch") + (return-type "guint") + (parameters + '("GIOChannel*" "channel") + '("GIOCondition" "condition") + '("GIOFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-method set_buffer_size + (of-object "GIOChannel") + (c-name "g_io_channel_set_buffer_size") + (return-type "none") + (parameters + '("gsize" "size") + ) +) + +(define-method get_buffer_size + (of-object "GIOChannel") + (c-name "g_io_channel_get_buffer_size") + (return-type "gsize") +) + +(define-method get_buffer_condition + (of-object "GIOChannel") + (c-name "g_io_channel_get_buffer_condition") + (return-type "GIOCondition") +) + +(define-method set_flags + (of-object "GIOChannel") + (c-name "g_io_channel_set_flags") + (return-type "GIOStatus") + (parameters + '("GIOFlags" "flags") + '("GError**" "error") + ) +) + +(define-method get_flags + (of-object "GIOChannel") + (c-name "g_io_channel_get_flags") + (return-type "GIOFlags") +) + +(define-method set_line_term + (of-object "GIOChannel") + (c-name "g_io_channel_set_line_term") + (return-type "none") + (parameters + '("const-gchar*" "line_term") + '("gint" "length") + ) +) + +(define-method get_line_term + (of-object "GIOChannel") + (c-name "g_io_channel_get_line_term") + (return-type "const-gchar*") + (parameters + '("gint*" "length") + ) +) + +(define-method set_buffered + (of-object "GIOChannel") + (c-name "g_io_channel_set_buffered") + (return-type "none") + (parameters + '("gboolean" "buffered") + ) +) + +(define-method get_buffered + (of-object "GIOChannel") + (c-name "g_io_channel_get_buffered") + (return-type "gboolean") +) + +(define-method set_encoding + (of-object "GIOChannel") + (c-name "g_io_channel_set_encoding") + (return-type "GIOStatus") + (parameters + '("const-gchar*" "encoding") + '("GError**" "error") + ) +) + +(define-method get_encoding + (of-object "GIOChannel") + (c-name "g_io_channel_get_encoding") + (return-type "const-gchar*") +) + +(define-method set_close_on_unref + (of-object "GIOChannel") + (c-name "g_io_channel_set_close_on_unref") + (return-type "none") + (parameters + '("gboolean" "do_close") + ) +) + +(define-method get_close_on_unref + (of-object "GIOChannel") + (c-name "g_io_channel_get_close_on_unref") + (return-type "gboolean") +) + +(define-method flush + (of-object "GIOChannel") + (c-name "g_io_channel_flush") + (return-type "GIOStatus") + (parameters + '("GError**" "error") + ) +) + +(define-method read_line + (of-object "GIOChannel") + (c-name "g_io_channel_read_line") + (return-type "GIOStatus") + (parameters + '("gchar**" "str_return") + '("gsize*" "length") + '("gsize*" "terminator_pos") + '("GError**" "error") + ) +) + +(define-method read_line_string + (of-object "GIOChannel") + (c-name "g_io_channel_read_line_string") + (return-type "GIOStatus") + (parameters + '("GString*" "buffer") + '("gsize*" "terminator_pos") + '("GError**" "error") + ) +) + +(define-method read_to_end + (of-object "GIOChannel") + (c-name "g_io_channel_read_to_end") + (return-type "GIOStatus") + (parameters + '("gchar**" "str_return") + '("gsize*" "length") + '("GError**" "error") + ) +) + +(define-method read_chars + (of-object "GIOChannel") + (c-name "g_io_channel_read_chars") + (return-type "GIOStatus") + (parameters + '("gchar*" "buf") + '("gsize" "count") + '("gsize*" "bytes_read") + '("GError**" "error") + ) +) + +(define-method read_unichar + (of-object "GIOChannel") + (c-name "g_io_channel_read_unichar") + (return-type "GIOStatus") + (parameters + '("gunichar*" "thechar") + '("GError**" "error") + ) +) + +(define-method write_chars + (of-object "GIOChannel") + (c-name "g_io_channel_write_chars") + (return-type "GIOStatus") + (parameters + '("const-gchar*" "buf") + '("gssize" "count") + '("gsize*" "bytes_written") + '("GError**" "error") + ) +) + +(define-method write_unichar + (of-object "GIOChannel") + (c-name "g_io_channel_write_unichar") + (return-type "GIOStatus") + (parameters + '("gunichar" "thechar") + '("GError**" "error") + ) +) + +(define-method seek_position + (of-object "GIOChannel") + (c-name "g_io_channel_seek_position") + (return-type "GIOStatus") + (parameters + '("gint64" "offset") + '("GSeekType" "type") + '("GError**" "error") + ) +) + +(define-function g_io_channel_new_file + (c-name "g_io_channel_new_file") + (return-type "GIOChannel*") + (parameters + '("const-gchar*" "filename") + '("const-gchar*" "mode") + '("GError**" "error") + ) +) + +(define-function g_io_channel_error_quark + (c-name "g_io_channel_error_quark") + (return-type "GQuark") +) + +(define-function g_io_channel_error_from_errno + (c-name "g_io_channel_error_from_errno") + (return-type "GIOChannelError") + (parameters + '("gint" "en") + ) +) + +(define-function g_io_channel_unix_new + (c-name "g_io_channel_unix_new") + (is-constructor-of "GIoChannelUnix") + (return-type "GIOChannel*") + (parameters + '("int" "fd") + ) +) + +(define-method unix_get_fd + (of-object "GIOChannel") + (c-name "g_io_channel_unix_get_fd") + (return-type "gint") +) + +(define-method win32_make_pollfd + (of-object "GIOChannel") + (c-name "g_io_channel_win32_make_pollfd") + (return-type "none") + (parameters + '("GIOCondition" "condition") + '("GPollFD*" "fd") + ) +) + +(define-function g_io_channel_win32_poll + (c-name "g_io_channel_win32_poll") + (return-type "gint") + (parameters + '("GPollFD*" "fds") + '("gint" "n_fds") + '("gint" "timeout_") + ) +) + +(define-function g_io_channel_win32_new_messages + (c-name "g_io_channel_win32_new_messages") + (return-type "GIOChannel*") + (parameters + '("gsize" "hwnd") + ) +) + +(define-function g_io_channel_win32_new_fd + (c-name "g_io_channel_win32_new_fd") + (return-type "GIOChannel*") + (parameters + '("gint" "fd") + ) +) + +(define-method win32_get_fd + (of-object "GIOChannel") + (c-name "g_io_channel_win32_get_fd") + (return-type "gint") +) + +(define-function g_io_channel_win32_new_socket + (c-name "g_io_channel_win32_new_socket") + (return-type "GIOChannel*") + (parameters + '("gint" "socket") + ) +) + +(define-function g_io_channel_win32_new_stream_socket + (c-name "g_io_channel_win32_new_stream_socket") + (return-type "GIOChannel*") + (parameters + '("gint" "socket") + ) +) + +(define-method win32_set_debug + (of-object "GIOChannel") + (c-name "g_io_channel_win32_set_debug") + (return-type "none") + (parameters + '("gboolean" "flag") + ) +) + +(define-function g_io_channel_new_file_utf8 + (c-name "g_io_channel_new_file_utf8") + (return-type "GIOChannel*") + (parameters + '("const-gchar*" "filename") + '("const-gchar*" "mode") + '("GError**" "error") + ) +) + + + +;; From gkeyfile.h + +(define-function g_key_file_error_quark + (c-name "g_key_file_error_quark") + (return-type "GQuark") +) + +(define-function g_key_file_new + (c-name "g_key_file_new") + (is-constructor-of "GKeyFile") + (return-type "GKeyFile*") +) + +(define-method ref + (of-object "GKeyFile") + (c-name "g_key_file_ref") + (return-type "GKeyFile*") +) + +(define-method unref + (of-object "GKeyFile") + (c-name "g_key_file_unref") + (return-type "none") +) + +(define-method free + (of-object "GKeyFile") + (c-name "g_key_file_free") + (return-type "none") +) + +(define-method set_list_separator + (of-object "GKeyFile") + (c-name "g_key_file_set_list_separator") + (return-type "none") + (parameters + '("gchar" "separator") + ) +) + +(define-method load_from_file + (of-object "GKeyFile") + (c-name "g_key_file_load_from_file") + (return-type "gboolean") + (parameters + '("const-gchar*" "file") + '("GKeyFileFlags" "flags") + '("GError**" "error") + ) +) + +(define-method load_from_data + (of-object "GKeyFile") + (c-name "g_key_file_load_from_data") + (return-type "gboolean") + (parameters + '("const-gchar*" "data") + '("gsize" "length") + '("GKeyFileFlags" "flags") + '("GError**" "error") + ) +) + +(define-method load_from_dirs + (of-object "GKeyFile") + (c-name "g_key_file_load_from_dirs") + (return-type "gboolean") + (parameters + '("const-gchar*" "file") + '("const-gchar**" "search_dirs") + '("gchar**" "full_path") + '("GKeyFileFlags" "flags") + '("GError**" "error") + ) +) + +(define-method load_from_data_dirs + (of-object "GKeyFile") + (c-name "g_key_file_load_from_data_dirs") + (return-type "gboolean") + (parameters + '("const-gchar*" "file") + '("gchar**" "full_path") + '("GKeyFileFlags" "flags") + '("GError**" "error") + ) +) + +(define-method to_data + (of-object "GKeyFile") + (c-name "g_key_file_to_data") + (return-type "gchar*") + (parameters + '("gsize*" "length") + '("GError**" "error") + ) +) + +(define-method save_to_file + (of-object "GKeyFile") + (c-name "g_key_file_save_to_file") + (return-type "gboolean") + (parameters + '("const-gchar*" "filename") + '("GError**" "error") + ) +) + +(define-method get_start_group + (of-object "GKeyFile") + (c-name "g_key_file_get_start_group") + (return-type "gchar*") +) + +(define-method get_groups + (of-object "GKeyFile") + (c-name "g_key_file_get_groups") + (return-type "gchar**") + (parameters + '("gsize*" "length") + ) +) + +(define-method get_keys + (of-object "GKeyFile") + (c-name "g_key_file_get_keys") + (return-type "gchar**") + (parameters + '("const-gchar*" "group_name") + '("gsize*" "length") + '("GError**" "error") + ) +) + +(define-method has_group + (of-object "GKeyFile") + (c-name "g_key_file_has_group") + (return-type "gboolean") + (parameters + '("const-gchar*" "group_name") + ) +) + +(define-method has_key + (of-object "GKeyFile") + (c-name "g_key_file_has_key") + (return-type "gboolean") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("GError**" "error") + ) +) + +(define-method get_value + (of-object "GKeyFile") + (c-name "g_key_file_get_value") + (return-type "gchar*") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("GError**" "error") + ) +) + +(define-method set_value + (of-object "GKeyFile") + (c-name "g_key_file_set_value") + (return-type "none") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("const-gchar*" "value") + ) +) + +(define-method get_string + (of-object "GKeyFile") + (c-name "g_key_file_get_string") + (return-type "gchar*") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("GError**" "error") + ) +) + +(define-method set_string + (of-object "GKeyFile") + (c-name "g_key_file_set_string") + (return-type "none") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("const-gchar*" "string") + ) +) + +(define-method get_locale_string + (of-object "GKeyFile") + (c-name "g_key_file_get_locale_string") + (return-type "gchar*") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("const-gchar*" "locale") + '("GError**" "error") + ) +) + +(define-method set_locale_string + (of-object "GKeyFile") + (c-name "g_key_file_set_locale_string") + (return-type "none") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("const-gchar*" "locale") + '("const-gchar*" "string") + ) +) + +(define-method get_boolean + (of-object "GKeyFile") + (c-name "g_key_file_get_boolean") + (return-type "gboolean") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("GError**" "error") + ) +) + +(define-method set_boolean + (of-object "GKeyFile") + (c-name "g_key_file_set_boolean") + (return-type "none") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("gboolean" "value") + ) +) + +(define-method get_integer + (of-object "GKeyFile") + (c-name "g_key_file_get_integer") + (return-type "gint") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("GError**" "error") + ) +) + +(define-method set_integer + (of-object "GKeyFile") + (c-name "g_key_file_set_integer") + (return-type "none") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("gint" "value") + ) +) + +(define-method get_int64 + (of-object "GKeyFile") + (c-name "g_key_file_get_int64") + (return-type "gint64") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("GError**" "error") + ) +) + +(define-method set_int64 + (of-object "GKeyFile") + (c-name "g_key_file_set_int64") + (return-type "none") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("gint64" "value") + ) +) + +(define-method get_uint64 + (of-object "GKeyFile") + (c-name "g_key_file_get_uint64") + (return-type "guint64") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("GError**" "error") + ) +) + +(define-method set_uint64 + (of-object "GKeyFile") + (c-name "g_key_file_set_uint64") + (return-type "none") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("guint64" "value") + ) +) + +(define-method get_double + (of-object "GKeyFile") + (c-name "g_key_file_get_double") + (return-type "gdouble") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("GError**" "error") + ) +) + +(define-method set_double + (of-object "GKeyFile") + (c-name "g_key_file_set_double") + (return-type "none") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("gdouble" "value") + ) +) + +(define-method get_string_list + (of-object "GKeyFile") + (c-name "g_key_file_get_string_list") + (return-type "gchar**") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("gsize*" "length") + '("GError**" "error") + ) +) + +(define-method set_string_list + (of-object "GKeyFile") + (c-name "g_key_file_set_string_list") + (return-type "none") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("const-gchar*-const[]" "list") + '("gsize" "length") + ) +) + +(define-method get_locale_string_list + (of-object "GKeyFile") + (c-name "g_key_file_get_locale_string_list") + (return-type "gchar**") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("const-gchar*" "locale") + '("gsize*" "length") + '("GError**" "error") + ) +) + +(define-method set_locale_string_list + (of-object "GKeyFile") + (c-name "g_key_file_set_locale_string_list") + (return-type "none") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("const-gchar*" "locale") + '("const-gchar*-const[]" "list") + '("gsize" "length") + ) +) + +(define-method get_boolean_list + (of-object "GKeyFile") + (c-name "g_key_file_get_boolean_list") + (return-type "gboolean*") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("gsize*" "length") + '("GError**" "error") + ) +) + +(define-method set_boolean_list + (of-object "GKeyFile") + (c-name "g_key_file_set_boolean_list") + (return-type "none") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("gboolean[]" "list") + '("gsize" "length") + ) +) + +(define-method get_integer_list + (of-object "GKeyFile") + (c-name "g_key_file_get_integer_list") + (return-type "gint*") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("gsize*" "length") + '("GError**" "error") + ) +) + +(define-method set_double_list + (of-object "GKeyFile") + (c-name "g_key_file_set_double_list") + (return-type "none") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("gdouble[]" "list") + '("gsize" "length") + ) +) + +(define-method get_double_list + (of-object "GKeyFile") + (c-name "g_key_file_get_double_list") + (return-type "gdouble*") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("gsize*" "length") + '("GError**" "error") + ) +) + +(define-method set_integer_list + (of-object "GKeyFile") + (c-name "g_key_file_set_integer_list") + (return-type "none") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("gint[]" "list") + '("gsize" "length") + ) +) + +(define-method set_comment + (of-object "GKeyFile") + (c-name "g_key_file_set_comment") + (return-type "gboolean") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("const-gchar*" "comment") + '("GError**" "error") + ) +) + +(define-method get_comment + (of-object "GKeyFile") + (c-name "g_key_file_get_comment") + (return-type "gchar*") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("GError**" "error") + ) +) + +(define-method remove_comment + (of-object "GKeyFile") + (c-name "g_key_file_remove_comment") + (return-type "gboolean") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("GError**" "error") + ) +) + +(define-method remove_key + (of-object "GKeyFile") + (c-name "g_key_file_remove_key") + (return-type "gboolean") + (parameters + '("const-gchar*" "group_name") + '("const-gchar*" "key") + '("GError**" "error") + ) +) + +(define-method remove_group + (of-object "GKeyFile") + (c-name "g_key_file_remove_group") + (return-type "gboolean") + (parameters + '("const-gchar*" "group_name") + '("GError**" "error") + ) +) + + + +;; From glib-autocleanups.h + +(define-function g_autoptr_cleanup_generic_gfree + (c-name "g_autoptr_cleanup_generic_gfree") + (return-type "none") + (parameters + '("void*" "p") + ) +) + + + +;; From glibconfig.h + + + +;; From glib.h + + + +;; From glib-init.h + +(define-function g_thread_win32_thread_detach + (c-name "g_thread_win32_thread_detach") + (return-type "none") +) + +(define-function g_thread_win32_init + (c-name "g_thread_win32_init") + (return-type "none") +) + +(define-function g_clock_win32_init + (c-name "g_clock_win32_init") + (return-type "none") +) + + + +;; From glibintl.h + +(define-function glib_gettext + (c-name "glib_gettext") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "str") + ) +) + +(define-function glib_pgettext + (c-name "glib_pgettext") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "msgctxtid") + '("gsize" "msgidoffset") + ) +) + + + +;; From glib-object.h + + + +;; From glib_trace.h + + + +;; From glib-unix.h + +(define-function g_unix_error_quark + (c-name "g_unix_error_quark") + (return-type "GQuark") +) + +(define-function g_unix_open_pipe + (c-name "g_unix_open_pipe") + (return-type "gboolean") + (parameters + '("gint*" "fds") + '("gint" "flags") + '("GError**" "error") + ) +) + +(define-function g_unix_set_fd_nonblocking + (c-name "g_unix_set_fd_nonblocking") + (return-type "gboolean") + (parameters + '("gint" "fd") + '("gboolean" "nonblock") + '("GError**" "error") + ) +) + +(define-function g_unix_signal_source_new + (c-name "g_unix_signal_source_new") + (is-constructor-of "GUnixSignalSource") + (return-type "GSource*") + (parameters + '("gint" "signum") + ) +) + +(define-function g_unix_signal_add_full + (c-name "g_unix_signal_add_full") + (return-type "guint") + (parameters + '("gint" "priority") + '("gint" "signum") + '("GSourceFunc" "handler") + '("gpointer" "user_data") + '("GDestroyNotify" "notify") + ) +) + +(define-function g_unix_signal_add + (c-name "g_unix_signal_add") + (return-type "guint") + (parameters + '("gint" "signum") + '("GSourceFunc" "handler") + '("gpointer" "user_data") + ) +) + +(define-function g_unix_fd_source_new + (c-name "g_unix_fd_source_new") + (is-constructor-of "GUnixFdSource") + (return-type "GSource*") + (parameters + '("gint" "fd") + '("GIOCondition" "condition") + ) +) + +(define-function g_unix_fd_add_full + (c-name "g_unix_fd_add_full") + (return-type "guint") + (parameters + '("gint" "priority") + '("gint" "fd") + '("GIOCondition" "condition") + '("GUnixFDSourceFunc" "function") + '("gpointer" "user_data") + '("GDestroyNotify" "notify") + ) +) + +(define-function g_unix_fd_add + (c-name "g_unix_fd_add") + (return-type "guint") + (parameters + '("gint" "fd") + '("GIOCondition" "condition") + '("GUnixFDSourceFunc" "function") + '("gpointer" "user_data") + ) +) + + + +;; From glist.h + +(define-function g_list_alloc + (c-name "g_list_alloc") + (return-type "GList*") +) + +(define-method free + (of-object "GList") + (c-name "g_list_free") + (return-type "none") +) + +(define-method free_1 + (of-object "GList") + (c-name "g_list_free_1") + (return-type "none") +) + +(define-method free_full + (of-object "GList") + (c-name "g_list_free_full") + (return-type "none") + (parameters + '("GDestroyNotify" "free_func") + ) +) + +(define-method append + (of-object "GList") + (c-name "g_list_append") + (return-type "GList*") + (parameters + '("gpointer" "data") + ) +) + +(define-method prepend + (of-object "GList") + (c-name "g_list_prepend") + (return-type "GList*") + (parameters + '("gpointer" "data") + ) +) + +(define-method insert + (of-object "GList") + (c-name "g_list_insert") + (return-type "GList*") + (parameters + '("gpointer" "data") + '("gint" "position") + ) +) + +(define-method insert_sorted + (of-object "GList") + (c-name "g_list_insert_sorted") + (return-type "GList*") + (parameters + '("gpointer" "data") + '("GCompareFunc" "func") + ) +) + +(define-method insert_sorted_with_data + (of-object "GList") + (c-name "g_list_insert_sorted_with_data") + (return-type "GList*") + (parameters + '("gpointer" "data") + '("GCompareDataFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-method insert_before + (of-object "GList") + (c-name "g_list_insert_before") + (return-type "GList*") + (parameters + '("GList*" "sibling") + '("gpointer" "data") + ) +) + +(define-method concat + (of-object "GList") + (c-name "g_list_concat") + (return-type "GList*") + (parameters + '("GList*" "list2") + ) +) + +(define-method remove + (of-object "GList") + (c-name "g_list_remove") + (return-type "GList*") + (parameters + '("gconstpointer" "data") + ) +) + +(define-method remove_all + (of-object "GList") + (c-name "g_list_remove_all") + (return-type "GList*") + (parameters + '("gconstpointer" "data") + ) +) + +(define-method remove_link + (of-object "GList") + (c-name "g_list_remove_link") + (return-type "GList*") + (parameters + '("GList*" "llink") + ) +) + +(define-method delete_link + (of-object "GList") + (c-name "g_list_delete_link") + (return-type "GList*") + (parameters + '("GList*" "link_") + ) +) + +(define-method reverse + (of-object "GList") + (c-name "g_list_reverse") + (return-type "GList*") +) + +(define-method copy + (of-object "GList") + (c-name "g_list_copy") + (return-type "GList*") +) + +(define-method copy_deep + (of-object "GList") + (c-name "g_list_copy_deep") + (return-type "GList*") + (parameters + '("GCopyFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-method nth + (of-object "GList") + (c-name "g_list_nth") + (return-type "GList*") + (parameters + '("guint" "n") + ) +) + +(define-method nth_prev + (of-object "GList") + (c-name "g_list_nth_prev") + (return-type "GList*") + (parameters + '("guint" "n") + ) +) + +(define-method find + (of-object "GList") + (c-name "g_list_find") + (return-type "GList*") + (parameters + '("gconstpointer" "data") + ) +) + +(define-method find_custom + (of-object "GList") + (c-name "g_list_find_custom") + (return-type "GList*") + (parameters + '("gconstpointer" "data") + '("GCompareFunc" "func") + ) +) + +(define-method position + (of-object "GList") + (c-name "g_list_position") + (return-type "gint") + (parameters + '("GList*" "llink") + ) +) + +(define-method index + (of-object "GList") + (c-name "g_list_index") + (return-type "gint") + (parameters + '("gconstpointer" "data") + ) +) + +(define-method last + (of-object "GList") + (c-name "g_list_last") + (return-type "GList*") +) + +(define-method first + (of-object "GList") + (c-name "g_list_first") + (return-type "GList*") +) + +(define-method length + (of-object "GList") + (c-name "g_list_length") + (return-type "guint") +) + +(define-method foreach + (of-object "GList") + (c-name "g_list_foreach") + (return-type "none") + (parameters + '("GFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-method sort + (of-object "GList") + (c-name "g_list_sort") + (return-type "GList*") + (parameters + '("GCompareFunc" "compare_func") + ) +) + +(define-method sort_with_data + (of-object "GList") + (c-name "g_list_sort_with_data") + (return-type "GList*") + (parameters + '("GCompareDataFunc" "compare_func") + '("gpointer" "user_data") + ) +) + +(define-method nth_data + (of-object "GList") + (c-name "g_list_nth_data") + (return-type "gpointer") + (parameters + '("guint" "n") + ) +) + + + +;; From gmacros.h + + + +;; From gmain.h + +(define-function g_main_context_new + (c-name "g_main_context_new") + (is-constructor-of "GMainContext") + (return-type "GMainContext*") +) + (define-method ref (of-object "GMainContext") (c-name "g_main_context_ref") (return-type "GMainContext*") ) +(define-method unref + (of-object "GMainContext") + (c-name "g_main_context_unref") + (return-type "none") +) + +(define-function g_main_context_default + (c-name "g_main_context_default") + (return-type "GMainContext*") +) + +(define-method iteration + (of-object "GMainContext") + (c-name "g_main_context_iteration") + (return-type "gboolean") + (parameters + '("gboolean" "may_block") + ) +) + +(define-method pending + (of-object "GMainContext") + (c-name "g_main_context_pending") + (return-type "gboolean") +) + +(define-method find_source_by_id + (of-object "GMainContext") + (c-name "g_main_context_find_source_by_id") + (return-type "GSource*") + (parameters + '("guint" "source_id") + ) +) + +(define-method find_source_by_user_data + (of-object "GMainContext") + (c-name "g_main_context_find_source_by_user_data") + (return-type "GSource*") + (parameters + '("gpointer" "user_data") + ) +) + +(define-method find_source_by_funcs_user_data + (of-object "GMainContext") + (c-name "g_main_context_find_source_by_funcs_user_data") + (return-type "GSource*") + (parameters + '("GSourceFuncs*" "funcs") + '("gpointer" "user_data") + ) +) + +(define-method wakeup + (of-object "GMainContext") + (c-name "g_main_context_wakeup") + (return-type "none") +) + +(define-method acquire + (of-object "GMainContext") + (c-name "g_main_context_acquire") + (return-type "gboolean") +) + +(define-method release + (of-object "GMainContext") + (c-name "g_main_context_release") + (return-type "none") +) + +(define-method is_owner + (of-object "GMainContext") + (c-name "g_main_context_is_owner") + (return-type "gboolean") +) + +(define-method wait + (of-object "GMainContext") + (c-name "g_main_context_wait") + (return-type "gboolean") + (parameters + '("GCond*" "cond") + '("GMutex*" "mutex") + ) +) + +(define-method prepare + (of-object "GMainContext") + (c-name "g_main_context_prepare") + (return-type "gboolean") + (parameters + '("gint*" "priority") + ) +) + +(define-method query + (of-object "GMainContext") + (c-name "g_main_context_query") + (return-type "gint") + (parameters + '("gint" "max_priority") + '("gint*" "timeout_") + '("GPollFD*" "fds") + '("gint" "n_fds") + ) +) + +(define-method check + (of-object "GMainContext") + (c-name "g_main_context_check") + (return-type "gint") + (parameters + '("gint" "max_priority") + '("GPollFD*" "fds") + '("gint" "n_fds") + ) +) + +(define-method dispatch + (of-object "GMainContext") + (c-name "g_main_context_dispatch") + (return-type "none") +) + +(define-method set_poll_func + (of-object "GMainContext") + (c-name "g_main_context_set_poll_func") + (return-type "none") + (parameters + '("GPollFunc" "func") + ) +) + +(define-method get_poll_func + (of-object "GMainContext") + (c-name "g_main_context_get_poll_func") + (return-type "GPollFunc") +) + +(define-method add_poll + (of-object "GMainContext") + (c-name "g_main_context_add_poll") + (return-type "none") + (parameters + '("GPollFD*" "fd") + '("gint" "priority") + ) +) + +(define-method remove_poll + (of-object "GMainContext") + (c-name "g_main_context_remove_poll") + (return-type "none") + (parameters + '("GPollFD*" "fd") + ) +) + +(define-function g_main_depth + (c-name "g_main_depth") + (return-type "gint") +) + +(define-function g_main_current_source + (c-name "g_main_current_source") + (return-type "GSource*") +) + +(define-method push_thread_default + (of-object "GMainContext") + (c-name "g_main_context_push_thread_default") + (return-type "none") +) + +(define-method pop_thread_default + (of-object "GMainContext") + (c-name "g_main_context_pop_thread_default") + (return-type "none") +) + +(define-function g_main_context_get_thread_default + (c-name "g_main_context_get_thread_default") + (return-type "GMainContext*") +) + +(define-function g_main_context_ref_thread_default + (c-name "g_main_context_ref_thread_default") + (return-type "GMainContext*") +) + +(define-function g_main_loop_new + (c-name "g_main_loop_new") + (is-constructor-of "GMainLoop") + (return-type "GMainLoop*") + (parameters + '("GMainContext*" "context") + '("gboolean" "is_running") + ) +) + +(define-method run + (of-object "GMainLoop") + (c-name "g_main_loop_run") + (return-type "none") +) + +(define-method quit + (of-object "GMainLoop") + (c-name "g_main_loop_quit") + (return-type "none") +) + +(define-method ref + (of-object "GMainLoop") + (c-name "g_main_loop_ref") + (return-type "GMainLoop*") +) + +(define-method unref + (of-object "GMainLoop") + (c-name "g_main_loop_unref") + (return-type "none") +) + +(define-method is_running + (of-object "GMainLoop") + (c-name "g_main_loop_is_running") + (return-type "gboolean") +) + +(define-method get_context + (of-object "GMainLoop") + (c-name "g_main_loop_get_context") + (return-type "GMainContext*") +) + +(define-function g_source_new + (c-name "g_source_new") + (is-constructor-of "GSource") + (return-type "GSource*") + (parameters + '("GSourceFuncs*" "source_funcs") + '("guint" "struct_size") + ) +) + +(define-method ref + (of-object "GSource") + (c-name "g_source_ref") + (return-type "GSource*") +) + +(define-method unref + (of-object "GSource") + (c-name "g_source_unref") + (return-type "none") +) + +(define-method attach + (of-object "GSource") + (c-name "g_source_attach") + (return-type "guint") + (parameters + '("GMainContext*" "context") + ) +) + +(define-method destroy + (of-object "GSource") + (c-name "g_source_destroy") + (return-type "none") +) + +(define-method set_priority + (of-object "GSource") + (c-name "g_source_set_priority") + (return-type "none") + (parameters + '("gint" "priority") + ) +) + +(define-method get_priority + (of-object "GSource") + (c-name "g_source_get_priority") + (return-type "gint") +) + +(define-method set_can_recurse + (of-object "GSource") + (c-name "g_source_set_can_recurse") + (return-type "none") + (parameters + '("gboolean" "can_recurse") + ) +) + +(define-method get_can_recurse + (of-object "GSource") + (c-name "g_source_get_can_recurse") + (return-type "gboolean") +) + +(define-method get_id + (of-object "GSource") + (c-name "g_source_get_id") + (return-type "guint") +) + +(define-method get_context + (of-object "GSource") + (c-name "g_source_get_context") + (return-type "GMainContext*") +) + +(define-method set_callback + (of-object "GSource") + (c-name "g_source_set_callback") + (return-type "none") + (parameters + '("GSourceFunc" "func") + '("gpointer" "data") + '("GDestroyNotify" "notify") + ) +) + +(define-method set_funcs + (of-object "GSource") + (c-name "g_source_set_funcs") + (return-type "none") + (parameters + '("GSourceFuncs*" "funcs") + ) +) + +(define-method is_destroyed + (of-object "GSource") + (c-name "g_source_is_destroyed") + (return-type "gboolean") +) + +(define-method set_name + (of-object "GSource") + (c-name "g_source_set_name") + (return-type "none") + (parameters + '("const-char*" "name") + ) +) + +(define-method get_name + (of-object "GSource") + (c-name "g_source_get_name") + (return-type "const-char*") +) + +(define-function g_source_set_name_by_id + (c-name "g_source_set_name_by_id") + (return-type "none") + (parameters + '("guint" "tag") + '("const-char*" "name") + ) +) + +(define-method set_ready_time + (of-object "GSource") + (c-name "g_source_set_ready_time") + (return-type "none") + (parameters + '("gint64" "ready_time") + ) +) + +(define-method get_ready_time + (of-object "GSource") + (c-name "g_source_get_ready_time") + (return-type "gint64") +) + +(define-method add_unix_fd + (of-object "GSource") + (c-name "g_source_add_unix_fd") + (return-type "gpointer") + (parameters + '("gint" "fd") + '("GIOCondition" "events") + ) +) + +(define-method modify_unix_fd + (of-object "GSource") + (c-name "g_source_modify_unix_fd") + (return-type "none") + (parameters + '("gpointer" "tag") + '("GIOCondition" "new_events") + ) +) + +(define-method remove_unix_fd + (of-object "GSource") + (c-name "g_source_remove_unix_fd") + (return-type "none") + (parameters + '("gpointer" "tag") + ) +) + +(define-method query_unix_fd + (of-object "GSource") + (c-name "g_source_query_unix_fd") + (return-type "GIOCondition") + (parameters + '("gpointer" "tag") + ) +) + +(define-method set_callback_indirect + (of-object "GSource") + (c-name "g_source_set_callback_indirect") + (return-type "none") + (parameters + '("gpointer" "callback_data") + '("GSourceCallbackFuncs*" "callback_funcs") + ) +) + +(define-method add_poll + (of-object "GSource") + (c-name "g_source_add_poll") + (return-type "none") + (parameters + '("GPollFD*" "fd") + ) +) + +(define-method remove_poll + (of-object "GSource") + (c-name "g_source_remove_poll") + (return-type "none") + (parameters + '("GPollFD*" "fd") + ) +) + +(define-method add_child_source + (of-object "GSource") + (c-name "g_source_add_child_source") + (return-type "none") + (parameters + '("GSource*" "child_source") + ) +) + +(define-method remove_child_source + (of-object "GSource") + (c-name "g_source_remove_child_source") + (return-type "none") + (parameters + '("GSource*" "child_source") + ) +) + +(define-method get_current_time + (of-object "GSource") + (c-name "g_source_get_current_time") + (return-type "none") + (parameters + '("GTimeVal*" "timeval") + ) +) + +(define-method get_time + (of-object "GSource") + (c-name "g_source_get_time") + (return-type "gint64") +) + +(define-function g_idle_source_new + (c-name "g_idle_source_new") + (is-constructor-of "GIdleSource") + (return-type "GSource*") +) + +(define-function g_child_watch_source_new + (c-name "g_child_watch_source_new") + (is-constructor-of "GChildWatchSource") + (return-type "GSource*") + (parameters + '("GPid" "pid") + ) +) + +(define-function g_timeout_source_new + (c-name "g_timeout_source_new") + (is-constructor-of "GTimeoutSource") + (return-type "GSource*") + (parameters + '("guint" "interval") + ) +) + +(define-function g_timeout_source_new_seconds + (c-name "g_timeout_source_new_seconds") + (return-type "GSource*") + (parameters + '("guint" "interval") + ) +) + +(define-function g_get_current_time + (c-name "g_get_current_time") + (return-type "none") + (parameters + '("GTimeVal*" "result") + ) +) + +(define-function g_get_monotonic_time + (c-name "g_get_monotonic_time") + (return-type "gint64") +) + +(define-function g_get_real_time + (c-name "g_get_real_time") + (return-type "gint64") +) + +(define-function g_source_remove + (c-name "g_source_remove") + (return-type "gboolean") + (parameters + '("guint" "tag") + ) +) + +(define-function g_source_remove_by_user_data + (c-name "g_source_remove_by_user_data") + (return-type "gboolean") + (parameters + '("gpointer" "user_data") + ) +) + +(define-function g_source_remove_by_funcs_user_data + (c-name "g_source_remove_by_funcs_user_data") + (return-type "gboolean") + (parameters + '("GSourceFuncs*" "funcs") + '("gpointer" "user_data") + ) +) + +(define-function g_timeout_add_full + (c-name "g_timeout_add_full") + (return-type "guint") + (parameters + '("gint" "priority") + '("guint" "interval") + '("GSourceFunc" "function") + '("gpointer" "data") + '("GDestroyNotify" "notify") + ) +) + +(define-function g_timeout_add + (c-name "g_timeout_add") + (return-type "guint") + (parameters + '("guint" "interval") + '("GSourceFunc" "function") + '("gpointer" "data") + ) +) + +(define-function g_timeout_add_seconds_full + (c-name "g_timeout_add_seconds_full") + (return-type "guint") + (parameters + '("gint" "priority") + '("guint" "interval") + '("GSourceFunc" "function") + '("gpointer" "data") + '("GDestroyNotify" "notify") + ) +) + +(define-function g_timeout_add_seconds + (c-name "g_timeout_add_seconds") + (return-type "guint") + (parameters + '("guint" "interval") + '("GSourceFunc" "function") + '("gpointer" "data") + ) +) + +(define-function g_child_watch_add_full + (c-name "g_child_watch_add_full") + (return-type "guint") + (parameters + '("gint" "priority") + '("GPid" "pid") + '("GChildWatchFunc" "function") + '("gpointer" "data") + '("GDestroyNotify" "notify") + ) +) + +(define-function g_child_watch_add + (c-name "g_child_watch_add") + (return-type "guint") + (parameters + '("GPid" "pid") + '("GChildWatchFunc" "function") + '("gpointer" "data") + ) +) + +(define-function g_idle_add + (c-name "g_idle_add") + (return-type "guint") + (parameters + '("GSourceFunc" "function") + '("gpointer" "data") + ) +) + +(define-function g_idle_add_full + (c-name "g_idle_add_full") + (return-type "guint") + (parameters + '("gint" "priority") + '("GSourceFunc" "function") + '("gpointer" "data") + '("GDestroyNotify" "notify") + ) +) + +(define-function g_idle_remove_by_data + (c-name "g_idle_remove_by_data") + (return-type "gboolean") + (parameters + '("gpointer" "data") + ) +) + +(define-method invoke_full + (of-object "GMainContext") + (c-name "g_main_context_invoke_full") + (return-type "none") + (parameters + '("gint" "priority") + '("GSourceFunc" "function") + '("gpointer" "data") + '("GDestroyNotify" "notify") + ) +) + +(define-method invoke + (of-object "GMainContext") + (c-name "g_main_context_invoke") + (return-type "none") + (parameters + '("GSourceFunc" "function") + '("gpointer" "data") + ) +) + + + +;; From gmain-internal.h + + + +;; From gmappedfile.h + +(define-function g_mapped_file_new + (c-name "g_mapped_file_new") + (is-constructor-of "GMappedFile") + (return-type "GMappedFile*") + (parameters + '("const-gchar*" "filename") + '("gboolean" "writable") + '("GError**" "error") + ) +) + +(define-function g_mapped_file_new_from_fd + (c-name "g_mapped_file_new_from_fd") + (return-type "GMappedFile*") + (parameters + '("gint" "fd") + '("gboolean" "writable") + '("GError**" "error") + ) +) + +(define-method get_length + (of-object "GMappedFile") + (c-name "g_mapped_file_get_length") + (return-type "gsize") +) + +(define-method get_contents + (of-object "GMappedFile") + (c-name "g_mapped_file_get_contents") + (return-type "gchar*") +) + +(define-method get_bytes + (of-object "GMappedFile") + (c-name "g_mapped_file_get_bytes") + (return-type "GBytes*") +) + +(define-method ref + (of-object "GMappedFile") + (c-name "g_mapped_file_ref") + (return-type "GMappedFile*") +) + +(define-method unref + (of-object "GMappedFile") + (c-name "g_mapped_file_unref") + (return-type "none") +) + +(define-method free + (of-object "GMappedFile") + (c-name "g_mapped_file_free") + (return-type "none") +) + + + +;; From gmarkup.h + +(define-function g_markup_error_quark + (c-name "g_markup_error_quark") + (return-type "GQuark") +) + +(define-function g_markup_parse_context_new + (c-name "g_markup_parse_context_new") + (is-constructor-of "GMarkupParseContext") + (return-type "GMarkupParseContext*") + (parameters + '("const-GMarkupParser*" "parser") + '("GMarkupParseFlags" "flags") + '("gpointer" "user_data") + '("GDestroyNotify" "user_data_dnotify") + ) +) + +(define-method ref + (of-object "GMarkupParseContext") + (c-name "g_markup_parse_context_ref") + (return-type "GMarkupParseContext*") +) + +(define-method unref + (of-object "GMarkupParseContext") + (c-name "g_markup_parse_context_unref") + (return-type "none") +) + +(define-method free + (of-object "GMarkupParseContext") + (c-name "g_markup_parse_context_free") + (return-type "none") +) + +(define-method parse + (of-object "GMarkupParseContext") + (c-name "g_markup_parse_context_parse") + (return-type "gboolean") + (parameters + '("const-gchar*" "text") + '("gssize" "text_len") + '("GError**" "error") + ) +) + +(define-method push + (of-object "GMarkupParseContext") + (c-name "g_markup_parse_context_push") + (return-type "none") + (parameters + '("const-GMarkupParser*" "parser") + '("gpointer" "user_data") + ) +) + +(define-method pop + (of-object "GMarkupParseContext") + (c-name "g_markup_parse_context_pop") + (return-type "gpointer") +) + +(define-method end_parse + (of-object "GMarkupParseContext") + (c-name "g_markup_parse_context_end_parse") + (return-type "gboolean") + (parameters + '("GError**" "error") + ) +) + +(define-method get_element + (of-object "GMarkupParseContext") + (c-name "g_markup_parse_context_get_element") + (return-type "const-gchar*") +) + +(define-method get_element_stack + (of-object "GMarkupParseContext") + (c-name "g_markup_parse_context_get_element_stack") + (return-type "const-GSList*") +) + +(define-method get_position + (of-object "GMarkupParseContext") + (c-name "g_markup_parse_context_get_position") + (return-type "none") + (parameters + '("gint*" "line_number") + '("gint*" "char_number") + ) +) + +(define-method get_user_data + (of-object "GMarkupParseContext") + (c-name "g_markup_parse_context_get_user_data") + (return-type "gpointer") +) + +(define-function g_markup_escape_text + (c-name "g_markup_escape_text") + (return-type "gchar*") + (parameters + '("const-gchar*" "text") + '("gssize" "length") + ) +) + +(define-function g_markup_printf_escaped + (c-name "g_markup_printf_escaped") + (return-type "gchar*") + (parameters + '("const-char*" "format") + ) + (varargs #t) +) + +(define-function g_markup_vprintf_escaped + (c-name "g_markup_vprintf_escaped") + (return-type "gchar*") + (parameters + '("const-char*" "format") + '("va_list" "args") + ) +) + +(define-function g_markup_collect_attributes + (c-name "g_markup_collect_attributes") + (return-type "gboolean") + (parameters + '("const-gchar*" "element_name") + '("const-gchar**" "attribute_names") + '("const-gchar**" "attribute_values") + '("GError**" "error") + '("GMarkupCollectType" "first_type") + '("const-gchar*" "first_attr") + ) + (varargs #t) +) + + + +;; From gmem.h + +(define-function g_free + (c-name "g_free") + (return-type "none") + (parameters + '("gpointer" "mem") + ) +) + +(define-function g_clear_pointer + (c-name "g_clear_pointer") + (return-type "none") + (parameters + '("gpointer*" "pp") + '("GDestroyNotify" "destroy") + ) +) + +(define-function g_malloc + (c-name "g_malloc") + (return-type "gpointer") + (parameters + '("gsize" "n_bytes") + ) +) + +(define-function g_malloc0 + (c-name "g_malloc0") + (return-type "gpointer") + (parameters + '("gsize" "n_bytes") + ) +) + +(define-function g_realloc + (c-name "g_realloc") + (return-type "gpointer") + (parameters + '("gpointer" "mem") + '("gsize" "n_bytes") + ) +) + +(define-function g_try_malloc + (c-name "g_try_malloc") + (return-type "gpointer") + (parameters + '("gsize" "n_bytes") + ) +) + +(define-function g_try_malloc0 + (c-name "g_try_malloc0") + (return-type "gpointer") + (parameters + '("gsize" "n_bytes") + ) +) + +(define-function g_try_realloc + (c-name "g_try_realloc") + (return-type "gpointer") + (parameters + '("gpointer" "mem") + '("gsize" "n_bytes") + ) +) + +(define-function g_malloc_n + (c-name "g_malloc_n") + (return-type "gpointer") + (parameters + '("gsize" "n_blocks") + '("gsize" "n_block_bytes") + ) +) + +(define-function g_malloc0_n + (c-name "g_malloc0_n") + (return-type "gpointer") + (parameters + '("gsize" "n_blocks") + '("gsize" "n_block_bytes") + ) +) + +(define-function g_realloc_n + (c-name "g_realloc_n") + (return-type "gpointer") + (parameters + '("gpointer" "mem") + '("gsize" "n_blocks") + '("gsize" "n_block_bytes") + ) +) + +(define-function g_try_malloc_n + (c-name "g_try_malloc_n") + (return-type "gpointer") + (parameters + '("gsize" "n_blocks") + '("gsize" "n_block_bytes") + ) +) + +(define-function g_try_malloc0_n + (c-name "g_try_malloc0_n") + (return-type "gpointer") + (parameters + '("gsize" "n_blocks") + '("gsize" "n_block_bytes") + ) +) + +(define-function g_try_realloc_n + (c-name "g_try_realloc_n") + (return-type "gpointer") + (parameters + '("gpointer" "mem") + '("gsize" "n_blocks") + '("gsize" "n_block_bytes") + ) +) + +(define-function g_steal_pointer + (c-name "g_steal_pointer") + (return-type "gpointer") + (parameters + '("gpointer" "pp") + ) +) + +(define-function g_mem_set_vtable + (c-name "g_mem_set_vtable") + (return-type "none") + (parameters + '("GMemVTable*" "vtable") + ) +) + +(define-function g_mem_is_system_malloc + (c-name "g_mem_is_system_malloc") + (return-type "gboolean") +) + +(define-function g_mem_profile + (c-name "g_mem_profile") + (return-type "none") +) + + + +;; From gmessages.h + +(define-function g_printf_string_upper_bound + (c-name "g_printf_string_upper_bound") + (return-type "gsize") + (parameters + '("const-gchar*" "format") + '("va_list" "args") + ) +) + +(define-function g_log_set_handler + (c-name "g_log_set_handler") + (return-type "guint") + (parameters + '("const-gchar*" "log_domain") + '("GLogLevelFlags" "log_levels") + '("GLogFunc" "log_func") + '("gpointer" "user_data") + ) +) + +(define-function g_log_set_handler_full + (c-name "g_log_set_handler_full") + (return-type "guint") + (parameters + '("const-gchar*" "log_domain") + '("GLogLevelFlags" "log_levels") + '("GLogFunc" "log_func") + '("gpointer" "user_data") + '("GDestroyNotify" "destroy") + ) +) + +(define-function g_log_remove_handler + (c-name "g_log_remove_handler") + (return-type "none") + (parameters + '("const-gchar*" "log_domain") + '("guint" "handler_id") + ) +) + +(define-function g_log_default_handler + (c-name "g_log_default_handler") + (return-type "none") + (parameters + '("const-gchar*" "log_domain") + '("GLogLevelFlags" "log_level") + '("const-gchar*" "message") + '("gpointer" "unused_data") + ) +) + +(define-function g_log_set_default_handler + (c-name "g_log_set_default_handler") + (return-type "GLogFunc") + (parameters + '("GLogFunc" "log_func") + '("gpointer" "user_data") + ) +) + +(define-function g_log + (c-name "g_log") + (return-type "none") + (parameters + '("const-gchar*" "log_domain") + '("GLogLevelFlags" "log_level") + '("const-gchar*" "format") + ) + (varargs #t) +) + +(define-function g_logv + (c-name "g_logv") + (return-type "none") + (parameters + '("const-gchar*" "log_domain") + '("GLogLevelFlags" "log_level") + '("const-gchar*" "format") + '("va_list" "args") + ) +) + +(define-function g_log_set_fatal_mask + (c-name "g_log_set_fatal_mask") + (return-type "GLogLevelFlags") + (parameters + '("const-gchar*" "log_domain") + '("GLogLevelFlags" "fatal_mask") + ) +) + +(define-function g_log_set_always_fatal + (c-name "g_log_set_always_fatal") + (return-type "GLogLevelFlags") + (parameters + '("GLogLevelFlags" "fatal_mask") + ) +) + +(define-function g_return_if_fail_warning + (c-name "g_return_if_fail_warning") + (return-type "none") + (parameters + '("const-char*" "log_domain") + '("const-char*" "pretty_function") + '("const-char*" "expression") + ) +) + +(define-function g_warn_message + (c-name "g_warn_message") + (return-type "none") + (parameters + '("const-char*" "domain") + '("const-char*" "file") + '("int" "line") + '("const-char*" "func") + '("const-char*" "warnexpr") + ) +) + +(define-function g_assert_warning + (c-name "g_assert_warning") + (return-type "none") + (parameters + '("const-char*" "log_domain") + '("const-char*" "file") + '("const-int" "line") + '("const-char*" "pretty_function") + '("const-char*" "expression") + ) +) + +(define-function g_error + (c-name "g_error") + (return-type "none") + (parameters + '("const-gchar*" "format") + ) + (varargs #t) +) + +(define-function g_critical + (c-name "g_critical") + (return-type "none") + (parameters + '("const-gchar*" "format") + ) + (varargs #t) +) + +(define-function g_message + (c-name "g_message") + (return-type "none") + (parameters + '("const-gchar*" "format") + ) + (varargs #t) +) + +(define-function g_warning + (c-name "g_warning") + (return-type "none") + (parameters + '("const-gchar*" "format") + ) + (varargs #t) +) + +(define-function g_info + (c-name "g_info") + (return-type "none") + (parameters + '("const-gchar*" "format") + ) + (varargs #t) +) + +(define-function g_debug + (c-name "g_debug") + (return-type "none") + (parameters + '("const-gchar*" "format") + ) + (varargs #t) +) + +(define-function g_print + (c-name "g_print") + (return-type "none") + (parameters + '("const-gchar*" "format") + ) + (varargs #t) +) + +(define-function g_set_print_handler + (c-name "g_set_print_handler") + (return-type "GPrintFunc") + (parameters + '("GPrintFunc" "func") + ) +) + +(define-function g_printerr + (c-name "g_printerr") + (return-type "none") + (parameters + '("const-gchar*" "format") + ) + (varargs #t) +) + +(define-function g_set_printerr_handler + (c-name "g_set_printerr_handler") + (return-type "GPrintFunc") + (parameters + '("GPrintFunc" "func") + ) +) + + + +;; From gmirroringtable.h + + + +;; From gnode.h + +(define-function g_node_new + (c-name "g_node_new") + (is-constructor-of "GNode") + (return-type "GNode*") + (parameters + '("gpointer" "data") + ) +) + +(define-method destroy + (of-object "GNode") + (c-name "g_node_destroy") + (return-type "none") +) + +(define-method unlink + (of-object "GNode") + (c-name "g_node_unlink") + (return-type "none") +) + +(define-method copy_deep + (of-object "GNode") + (c-name "g_node_copy_deep") + (return-type "GNode*") + (parameters + '("GCopyFunc" "copy_func") + '("gpointer" "data") + ) +) + +(define-method copy + (of-object "GNode") + (c-name "g_node_copy") + (return-type "GNode*") +) + +(define-method insert + (of-object "GNode") + (c-name "g_node_insert") + (return-type "GNode*") + (parameters + '("gint" "position") + '("GNode*" "node") + ) +) + +(define-method insert_before + (of-object "GNode") + (c-name "g_node_insert_before") + (return-type "GNode*") + (parameters + '("GNode*" "sibling") + '("GNode*" "node") + ) +) + +(define-method insert_after + (of-object "GNode") + (c-name "g_node_insert_after") + (return-type "GNode*") + (parameters + '("GNode*" "sibling") + '("GNode*" "node") + ) +) + +(define-method prepend + (of-object "GNode") + (c-name "g_node_prepend") + (return-type "GNode*") + (parameters + '("GNode*" "node") + ) +) + +(define-method n_nodes + (of-object "GNode") + (c-name "g_node_n_nodes") + (return-type "guint") + (parameters + '("GTraverseFlags" "flags") + ) +) + +(define-method get_root + (of-object "GNode") + (c-name "g_node_get_root") + (return-type "GNode*") +) + +(define-method is_ancestor + (of-object "GNode") + (c-name "g_node_is_ancestor") + (return-type "gboolean") + (parameters + '("GNode*" "descendant") + ) +) + +(define-method depth + (of-object "GNode") + (c-name "g_node_depth") + (return-type "guint") +) + +(define-method find + (of-object "GNode") + (c-name "g_node_find") + (return-type "GNode*") + (parameters + '("GTraverseType" "order") + '("GTraverseFlags" "flags") + '("gpointer" "data") + ) +) + +(define-method traverse + (of-object "GNode") + (c-name "g_node_traverse") + (return-type "none") + (parameters + '("GTraverseType" "order") + '("GTraverseFlags" "flags") + '("gint" "max_depth") + '("GNodeTraverseFunc" "func") + '("gpointer" "data") + ) +) + +(define-method max_height + (of-object "GNode") + (c-name "g_node_max_height") + (return-type "guint") +) + +(define-method children_foreach + (of-object "GNode") + (c-name "g_node_children_foreach") + (return-type "none") + (parameters + '("GTraverseFlags" "flags") + '("GNodeForeachFunc" "func") + '("gpointer" "data") + ) +) + +(define-method reverse_children + (of-object "GNode") + (c-name "g_node_reverse_children") + (return-type "none") +) + +(define-method n_children + (of-object "GNode") + (c-name "g_node_n_children") + (return-type "guint") +) + +(define-method nth_child + (of-object "GNode") + (c-name "g_node_nth_child") + (return-type "GNode*") + (parameters + '("guint" "n") + ) +) + +(define-method last_child + (of-object "GNode") + (c-name "g_node_last_child") + (return-type "GNode*") +) + +(define-method find_child + (of-object "GNode") + (c-name "g_node_find_child") + (return-type "GNode*") + (parameters + '("GTraverseFlags" "flags") + '("gpointer" "data") + ) +) + +(define-method child_position + (of-object "GNode") + (c-name "g_node_child_position") + (return-type "gint") + (parameters + '("GNode*" "child") + ) +) + +(define-method child_index + (of-object "GNode") + (c-name "g_node_child_index") + (return-type "gint") + (parameters + '("gpointer" "data") + ) +) + +(define-method first_sibling + (of-object "GNode") + (c-name "g_node_first_sibling") + (return-type "GNode*") +) + +(define-method last_sibling + (of-object "GNode") + (c-name "g_node_last_sibling") + (return-type "GNode*") +) + + + +;; From goption.h + +(define-function g_option_error_quark + (c-name "g_option_error_quark") + (return-type "GQuark") +) + +(define-function g_option_context_new + (c-name "g_option_context_new") + (is-constructor-of "GOptionContext") + (return-type "GOptionContext*") + (parameters + '("const-gchar*" "parameter_string") + ) +) + +(define-method set_summary + (of-object "GOptionContext") + (c-name "g_option_context_set_summary") + (return-type "none") + (parameters + '("const-gchar*" "summary") + ) +) + +(define-method get_summary + (of-object "GOptionContext") + (c-name "g_option_context_get_summary") + (return-type "const-gchar*") +) + +(define-method set_description + (of-object "GOptionContext") + (c-name "g_option_context_set_description") + (return-type "none") + (parameters + '("const-gchar*" "description") + ) +) + +(define-method get_description + (of-object "GOptionContext") + (c-name "g_option_context_get_description") + (return-type "const-gchar*") +) + +(define-method free + (of-object "GOptionContext") + (c-name "g_option_context_free") + (return-type "none") +) + +(define-method set_help_enabled + (of-object "GOptionContext") + (c-name "g_option_context_set_help_enabled") + (return-type "none") + (parameters + '("gboolean" "help_enabled") + ) +) + +(define-method get_help_enabled + (of-object "GOptionContext") + (c-name "g_option_context_get_help_enabled") + (return-type "gboolean") +) + +(define-method set_ignore_unknown_options + (of-object "GOptionContext") + (c-name "g_option_context_set_ignore_unknown_options") + (return-type "none") + (parameters + '("gboolean" "ignore_unknown") + ) +) + +(define-method get_ignore_unknown_options + (of-object "GOptionContext") + (c-name "g_option_context_get_ignore_unknown_options") + (return-type "gboolean") +) + +(define-method set_strict_posix + (of-object "GOptionContext") + (c-name "g_option_context_set_strict_posix") + (return-type "none") + (parameters + '("gboolean" "strict_posix") + ) +) + +(define-method get_strict_posix + (of-object "GOptionContext") + (c-name "g_option_context_get_strict_posix") + (return-type "gboolean") +) + +(define-method add_main_entries + (of-object "GOptionContext") + (c-name "g_option_context_add_main_entries") + (return-type "none") + (parameters + '("const-GOptionEntry*" "entries") + '("const-gchar*" "translation_domain") + ) +) + +(define-method parse + (of-object "GOptionContext") + (c-name "g_option_context_parse") + (return-type "gboolean") + (parameters + '("gint*" "argc") + '("gchar***" "argv") + '("GError**" "error") + ) +) + +(define-method parse_strv + (of-object "GOptionContext") + (c-name "g_option_context_parse_strv") + (return-type "gboolean") + (parameters + '("gchar***" "arguments") + '("GError**" "error") + ) +) + +(define-method set_translate_func + (of-object "GOptionContext") + (c-name "g_option_context_set_translate_func") + (return-type "none") + (parameters + '("GTranslateFunc" "func") + '("gpointer" "data") + '("GDestroyNotify" "destroy_notify") + ) +) + +(define-method set_translation_domain + (of-object "GOptionContext") + (c-name "g_option_context_set_translation_domain") + (return-type "none") + (parameters + '("const-gchar*" "domain") + ) +) + +(define-method add_group + (of-object "GOptionContext") + (c-name "g_option_context_add_group") + (return-type "none") + (parameters + '("GOptionGroup*" "group") + ) +) + +(define-method set_main_group + (of-object "GOptionContext") + (c-name "g_option_context_set_main_group") + (return-type "none") + (parameters + '("GOptionGroup*" "group") + ) +) + +(define-method get_main_group + (of-object "GOptionContext") + (c-name "g_option_context_get_main_group") + (return-type "GOptionGroup*") +) + +(define-method get_help + (of-object "GOptionContext") + (c-name "g_option_context_get_help") + (return-type "gchar*") + (parameters + '("gboolean" "main_help") + '("GOptionGroup*" "group") + ) +) + +(define-function g_option_group_new + (c-name "g_option_group_new") + (is-constructor-of "GOptionGroup") + (return-type "GOptionGroup*") + (parameters + '("const-gchar*" "name") + '("const-gchar*" "description") + '("const-gchar*" "help_description") + '("gpointer" "user_data") + '("GDestroyNotify" "destroy") + ) +) + +(define-method set_parse_hooks + (of-object "GOptionGroup") + (c-name "g_option_group_set_parse_hooks") + (return-type "none") + (parameters + '("GOptionParseFunc" "pre_parse_func") + '("GOptionParseFunc" "post_parse_func") + ) +) + +(define-method set_error_hook + (of-object "GOptionGroup") + (c-name "g_option_group_set_error_hook") + (return-type "none") + (parameters + '("GOptionErrorFunc" "error_func") + ) +) + +(define-method free + (of-object "GOptionGroup") + (c-name "g_option_group_free") + (return-type "none") +) + +(define-method ref + (of-object "GOptionGroup") + (c-name "g_option_group_ref") + (return-type "GOptionGroup*") +) + +(define-method unref + (of-object "GOptionGroup") + (c-name "g_option_group_unref") + (return-type "none") +) + +(define-method add_entries + (of-object "GOptionGroup") + (c-name "g_option_group_add_entries") + (return-type "none") + (parameters + '("const-GOptionEntry*" "entries") + ) +) + +(define-method set_translate_func + (of-object "GOptionGroup") + (c-name "g_option_group_set_translate_func") + (return-type "none") + (parameters + '("GTranslateFunc" "func") + '("gpointer" "data") + '("GDestroyNotify" "destroy_notify") + ) +) + +(define-method set_translation_domain + (of-object "GOptionGroup") + (c-name "g_option_group_set_translation_domain") + (return-type "none") + (parameters + '("const-gchar*" "domain") + ) +) + + + +;; From gpattern.h + +(define-function g_pattern_spec_new + (c-name "g_pattern_spec_new") + (is-constructor-of "GPatternSpec") + (return-type "GPatternSpec*") + (parameters + '("const-gchar*" "pattern") + ) +) + +(define-method free + (of-object "GPatternSpec") + (c-name "g_pattern_spec_free") + (return-type "none") +) + +(define-method equal + (of-object "GPatternSpec") + (c-name "g_pattern_spec_equal") + (return-type "gboolean") + (parameters + '("GPatternSpec*" "pspec2") + ) +) + +(define-function g_pattern_match + (c-name "g_pattern_match") + (return-type "gboolean") + (parameters + '("GPatternSpec*" "pspec") + '("guint" "string_length") + '("const-gchar*" "string") + '("const-gchar*" "string_reversed") + ) +) + +(define-function g_pattern_match_string + (c-name "g_pattern_match_string") + (return-type "gboolean") + (parameters + '("GPatternSpec*" "pspec") + '("const-gchar*" "string") + ) +) + +(define-function g_pattern_match_simple + (c-name "g_pattern_match_simple") + (return-type "gboolean") + (parameters + '("const-gchar*" "pattern") + '("const-gchar*" "string") + ) +) + + + +;; From gpoll.h + +(define-function g_poll + (c-name "g_poll") + (return-type "gint") + (parameters + '("GPollFD*" "fds") + '("guint" "nfds") + '("gint" "timeout") + ) +) + + + +;; From gprimes.h + +(define-function g_spaced_primes_closest + (c-name "g_spaced_primes_closest") + (return-type "guint") + (parameters + '("guint" "num") + ) +) + + + +;; From gprintf.h + +(define-function g_printf + (c-name "g_printf") + (return-type "gint") + (parameters + '("gchar-const*" "format") + ) + (varargs #t) +) + +(define-function g_fprintf + (c-name "g_fprintf") + (return-type "gint") + (parameters + '("FILE*" "file") + '("gchar-const*" "format") + ) + (varargs #t) +) + +(define-function g_sprintf + (c-name "g_sprintf") + (return-type "gint") + (parameters + '("gchar*" "string") + '("gchar-const*" "format") + ) + (varargs #t) +) + +(define-function g_vprintf + (c-name "g_vprintf") + (return-type "gint") + (parameters + '("gchar-const*" "format") + '("va_list" "args") + ) +) + +(define-function g_vfprintf + (c-name "g_vfprintf") + (return-type "gint") + (parameters + '("FILE*" "file") + '("gchar-const*" "format") + '("va_list" "args") + ) +) + +(define-function g_vsprintf + (c-name "g_vsprintf") + (return-type "gint") + (parameters + '("gchar*" "string") + '("gchar-const*" "format") + '("va_list" "args") + ) +) + +(define-function g_vasprintf + (c-name "g_vasprintf") + (return-type "gint") + (parameters + '("gchar**" "string") + '("gchar-const*" "format") + '("va_list" "args") + ) +) + + + +;; From gprintfint.h + + + +;; From gqsort.h + +(define-function g_qsort_with_data + (c-name "g_qsort_with_data") + (return-type "none") + (parameters + '("gconstpointer" "pbase") + '("gint" "total_elems") + '("gsize" "size") + '("GCompareDataFunc" "compare_func") + '("gpointer" "user_data") + ) +) + + + +;; From gquark.h + +(define-function g_quark_try_string + (c-name "g_quark_try_string") + (return-type "GQuark") + (parameters + '("const-gchar*" "string") + ) +) + +(define-function g_quark_from_static_string + (c-name "g_quark_from_static_string") + (return-type "GQuark") + (parameters + '("const-gchar*" "string") + ) +) + +(define-function g_quark_from_string + (c-name "g_quark_from_string") + (return-type "GQuark") + (parameters + '("const-gchar*" "string") + ) +) + +(define-method to_string + (of-object "GQuark") + (c-name "g_quark_to_string") + (return-type "const-gchar*") +) + +(define-function g_intern_string + (c-name "g_intern_string") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "string") + ) +) + +(define-function g_intern_static_string + (c-name "g_intern_static_string") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "string") + ) +) + + + +;; From gqueue.h + +(define-function g_queue_new + (c-name "g_queue_new") + (is-constructor-of "GQueue") + (return-type "GQueue*") +) + +(define-method free + (of-object "GQueue") + (c-name "g_queue_free") + (return-type "none") +) + +(define-method free_full + (of-object "GQueue") + (c-name "g_queue_free_full") + (return-type "none") + (parameters + '("GDestroyNotify" "free_func") + ) +) + +(define-method init + (of-object "GQueue") + (c-name "g_queue_init") + (return-type "none") +) + +(define-method clear + (of-object "GQueue") + (c-name "g_queue_clear") + (return-type "none") +) + +(define-method is_empty + (of-object "GQueue") + (c-name "g_queue_is_empty") + (return-type "gboolean") +) + +(define-method get_length + (of-object "GQueue") + (c-name "g_queue_get_length") + (return-type "guint") +) + +(define-method reverse + (of-object "GQueue") + (c-name "g_queue_reverse") + (return-type "none") +) + +(define-method copy + (of-object "GQueue") + (c-name "g_queue_copy") + (return-type "GQueue*") +) + +(define-method foreach + (of-object "GQueue") + (c-name "g_queue_foreach") + (return-type "none") + (parameters + '("GFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-method find + (of-object "GQueue") + (c-name "g_queue_find") + (return-type "GList*") + (parameters + '("gconstpointer" "data") + ) +) + +(define-method find_custom + (of-object "GQueue") + (c-name "g_queue_find_custom") + (return-type "GList*") + (parameters + '("gconstpointer" "data") + '("GCompareFunc" "func") + ) +) + +(define-method sort + (of-object "GQueue") + (c-name "g_queue_sort") + (return-type "none") + (parameters + '("GCompareDataFunc" "compare_func") + '("gpointer" "user_data") + ) +) + +(define-method push_head + (of-object "GQueue") + (c-name "g_queue_push_head") + (return-type "none") + (parameters + '("gpointer" "data") + ) +) + +(define-method push_tail + (of-object "GQueue") + (c-name "g_queue_push_tail") + (return-type "none") + (parameters + '("gpointer" "data") + ) +) + +(define-method push_nth + (of-object "GQueue") + (c-name "g_queue_push_nth") + (return-type "none") + (parameters + '("gpointer" "data") + '("gint" "n") + ) +) + +(define-method pop_head + (of-object "GQueue") + (c-name "g_queue_pop_head") + (return-type "gpointer") +) + +(define-method pop_tail + (of-object "GQueue") + (c-name "g_queue_pop_tail") + (return-type "gpointer") +) + +(define-method pop_nth + (of-object "GQueue") + (c-name "g_queue_pop_nth") + (return-type "gpointer") + (parameters + '("guint" "n") + ) +) + +(define-method peek_head + (of-object "GQueue") + (c-name "g_queue_peek_head") + (return-type "gpointer") +) + +(define-method peek_tail + (of-object "GQueue") + (c-name "g_queue_peek_tail") + (return-type "gpointer") +) + +(define-method peek_nth + (of-object "GQueue") + (c-name "g_queue_peek_nth") + (return-type "gpointer") + (parameters + '("guint" "n") + ) +) + +(define-method index + (of-object "GQueue") + (c-name "g_queue_index") + (return-type "gint") + (parameters + '("gconstpointer" "data") + ) +) + +(define-method remove + (of-object "GQueue") + (c-name "g_queue_remove") + (return-type "gboolean") + (parameters + '("gconstpointer" "data") + ) +) + +(define-method remove_all + (of-object "GQueue") + (c-name "g_queue_remove_all") + (return-type "guint") + (parameters + '("gconstpointer" "data") + ) +) + +(define-method insert_before + (of-object "GQueue") + (c-name "g_queue_insert_before") + (return-type "none") + (parameters + '("GList*" "sibling") + '("gpointer" "data") + ) +) + +(define-method insert_after + (of-object "GQueue") + (c-name "g_queue_insert_after") + (return-type "none") + (parameters + '("GList*" "sibling") + '("gpointer" "data") + ) +) + +(define-method insert_sorted + (of-object "GQueue") + (c-name "g_queue_insert_sorted") + (return-type "none") + (parameters + '("gpointer" "data") + '("GCompareDataFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-method push_head_link + (of-object "GQueue") + (c-name "g_queue_push_head_link") + (return-type "none") + (parameters + '("GList*" "link_") + ) +) + +(define-method push_tail_link + (of-object "GQueue") + (c-name "g_queue_push_tail_link") + (return-type "none") + (parameters + '("GList*" "link_") + ) +) + +(define-method push_nth_link + (of-object "GQueue") + (c-name "g_queue_push_nth_link") + (return-type "none") + (parameters + '("gint" "n") + '("GList*" "link_") + ) +) + +(define-method pop_head_link + (of-object "GQueue") + (c-name "g_queue_pop_head_link") + (return-type "GList*") +) + +(define-method pop_tail_link + (of-object "GQueue") + (c-name "g_queue_pop_tail_link") + (return-type "GList*") +) + +(define-method pop_nth_link + (of-object "GQueue") + (c-name "g_queue_pop_nth_link") + (return-type "GList*") + (parameters + '("guint" "n") + ) +) + +(define-method peek_head_link + (of-object "GQueue") + (c-name "g_queue_peek_head_link") + (return-type "GList*") +) + +(define-method peek_tail_link + (of-object "GQueue") + (c-name "g_queue_peek_tail_link") + (return-type "GList*") +) + +(define-method peek_nth_link + (of-object "GQueue") + (c-name "g_queue_peek_nth_link") + (return-type "GList*") + (parameters + '("guint" "n") + ) +) + +(define-method link_index + (of-object "GQueue") + (c-name "g_queue_link_index") + (return-type "gint") + (parameters + '("GList*" "link_") + ) +) + +(define-method unlink + (of-object "GQueue") + (c-name "g_queue_unlink") + (return-type "none") + (parameters + '("GList*" "link_") + ) +) + +(define-method delete_link + (of-object "GQueue") + (c-name "g_queue_delete_link") + (return-type "none") + (parameters + '("GList*" "link_") + ) +) + + + +;; From grand.h + +(define-function g_rand_new_with_seed + (c-name "g_rand_new_with_seed") + (return-type "GRand*") + (parameters + '("guint32" "seed") + ) +) + +(define-function g_rand_new_with_seed_array + (c-name "g_rand_new_with_seed_array") + (return-type "GRand*") + (parameters + '("const-guint32*" "seed") + '("guint" "seed_length") + ) +) + +(define-function g_rand_new + (c-name "g_rand_new") + (is-constructor-of "GRand") + (return-type "GRand*") +) + +(define-method free + (of-object "GRand") + (c-name "g_rand_free") + (return-type "none") +) + +(define-method copy + (of-object "GRand") + (c-name "g_rand_copy") + (return-type "GRand*") +) + +(define-method set_seed + (of-object "GRand") + (c-name "g_rand_set_seed") + (return-type "none") + (parameters + '("guint32" "seed") + ) +) + +(define-method set_seed_array + (of-object "GRand") + (c-name "g_rand_set_seed_array") + (return-type "none") + (parameters + '("const-guint32*" "seed") + '("guint" "seed_length") + ) +) + +(define-method int + (of-object "GRand") + (c-name "g_rand_int") + (return-type "guint32") +) + +(define-method int_range + (of-object "GRand") + (c-name "g_rand_int_range") + (return-type "gint32") + (parameters + '("gint32" "begin") + '("gint32" "end") + ) +) + +(define-method double + (of-object "GRand") + (c-name "g_rand_double") + (return-type "gdouble") +) + +(define-method double_range + (of-object "GRand") + (c-name "g_rand_double_range") + (return-type "gdouble") + (parameters + '("gdouble" "begin") + '("gdouble" "end") + ) +) + +(define-function g_random_set_seed + (c-name "g_random_set_seed") + (return-type "none") + (parameters + '("guint32" "seed") + ) +) + +(define-function g_random_int + (c-name "g_random_int") + (return-type "guint32") +) + +(define-function g_random_int_range + (c-name "g_random_int_range") + (return-type "gint32") + (parameters + '("gint32" "begin") + '("gint32" "end") + ) +) + +(define-function g_random_double + (c-name "g_random_double") + (return-type "gdouble") +) + +(define-function g_random_double_range + (c-name "g_random_double_range") + (return-type "gdouble") + (parameters + '("gdouble" "begin") + '("gdouble" "end") + ) +) + + + +;; From gregex.h + +(define-function g_regex_error_quark + (c-name "g_regex_error_quark") + (return-type "GQuark") +) + +(define-function g_regex_new + (c-name "g_regex_new") + (is-constructor-of "GRegex") + (return-type "GRegex*") + (parameters + '("const-gchar*" "pattern") + '("GRegexCompileFlags" "compile_options") + '("GRegexMatchFlags" "match_options") + '("GError**" "error") + ) +) + +(define-method ref + (of-object "GRegex") + (c-name "g_regex_ref") + (return-type "GRegex*") +) + +(define-method unref + (of-object "GRegex") + (c-name "g_regex_unref") + (return-type "none") +) + +(define-method get_pattern + (of-object "GRegex") + (c-name "g_regex_get_pattern") + (return-type "const-gchar*") +) + +(define-method get_max_backref + (of-object "GRegex") + (c-name "g_regex_get_max_backref") + (return-type "gint") +) + +(define-method get_capture_count + (of-object "GRegex") + (c-name "g_regex_get_capture_count") + (return-type "gint") +) + +(define-method get_has_cr_or_lf + (of-object "GRegex") + (c-name "g_regex_get_has_cr_or_lf") + (return-type "gboolean") +) + +(define-method get_max_lookbehind + (of-object "GRegex") + (c-name "g_regex_get_max_lookbehind") + (return-type "gint") +) + +(define-method get_string_number + (of-object "GRegex") + (c-name "g_regex_get_string_number") + (return-type "gint") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function g_regex_escape_string + (c-name "g_regex_escape_string") + (return-type "gchar*") + (parameters + '("const-gchar*" "string") + '("gint" "length") + ) +) + +(define-function g_regex_escape_nul + (c-name "g_regex_escape_nul") + (return-type "gchar*") + (parameters + '("const-gchar*" "string") + '("gint" "length") + ) +) + +(define-method get_compile_flags + (of-object "GRegex") + (c-name "g_regex_get_compile_flags") + (return-type "GRegexCompileFlags") +) + +(define-method get_match_flags + (of-object "GRegex") + (c-name "g_regex_get_match_flags") + (return-type "GRegexMatchFlags") +) + +(define-function g_regex_match_simple + (c-name "g_regex_match_simple") + (return-type "gboolean") + (parameters + '("const-gchar*" "pattern") + '("const-gchar*" "string") + '("GRegexCompileFlags" "compile_options") + '("GRegexMatchFlags" "match_options") + ) +) + +(define-method match + (of-object "GRegex") + (c-name "g_regex_match") + (return-type "gboolean") + (parameters + '("const-gchar*" "string") + '("GRegexMatchFlags" "match_options") + '("GMatchInfo**" "match_info") + ) +) + +(define-method match_full + (of-object "GRegex") + (c-name "g_regex_match_full") + (return-type "gboolean") + (parameters + '("const-gchar*" "string") + '("gssize" "string_len") + '("gint" "start_position") + '("GRegexMatchFlags" "match_options") + '("GMatchInfo**" "match_info") + '("GError**" "error") + ) +) + +(define-method match_all + (of-object "GRegex") + (c-name "g_regex_match_all") + (return-type "gboolean") + (parameters + '("const-gchar*" "string") + '("GRegexMatchFlags" "match_options") + '("GMatchInfo**" "match_info") + ) +) + +(define-method match_all_full + (of-object "GRegex") + (c-name "g_regex_match_all_full") + (return-type "gboolean") + (parameters + '("const-gchar*" "string") + '("gssize" "string_len") + '("gint" "start_position") + '("GRegexMatchFlags" "match_options") + '("GMatchInfo**" "match_info") + '("GError**" "error") + ) +) + +(define-function g_regex_split_simple + (c-name "g_regex_split_simple") + (return-type "gchar**") + (parameters + '("const-gchar*" "pattern") + '("const-gchar*" "string") + '("GRegexCompileFlags" "compile_options") + '("GRegexMatchFlags" "match_options") + ) +) + +(define-method split + (of-object "GRegex") + (c-name "g_regex_split") + (return-type "gchar**") + (parameters + '("const-gchar*" "string") + '("GRegexMatchFlags" "match_options") + ) +) + +(define-method split_full + (of-object "GRegex") + (c-name "g_regex_split_full") + (return-type "gchar**") + (parameters + '("const-gchar*" "string") + '("gssize" "string_len") + '("gint" "start_position") + '("GRegexMatchFlags" "match_options") + '("gint" "max_tokens") + '("GError**" "error") + ) +) + +(define-method replace + (of-object "GRegex") + (c-name "g_regex_replace") + (return-type "gchar*") + (parameters + '("const-gchar*" "string") + '("gssize" "string_len") + '("gint" "start_position") + '("const-gchar*" "replacement") + '("GRegexMatchFlags" "match_options") + '("GError**" "error") + ) +) + +(define-method replace_literal + (of-object "GRegex") + (c-name "g_regex_replace_literal") + (return-type "gchar*") + (parameters + '("const-gchar*" "string") + '("gssize" "string_len") + '("gint" "start_position") + '("const-gchar*" "replacement") + '("GRegexMatchFlags" "match_options") + '("GError**" "error") + ) +) + +(define-method replace_eval + (of-object "GRegex") + (c-name "g_regex_replace_eval") + (return-type "gchar*") + (parameters + '("const-gchar*" "string") + '("gssize" "string_len") + '("gint" "start_position") + '("GRegexMatchFlags" "match_options") + '("GRegexEvalCallback" "eval") + '("gpointer" "user_data") + '("GError**" "error") + ) +) + +(define-function g_regex_check_replacement + (c-name "g_regex_check_replacement") + (return-type "gboolean") + (parameters + '("const-gchar*" "replacement") + '("gboolean*" "has_references") + '("GError**" "error") + ) +) + +(define-method get_regex + (of-object "GMatchInfo") + (c-name "g_match_info_get_regex") + (return-type "GRegex*") +) + +(define-method get_string + (of-object "GMatchInfo") + (c-name "g_match_info_get_string") + (return-type "const-gchar*") +) + +(define-method ref + (of-object "GMatchInfo") + (c-name "g_match_info_ref") + (return-type "GMatchInfo*") +) + +(define-method unref + (of-object "GMatchInfo") + (c-name "g_match_info_unref") + (return-type "none") +) + +(define-method free + (of-object "GMatchInfo") + (c-name "g_match_info_free") + (return-type "none") +) + +(define-method next + (of-object "GMatchInfo") + (c-name "g_match_info_next") + (return-type "gboolean") + (parameters + '("GError**" "error") + ) +) + +(define-method matches + (of-object "GMatchInfo") + (c-name "g_match_info_matches") + (return-type "gboolean") +) + +(define-method get_match_count + (of-object "GMatchInfo") + (c-name "g_match_info_get_match_count") + (return-type "gint") +) + +(define-method is_partial_match + (of-object "GMatchInfo") + (c-name "g_match_info_is_partial_match") + (return-type "gboolean") +) + +(define-method expand_references + (of-object "GMatchInfo") + (c-name "g_match_info_expand_references") + (return-type "gchar*") + (parameters + '("const-gchar*" "string_to_expand") + '("GError**" "error") + ) +) + +(define-method fetch + (of-object "GMatchInfo") + (c-name "g_match_info_fetch") + (return-type "gchar*") + (parameters + '("gint" "match_num") + ) +) + +(define-method fetch_pos + (of-object "GMatchInfo") + (c-name "g_match_info_fetch_pos") + (return-type "gboolean") + (parameters + '("gint" "match_num") + '("gint*" "start_pos") + '("gint*" "end_pos") + ) +) + +(define-method fetch_named + (of-object "GMatchInfo") + (c-name "g_match_info_fetch_named") + (return-type "gchar*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method fetch_named_pos + (of-object "GMatchInfo") + (c-name "g_match_info_fetch_named_pos") + (return-type "gboolean") + (parameters + '("const-gchar*" "name") + '("gint*" "start_pos") + '("gint*" "end_pos") + ) +) + +(define-method fetch_all + (of-object "GMatchInfo") + (c-name "g_match_info_fetch_all") + (return-type "gchar**") +) + + + +;; From gscanner.h + +(define-function g_scanner_new + (c-name "g_scanner_new") + (is-constructor-of "GScanner") + (return-type "GScanner*") + (parameters + '("const-GScannerConfig*" "config_templ") + ) +) + +(define-method destroy + (of-object "GScanner") + (c-name "g_scanner_destroy") + (return-type "none") +) + +(define-method input_file + (of-object "GScanner") + (c-name "g_scanner_input_file") + (return-type "none") + (parameters + '("gint" "input_fd") + ) +) + +(define-method sync_file_offset + (of-object "GScanner") + (c-name "g_scanner_sync_file_offset") + (return-type "none") +) + +(define-method input_text + (of-object "GScanner") + (c-name "g_scanner_input_text") + (return-type "none") + (parameters + '("const-gchar*" "text") + '("guint" "text_len") + ) +) + +(define-method get_next_token + (of-object "GScanner") + (c-name "g_scanner_get_next_token") + (return-type "GTokenType") +) + +(define-method peek_next_token + (of-object "GScanner") + (c-name "g_scanner_peek_next_token") + (return-type "GTokenType") +) + +(define-method cur_token + (of-object "GScanner") + (c-name "g_scanner_cur_token") + (return-type "GTokenType") +) + +(define-method cur_value + (of-object "GScanner") + (c-name "g_scanner_cur_value") + (return-type "GTokenValue") +) + +(define-method cur_line + (of-object "GScanner") + (c-name "g_scanner_cur_line") + (return-type "guint") +) + +(define-method cur_position + (of-object "GScanner") + (c-name "g_scanner_cur_position") + (return-type "guint") +) + +(define-method eof + (of-object "GScanner") + (c-name "g_scanner_eof") + (return-type "gboolean") +) + +(define-method set_scope + (of-object "GScanner") + (c-name "g_scanner_set_scope") + (return-type "guint") + (parameters + '("guint" "scope_id") + ) +) + +(define-method scope_add_symbol + (of-object "GScanner") + (c-name "g_scanner_scope_add_symbol") + (return-type "none") + (parameters + '("guint" "scope_id") + '("const-gchar*" "symbol") + '("gpointer" "value") + ) +) + +(define-method scope_remove_symbol + (of-object "GScanner") + (c-name "g_scanner_scope_remove_symbol") + (return-type "none") + (parameters + '("guint" "scope_id") + '("const-gchar*" "symbol") + ) +) + +(define-method scope_lookup_symbol + (of-object "GScanner") + (c-name "g_scanner_scope_lookup_symbol") + (return-type "gpointer") + (parameters + '("guint" "scope_id") + '("const-gchar*" "symbol") + ) +) + +(define-method scope_foreach_symbol + (of-object "GScanner") + (c-name "g_scanner_scope_foreach_symbol") + (return-type "none") + (parameters + '("guint" "scope_id") + '("GHFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-method lookup_symbol + (of-object "GScanner") + (c-name "g_scanner_lookup_symbol") + (return-type "gpointer") + (parameters + '("const-gchar*" "symbol") + ) +) + +(define-method unexp_token + (of-object "GScanner") + (c-name "g_scanner_unexp_token") + (return-type "none") + (parameters + '("GTokenType" "expected_token") + '("const-gchar*" "identifier_spec") + '("const-gchar*" "symbol_spec") + '("const-gchar*" "symbol_name") + '("const-gchar*" "message") + '("gint" "is_error") + ) +) + +(define-method error + (of-object "GScanner") + (c-name "g_scanner_error") + (return-type "none") + (parameters + '("const-gchar*" "format") + ) + (varargs #t) +) + +(define-method warn + (of-object "GScanner") + (c-name "g_scanner_warn") + (return-type "none") + (parameters + '("const-gchar*" "format") + ) + (varargs #t) +) + + + +;; From gscripttable.h + + + +;; From gsequence.h + +(define-function g_sequence_new + (c-name "g_sequence_new") + (is-constructor-of "GSequence") + (return-type "GSequence*") + (parameters + '("GDestroyNotify" "data_destroy") + ) +) + +(define-method free + (of-object "GSequence") + (c-name "g_sequence_free") + (return-type "none") +) + +(define-method get_length + (of-object "GSequence") + (c-name "g_sequence_get_length") + (return-type "gint") +) + +(define-method foreach + (of-object "GSequence") + (c-name "g_sequence_foreach") + (return-type "none") + (parameters + '("GFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-function g_sequence_foreach_range + (c-name "g_sequence_foreach_range") + (return-type "none") + (parameters + '("GSequenceIter*" "begin") + '("GSequenceIter*" "end") + '("GFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-method sort + (of-object "GSequence") + (c-name "g_sequence_sort") + (return-type "none") + (parameters + '("GCompareDataFunc" "cmp_func") + '("gpointer" "cmp_data") + ) +) + +(define-method sort_iter + (of-object "GSequence") + (c-name "g_sequence_sort_iter") + (return-type "none") + (parameters + '("GSequenceIterCompareFunc" "cmp_func") + '("gpointer" "cmp_data") + ) +) + +(define-method get_begin_iter + (of-object "GSequence") + (c-name "g_sequence_get_begin_iter") + (return-type "GSequenceIter*") +) + +(define-method get_end_iter + (of-object "GSequence") + (c-name "g_sequence_get_end_iter") + (return-type "GSequenceIter*") +) + +(define-method get_iter_at_pos + (of-object "GSequence") + (c-name "g_sequence_get_iter_at_pos") + (return-type "GSequenceIter*") + (parameters + '("gint" "pos") + ) +) + +(define-method append + (of-object "GSequence") + (c-name "g_sequence_append") + (return-type "GSequenceIter*") + (parameters + '("gpointer" "data") + ) +) + +(define-method prepend + (of-object "GSequence") + (c-name "g_sequence_prepend") + (return-type "GSequenceIter*") + (parameters + '("gpointer" "data") + ) +) + +(define-function g_sequence_insert_before + (c-name "g_sequence_insert_before") + (return-type "GSequenceIter*") + (parameters + '("GSequenceIter*" "iter") + '("gpointer" "data") + ) +) + +(define-function g_sequence_move + (c-name "g_sequence_move") + (return-type "none") + (parameters + '("GSequenceIter*" "src") + '("GSequenceIter*" "dest") + ) +) + +(define-function g_sequence_swap + (c-name "g_sequence_swap") + (return-type "none") + (parameters + '("GSequenceIter*" "a") + '("GSequenceIter*" "b") + ) +) + +(define-method insert_sorted + (of-object "GSequence") + (c-name "g_sequence_insert_sorted") + (return-type "GSequenceIter*") + (parameters + '("gpointer" "data") + '("GCompareDataFunc" "cmp_func") + '("gpointer" "cmp_data") + ) +) + +(define-method insert_sorted_iter + (of-object "GSequence") + (c-name "g_sequence_insert_sorted_iter") + (return-type "GSequenceIter*") + (parameters + '("gpointer" "data") + '("GSequenceIterCompareFunc" "iter_cmp") + '("gpointer" "cmp_data") + ) +) + +(define-function g_sequence_sort_changed + (c-name "g_sequence_sort_changed") + (return-type "none") + (parameters + '("GSequenceIter*" "iter") + '("GCompareDataFunc" "cmp_func") + '("gpointer" "cmp_data") + ) +) + +(define-function g_sequence_sort_changed_iter + (c-name "g_sequence_sort_changed_iter") + (return-type "none") + (parameters + '("GSequenceIter*" "iter") + '("GSequenceIterCompareFunc" "iter_cmp") + '("gpointer" "cmp_data") + ) +) + +(define-function g_sequence_remove + (c-name "g_sequence_remove") + (return-type "none") + (parameters + '("GSequenceIter*" "iter") + ) +) + +(define-function g_sequence_remove_range + (c-name "g_sequence_remove_range") + (return-type "none") + (parameters + '("GSequenceIter*" "begin") + '("GSequenceIter*" "end") + ) +) + +(define-function g_sequence_move_range + (c-name "g_sequence_move_range") + (return-type "none") + (parameters + '("GSequenceIter*" "dest") + '("GSequenceIter*" "begin") + '("GSequenceIter*" "end") + ) +) + +(define-method search + (of-object "GSequence") + (c-name "g_sequence_search") + (return-type "GSequenceIter*") + (parameters + '("gpointer" "data") + '("GCompareDataFunc" "cmp_func") + '("gpointer" "cmp_data") + ) +) + +(define-method search_iter + (of-object "GSequence") + (c-name "g_sequence_search_iter") + (return-type "GSequenceIter*") + (parameters + '("gpointer" "data") + '("GSequenceIterCompareFunc" "iter_cmp") + '("gpointer" "cmp_data") + ) +) + +(define-method lookup + (of-object "GSequence") + (c-name "g_sequence_lookup") + (return-type "GSequenceIter*") + (parameters + '("gpointer" "data") + '("GCompareDataFunc" "cmp_func") + '("gpointer" "cmp_data") + ) +) + +(define-method lookup_iter + (of-object "GSequence") + (c-name "g_sequence_lookup_iter") + (return-type "GSequenceIter*") + (parameters + '("gpointer" "data") + '("GSequenceIterCompareFunc" "iter_cmp") + '("gpointer" "cmp_data") + ) +) + +(define-function g_sequence_get + (c-name "g_sequence_get") + (return-type "gpointer") + (parameters + '("GSequenceIter*" "iter") + ) +) + +(define-function g_sequence_set + (c-name "g_sequence_set") + (return-type "none") + (parameters + '("GSequenceIter*" "iter") + '("gpointer" "data") + ) +) + +(define-method is_begin + (of-object "GSequenceIter") + (c-name "g_sequence_iter_is_begin") + (return-type "gboolean") +) + +(define-method is_end + (of-object "GSequenceIter") + (c-name "g_sequence_iter_is_end") + (return-type "gboolean") +) + +(define-method next + (of-object "GSequenceIter") + (c-name "g_sequence_iter_next") + (return-type "GSequenceIter*") +) + +(define-method prev + (of-object "GSequenceIter") + (c-name "g_sequence_iter_prev") + (return-type "GSequenceIter*") +) + +(define-method get_position + (of-object "GSequenceIter") + (c-name "g_sequence_iter_get_position") + (return-type "gint") +) + +(define-method move + (of-object "GSequenceIter") + (c-name "g_sequence_iter_move") + (return-type "GSequenceIter*") + (parameters + '("gint" "delta") + ) +) + +(define-method get_sequence + (of-object "GSequenceIter") + (c-name "g_sequence_iter_get_sequence") + (return-type "GSequence*") +) + +(define-method compare + (of-object "GSequenceIter") + (c-name "g_sequence_iter_compare") + (return-type "gint") + (parameters + '("GSequenceIter*" "b") + ) +) + +(define-function g_sequence_range_get_midpoint + (c-name "g_sequence_range_get_midpoint") + (return-type "GSequenceIter*") + (parameters + '("GSequenceIter*" "begin") + '("GSequenceIter*" "end") + ) +) + + + +;; From gshell.h + +(define-function g_shell_error_quark + (c-name "g_shell_error_quark") + (return-type "GQuark") +) + +(define-function g_shell_quote + (c-name "g_shell_quote") + (return-type "gchar*") + (parameters + '("const-gchar*" "unquoted_string") + ) +) + +(define-function g_shell_unquote + (c-name "g_shell_unquote") + (return-type "gchar*") + (parameters + '("const-gchar*" "quoted_string") + '("GError**" "error") + ) +) + +(define-function g_shell_parse_argv + (c-name "g_shell_parse_argv") + (return-type "gboolean") + (parameters + '("const-gchar*" "command_line") + '("gint*" "argcp") + '("gchar***" "argvp") + '("GError**" "error") + ) +) + + + +;; From gslice.h + +(define-function g_slice_alloc + (c-name "g_slice_alloc") + (return-type "gpointer") + (parameters + '("gsize" "block_size") + ) +) + +(define-function g_slice_alloc0 + (c-name "g_slice_alloc0") + (return-type "gpointer") + (parameters + '("gsize" "block_size") + ) +) + +(define-function g_slice_copy + (c-name "g_slice_copy") + (return-type "gpointer") + (parameters + '("gsize" "block_size") + '("gconstpointer" "mem_block") + ) +) + +(define-function g_slice_free1 + (c-name "g_slice_free1") + (return-type "none") + (parameters + '("gsize" "block_size") + '("gpointer" "mem_block") + ) +) + +(define-function g_slice_free_chain_with_offset + (c-name "g_slice_free_chain_with_offset") + (return-type "none") + (parameters + '("gsize" "block_size") + '("gpointer" "mem_chain") + '("gsize" "next_offset") + ) +) + +(define-function g_slice_set_config + (c-name "g_slice_set_config") + (return-type "none") + (parameters + '("GSliceConfig" "ckey") + '("gint64" "value") + ) +) + +(define-function g_slice_get_config + (c-name "g_slice_get_config") + (return-type "gint64") + (parameters + '("GSliceConfig" "ckey") + ) +) + +(define-function g_slice_get_config_state + (c-name "g_slice_get_config_state") + (return-type "gint64*") + (parameters + '("GSliceConfig" "ckey") + '("gint64" "address") + '("guint*" "n_values") + ) +) + +(define-function g_slice_debug_tree_statistics + (c-name "g_slice_debug_tree_statistics") + (return-type "none") +) + + + +;; From gslist.h + +(define-function g_slist_alloc + (c-name "g_slist_alloc") + (return-type "GSList*") +) + +(define-method free + (of-object "GSList") + (c-name "g_slist_free") + (return-type "none") +) + +(define-method free_1 + (of-object "GSList") + (c-name "g_slist_free_1") + (return-type "none") +) + +(define-method free_full + (of-object "GSList") + (c-name "g_slist_free_full") + (return-type "none") + (parameters + '("GDestroyNotify" "free_func") + ) +) + +(define-method append + (of-object "GSList") + (c-name "g_slist_append") + (return-type "GSList*") + (parameters + '("gpointer" "data") + ) +) + +(define-method prepend + (of-object "GSList") + (c-name "g_slist_prepend") + (return-type "GSList*") + (parameters + '("gpointer" "data") + ) +) + +(define-method insert + (of-object "GSList") + (c-name "g_slist_insert") + (return-type "GSList*") + (parameters + '("gpointer" "data") + '("gint" "position") + ) +) + +(define-method insert_sorted + (of-object "GSList") + (c-name "g_slist_insert_sorted") + (return-type "GSList*") + (parameters + '("gpointer" "data") + '("GCompareFunc" "func") + ) +) + +(define-method insert_sorted_with_data + (of-object "GSList") + (c-name "g_slist_insert_sorted_with_data") + (return-type "GSList*") + (parameters + '("gpointer" "data") + '("GCompareDataFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-method insert_before + (of-object "GSList") + (c-name "g_slist_insert_before") + (return-type "GSList*") + (parameters + '("GSList*" "sibling") + '("gpointer" "data") + ) +) + +(define-method concat + (of-object "GSList") + (c-name "g_slist_concat") + (return-type "GSList*") + (parameters + '("GSList*" "list2") + ) +) + +(define-method remove + (of-object "GSList") + (c-name "g_slist_remove") + (return-type "GSList*") + (parameters + '("gconstpointer" "data") + ) +) + +(define-method remove_all + (of-object "GSList") + (c-name "g_slist_remove_all") + (return-type "GSList*") + (parameters + '("gconstpointer" "data") + ) +) + +(define-method remove_link + (of-object "GSList") + (c-name "g_slist_remove_link") + (return-type "GSList*") + (parameters + '("GSList*" "link_") + ) +) + +(define-method delete_link + (of-object "GSList") + (c-name "g_slist_delete_link") + (return-type "GSList*") + (parameters + '("GSList*" "link_") + ) +) + +(define-method reverse + (of-object "GSList") + (c-name "g_slist_reverse") + (return-type "GSList*") +) + +(define-method copy + (of-object "GSList") + (c-name "g_slist_copy") + (return-type "GSList*") +) + +(define-method copy_deep + (of-object "GSList") + (c-name "g_slist_copy_deep") + (return-type "GSList*") + (parameters + '("GCopyFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-method nth + (of-object "GSList") + (c-name "g_slist_nth") + (return-type "GSList*") + (parameters + '("guint" "n") + ) +) + +(define-method find + (of-object "GSList") + (c-name "g_slist_find") + (return-type "GSList*") + (parameters + '("gconstpointer" "data") + ) +) + +(define-method find_custom + (of-object "GSList") + (c-name "g_slist_find_custom") + (return-type "GSList*") + (parameters + '("gconstpointer" "data") + '("GCompareFunc" "func") + ) +) + +(define-method position + (of-object "GSList") + (c-name "g_slist_position") + (return-type "gint") + (parameters + '("GSList*" "llink") + ) +) + +(define-method index + (of-object "GSList") + (c-name "g_slist_index") + (return-type "gint") + (parameters + '("gconstpointer" "data") + ) +) + +(define-method last + (of-object "GSList") + (c-name "g_slist_last") + (return-type "GSList*") +) + +(define-method length + (of-object "GSList") + (c-name "g_slist_length") + (return-type "guint") +) + +(define-method foreach + (of-object "GSList") + (c-name "g_slist_foreach") + (return-type "none") + (parameters + '("GFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-method sort + (of-object "GSList") + (c-name "g_slist_sort") + (return-type "GSList*") + (parameters + '("GCompareFunc" "compare_func") + ) +) + +(define-method sort_with_data + (of-object "GSList") + (c-name "g_slist_sort_with_data") + (return-type "GSList*") + (parameters + '("GCompareDataFunc" "compare_func") + '("gpointer" "user_data") + ) +) + +(define-method nth_data + (of-object "GSList") + (c-name "g_slist_nth_data") + (return-type "gpointer") + (parameters + '("guint" "n") + ) +) + + + +;; From gspawn.h + +(define-function g_spawn_error_quark + (c-name "g_spawn_error_quark") + (return-type "GQuark") +) + +(define-function g_spawn_exit_error_quark + (c-name "g_spawn_exit_error_quark") + (return-type "GQuark") +) + +(define-function g_spawn_async + (c-name "g_spawn_async") + (return-type "gboolean") + (parameters + '("const-gchar*" "working_directory") + '("gchar**" "argv") + '("gchar**" "envp") + '("GSpawnFlags" "flags") + '("GSpawnChildSetupFunc" "child_setup") + '("gpointer" "user_data") + '("GPid*" "child_pid") + '("GError**" "error") + ) +) + +(define-function g_spawn_async_with_pipes + (c-name "g_spawn_async_with_pipes") + (return-type "gboolean") + (parameters + '("const-gchar*" "working_directory") + '("gchar**" "argv") + '("gchar**" "envp") + '("GSpawnFlags" "flags") + '("GSpawnChildSetupFunc" "child_setup") + '("gpointer" "user_data") + '("GPid*" "child_pid") + '("gint*" "standard_input") + '("gint*" "standard_output") + '("gint*" "standard_error") + '("GError**" "error") + ) +) + +(define-function g_spawn_sync + (c-name "g_spawn_sync") + (return-type "gboolean") + (parameters + '("const-gchar*" "working_directory") + '("gchar**" "argv") + '("gchar**" "envp") + '("GSpawnFlags" "flags") + '("GSpawnChildSetupFunc" "child_setup") + '("gpointer" "user_data") + '("gchar**" "standard_output") + '("gchar**" "standard_error") + '("gint*" "exit_status") + '("GError**" "error") + ) +) + +(define-function g_spawn_command_line_sync + (c-name "g_spawn_command_line_sync") + (return-type "gboolean") + (parameters + '("const-gchar*" "command_line") + '("gchar**" "standard_output") + '("gchar**" "standard_error") + '("gint*" "exit_status") + '("GError**" "error") + ) +) + +(define-function g_spawn_command_line_async + (c-name "g_spawn_command_line_async") + (return-type "gboolean") + (parameters + '("const-gchar*" "command_line") + '("GError**" "error") + ) +) + +(define-function g_spawn_check_exit_status + (c-name "g_spawn_check_exit_status") + (return-type "gboolean") + (parameters + '("gint" "exit_status") + '("GError**" "error") + ) +) + +(define-function g_spawn_close_pid + (c-name "g_spawn_close_pid") + (return-type "none") + (parameters + '("GPid" "pid") + ) +) + +(define-function g_spawn_async_utf8 + (c-name "g_spawn_async_utf8") + (return-type "gboolean") + (parameters + '("const-gchar*" "working_directory") + '("gchar**" "argv") + '("gchar**" "envp") + '("GSpawnFlags" "flags") + '("GSpawnChildSetupFunc" "child_setup") + '("gpointer" "user_data") + '("GPid*" "child_pid") + '("GError**" "error") + ) +) + +(define-function g_spawn_async_with_pipes_utf8 + (c-name "g_spawn_async_with_pipes_utf8") + (return-type "gboolean") + (parameters + '("const-gchar*" "working_directory") + '("gchar**" "argv") + '("gchar**" "envp") + '("GSpawnFlags" "flags") + '("GSpawnChildSetupFunc" "child_setup") + '("gpointer" "user_data") + '("GPid*" "child_pid") + '("gint*" "standard_input") + '("gint*" "standard_output") + '("gint*" "standard_error") + '("GError**" "error") + ) +) + +(define-function g_spawn_sync_utf8 + (c-name "g_spawn_sync_utf8") + (return-type "gboolean") + (parameters + '("const-gchar*" "working_directory") + '("gchar**" "argv") + '("gchar**" "envp") + '("GSpawnFlags" "flags") + '("GSpawnChildSetupFunc" "child_setup") + '("gpointer" "user_data") + '("gchar**" "standard_output") + '("gchar**" "standard_error") + '("gint*" "exit_status") + '("GError**" "error") + ) +) + +(define-function g_spawn_command_line_sync_utf8 + (c-name "g_spawn_command_line_sync_utf8") + (return-type "gboolean") + (parameters + '("const-gchar*" "command_line") + '("gchar**" "standard_output") + '("gchar**" "standard_error") + '("gint*" "exit_status") + '("GError**" "error") + ) +) + +(define-function g_spawn_command_line_async_utf8 + (c-name "g_spawn_command_line_async_utf8") + (return-type "gboolean") + (parameters + '("const-gchar*" "command_line") + '("GError**" "error") + ) +) + + + +;; From gstdio.h + +(define-function g_access + (c-name "g_access") + (return-type "int") + (parameters + '("const-gchar*" "filename") + '("int" "mode") + ) +) + +(define-function g_chdir + (c-name "g_chdir") + (return-type "int") + (parameters + '("const-gchar*" "path") + ) +) + +(define-function g_unlink + (c-name "g_unlink") + (return-type "int") + (parameters + '("const-gchar*" "filename") + ) +) + +(define-function g_rmdir + (c-name "g_rmdir") + (return-type "int") + (parameters + '("const-gchar*" "filename") + ) +) + +(define-function g_chmod + (c-name "g_chmod") + (return-type "int") + (parameters + '("const-gchar*" "filename") + '("int" "mode") + ) +) + +(define-function g_open + (c-name "g_open") + (return-type "int") + (parameters + '("const-gchar*" "filename") + '("int" "flags") + '("int" "mode") + ) +) + +(define-function g_creat + (c-name "g_creat") + (return-type "int") + (parameters + '("const-gchar*" "filename") + '("int" "mode") + ) +) + +(define-function g_rename + (c-name "g_rename") + (return-type "int") + (parameters + '("const-gchar*" "oldfilename") + '("const-gchar*" "newfilename") + ) +) + +(define-function g_mkdir + (c-name "g_mkdir") + (return-type "int") + (parameters + '("const-gchar*" "filename") + '("int" "mode") + ) +) + +(define-function g_stat + (c-name "g_stat") + (return-type "int") + (parameters + '("const-gchar*" "filename") + '("GStatBuf*" "buf") + ) +) + +(define-function g_lstat + (c-name "g_lstat") + (return-type "int") + (parameters + '("const-gchar*" "filename") + '("GStatBuf*" "buf") + ) +) + +(define-function g_remove + (c-name "g_remove") + (return-type "int") + (parameters + '("const-gchar*" "filename") + ) +) + +(define-function g_fopen + (c-name "g_fopen") + (return-type "FILE*") + (parameters + '("const-gchar*" "filename") + '("const-gchar*" "mode") + ) +) + +(define-function g_freopen + (c-name "g_freopen") + (return-type "FILE*") + (parameters + '("const-gchar*" "filename") + '("const-gchar*" "mode") + '("FILE*" "stream") + ) +) + +(define-function g_utime + (c-name "g_utime") + (return-type "int") + (parameters + '("const-gchar*" "filename") + '("struct-utimbuf*" "utb") + ) +) + +(define-function g_close + (c-name "g_close") + (return-type "gboolean") + (parameters + '("gint" "fd") + '("GError**" "error") + ) +) + + + +;; From gstrfuncs.h + +(define-function g_ascii_tolower + (c-name "g_ascii_tolower") + (return-type "gchar") + (parameters + '("gchar" "c") + ) +) + +(define-function g_ascii_toupper + (c-name "g_ascii_toupper") + (return-type "gchar") + (parameters + '("gchar" "c") + ) +) + +(define-function g_ascii_digit_value + (c-name "g_ascii_digit_value") + (return-type "gint") + (parameters + '("gchar" "c") + ) +) + +(define-function g_ascii_xdigit_value + (c-name "g_ascii_xdigit_value") + (return-type "gint") + (parameters + '("gchar" "c") + ) +) + +(define-function g_strdelimit + (c-name "g_strdelimit") + (return-type "gchar*") + (parameters + '("gchar*" "string") + '("const-gchar*" "delimiters") + '("gchar" "new_delimiter") + ) +) + +(define-function g_strcanon + (c-name "g_strcanon") + (return-type "gchar*") + (parameters + '("gchar*" "string") + '("const-gchar*" "valid_chars") + '("gchar" "substitutor") + ) +) + +(define-function g_strerror + (c-name "g_strerror") + (return-type "const-gchar*") + (parameters + '("gint" "errnum") + ) +) + +(define-function g_strsignal + (c-name "g_strsignal") + (return-type "const-gchar*") + (parameters + '("gint" "signum") + ) +) + +(define-function g_strreverse + (c-name "g_strreverse") + (return-type "gchar*") + (parameters + '("gchar*" "string") + ) +) + +(define-function g_strlcpy + (c-name "g_strlcpy") + (return-type "gsize") + (parameters + '("gchar*" "dest") + '("const-gchar*" "src") + '("gsize" "dest_size") + ) +) + +(define-function g_strlcat + (c-name "g_strlcat") + (return-type "gsize") + (parameters + '("gchar*" "dest") + '("const-gchar*" "src") + '("gsize" "dest_size") + ) +) + +(define-function g_strstr_len + (c-name "g_strstr_len") + (return-type "gchar*") + (parameters + '("const-gchar*" "haystack") + '("gssize" "haystack_len") + '("const-gchar*" "needle") + ) +) + +(define-function g_strrstr + (c-name "g_strrstr") + (return-type "gchar*") + (parameters + '("const-gchar*" "haystack") + '("const-gchar*" "needle") + ) +) + +(define-function g_strrstr_len + (c-name "g_strrstr_len") + (return-type "gchar*") + (parameters + '("const-gchar*" "haystack") + '("gssize" "haystack_len") + '("const-gchar*" "needle") + ) +) + +(define-function g_str_has_suffix + (c-name "g_str_has_suffix") + (return-type "gboolean") + (parameters + '("const-gchar*" "str") + '("const-gchar*" "suffix") + ) +) + +(define-function g_str_has_prefix + (c-name "g_str_has_prefix") + (return-type "gboolean") + (parameters + '("const-gchar*" "str") + '("const-gchar*" "prefix") + ) +) + +(define-function g_strtod + (c-name "g_strtod") + (return-type "gdouble") + (parameters + '("const-gchar*" "nptr") + '("gchar**" "endptr") + ) +) + +(define-function g_ascii_strtod + (c-name "g_ascii_strtod") + (return-type "gdouble") + (parameters + '("const-gchar*" "nptr") + '("gchar**" "endptr") + ) +) + +(define-function g_ascii_strtoull + (c-name "g_ascii_strtoull") + (return-type "guint64") + (parameters + '("const-gchar*" "nptr") + '("gchar**" "endptr") + '("guint" "base") + ) +) + +(define-function g_ascii_strtoll + (c-name "g_ascii_strtoll") + (return-type "gint64") + (parameters + '("const-gchar*" "nptr") + '("gchar**" "endptr") + '("guint" "base") + ) +) + +(define-function g_ascii_dtostr + (c-name "g_ascii_dtostr") + (return-type "gchar*") + (parameters + '("gchar*" "buffer") + '("gint" "buf_len") + '("gdouble" "d") + ) +) + +(define-function g_ascii_formatd + (c-name "g_ascii_formatd") + (return-type "gchar*") + (parameters + '("gchar*" "buffer") + '("gint" "buf_len") + '("const-gchar*" "format") + '("gdouble" "d") + ) +) + +(define-function g_strchug + (c-name "g_strchug") + (return-type "gchar*") + (parameters + '("gchar*" "string") + ) +) + +(define-function g_strchomp + (c-name "g_strchomp") + (return-type "gchar*") + (parameters + '("gchar*" "string") + ) +) + +(define-function g_ascii_strcasecmp + (c-name "g_ascii_strcasecmp") + (return-type "gint") + (parameters + '("const-gchar*" "s1") + '("const-gchar*" "s2") + ) +) + +(define-function g_ascii_strncasecmp + (c-name "g_ascii_strncasecmp") + (return-type "gint") + (parameters + '("const-gchar*" "s1") + '("const-gchar*" "s2") + '("gsize" "n") + ) +) + +(define-function g_ascii_strdown + (c-name "g_ascii_strdown") + (return-type "gchar*") + (parameters + '("const-gchar*" "str") + '("gssize" "len") + ) +) + +(define-function g_ascii_strup + (c-name "g_ascii_strup") + (return-type "gchar*") + (parameters + '("const-gchar*" "str") + '("gssize" "len") + ) +) + +(define-function g_str_is_ascii + (c-name "g_str_is_ascii") + (return-type "gboolean") + (parameters + '("const-gchar*" "str") + ) +) + +(define-function g_strcasecmp + (c-name "g_strcasecmp") + (return-type "gint") + (parameters + '("const-gchar*" "s1") + '("const-gchar*" "s2") + ) +) + +(define-function g_strncasecmp + (c-name "g_strncasecmp") + (return-type "gint") + (parameters + '("const-gchar*" "s1") + '("const-gchar*" "s2") + '("guint" "n") + ) +) + +(define-function g_strdown + (c-name "g_strdown") + (return-type "gchar*") + (parameters + '("gchar*" "string") + ) +) + +(define-function g_strup + (c-name "g_strup") + (return-type "gchar*") + (parameters + '("gchar*" "string") + ) +) + +(define-function g_strdup + (c-name "g_strdup") + (return-type "gchar*") + (parameters + '("const-gchar*" "str") + ) +) + +(define-function g_strdup_printf + (c-name "g_strdup_printf") + (return-type "gchar*") + (parameters + '("const-gchar*" "format") + ) + (varargs #t) +) + +(define-function g_strdup_vprintf + (c-name "g_strdup_vprintf") + (return-type "gchar*") + (parameters + '("const-gchar*" "format") + '("va_list" "args") + ) +) + +(define-function g_strndup + (c-name "g_strndup") + (return-type "gchar*") + (parameters + '("const-gchar*" "str") + '("gsize" "n") + ) +) + +(define-function g_strnfill + (c-name "g_strnfill") + (return-type "gchar*") + (parameters + '("gsize" "length") + '("gchar" "fill_char") + ) +) + +(define-function g_strconcat + (c-name "g_strconcat") + (return-type "gchar*") + (parameters + '("const-gchar*" "string1") + ) + (varargs #t) +) + +(define-function g_strjoin + (c-name "g_strjoin") + (return-type "gchar*") + (parameters + '("const-gchar*" "separator") + ) + (varargs #t) +) + +(define-function g_strcompress + (c-name "g_strcompress") + (return-type "gchar*") + (parameters + '("const-gchar*" "source") + ) +) + +(define-function g_strescape + (c-name "g_strescape") + (return-type "gchar*") + (parameters + '("const-gchar*" "source") + '("const-gchar*" "exceptions") + ) +) + +(define-function g_memdup + (c-name "g_memdup") + (return-type "gpointer") + (parameters + '("gconstpointer" "mem") + '("guint" "byte_size") + ) +) + +(define-function g_strsplit + (c-name "g_strsplit") + (return-type "gchar**") + (parameters + '("const-gchar*" "string") + '("const-gchar*" "delimiter") + '("gint" "max_tokens") + ) +) + +(define-function g_strsplit_set + (c-name "g_strsplit_set") + (return-type "gchar**") + (parameters + '("const-gchar*" "string") + '("const-gchar*" "delimiters") + '("gint" "max_tokens") + ) +) + +(define-function g_strjoinv + (c-name "g_strjoinv") + (return-type "gchar*") + (parameters + '("const-gchar*" "separator") + '("gchar**" "str_array") + ) +) + +(define-function g_strfreev + (c-name "g_strfreev") + (return-type "none") + (parameters + '("gchar**" "str_array") + ) +) + +(define-function g_strdupv + (c-name "g_strdupv") + (return-type "gchar**") + (parameters + '("gchar**" "str_array") + ) +) + +(define-function g_strv_length + (c-name "g_strv_length") + (return-type "guint") + (parameters + '("gchar**" "str_array") + ) +) + +(define-function g_stpcpy + (c-name "g_stpcpy") + (return-type "gchar*") + (parameters + '("gchar*" "dest") + '("const-char*" "src") + ) +) + +(define-function g_str_to_ascii + (c-name "g_str_to_ascii") + (return-type "gchar*") + (parameters + '("const-gchar*" "str") + '("const-gchar*" "from_locale") + ) +) + +(define-function g_str_tokenize_and_fold + (c-name "g_str_tokenize_and_fold") + (return-type "gchar**") + (parameters + '("const-gchar*" "string") + '("const-gchar*" "translit_locale") + '("gchar***" "ascii_alternates") + ) +) + +(define-function g_str_match_string + (c-name "g_str_match_string") + (return-type "gboolean") + (parameters + '("const-gchar*" "search_term") + '("const-gchar*" "potential_hit") + '("gboolean" "accept_alternates") + ) +) + +(define-function g_strv_contains + (c-name "g_strv_contains") + (return-type "gboolean") + (parameters + '("const-gchar*-const*" "strv") + '("const-gchar*" "str") + ) +) + + + +;; From gstringchunk.h + +(define-function g_string_chunk_new + (c-name "g_string_chunk_new") + (is-constructor-of "GStringChunk") + (return-type "GStringChunk*") + (parameters + '("gsize" "size") + ) +) + +(define-method free + (of-object "GStringChunk") + (c-name "g_string_chunk_free") + (return-type "none") +) + +(define-method clear + (of-object "GStringChunk") + (c-name "g_string_chunk_clear") + (return-type "none") +) + +(define-method insert + (of-object "GStringChunk") + (c-name "g_string_chunk_insert") + (return-type "gchar*") + (parameters + '("const-gchar*" "string") + ) +) + +(define-method insert_len + (of-object "GStringChunk") + (c-name "g_string_chunk_insert_len") + (return-type "gchar*") + (parameters + '("const-gchar*" "string") + '("gssize" "len") + ) +) + + + +;; From gstring.h + +(define-function g_string_new + (c-name "g_string_new") + (is-constructor-of "GString") + (return-type "GString*") + (parameters + '("const-gchar*" "init") + ) +) + +(define-function g_string_new_len + (c-name "g_string_new_len") + (return-type "GString*") + (parameters + '("const-gchar*" "init") + '("gssize" "len") + ) +) + +(define-function g_string_sized_new + (c-name "g_string_sized_new") + (is-constructor-of "GStringSized") + (return-type "GString*") + (parameters + '("gsize" "dfl_size") + ) +) + +(define-method free + (of-object "GString") + (c-name "g_string_free") + (return-type "gchar*") + (parameters + '("gboolean" "free_segment") + ) +) + +(define-method free_to_bytes + (of-object "GString") + (c-name "g_string_free_to_bytes") + (return-type "GBytes*") +) + +(define-method equal + (of-object "GString") + (c-name "g_string_equal") + (return-type "gboolean") + (parameters + '("const-GString*" "v2") + ) +) + +(define-method hash + (of-object "GString") + (c-name "g_string_hash") + (return-type "guint") +) + +(define-method assign + (of-object "GString") + (c-name "g_string_assign") + (return-type "GString*") + (parameters + '("const-gchar*" "rval") + ) +) + +(define-method truncate + (of-object "GString") + (c-name "g_string_truncate") + (return-type "GString*") + (parameters + '("gsize" "len") + ) +) + +(define-method set_size + (of-object "GString") + (c-name "g_string_set_size") + (return-type "GString*") + (parameters + '("gsize" "len") + ) +) + +(define-method insert_len + (of-object "GString") + (c-name "g_string_insert_len") + (return-type "GString*") + (parameters + '("gssize" "pos") + '("const-gchar*" "val") + '("gssize" "len") + ) +) + +(define-method append + (of-object "GString") + (c-name "g_string_append") + (return-type "GString*") + (parameters + '("const-gchar*" "val") + ) +) + +(define-method append_len + (of-object "GString") + (c-name "g_string_append_len") + (return-type "GString*") + (parameters + '("const-gchar*" "val") + '("gssize" "len") + ) +) + +(define-method append_c + (of-object "GString") + (c-name "g_string_append_c") + (return-type "GString*") + (parameters + '("gchar" "c") + ) +) + +(define-method append_unichar + (of-object "GString") + (c-name "g_string_append_unichar") + (return-type "GString*") + (parameters + '("gunichar" "wc") + ) +) + +(define-method prepend + (of-object "GString") + (c-name "g_string_prepend") + (return-type "GString*") + (parameters + '("const-gchar*" "val") + ) +) + +(define-method prepend_c + (of-object "GString") + (c-name "g_string_prepend_c") + (return-type "GString*") + (parameters + '("gchar" "c") + ) +) + +(define-method prepend_unichar + (of-object "GString") + (c-name "g_string_prepend_unichar") + (return-type "GString*") + (parameters + '("gunichar" "wc") + ) +) + +(define-method prepend_len + (of-object "GString") + (c-name "g_string_prepend_len") + (return-type "GString*") + (parameters + '("const-gchar*" "val") + '("gssize" "len") + ) +) + +(define-method insert + (of-object "GString") + (c-name "g_string_insert") + (return-type "GString*") + (parameters + '("gssize" "pos") + '("const-gchar*" "val") + ) +) + +(define-method insert_c + (of-object "GString") + (c-name "g_string_insert_c") + (return-type "GString*") + (parameters + '("gssize" "pos") + '("gchar" "c") + ) +) + +(define-method insert_unichar + (of-object "GString") + (c-name "g_string_insert_unichar") + (return-type "GString*") + (parameters + '("gssize" "pos") + '("gunichar" "wc") + ) +) + +(define-method overwrite + (of-object "GString") + (c-name "g_string_overwrite") + (return-type "GString*") + (parameters + '("gsize" "pos") + '("const-gchar*" "val") + ) +) + +(define-method overwrite_len + (of-object "GString") + (c-name "g_string_overwrite_len") + (return-type "GString*") + (parameters + '("gsize" "pos") + '("const-gchar*" "val") + '("gssize" "len") + ) +) + +(define-method erase + (of-object "GString") + (c-name "g_string_erase") + (return-type "GString*") + (parameters + '("gssize" "pos") + '("gssize" "len") + ) +) + +(define-method ascii_down + (of-object "GString") + (c-name "g_string_ascii_down") + (return-type "GString*") +) + +(define-method ascii_up + (of-object "GString") + (c-name "g_string_ascii_up") + (return-type "GString*") +) + +(define-method vprintf + (of-object "GString") + (c-name "g_string_vprintf") + (return-type "none") + (parameters + '("const-gchar*" "format") + '("va_list" "args") + ) +) + +(define-method printf + (of-object "GString") + (c-name "g_string_printf") + (return-type "none") + (parameters + '("const-gchar*" "format") + ) + (varargs #t) +) + +(define-method append_vprintf + (of-object "GString") + (c-name "g_string_append_vprintf") + (return-type "none") + (parameters + '("const-gchar*" "format") + '("va_list" "args") + ) +) + +(define-method append_printf + (of-object "GString") + (c-name "g_string_append_printf") + (return-type "none") + (parameters + '("const-gchar*" "format") + ) + (varargs #t) +) + +(define-method append_uri_escaped + (of-object "GString") + (c-name "g_string_append_uri_escaped") + (return-type "GString*") + (parameters + '("const-gchar*" "unescaped") + '("const-gchar*" "reserved_chars_allowed") + '("gboolean" "allow_utf8") + ) +) + +(define-method append_c_inline + (of-object "GString") + (c-name "g_string_append_c_inline") + (return-type "GString*") + (parameters + '("gchar" "c") + ) +) + +(define-method down + (of-object "GString") + (c-name "g_string_down") + (return-type "GString*") +) + +(define-method up + (of-object "GString") + (c-name "g_string_up") + (return-type "GString*") +) + + + +;; From gtestutils.h + +(define-function g_strcmp0 + (c-name "g_strcmp0") + (return-type "int") + (parameters + '("const-char*" "str1") + '("const-char*" "str2") + ) +) + +(define-function g_test_minimized_result + (c-name "g_test_minimized_result") + (return-type "none") + (parameters + '("double" "minimized_quantity") + '("const-char*" "format") + ) + (varargs #t) +) + +(define-function g_test_maximized_result + (c-name "g_test_maximized_result") + (return-type "none") + (parameters + '("double" "maximized_quantity") + '("const-char*" "format") + ) + (varargs #t) +) + +(define-function g_test_init + (c-name "g_test_init") + (return-type "none") + (parameters + '("int*" "argc") + '("char***" "argv") + ) + (varargs #t) +) + +(define-function g_test_subprocess + (c-name "g_test_subprocess") + (return-type "gboolean") +) + +(define-function g_test_run + (c-name "g_test_run") + (return-type "int") +) + +(define-function g_test_add_func + (c-name "g_test_add_func") + (return-type "none") + (parameters + '("const-char*" "testpath") + '("GTestFunc" "test_func") + ) +) + +(define-function g_test_add_data_func + (c-name "g_test_add_data_func") + (return-type "none") + (parameters + '("const-char*" "testpath") + '("gconstpointer" "test_data") + '("GTestDataFunc" "test_func") + ) +) + +(define-function g_test_add_data_func_full + (c-name "g_test_add_data_func_full") + (return-type "none") + (parameters + '("const-char*" "testpath") + '("gpointer" "test_data") + '("GTestDataFunc" "test_func") + '("GDestroyNotify" "data_free_func") + ) +) + +(define-function g_test_fail + (c-name "g_test_fail") + (return-type "none") +) + +(define-function g_test_incomplete + (c-name "g_test_incomplete") + (return-type "none") + (parameters + '("const-gchar*" "msg") + ) +) + +(define-function g_test_skip + (c-name "g_test_skip") + (return-type "none") + (parameters + '("const-gchar*" "msg") + ) +) + +(define-function g_test_failed + (c-name "g_test_failed") + (return-type "gboolean") +) + +(define-function g_test_set_nonfatal_assertions + (c-name "g_test_set_nonfatal_assertions") + (return-type "none") +) + +(define-function g_test_message + (c-name "g_test_message") + (return-type "none") + (parameters + '("const-char*" "format") + ) + (varargs #t) +) + +(define-function g_test_bug_base + (c-name "g_test_bug_base") + (return-type "none") + (parameters + '("const-char*" "uri_pattern") + ) +) + +(define-function g_test_bug + (c-name "g_test_bug") + (return-type "none") + (parameters + '("const-char*" "bug_uri_snippet") + ) +) + (define-method release (of-object "GMainContext") (c-name "g_main_context_release") @@ -3079,12 +11058,19 @@ (return-type "GNode*") ) -(define-method last_sibling - (of-object "GNode") - (c-name "g_node_last_sibling") - (return-type "GNode*") +(define-method locker_new + (of-object "GMutex") + (c-name "g_mutex_locker_new") + (return-type "GMutexLocker*") +) + +(define-method free + (of-object "GMutexLocker") + (c-name "g_mutex_locker_free") + (return-type "none") ) + (define-method max_height (of-object "GNode") (c-name "g_node_max_height") @@ -3168,10 +11154,19 @@ ) ) -(define-method add_main_entries - (of-object "GOptionContext") - (c-name "g_option_context_add_main_entries") - (return-type "none") +(define-method move_to_front + (of-object "GThreadPool") + (c-name "g_thread_pool_move_to_front") + (return-type "gboolean") + (parameters + '("gpointer" "data") + ) +) + +(define-method set_max_threads + (of-object "GThreadPool") + (c-name "g_thread_pool_set_max_threads") + (return-type "gboolean") (parameters '("const-GOptionEntry*" "entries") '("const-gchar*" "translation_domain") @@ -3224,75 +11219,19 @@ (return-type "const-gchar*") ) -(define-method parse - (of-object "GOptionContext") - (c-name "g_option_context_parse") - (return-type "gboolean") - (parameters - '("gint*" "argc") - '("gchar***" "argv") - '("GError**" "error") - ) -) - -(define-method parse_strv - (of-object "GOptionContext") - (c-name "g_option_context_parse_strv") - (return-type "gboolean") - (parameters - '("gchar***" "arguments") - '("GError**" "error") - ) -) - -(define-method set_description - (of-object "GOptionContext") - (c-name "g_option_context_set_description") - (return-type "none") - (parameters - '("const-gchar*" "description") - ) -) -(define-method set_help_enabled - (of-object "GOptionContext") - (c-name "g_option_context_set_help_enabled") - (return-type "none") - (parameters - '("gboolean" "help_enabled") - ) -) - -(define-method set_ignore_unknown_options - (of-object "GOptionContext") - (c-name "g_option_context_set_ignore_unknown_options") - (return-type "none") - (parameters - '("gboolean" "ignore_unknown") - ) -) -(define-method set_main_group - (of-object "GOptionContext") - (c-name "g_option_context_set_main_group") - (return-type "none") - (parameters - '("GOptionGroup*" "group") - ) -) +;; From gtimer.h -(define-method set_summary - (of-object "GOptionContext") - (c-name "g_option_context_set_summary") - (return-type "none") - (parameters - '("const-gchar*" "summary") - ) +(define-function g_timer_new + (c-name "g_timer_new") + (is-constructor-of "GTimer") + (return-type "GTimer*") ) -(define-method set_translate_func - (of-object "GOptionContext") - (c-name "g_option_context_set_translate_func") +(define-method destroy + (of-object "GTimer") + (c-name "g_timer_destroy") (return-type "none") (parameters '("GTranslateFunc" "func") @@ -4095,10 +12034,25 @@ ) ) -(define-method get_next_token - (of-object "GScanner") - (c-name "g_scanner_get_next_token") - (return-type "GTokenType") + + +;; From gunicomp.h + + + +;; From gunidecomp.h + + + +;; From gurifuncs.h + +(define-function g_uri_unescape_string + (c-name "g_uri_unescape_string") + (return-type "char*") + (parameters + '("const-char*" "escaped_string") + '("const-char*" "illegal_characters") + ) ) (define-method input_file @@ -5910,27 +13864,35 @@ (return-type "gboolean") ) -(define-method is_normal_form - (of-object "GVariant") - (c-name "g_variant_is_normal_form") - (return-type "gboolean") +(define-function g_win32_get_package_installation_directory_utf8 + (c-name "g_win32_get_package_installation_directory_utf8") + (return-type "gchar*") + (parameters + '("const-gchar*" "package") + '("const-gchar*" "dll_name") + ) ) -(define-method is_of_type - (of-object "GVariant") - (c-name "g_variant_is_of_type") - (return-type "gboolean") +(define-function g_win32_get_package_installation_subdirectory_utf8 + (c-name "g_win32_get_package_installation_subdirectory_utf8") + (return-type "gchar*") (parameters '("const-GVariantType*" "type") ) ) -(define-method iter_new - (of-object "GVariant") - (c-name "g_variant_iter_new") - (return-type "GVariantIter*") +(define-function g_win32_check_windows_version + (c-name "g_win32_check_windows_version") + (return-type "gboolean") + (parameters + '("const-gint" "major") + '("const-gint" "minor") + '("const-gint" "spver") + '("const-GWin32OSType" "os_type") + ) ) + (define-method lookup (of-object "GVariant") (c-name "g_variant_lookup") |