Module:    glib
Copyright:    Original Code is Copyright (c) 1995-2004 Functional Objects, Inc.
              All rights reserved.
License:      Functional Objects Library Public License Version 1.0
Dual-license: GNU Lesser General Public License
Warranty:     Distributed WITHOUT WARRANTY OF ANY KIND

// This file is automatically generated from "glib.h"; do not edit.

define inline-only constant $G-CAN-INLINE                  =    1;
define C-pointer-type <gchar*> => <gchar>;
define C-pointer-type <gchar**> => <gchar*>;
define C-pointer-type <gshort*> => <gshort>;
define C-pointer-type <gshort**> => <gshort*>;
define C-pointer-type <glong*> => <glong>;
define C-pointer-type <glong**> => <glong*>;
define C-pointer-type <gint*> => <gint>;
define C-pointer-type <gint**> => <gint*>;
define C-pointer-type <gboolean*> => <gboolean>;
define C-pointer-type <gboolean**> => <gboolean*>;
define C-pointer-type <guchar*> => <guchar>;
define C-pointer-type <guchar**> => <guchar*>;
define C-pointer-type <gushort*> => <gushort>;
define C-pointer-type <gushort**> => <gushort*>;
define C-pointer-type <gulong*> => <gulong>;
define C-pointer-type <gulong**> => <gulong*>;
define C-pointer-type <guint*> => <guint>;
define C-pointer-type <guint**> => <guint*>;
define C-pointer-type <gfloat*> => <gfloat>;
define C-pointer-type <gfloat**> => <gfloat*>;
define C-pointer-type <gdouble*> => <gdouble>;
define C-pointer-type <gdouble**> => <gdouble*>;
define C-pointer-type <gpointer*> => <gpointer>;
define C-pointer-type <gpointer**> => <gpointer*>;
define C-pointer-type <gconstpointer*> => <gconstpointer>;
define C-pointer-type <gconstpointer**> => <gconstpointer*>;
define C-pointer-type <gssize*> => <gssize>;
define C-pointer-type <gssize**> => <gssize*>;
define C-pointer-type <gsize*> => <gsize>;
define C-pointer-type <gsize**> => <gsize*>;
define C-pointer-type <GQuark*> => <GQuark>;
define C-pointer-type <GQuark**> => <GQuark*>;
define C-pointer-type <GTime*> => <GTime>;
define C-pointer-type <GTime**> => <GTime*>;
define inline-only constant $G-LITTLE-ENDIAN               = 1234;
define inline-only constant $G-BIG-ENDIAN                  = 4321;
define inline-only constant $G-PDP-ENDIAN                  = 3412;
define C-pointer-type <GArray*> => <GArray>;
define C-pointer-type <GArray**> => <GArray*>;
define C-pointer-type <GByteArray*> => <GByteArray>;
define C-pointer-type <GByteArray**> => <GByteArray*>;
define C-pointer-type <GCompletion*> => <GCompletion>;
define C-pointer-type <GCompletion**> => <GCompletion*>;
define C-pointer-type <GDebugKey*> => <GDebugKey>;
define C-pointer-type <GDebugKey**> => <GDebugKey*>;
define C-pointer-type <GHook*> => <GHook>;
define C-pointer-type <GHook**> => <GHook*>;
define C-pointer-type <GHookList*> => <GHookList>;
define C-pointer-type <GHookList**> => <GHookList*>;
define C-pointer-type <GList*> => <GList>;
define C-pointer-type <GList**> => <GList*>;
define C-pointer-type <GNode*> => <GNode>;
define C-pointer-type <GNode**> => <GNode*>;
define C-pointer-type <GPtrArray*> => <GPtrArray>;
define C-pointer-type <GPtrArray**> => <GPtrArray*>;
define C-pointer-type <GScanner*> => <GScanner>;
define C-pointer-type <GScanner**> => <GScanner*>;
define C-pointer-type <GScannerConfig*> => <GScannerConfig>;
define C-pointer-type <GScannerConfig**> => <GScannerConfig*>;
define C-pointer-type <GSList*> => <GSList>;
define C-pointer-type <GSList**> => <GSList*>;
define C-pointer-type <GString*> => <GString>;
define C-pointer-type <GString**> => <GString*>;
define C-pointer-type <GTuples*> => <GTuples>;
define C-pointer-type <GTuples**> => <GTuples*>;
define C-pointer-type <GTokenValue*> => <GTokenValue>;
define C-pointer-type <GTokenValue**> => <GTokenValue*>;
define C-pointer-type <GIOChannel*> => <GIOChannel>;
define C-pointer-type <GIOChannel**> => <GIOChannel*>;
// enum GTraverseFlags:
define C-pointer-type <GTraverseFlags*> => <GTraverseFlags>;
define C-pointer-type <GTraverseFlags**> => <GTraverseFlags*>;
define inline-only constant $G-TRAVERSE-LEAFS = ash(1,0);
define inline-only constant $G-TRAVERSE-NON-LEAFS = ash(1,1);
define inline-only constant $G-TRAVERSE-ALL = logior($G-TRAVERSE-LEAFS, $G-TRAVERSE-NON-LEAFS);
define inline-only constant $G-TRAVERSE-MASK = #x03;

// enum GTraverseType:
define C-pointer-type <GTraverseType*> => <GTraverseType>;
define C-pointer-type <GTraverseType**> => <GTraverseType*>;
define inline-only constant $G-IN-ORDER = -1 + 1;
define inline-only constant $G-PRE-ORDER = $G-IN-ORDER + 1;
define inline-only constant $G-POST-ORDER = $G-PRE-ORDER + 1;
define inline-only constant $G-LEVEL-ORDER = $G-POST-ORDER + 1;

define inline-only constant $G-LOG-LEVEL-USER-SHIFT        =    8;
// enum GLogLevelFlags:
define C-pointer-type <GLogLevelFlags*> => <GLogLevelFlags>;
define C-pointer-type <GLogLevelFlags**> => <GLogLevelFlags*>;
define inline-only constant $G-LOG-FLAG-RECURSION = ash(1,0);
define inline-only constant $G-LOG-FLAG-FATAL = ash(1,1);
define inline-only constant $G-LOG-LEVEL-ERROR = ash(1,2);
define inline-only constant $G-LOG-LEVEL-CRITICAL = ash(1,3);
define inline-only constant $G-LOG-LEVEL-WARNING = ash(1,4);
define inline-only constant $G-LOG-LEVEL-MESSAGE = ash(1,5);
define inline-only constant $G-LOG-LEVEL-INFO = ash(1,6);
define inline-only constant $G-LOG-LEVEL-DEBUG = ash(1,7);
define inline-only constant $G-LOG-LEVEL-MASK = lognot(logior($G-LOG-FLAG-RECURSION, $G-LOG-FLAG-FATAL));

define inline-only constant $G-LOG-FATAL-MASK              =
	logior($G-LOG-FLAG-RECURSION, $G-LOG-LEVEL-ERROR);
define C-pointer-type <GCacheNewFunc*> => <GCacheNewFunc>;
define C-pointer-type <GCacheNewFunc**> => <GCacheNewFunc*>;
define C-pointer-type <GCacheDupFunc*> => <GCacheDupFunc>;
define C-pointer-type <GCacheDupFunc**> => <GCacheDupFunc*>;
define C-pointer-type <GCacheDestroyFunc*> => <GCacheDestroyFunc>;
define C-pointer-type <GCacheDestroyFunc**> => <GCacheDestroyFunc*>;
define C-pointer-type <GCompareFunc*> => <GCompareFunc>;
define C-pointer-type <GCompareFunc**> => <GCompareFunc*>;
define C-pointer-type <GCompletionFunc*> => <GCompletionFunc>;
define C-pointer-type <GCompletionFunc**> => <GCompletionFunc*>;
define C-pointer-type <GDestroyNotify*> => <GDestroyNotify>;
define C-pointer-type <GDestroyNotify**> => <GDestroyNotify*>;
define C-pointer-type <GDataForeachFunc*> => <GDataForeachFunc>;
define C-pointer-type <GDataForeachFunc**> => <GDataForeachFunc*>;
define C-pointer-type <GFunc*> => <GFunc>;
define C-pointer-type <GFunc**> => <GFunc*>;
define C-pointer-type <GHashFunc*> => <GHashFunc>;
define C-pointer-type <GHashFunc**> => <GHashFunc*>;
define C-pointer-type <GFreeFunc*> => <GFreeFunc>;
define C-pointer-type <GFreeFunc**> => <GFreeFunc*>;
define C-pointer-type <GHFunc*> => <GHFunc>;
define C-pointer-type <GHFunc**> => <GHFunc*>;
define C-pointer-type <GHRFunc*> => <GHRFunc>;
define C-pointer-type <GHRFunc**> => <GHRFunc*>;
define C-pointer-type <GHookCompareFunc*> => <GHookCompareFunc>;
define C-pointer-type <GHookCompareFunc**> => <GHookCompareFunc*>;
define C-pointer-type <GHookFindFunc*> => <GHookFindFunc>;
define C-pointer-type <GHookFindFunc**> => <GHookFindFunc*>;
define C-pointer-type <GHookMarshaller*> => <GHookMarshaller>;
define C-pointer-type <GHookMarshaller**> => <GHookMarshaller*>;
define C-pointer-type <GHookCheckMarshaller*> => <GHookCheckMarshaller>;
define C-pointer-type <GHookCheckMarshaller**> => <GHookCheckMarshaller*>;
define C-pointer-type <GHookFunc*> => <GHookFunc>;
define C-pointer-type <GHookFunc**> => <GHookFunc*>;
define C-pointer-type <GHookCheckFunc*> => <GHookCheckFunc>;
define C-pointer-type <GHookCheckFunc**> => <GHookCheckFunc*>;
define C-pointer-type <GHookFreeFunc*> => <GHookFreeFunc>;
define C-pointer-type <GHookFreeFunc**> => <GHookFreeFunc*>;
define C-pointer-type <GLogFunc*> => <GLogFunc>;
define C-pointer-type <GLogFunc**> => <GLogFunc*>;
define C-pointer-type <GNodeTraverseFunc*> => <GNodeTraverseFunc>;
define C-pointer-type <GNodeTraverseFunc**> => <GNodeTraverseFunc*>;
define C-pointer-type <GNodeForeachFunc*> => <GNodeForeachFunc>;
define C-pointer-type <GNodeForeachFunc**> => <GNodeForeachFunc*>;
define C-pointer-type <GSearchFunc*> => <GSearchFunc>;
define C-pointer-type <GSearchFunc**> => <GSearchFunc*>;
define C-pointer-type <GScannerMsgFunc*> => <GScannerMsgFunc>;
define C-pointer-type <GScannerMsgFunc**> => <GScannerMsgFunc*>;
define C-pointer-type <GTraverseFunc*> => <GTraverseFunc>;
define C-pointer-type <GTraverseFunc**> => <GTraverseFunc*>;
define C-pointer-type <GVoidFunc*> => <GVoidFunc>;
define C-pointer-type <GVoidFunc**> => <GVoidFunc*>;

define C-struct <_GList>
  sealed inline-only slot data-value     :: <gpointer>;
  sealed inline-only slot next-value     :: <GList*>;
  sealed inline-only slot prev-value     :: <GList*>;
  pointer-type-name: <_GList*>;
  c-name: "struct _GList";
end;

define C-struct <_GSList>
  sealed inline-only slot data-value     :: <gpointer>;
  sealed inline-only slot next-value     :: <GSList*>;
  pointer-type-name: <_GSList*>;
  c-name: "struct _GSList";
end;

define C-struct <_GString>
  sealed inline-only slot str-value      :: <gchar*>;
  sealed inline-only slot len-value      :: <gint>;
  pointer-type-name: <_GString*>;
  c-name: "struct _GString";
end;

define C-struct <_GArray>
  sealed inline-only slot data-value     :: <gchar*>;
  sealed inline-only slot len-value      :: <guint>;
  pointer-type-name: <_GArray*>;
  c-name: "struct _GArray";
end;

define C-struct <_GByteArray>
  sealed inline-only slot data-value     :: <guint8*>;
  sealed inline-only slot len-value      :: <guint>;
  pointer-type-name: <_GByteArray*>;
  c-name: "struct _GByteArray";
end;

define C-struct <_GPtrArray>
  sealed inline-only slot pdata-value    :: <gpointer*>;
  sealed inline-only slot len-value      :: <guint>;
  pointer-type-name: <_GPtrArray*>;
  c-name: "struct _GPtrArray";
end;

define C-struct <_GTuples>
  sealed inline-only slot len-value      :: <guint>;
  pointer-type-name: <_GTuples*>;
  c-name: "struct _GTuples";
end;

define C-struct <_GDebugKey>
  sealed inline-only slot key-value      :: <gchar*>;
  sealed inline-only slot value-value    :: <guint>;
  pointer-type-name: <_GDebugKey*>;
  c-name: "struct _GDebugKey";
end;

define inline-only C-function g-list-push-allocator
  parameter allocator1 :: <GAllocator*>;
  c-name: "g_list_push_allocator";
end;

define inline-only C-function g-list-pop-allocator
  c-name: "g_list_pop_allocator";
end;

define inline-only C-function g-list-alloc
  result value :: <GList*>;
  c-name: "g_list_alloc";
end;

define inline-only C-function g-list-free
  parameter list1      :: <GList*>;
  c-name: "g_list_free";
end;

define inline-only C-function g-list-free-1
  parameter list1      :: <GList*>;
  c-name: "g_list_free_1";
end;

define inline-only C-function g-list-append
  parameter list1      :: <GList*>;
  parameter data2      :: <gpointer>;
  result value :: <GList*>;
  c-name: "g_list_append";
end;

define inline-only C-function g-list-prepend
  parameter list1      :: <GList*>;
  parameter data2      :: <gpointer>;
  result value :: <GList*>;
  c-name: "g_list_prepend";
end;

define inline-only C-function g-list-insert
  parameter list1      :: <GList*>;
  parameter data2      :: <gpointer>;
  parameter position3  :: <gint>;
  result value :: <GList*>;
  c-name: "g_list_insert";
end;

define inline-only C-function g-list-insert-sorted
  parameter list1      :: <GList*>;
  parameter data2      :: <gpointer>;
  parameter func3      :: <GCompareFunc>;
  result value :: <GList*>;
  c-name: "g_list_insert_sorted";
end;

define inline-only C-function g-list-concat
  parameter list11     :: <GList*>;
  parameter list22     :: <GList*>;
  result value :: <GList*>;
  c-name: "g_list_concat";
end;

define inline-only C-function g-list-remove
  parameter list1      :: <GList*>;
  parameter data2      :: <gpointer>;
  result value :: <GList*>;
  c-name: "g_list_remove";
end;

define inline-only C-function g-list-remove-link
  parameter list1      :: <GList*>;
  parameter llink2     :: <GList*>;
  result value :: <GList*>;
  c-name: "g_list_remove_link";
end;

define inline-only C-function g-list-reverse
  parameter list1      :: <GList*>;
  result value :: <GList*>;
  c-name: "g_list_reverse";
end;

define inline-only C-function g-list-copy
  parameter list1      :: <GList*>;
  result value :: <GList*>;
  c-name: "g_list_copy";
end;

define inline-only C-function g-list-nth
  parameter list1      :: <GList*>;
  parameter n2         :: <guint>;
  result value :: <GList*>;
  c-name: "g_list_nth";
end;

define inline-only C-function g-list-find
  parameter list1      :: <GList*>;
  parameter data2      :: <gpointer>;
  result value :: <GList*>;
  c-name: "g_list_find";
end;

define inline-only C-function g-list-find-custom
  parameter list1      :: <GList*>;
  parameter data2      :: <gpointer>;
  parameter func3      :: <GCompareFunc>;
  result value :: <GList*>;
  c-name: "g_list_find_custom";
end;

define inline-only C-function g-list-position
  parameter list1      :: <GList*>;
  parameter llink2     :: <GList*>;
  result value :: <gint>;
  c-name: "g_list_position";
end;

define inline-only C-function g-list-index
  parameter list1      :: <GList*>;
  parameter data2      :: <gpointer>;
  result value :: <gint>;
  c-name: "g_list_index";
end;

define inline-only C-function g-list-last
  parameter list1      :: <GList*>;
  result value :: <GList*>;
  c-name: "g_list_last";
end;

define inline-only C-function g-list-first
  parameter list1      :: <GList*>;
  result value :: <GList*>;
  c-name: "g_list_first";
end;

define inline-only C-function g-list-length
  parameter list1      :: <GList*>;
  result value :: <guint>;
  c-name: "g_list_length";
end;

define inline-only C-function g-list-foreach
  parameter list1      :: <GList*>;
  parameter func2      :: <GFunc>;
  parameter user_data3 :: <gpointer>;
  c-name: "g_list_foreach";
end;

define inline-only C-function g-list-sort
  parameter list1      :: <GList*>;
  parameter compare_func2 :: <GCompareFunc>;
  result value :: <GList*>;
  c-name: "g_list_sort";
end;

define inline-only C-function g-list-nth-data
  parameter list1      :: <GList*>;
  parameter n2         :: <guint>;
  result value :: <gpointer>;
  c-name: "g_list_nth_data";
end;

define inline-only C-function g-slist-push-allocator
  parameter allocator1 :: <GAllocator*>;
  c-name: "g_slist_push_allocator";
end;

define inline-only C-function g-slist-pop-allocator
  c-name: "g_slist_pop_allocator";
end;

define inline-only C-function g-slist-alloc
  result value :: <GSList*>;
  c-name: "g_slist_alloc";
end;

define inline-only C-function g-slist-free
  parameter list1      :: <GSList*>;
  c-name: "g_slist_free";
end;

define inline-only C-function g-slist-free-1
  parameter list1      :: <GSList*>;
  c-name: "g_slist_free_1";
end;

define inline-only C-function g-slist-append
  parameter list1      :: <GSList*>;
  parameter data2      :: <gpointer>;
  result value :: <GSList*>;
  c-name: "g_slist_append";
end;

define inline-only C-function g-slist-prepend
  parameter list1      :: <GSList*>;
  parameter data2      :: <gpointer>;
  result value :: <GSList*>;
  c-name: "g_slist_prepend";
end;

define inline-only C-function g-slist-insert
  parameter list1      :: <GSList*>;
  parameter data2      :: <gpointer>;
  parameter position3  :: <gint>;
  result value :: <GSList*>;
  c-name: "g_slist_insert";
end;

define inline-only C-function g-slist-insert-sorted
  parameter list1      :: <GSList*>;
  parameter data2      :: <gpointer>;
  parameter func3      :: <GCompareFunc>;
  result value :: <GSList*>;
  c-name: "g_slist_insert_sorted";
end;

define inline-only C-function g-slist-concat
  parameter list11     :: <GSList*>;
  parameter list22     :: <GSList*>;
  result value :: <GSList*>;
  c-name: "g_slist_concat";
end;

define inline-only C-function g-slist-remove
  parameter list1      :: <GSList*>;
  parameter data2      :: <gpointer>;
  result value :: <GSList*>;
  c-name: "g_slist_remove";
end;

define inline-only C-function g-slist-remove-link
  parameter list1      :: <GSList*>;
  parameter llink2     :: <GSList*>;
  result value :: <GSList*>;
  c-name: "g_slist_remove_link";
end;

define inline-only C-function g-slist-reverse
  parameter list1      :: <GSList*>;
  result value :: <GSList*>;
  c-name: "g_slist_reverse";
end;

define inline-only C-function g-slist-copy
  parameter list1      :: <GSList*>;
  result value :: <GSList*>;
  c-name: "g_slist_copy";
end;

define inline-only C-function g-slist-nth
  parameter list1      :: <GSList*>;
  parameter n2         :: <guint>;
  result value :: <GSList*>;
  c-name: "g_slist_nth";
end;

define inline-only C-function g-slist-find
  parameter list1      :: <GSList*>;
  parameter data2      :: <gpointer>;
  result value :: <GSList*>;
  c-name: "g_slist_find";
end;

define inline-only C-function g-slist-find-custom
  parameter list1      :: <GSList*>;
  parameter data2      :: <gpointer>;
  parameter func3      :: <GCompareFunc>;
  result value :: <GSList*>;
  c-name: "g_slist_find_custom";
end;

define inline-only C-function g-slist-position
  parameter list1      :: <GSList*>;
  parameter llink2     :: <GSList*>;
  result value :: <gint>;
  c-name: "g_slist_position";
end;

define inline-only C-function g-slist-index
  parameter list1      :: <GSList*>;
  parameter data2      :: <gpointer>;
  result value :: <gint>;
  c-name: "g_slist_index";
end;

define inline-only C-function g-slist-last
  parameter list1      :: <GSList*>;
  result value :: <GSList*>;
  c-name: "g_slist_last";
end;

define inline-only C-function g-slist-length
  parameter list1      :: <GSList*>;
  result value :: <guint>;
  c-name: "g_slist_length";
end;

define inline-only C-function g-slist-foreach
  parameter list1      :: <GSList*>;
  parameter func2      :: <GFunc>;
  parameter user_data3 :: <gpointer>;
  c-name: "g_slist_foreach";
end;

define inline-only C-function g-slist-sort
  parameter list1      :: <GSList*>;
  parameter compare_func2 :: <GCompareFunc>;
  result value :: <GSList*>;
  c-name: "g_slist_sort";
end;

define inline-only C-function g-slist-nth-data
  parameter list1      :: <GSList*>;
  parameter n2         :: <guint>;
  result value :: <gpointer>;
  c-name: "g_slist_nth_data";
end;

define inline-only C-function g-hash-table-new
  parameter hash_func1 :: <GHashFunc>;
  parameter key_compare_func2 :: <GCompareFunc>;
  result value :: <GHashTable*>;
  c-name: "g_hash_table_new";
end;

define inline-only C-function g-hash-table-destroy
  parameter hash_table1 :: <GHashTable*>;
  c-name: "g_hash_table_destroy";
end;

define inline-only C-function g-hash-table-insert
  parameter hash_table1 :: <GHashTable*>;
  parameter key2       :: <gpointer>;
  parameter value3     :: <gpointer>;
  c-name: "g_hash_table_insert";
end;

define inline-only C-function g-hash-table-remove
  parameter hash_table1 :: <GHashTable*>;
  parameter key2       :: <gconstpointer>;
  c-name: "g_hash_table_remove";
end;

define inline-only C-function g-hash-table-lookup
  parameter hash_table1 :: <GHashTable*>;
  parameter key2       :: <gconstpointer>;
  result value :: <gpointer>;
  c-name: "g_hash_table_lookup";
end;

define inline-only C-function g-hash-table-lookup-extended
  parameter hash_table1 :: <GHashTable*>;
  parameter lookup_key2 :: <gconstpointer>;
  parameter orig_key3  :: <gpointer*>;
  parameter value4     :: <gpointer*>;
  result value :: <gboolean>;
  c-name: "g_hash_table_lookup_extended";
end;

define inline-only C-function g-hash-table-freeze
  parameter hash_table1 :: <GHashTable*>;
  c-name: "g_hash_table_freeze";
end;

define inline-only C-function g-hash-table-thaw
  parameter hash_table1 :: <GHashTable*>;
  c-name: "g_hash_table_thaw";
end;

define inline-only C-function g-hash-table-foreach
  parameter hash_table1 :: <GHashTable*>;
  parameter func2      :: <GHFunc>;
  parameter user_data3 :: <gpointer>;
  c-name: "g_hash_table_foreach";
end;

define inline-only C-function g-hash-table-foreach-remove
  parameter hash_table1 :: <GHashTable*>;
  parameter func2      :: <GHRFunc>;
  parameter user_data3 :: <gpointer>;
  result value :: <guint>;
  c-name: "g_hash_table_foreach_remove";
end;

define inline-only C-function g-hash-table-size
  parameter hash_table1 :: <GHashTable*>;
  result value :: <guint>;
  c-name: "g_hash_table_size";
end;

define inline-only C-function g-cache-new
  parameter value_new_func1 :: <GCacheNewFunc>;
  parameter value_destroy_func2 :: <GCacheDestroyFunc>;
  parameter key_dup_func3 :: <GCacheDupFunc>;
  parameter key_destroy_func4 :: <GCacheDestroyFunc>;
  parameter hash_key_func5 :: <GHashFunc>;
  parameter hash_value_func6 :: <GHashFunc>;
  parameter key_compare_func7 :: <GCompareFunc>;
  result value :: <GCache*>;
  c-name: "g_cache_new";
end;

define inline-only C-function g-cache-destroy
  parameter cache1     :: <GCache*>;
  c-name: "g_cache_destroy";
end;

define inline-only C-function g-cache-insert
  parameter cache1     :: <GCache*>;
  parameter key2       :: <gpointer>;
  result value :: <gpointer>;
  c-name: "g_cache_insert";
end;

define inline-only C-function g-cache-remove
  parameter cache1     :: <GCache*>;
  parameter value2     :: <gpointer>;
  c-name: "g_cache_remove";
end;

define inline-only C-function g-cache-key-foreach
  parameter cache1     :: <GCache*>;
  parameter func2      :: <GHFunc>;
  parameter user_data3 :: <gpointer>;
  c-name: "g_cache_key_foreach";
end;

define inline-only C-function g-cache-value-foreach
  parameter cache1     :: <GCache*>;
  parameter func2      :: <GHFunc>;
  parameter user_data3 :: <gpointer>;
  c-name: "g_cache_value_foreach";
end;

define inline-only C-function g-tree-new
  parameter key_compare_func1 :: <GCompareFunc>;
  result value :: <GTree*>;
  c-name: "g_tree_new";
end;

define inline-only C-function g-tree-destroy
  parameter tree1      :: <GTree*>;
  c-name: "g_tree_destroy";
end;

define inline-only C-function g-tree-insert
  parameter tree1      :: <GTree*>;
  parameter key2       :: <gpointer>;
  parameter value3     :: <gpointer>;
  c-name: "g_tree_insert";
end;

define inline-only C-function g-tree-remove
  parameter tree1      :: <GTree*>;
  parameter key2       :: <gpointer>;
  c-name: "g_tree_remove";
end;

define inline-only C-function g-tree-lookup
  parameter tree1      :: <GTree*>;
  parameter key2       :: <gpointer>;
  result value :: <gpointer>;
  c-name: "g_tree_lookup";
end;

define inline-only C-function g-tree-traverse
  parameter tree1      :: <GTree*>;
  parameter traverse_func2 :: <GTraverseFunc>;
  parameter traverse_type3 :: <C-int>;
  parameter data4      :: <gpointer>;
  c-name: "g_tree_traverse";
end;

define inline-only C-function g-tree-search
  parameter tree1      :: <GTree*>;
  parameter search_func2 :: <GSearchFunc>;
  parameter data3      :: <gpointer>;
  result value :: <gpointer>;
  c-name: "g_tree_search";
end;

define inline-only C-function g-tree-height
  parameter tree1      :: <GTree*>;
  result value :: <gint>;
  c-name: "g_tree_height";
end;

define inline-only C-function g-tree-nnodes
  parameter tree1      :: <GTree*>;
  result value :: <gint>;
  c-name: "g_tree_nnodes";
end;

define C-struct <_GNode>
  sealed inline-only slot data-value     :: <gpointer>;
  sealed inline-only slot next-value     :: <GNode*>;
  sealed inline-only slot prev-value     :: <GNode*>;
  sealed inline-only slot parent-value   :: <GNode*>;
  sealed inline-only slot children-value :: <GNode*>;
  pointer-type-name: <_GNode*>;
  c-name: "struct _GNode";
end;

define inline-only C-function g-node-push-allocator
  parameter allocator1 :: <GAllocator*>;
  c-name: "g_node_push_allocator";
end;

define inline-only C-function g-node-pop-allocator
  c-name: "g_node_pop_allocator";
end;

define inline-only C-function g-node-new
  parameter data1      :: <gpointer>;
  result value :: <GNode*>;
  c-name: "g_node_new";
end;

define inline-only C-function g-node-destroy
  parameter root1      :: <GNode*>;
  c-name: "g_node_destroy";
end;

define inline-only C-function g-node-unlink
  parameter node1      :: <GNode*>;
  c-name: "g_node_unlink";
end;

define inline-only C-function g-node-insert
  parameter parent1    :: <GNode*>;
  parameter position2  :: <gint>;
  parameter node3      :: <GNode*>;
  result value :: <GNode*>;
  c-name: "g_node_insert";
end;

define inline-only C-function g-node-insert-before
  parameter parent1    :: <GNode*>;
  parameter sibling2   :: <GNode*>;
  parameter node3      :: <GNode*>;
  result value :: <GNode*>;
  c-name: "g_node_insert_before";
end;

define inline-only C-function g-node-prepend
  parameter parent1    :: <GNode*>;
  parameter node2      :: <GNode*>;
  result value :: <GNode*>;
  c-name: "g_node_prepend";
end;

define inline-only C-function g-node-n-nodes
  parameter root1      :: <GNode*>;
  parameter flags2     :: <C-int>;
  result value :: <guint>;
  c-name: "g_node_n_nodes";
end;

define inline-only C-function g-node-get-root
  parameter node1      :: <GNode*>;
  result value :: <GNode*>;
  c-name: "g_node_get_root";
end;

define inline-only C-function g-node-is-ancestor
  parameter node1      :: <GNode*>;
  parameter descendant2 :: <GNode*>;
  result value :: <gboolean>;
  c-name: "g_node_is_ancestor";
end;

define inline-only C-function g-node-depth
  parameter node1      :: <GNode*>;
  result value :: <guint>;
  c-name: "g_node_depth";
end;

define inline-only C-function g-node-find
  parameter root1      :: <GNode*>;
  parameter order2     :: <C-int>;
  parameter flags3     :: <C-int>;
  parameter data4      :: <gpointer>;
  result value :: <GNode*>;
  c-name: "g_node_find";
end;

define inline-only C-function g-node-traverse
  parameter root1      :: <GNode*>;
  parameter order2     :: <C-int>;
  parameter flags3     :: <C-int>;
  parameter max_depth4 :: <gint>;
  parameter func5      :: <GNodeTraverseFunc>;
  parameter data6      :: <gpointer>;
  c-name: "g_node_traverse";
end;

define inline-only C-function g-node-max-height
  parameter root1      :: <GNode*>;
  result value :: <guint>;
  c-name: "g_node_max_height";
end;

define inline-only C-function g-node-children-foreach
  parameter node1      :: <GNode*>;
  parameter flags2     :: <C-int>;
  parameter func3      :: <GNodeForeachFunc>;
  parameter data4      :: <gpointer>;
  c-name: "g_node_children_foreach";
end;

define inline-only C-function g-node-reverse-children
  parameter node1      :: <GNode*>;
  c-name: "g_node_reverse_children";
end;

define inline-only C-function g-node-n-children
  parameter node1      :: <GNode*>;
  result value :: <guint>;
  c-name: "g_node_n_children";
end;

define inline-only C-function g-node-nth-child
  parameter node1      :: <GNode*>;
  parameter n2         :: <guint>;
  result value :: <GNode*>;
  c-name: "g_node_nth_child";
end;

define inline-only C-function g-node-last-child
  parameter node1      :: <GNode*>;
  result value :: <GNode*>;
  c-name: "g_node_last_child";
end;

define inline-only C-function g-node-find-child
  parameter node1      :: <GNode*>;
  parameter flags2     :: <C-int>;
  parameter data3      :: <gpointer>;
  result value :: <GNode*>;
  c-name: "g_node_find_child";
end;

define inline-only C-function g-node-child-position
  parameter node1      :: <GNode*>;
  parameter child2     :: <GNode*>;
  result value :: <gint>;
  c-name: "g_node_child_position";
end;

define inline-only C-function g-node-child-index
  parameter node1      :: <GNode*>;
  parameter data2      :: <gpointer>;
  result value :: <gint>;
  c-name: "g_node_child_index";
end;

define inline-only C-function g-node-first-sibling
  parameter node1      :: <GNode*>;
  result value :: <GNode*>;
  c-name: "g_node_first_sibling";
end;

define inline-only C-function g-node-last-sibling
  parameter node1      :: <GNode*>;
  result value :: <GNode*>;
  c-name: "g_node_last_sibling";
end;
define inline-only constant $G-HOOK-FLAG-USER-SHIFT        =    4;
// enum GHookFlagMask:
define C-pointer-type <GHookFlagMask*> => <GHookFlagMask>;
define C-pointer-type <GHookFlagMask**> => <GHookFlagMask*>;
define inline-only constant $G-HOOK-FLAG-ACTIVE = ash(1,0);
define inline-only constant $G-HOOK-FLAG-IN-CALL = ash(1,1);
define inline-only constant $G-HOOK-FLAG-MASK = #x0f;


define C-struct <_GHookList>
  sealed inline-only slot seq-id-value   :: <guint>;
  sealed inline-only slot hook-size-value :: <guint>;
  sealed bitfield slot is-setup-value    :: <guint>,
    width: 1;
  sealed inline-only slot hooks-value    :: <GHook*>;
  sealed inline-only slot hook-memchunk-value :: <GMemChunk*>;
  sealed inline-only slot hook-free-value :: <GHookFreeFunc>;
  sealed inline-only slot hook-destroy-value :: <GHookFreeFunc>;
  pointer-type-name: <_GHookList*>;
  c-name: "struct _GHookList";
end;

define C-struct <_GHook>
  sealed inline-only slot data-value     :: <gpointer>;
  sealed inline-only slot next-value     :: <GHook*>;
  sealed inline-only slot prev-value     :: <GHook*>;
  sealed inline-only slot ref-count-value :: <guint>;
  sealed inline-only slot hook-id-value  :: <guint>;
  sealed inline-only slot flags-value    :: <guint>;
  sealed inline-only slot func-value     :: <gpointer>;
  sealed inline-only slot destroy-value  :: <GDestroyNotify>;
  pointer-type-name: <_GHook*>;
  c-name: "struct _GHook";
end;

define inline-only C-function g-hook-list-init
  parameter hook_list1 :: <GHookList*>;
  parameter hook_size2 :: <guint>;
  c-name: "g_hook_list_init";
end;

define inline-only C-function g-hook-list-clear
  parameter hook_list1 :: <GHookList*>;
  c-name: "g_hook_list_clear";
end;

define inline-only C-function g-hook-alloc
  parameter hook_list1 :: <GHookList*>;
  result value :: <GHook*>;
  c-name: "g_hook_alloc";
end;

define inline-only C-function g-hook-free
  parameter hook_list1 :: <GHookList*>;
  parameter hook2      :: <GHook*>;
  c-name: "g_hook_free";
end;

define inline-only C-function g-hook-ref
  parameter hook_list1 :: <GHookList*>;
  parameter hook2      :: <GHook*>;
  c-name: "g_hook_ref";
end;

define inline-only C-function g-hook-unref
  parameter hook_list1 :: <GHookList*>;
  parameter hook2      :: <GHook*>;
  c-name: "g_hook_unref";
end;

define inline-only C-function g-hook-destroy
  parameter hook_list1 :: <GHookList*>;
  parameter hook_id2   :: <guint>;
  result value :: <gboolean>;
  c-name: "g_hook_destroy";
end;

define inline-only C-function g-hook-destroy-link
  parameter hook_list1 :: <GHookList*>;
  parameter hook2      :: <GHook*>;
  c-name: "g_hook_destroy_link";
end;

define inline-only C-function g-hook-prepend
  parameter hook_list1 :: <GHookList*>;
  parameter hook2      :: <GHook*>;
  c-name: "g_hook_prepend";
end;

define inline-only C-function g-hook-insert-before
  parameter hook_list1 :: <GHookList*>;
  parameter sibling2   :: <GHook*>;
  parameter hook3      :: <GHook*>;
  c-name: "g_hook_insert_before";
end;

define inline-only C-function g-hook-insert-sorted
  parameter hook_list1 :: <GHookList*>;
  parameter hook2      :: <GHook*>;
  parameter func3      :: <GHookCompareFunc>;
  c-name: "g_hook_insert_sorted";
end;

define inline-only C-function g-hook-get
  parameter hook_list1 :: <GHookList*>;
  parameter hook_id2   :: <guint>;
  result value :: <GHook*>;
  c-name: "g_hook_get";
end;

define inline-only C-function g-hook-find
  parameter hook_list1 :: <GHookList*>;
  parameter need_valids2 :: <gboolean>;
  parameter func3      :: <GHookFindFunc>;
  parameter data4      :: <gpointer>;
  result value :: <GHook*>;
  c-name: "g_hook_find";
end;

define inline-only C-function g-hook-find-data
  parameter hook_list1 :: <GHookList*>;
  parameter need_valids2 :: <gboolean>;
  parameter data3      :: <gpointer>;
  result value :: <GHook*>;
  c-name: "g_hook_find_data";
end;

define inline-only C-function g-hook-find-func
  parameter hook_list1 :: <GHookList*>;
  parameter need_valids2 :: <gboolean>;
  parameter func3      :: <gpointer>;
  result value :: <GHook*>;
  c-name: "g_hook_find_func";
end;

define inline-only C-function g-hook-find-func-data
  parameter hook_list1 :: <GHookList*>;
  parameter need_valids2 :: <gboolean>;
  parameter func3      :: <gpointer>;
  parameter data4      :: <gpointer>;
  result value :: <GHook*>;
  c-name: "g_hook_find_func_data";
end;

define inline-only C-function g-hook-first-valid
  parameter hook_list1 :: <GHookList*>;
  parameter may_be_in_call2 :: <gboolean>;
  result value :: <GHook*>;
  c-name: "g_hook_first_valid";
end;

define inline-only C-function g-hook-next-valid
  parameter hook_list1 :: <GHookList*>;
  parameter hook2      :: <GHook*>;
  parameter may_be_in_call3 :: <gboolean>;
  result value :: <GHook*>;
  c-name: "g_hook_next_valid";
end;

define inline-only C-function g-hook-compare-ids
  parameter new_hook1  :: <GHook*>;
  parameter sibling2   :: <GHook*>;
  result value :: <gint>;
  c-name: "g_hook_compare_ids";
end;

define inline-only C-function g-hook-list-invoke
  parameter hook_list1 :: <GHookList*>;
  parameter may_recurse2 :: <gboolean>;
  c-name: "g_hook_list_invoke";
end;

define inline-only C-function g-hook-list-invoke-check
  parameter hook_list1 :: <GHookList*>;
  parameter may_recurse2 :: <gboolean>;
  c-name: "g_hook_list_invoke_check";
end;

define inline-only C-function g-hook-list-marshal
  parameter hook_list1 :: <GHookList*>;
  parameter may_recurse2 :: <gboolean>;
  parameter marshaller3 :: <GHookMarshaller>;
  parameter data4      :: <gpointer>;
  c-name: "g_hook_list_marshal";
end;

define inline-only C-function g-hook-list-marshal-check
  parameter hook_list1 :: <GHookList*>;
  parameter may_recurse2 :: <gboolean>;
  parameter marshaller3 :: <GHookCheckMarshaller>;
  parameter data4      :: <gpointer>;
  c-name: "g_hook_list_marshal_check";
end;

define inline-only C-function g-on-error-query
  parameter prg_name1  ::  /* const */ <gchar*>;
  c-name: "g_on_error_query";
end;

define inline-only C-function g-on-error-stack-trace
  parameter prg_name1  ::  /* const */ <gchar*>;
  c-name: "g_on_error_stack_trace";
end;

define inline-only C-function g-log-set-handler
  parameter log_domain1 ::  /* const */ <gchar*>;
  parameter log_levels2 :: <C-int>;
  parameter log_func3  :: <GLogFunc>;
  parameter user_data4 :: <gpointer>;
  result value :: <guint>;
  c-name: "g_log_set_handler";
end;

define inline-only C-function g-log-remove-handler
  parameter log_domain1 ::  /* const */ <gchar*>;
  parameter handler_id2 :: <guint>;
  c-name: "g_log_remove_handler";
end;

define inline-only C-function g-log-default-handler
  parameter log_domain1 ::  /* const */ <gchar*>;
  parameter log_level2 :: <C-int>;
  parameter message3   ::  /* const */ <gchar*>;
  parameter unused_data4 :: <gpointer>;
  c-name: "g_log_default_handler";
end;

define inline-only C-function g-log-set-fatal-mask
  parameter log_domain1 ::  /* const */ <gchar*>;
  parameter fatal_mask2 :: <C-int>;
  result value :: <C-int>;
  c-name: "g_log_set_fatal_mask";
end;

define inline-only C-function g-log-set-always-fatal
  parameter fatal_mask1 :: <C-int>;
  result value :: <C-int>;
  c-name: "g_log_set_always_fatal";
end;
define C-pointer-type <GPrintFunc*> => <GPrintFunc>;
define C-pointer-type <GPrintFunc**> => <GPrintFunc*>;

define inline-only C-function g-set-print-handler
  parameter func1      :: <GPrintFunc>;
  result value :: <GPrintFunc>;
  c-name: "g_set_print_handler";
end;

define inline-only C-function g-set-printerr-handler
  parameter func1      :: <GPrintFunc>;
  result value :: <GPrintFunc>;
  c-name: "g_set_printerr_handler";
end;
define C-pointer-type <GErrorFunc*> => <GErrorFunc>;
define C-pointer-type <GErrorFunc**> => <GErrorFunc*>;
define C-pointer-type <GWarningFunc*> => <GWarningFunc>;
define C-pointer-type <GWarningFunc**> => <GWarningFunc*>;

define inline-only C-function g-set-error-handler
  parameter func1      :: <GErrorFunc>;
  result value :: <GErrorFunc>;
  c-name: "g_set_error_handler";
end;

define inline-only C-function g-set-warning-handler
  parameter func1      :: <GWarningFunc>;
  result value :: <GWarningFunc>;
  c-name: "g_set_warning_handler";
end;

define inline-only C-function g-set-message-handler
  parameter func1      :: <GPrintFunc>;
  result value :: <GPrintFunc>;
  c-name: "g_set_message_handler";
end;

define inline-only C-function g-malloc
  parameter size1      :: <gulong>;
  result value :: <gpointer>;
  c-name: "g_malloc";
end;

define inline-only C-function g-malloc0
  parameter size1      :: <gulong>;
  result value :: <gpointer>;
  c-name: "g_malloc0";
end;

define inline-only C-function g-realloc
  parameter mem1       :: <gpointer>;
  parameter size2      :: <gulong>;
  result value :: <gpointer>;
  c-name: "g_realloc";
end;

define inline-only C-function g-free
  parameter mem1       :: <gpointer>;
  c-name: "g_free";
end;

define inline-only C-function g-mem-profile
  c-name: "g_mem_profile";
end;

define inline-only C-function g-mem-check
  parameter mem1       :: <gpointer>;
  c-name: "g_mem_check";
end;

define inline-only C-function g-allocator-new
  parameter name1      ::  /* const */ <gchar*>;
  parameter n_preallocs2 :: <guint>;
  result value :: <GAllocator*>;
  c-name: "g_allocator_new";
end;

define inline-only C-function g-allocator-free
  parameter allocator1 :: <GAllocator*>;
  c-name: "g_allocator_free";
end;
define inline-only constant $G-ALLOCATOR-LIST              =    1;
define inline-only constant $G-ALLOCATOR-SLIST             =    2;
define inline-only constant $G-ALLOCATOR-NODE              =    3;
define inline-only constant $G-ALLOC-ONLY                  =    1;
define inline-only constant $G-ALLOC-AND-FREE              =    2;

define inline-only C-function g-mem-chunk-new
  parameter name1      :: <gchar*>;
  parameter atom_size2 :: <gint>;
  parameter area_size3 :: <gulong>;
  parameter type4      :: <gint>;
  result value :: <GMemChunk*>;
  c-name: "g_mem_chunk_new";
end;

define inline-only C-function g-mem-chunk-destroy
  parameter mem_chunk1 :: <GMemChunk*>;
  c-name: "g_mem_chunk_destroy";
end;

define inline-only C-function g-mem-chunk-alloc
  parameter mem_chunk1 :: <GMemChunk*>;
  result value :: <gpointer>;
  c-name: "g_mem_chunk_alloc";
end;

define inline-only C-function g-mem-chunk-alloc0
  parameter mem_chunk1 :: <GMemChunk*>;
  result value :: <gpointer>;
  c-name: "g_mem_chunk_alloc0";
end;

define inline-only C-function g-mem-chunk-free
  parameter mem_chunk1 :: <GMemChunk*>;
  parameter mem2       :: <gpointer>;
  c-name: "g_mem_chunk_free";
end;

define inline-only C-function g-mem-chunk-clean
  parameter mem_chunk1 :: <GMemChunk*>;
  c-name: "g_mem_chunk_clean";
end;

define inline-only C-function g-mem-chunk-reset
  parameter mem_chunk1 :: <GMemChunk*>;
  c-name: "g_mem_chunk_reset";
end;

define inline-only C-function g-mem-chunk-print
  parameter mem_chunk1 :: <GMemChunk*>;
  c-name: "g_mem_chunk_print";
end;

define inline-only C-function g-mem-chunk-info
  c-name: "g_mem_chunk_info";
end;

define inline-only C-function g-blow-chunks
  c-name: "g_blow_chunks";
end;

define inline-only C-function g-timer-new
  result value :: <GTimer*>;
  c-name: "g_timer_new";
end;

define inline-only C-function g-timer-destroy
  parameter timer1     :: <GTimer*>;
  c-name: "g_timer_destroy";
end;

define inline-only C-function g-timer-start
  parameter timer1     :: <GTimer*>;
  c-name: "g_timer_start";
end;

define inline-only C-function g-timer-stop
  parameter timer1     :: <GTimer*>;
  c-name: "g_timer_stop";
end;

define inline-only C-function g-timer-reset
  parameter timer1     :: <GTimer*>;
  c-name: "g_timer_reset";
end;

define inline-only C-function g-timer-elapsed
  parameter timer1     :: <GTimer*>;
  parameter microseconds2 :: <gulong*>;
  result value :: <gdouble>;
  c-name: "g_timer_elapsed";
end;

define inline-only C-function g-strdelimit
  parameter string1    :: <gchar*>;
  parameter delimiters2 ::  /* const */ <gchar*>;
  parameter new_delimiter3 :: <gchar>;
  result value :: <gchar*>;
  c-name: "g_strdelimit";
end;

define inline-only C-function g-strtod
  parameter nptr1      ::  /* const */ <gchar*>;
  parameter endptr2    :: <gchar**>;
  result value :: <gdouble>;
  c-name: "g_strtod";
end;

define inline-only C-function g-strerror
  parameter errnum1    :: <gint>;
  result value :: <gchar*>;
  c-name: "g_strerror";
end;

define inline-only C-function g-strsignal
  parameter signum1    :: <gint>;
  result value :: <gchar*>;
  c-name: "g_strsignal";
end;

define inline-only C-function g-strcasecmp
  parameter s11        ::  /* const */ <gchar*>;
  parameter s22        ::  /* const */ <gchar*>;
  result value :: <gint>;
  c-name: "g_strcasecmp";
end;

define inline-only C-function g-strncasecmp
  parameter s11        ::  /* const */ <gchar*>;
  parameter s22        ::  /* const */ <gchar*>;
  parameter n3         :: <guint>;
  result value :: <gint>;
  c-name: "g_strncasecmp";
end;

define inline-only C-function g-strdown
  parameter string1    :: <gchar*>;
  c-name: "g_strdown";
end;

define inline-only C-function g-strup
  parameter string1    :: <gchar*>;
  c-name: "g_strup";
end;

define inline-only C-function g-strreverse
  parameter string1    :: <gchar*>;
  c-name: "g_strreverse";
end;

define inline-only C-function g-strchug
  parameter string1    :: <gchar*>;
  result value :: <gchar*>;
  c-name: "g_strchug";
end;

define inline-only C-function g-strchomp
  parameter string1    :: <gchar*>;
  result value :: <gchar*>;
  c-name: "g_strchomp";
end;

define inline-only C-function g-strdup
  parameter str1       ::  /* const */ <gchar*>;
  result value :: <gchar*>;
  c-name: "g_strdup";
end;

define inline-only C-function g-strndup
  parameter str1       ::  /* const */ <gchar*>;
  parameter n2         :: <guint>;
  result value :: <gchar*>;
  c-name: "g_strndup";
end;

define inline-only C-function g-strnfill
  parameter length1    :: <guint>;
  parameter fill_char2 :: <gchar>;
  result value :: <gchar*>;
  c-name: "g_strnfill";
end;

define inline-only C-function g-strescape
  parameter string1    :: <gchar*>;
  result value :: <gchar*>;
  c-name: "g_strescape";
end;

define inline-only C-function g-memdup
  parameter mem1       :: <gconstpointer>;
  parameter byte_size2 :: <guint>;
  result value :: <gpointer>;
  c-name: "g_memdup";
end;

define inline-only C-function g-strsplit
  parameter string1    ::  /* const */ <gchar*>;
  parameter delimiter2 ::  /* const */ <gchar*>;
  parameter max_tokens3 :: <gint>;
  result value :: <gchar**>;
  c-name: "g_strsplit";
end;

define inline-only C-function g-strjoinv
  parameter separator1 ::  /* const */ <gchar*>;
  parameter str_array2 :: <gchar**>;
  result value :: <gchar*>;
  c-name: "g_strjoinv";
end;

define inline-only C-function g-strfreev
  parameter str_array1 :: <gchar**>;
  c-name: "g_strfreev";
end;

define inline-only C-function g-get-user-name
  result value :: <gchar*>;
  c-name: "g_get_user_name";
end;

define inline-only C-function g-get-real-name
  result value :: <gchar*>;
  c-name: "g_get_real_name";
end;

define inline-only C-function g-get-home-dir
  result value :: <gchar*>;
  c-name: "g_get_home_dir";
end;

define inline-only C-function g-get-tmp-dir
  result value :: <gchar*>;
  c-name: "g_get_tmp_dir";
end;

define inline-only C-function g-get-prgname
  result value :: <gchar*>;
  c-name: "g_get_prgname";
end;

define inline-only C-function g-set-prgname
  parameter prgname1   ::  /* const */ <gchar*>;
  c-name: "g_set_prgname";
end;

define inline-only C-function g-parse-debug-string
  parameter string1    ::  /* const */ <gchar*>;
  parameter keys2      :: <GDebugKey*>;
  parameter nkeys3     :: <guint>;
  result value :: <guint>;
  c-name: "g_parse_debug_string";
end;

define inline-only C-function g-basename
  parameter file_name1 ::  /* const */ <gchar*>;
  result value :: <gchar*>;
  c-name: "g_basename";
end;

define inline-only C-function g-path-is-absolute
  parameter file_name1 ::  /* const */ <gchar*>;
  result value :: <gboolean>;
  c-name: "g_path_is_absolute";
end;

define inline-only C-function g-path-skip-root
  parameter file_name1 :: <gchar*>;
  result value :: <gchar*>;
  c-name: "g_path_skip_root";
end;

define inline-only C-function g-dirname
  parameter file_name1 ::  /* const */ <gchar*>;
  result value :: <gchar*>;
  c-name: "g_dirname";
end;

define inline-only C-function g-get-current-dir
  result value :: <gchar*>;
  c-name: "g_get_current_dir";
end;

define inline-only C-function g-getenv
  parameter variable1  ::  /* const */ <gchar*>;
  result value :: <gchar*>;
  c-name: "g_getenv";
end;

define inline-only C-function g-atexit
  parameter func1      :: <GVoidFunc>;
  c-name: "g_atexit";
end;

define inline-only C-function g-bit-nth-lsf
  parameter mask1      :: <guint32>;
  parameter nth_bit2   :: <gint>;
  result value :: <gint>;
  c-name: "g_bit_nth_lsf";
end;

define inline-only C-function g-bit-nth-msf
  parameter mask1      :: <guint32>;
  parameter nth_bit2   :: <gint>;
  result value :: <gint>;
  c-name: "g_bit_nth_msf";
end;

define inline-only C-function g-bit-storage
  parameter number1    :: <guint>;
  result value :: <guint>;
  c-name: "g_bit_storage";
end;

define inline-only C-function g-string-chunk-new
  parameter size1      :: <gint>;
  result value :: <GStringChunk*>;
  c-name: "g_string_chunk_new";
end;

define inline-only C-function g-string-chunk-free
  parameter chunk1     :: <GStringChunk*>;
  c-name: "g_string_chunk_free";
end;

define inline-only C-function g-string-chunk-insert
  parameter chunk1     :: <GStringChunk*>;
  parameter string2    ::  /* const */ <gchar*>;
  result value :: <gchar*>;
  c-name: "g_string_chunk_insert";
end;

define inline-only C-function g-string-chunk-insert-const
  parameter chunk1     :: <GStringChunk*>;
  parameter string2    ::  /* const */ <gchar*>;
  result value :: <gchar*>;
  c-name: "g_string_chunk_insert_const";
end;

define inline-only C-function g-string-new
  parameter init1      ::  /* const */ <gchar*>;
  result value :: <GString*>;
  c-name: "g_string_new";
end;

define inline-only C-function g-string-sized-new
  parameter dfl_size1  :: <guint>;
  result value :: <GString*>;
  c-name: "g_string_sized_new";
end;

define inline-only C-function g-string-free
  parameter string1    :: <GString*>;
  parameter free_segment2 :: <gint>;
  c-name: "g_string_free";
end;

define inline-only C-function g-string-assign
  parameter lval1      :: <GString*>;
  parameter rval2      ::  /* const */ <gchar*>;
  result value :: <GString*>;
  c-name: "g_string_assign";
end;

define inline-only C-function g-string-truncate
  parameter string1    :: <GString*>;
  parameter len2       :: <gint>;
  result value :: <GString*>;
  c-name: "g_string_truncate";
end;

define inline-only C-function g-string-append
  parameter string1    :: <GString*>;
  parameter val2       ::  /* const */ <gchar*>;
  result value :: <GString*>;
  c-name: "g_string_append";
end;

define inline-only C-function g-string-append-c
  parameter string1    :: <GString*>;
  parameter c2         :: <gchar>;
  result value :: <GString*>;
  c-name: "g_string_append_c";
end;

define inline-only C-function g-string-prepend
  parameter string1    :: <GString*>;
  parameter val2       ::  /* const */ <gchar*>;
  result value :: <GString*>;
  c-name: "g_string_prepend";
end;

define inline-only C-function g-string-prepend-c
  parameter string1    :: <GString*>;
  parameter c2         :: <gchar>;
  result value :: <GString*>;
  c-name: "g_string_prepend_c";
end;

define inline-only C-function g-string-insert
  parameter string1    :: <GString*>;
  parameter pos2       :: <gint>;
  parameter val3       ::  /* const */ <gchar*>;
  result value :: <GString*>;
  c-name: "g_string_insert";
end;

define inline-only C-function g-string-insert-c
  parameter string1    :: <GString*>;
  parameter pos2       :: <gint>;
  parameter c3         :: <gchar>;
  result value :: <GString*>;
  c-name: "g_string_insert_c";
end;

define inline-only C-function g-string-erase
  parameter string1    :: <GString*>;
  parameter pos2       :: <gint>;
  parameter len3       :: <gint>;
  result value :: <GString*>;
  c-name: "g_string_erase";
end;

define inline-only C-function g-string-down
  parameter string1    :: <GString*>;
  result value :: <GString*>;
  c-name: "g_string_down";
end;

define inline-only C-function g-string-up
  parameter string1    :: <GString*>;
  result value :: <GString*>;
  c-name: "g_string_up";
end;

define inline-only C-function g-array-new
  parameter zero_terminated1 :: <gboolean>;
  parameter clear2     :: <gboolean>;
  parameter element_size3 :: <guint>;
  result value :: <GArray*>;
  c-name: "g_array_new";
end;

define inline-only C-function g-array-free
  parameter array1     :: <GArray*>;
  parameter free_segment2 :: <gboolean>;
  c-name: "g_array_free";
end;

define inline-only C-function g-array-append-vals
  parameter array1     :: <GArray*>;
  parameter data2      :: <gconstpointer>;
  parameter len3       :: <guint>;
  result value :: <GArray*>;
  c-name: "g_array_append_vals";
end;

define inline-only C-function g-array-prepend-vals
  parameter array1     :: <GArray*>;
  parameter data2      :: <gconstpointer>;
  parameter len3       :: <guint>;
  result value :: <GArray*>;
  c-name: "g_array_prepend_vals";
end;

define inline-only C-function g-array-insert-vals
  parameter array1     :: <GArray*>;
  parameter index2     :: <guint>;
  parameter data3      :: <gconstpointer>;
  parameter len4       :: <guint>;
  result value :: <GArray*>;
  c-name: "g_array_insert_vals";
end;

define inline-only C-function g-array-set-size
  parameter array1     :: <GArray*>;
  parameter length2    :: <guint>;
  result value :: <GArray*>;
  c-name: "g_array_set_size";
end;

define inline-only C-function g-array-remove-index
  parameter array1     :: <GArray*>;
  parameter index2     :: <guint>;
  result value :: <GArray*>;
  c-name: "g_array_remove_index";
end;

define inline-only C-function g-array-remove-index-fast
  parameter array1     :: <GArray*>;
  parameter index2     :: <guint>;
  result value :: <GArray*>;
  c-name: "g_array_remove_index_fast";
end;

define inline-only C-function g-ptr-array-new
  result value :: <GPtrArray*>;
  c-name: "g_ptr_array_new";
end;

define inline-only C-function g-ptr-array-free
  parameter array1     :: <GPtrArray*>;
  parameter free_seg2  :: <gboolean>;
  c-name: "g_ptr_array_free";
end;

define inline-only C-function g-ptr-array-set-size
  parameter array1     :: <GPtrArray*>;
  parameter length2    :: <gint>;
  c-name: "g_ptr_array_set_size";
end;

define inline-only C-function g-ptr-array-remove-index
  parameter array1     :: <GPtrArray*>;
  parameter index2     :: <guint>;
  result value :: <gpointer>;
  c-name: "g_ptr_array_remove_index";
end;

define inline-only C-function g-ptr-array-remove-index-fast
  parameter array1     :: <GPtrArray*>;
  parameter index2     :: <guint>;
  result value :: <gpointer>;
  c-name: "g_ptr_array_remove_index_fast";
end;

define inline-only C-function g-ptr-array-remove
  parameter array1     :: <GPtrArray*>;
  parameter data2      :: <gpointer>;
  result value :: <gboolean>;
  c-name: "g_ptr_array_remove";
end;

define inline-only C-function g-ptr-array-remove-fast
  parameter array1     :: <GPtrArray*>;
  parameter data2      :: <gpointer>;
  result value :: <gboolean>;
  c-name: "g_ptr_array_remove_fast";
end;

define inline-only C-function g-ptr-array-add
  parameter array1     :: <GPtrArray*>;
  parameter data2      :: <gpointer>;
  c-name: "g_ptr_array_add";
end;

define inline-only C-function g-byte-array-new
  result value :: <GByteArray*>;
  c-name: "g_byte_array_new";
end;

define inline-only C-function g-byte-array-free
  parameter array1     :: <GByteArray*>;
  parameter free_segment2 :: <gboolean>;
  c-name: "g_byte_array_free";
end;

define inline-only C-function g-byte-array-append
  parameter array1     :: <GByteArray*>;
  parameter data2      ::  /* const */ <guint8*>;
  parameter len3       :: <guint>;
  result value :: <GByteArray*>;
  c-name: "g_byte_array_append";
end;

define inline-only C-function g-byte-array-prepend
  parameter array1     :: <GByteArray*>;
  parameter data2      ::  /* const */ <guint8*>;
  parameter len3       :: <guint>;
  result value :: <GByteArray*>;
  c-name: "g_byte_array_prepend";
end;

define inline-only C-function g-byte-array-set-size
  parameter array1     :: <GByteArray*>;
  parameter length2    :: <guint>;
  result value :: <GByteArray*>;
  c-name: "g_byte_array_set_size";
end;

define inline-only C-function g-byte-array-remove-index
  parameter array1     :: <GByteArray*>;
  parameter index2     :: <guint>;
  result value :: <GByteArray*>;
  c-name: "g_byte_array_remove_index";
end;

define inline-only C-function g-byte-array-remove-index-fast
  parameter array1     :: <GByteArray*>;
  parameter index2     :: <guint>;
  result value :: <GByteArray*>;
  c-name: "g_byte_array_remove_index_fast";
end;

define inline-only C-function g-str-equal
  parameter v1         :: <gconstpointer>;
  parameter v22        :: <gconstpointer>;
  result value :: <gint>;
  c-name: "g_str_equal";
end;

define inline-only C-function g-str-hash
  parameter v1         :: <gconstpointer>;
  result value :: <guint>;
  c-name: "g_str_hash";
end;

define inline-only C-function g-int-equal
  parameter v1         :: <gconstpointer>;
  parameter v22        :: <gconstpointer>;
  result value :: <gint>;
  c-name: "g_int_equal";
end;

define inline-only C-function g-int-hash
  parameter v1         :: <gconstpointer>;
  result value :: <guint>;
  c-name: "g_int_hash";
end;

define inline-only C-function g-direct-hash
  parameter v1         :: <gconstpointer>;
  result value :: <guint>;
  c-name: "g_direct_hash";
end;

define inline-only C-function g-direct-equal
  parameter v1         :: <gconstpointer>;
  parameter v22        :: <gconstpointer>;
  result value :: <gint>;
  c-name: "g_direct_equal";
end;

define inline-only C-function g-quark-try-string
  parameter string1    ::  /* const */ <gchar*>;
  result value :: <GQuark>;
  c-name: "g_quark_try_string";
end;

define inline-only C-function g-quark-from-static-string
  parameter string1    ::  /* const */ <gchar*>;
  result value :: <GQuark>;
  c-name: "g_quark_from_static_string";
end;

define inline-only C-function g-quark-from-string
  parameter string1    ::  /* const */ <gchar*>;
  result value :: <GQuark>;
  c-name: "g_quark_from_string";
end;

define inline-only C-function g-quark-to-string
  parameter quark1     :: <GQuark>;
  result value :: <gchar*>;
  c-name: "g_quark_to_string";
end;

define inline-only C-function g-datalist-init
  parameter datalist1  :: <GData**>;
  c-name: "g_datalist_init";
end;

define inline-only C-function g-datalist-clear
  parameter datalist1  :: <GData**>;
  c-name: "g_datalist_clear";
end;

define inline-only C-function g-datalist-id-get-data
  parameter datalist1  :: <GData**>;
  parameter key_id2    :: <GQuark>;
  result value :: <gpointer>;
  c-name: "g_datalist_id_get_data";
end;

define inline-only C-function g-datalist-id-set-data-full
  parameter datalist1  :: <GData**>;
  parameter key_id2    :: <GQuark>;
  parameter data3      :: <gpointer>;
  parameter destroy_func4 :: <GDestroyNotify>;
  c-name: "g_datalist_id_set_data_full";
end;

define inline-only C-function g-datalist-id-remove-no-notify
  parameter datalist1  :: <GData**>;
  parameter key_id2    :: <GQuark>;
  c-name: "g_datalist_id_remove_no_notify";
end;

define inline-only C-function g-datalist-foreach
  parameter datalist1  :: <GData**>;
  parameter func2      :: <GDataForeachFunc>;
  parameter user_data3 :: <gpointer>;
  c-name: "g_datalist_foreach";
end;

define inline-only C-function g-dataset-destroy
  parameter dataset_location1 :: <gconstpointer>;
  c-name: "g_dataset_destroy";
end;

define inline-only C-function g-dataset-id-get-data
  parameter dataset_location1 :: <gconstpointer>;
  parameter key_id2    :: <GQuark>;
  result value :: <gpointer>;
  c-name: "g_dataset_id_get_data";
end;

define inline-only C-function g-dataset-id-set-data-full
  parameter dataset_location1 :: <gconstpointer>;
  parameter key_id2    :: <GQuark>;
  parameter data3      :: <gpointer>;
  parameter destroy_func4 :: <GDestroyNotify>;
  c-name: "g_dataset_id_set_data_full";
end;

define inline-only C-function g-dataset-id-remove-no-notify
  parameter dataset_location1 :: <gconstpointer>;
  parameter key_id2    :: <GQuark>;
  c-name: "g_dataset_id_remove_no_notify";
end;

define inline-only C-function g-dataset-foreach
  parameter dataset_location1 :: <gconstpointer>;
  parameter func2      :: <GDataForeachFunc>;
  parameter user_data3 :: <gpointer>;
  c-name: "g_dataset_foreach";
end;
// enum GErrorType:
define C-pointer-type <GErrorType*> => <GErrorType>;
define C-pointer-type <GErrorType**> => <GErrorType*>;
define inline-only constant $G-ERR-UNKNOWN = -1 + 1;
define inline-only constant $G-ERR-UNEXP-EOF = $G-ERR-UNKNOWN + 1;
define inline-only constant $G-ERR-UNEXP-EOF-IN-STRING = $G-ERR-UNEXP-EOF + 1;
define inline-only constant $G-ERR-UNEXP-EOF-IN-COMMENT = $G-ERR-UNEXP-EOF-IN-STRING + 1;
define inline-only constant $G-ERR-NON-DIGIT-IN-CONST = $G-ERR-UNEXP-EOF-IN-COMMENT + 1;
define inline-only constant $G-ERR-DIGIT-RADIX = $G-ERR-NON-DIGIT-IN-CONST + 1;
define inline-only constant $G-ERR-FLOAT-RADIX = $G-ERR-DIGIT-RADIX + 1;
define inline-only constant $G-ERR-FLOAT-MALFORMED = $G-ERR-FLOAT-RADIX + 1;

// enum GTokenType:
define C-pointer-type <GTokenType*> => <GTokenType>;
define C-pointer-type <GTokenType**> => <GTokenType*>;
define inline-only constant $G-TOKEN-EOF = 0;
define inline-only constant $G-TOKEN-LEFT-PAREN = as(<integer>, '(');
define inline-only constant $G-TOKEN-RIGHT-PAREN = as(<integer>, ')');
define inline-only constant $G-TOKEN-LEFT-CURLY = as(<integer>, '{');
define inline-only constant $G-TOKEN-RIGHT-CURLY = as(<integer>, '}');
define inline-only constant $G-TOKEN-LEFT-BRACE = as(<integer>, '[');
define inline-only constant $G-TOKEN-RIGHT-BRACE = as(<integer>, ']');
define inline-only constant $G-TOKEN-EQUAL-SIGN = as(<integer>, '=');
define inline-only constant $G-TOKEN-COMMA = as(<integer>, ',');
define inline-only constant $G-TOKEN-NONE = 256;
define inline-only constant $G-TOKEN-ERROR = 256 + 1;
define inline-only constant $G-TOKEN-CHAR = $G-TOKEN-ERROR + 1;
define inline-only constant $G-TOKEN-BINARY = $G-TOKEN-CHAR + 1;
define inline-only constant $G-TOKEN-OCTAL = $G-TOKEN-BINARY + 1;
define inline-only constant $G-TOKEN-INT = $G-TOKEN-OCTAL + 1;
define inline-only constant $G-TOKEN-HEX = $G-TOKEN-INT + 1;
define inline-only constant $G-TOKEN-FLOAT = $G-TOKEN-HEX + 1;
define inline-only constant $G-TOKEN-STRING = $G-TOKEN-FLOAT + 1;
define inline-only constant $G-TOKEN-SYMBOL = $G-TOKEN-STRING + 1;
define inline-only constant $G-TOKEN-IDENTIFIER = $G-TOKEN-SYMBOL + 1;
define inline-only constant $G-TOKEN-IDENTIFIER-NULL = $G-TOKEN-IDENTIFIER + 1;
define inline-only constant $G-TOKEN-COMMENT-SINGLE = $G-TOKEN-IDENTIFIER-NULL + 1;
define inline-only constant $G-TOKEN-COMMENT-MULTI = $G-TOKEN-COMMENT-SINGLE + 1;
define inline-only constant $G-TOKEN-LAST = $G-TOKEN-COMMENT-MULTI + 1;


define C-union <_GTokenValue>
  sealed inline-only slot v-symbol-value :: <gpointer>;
  sealed inline-only slot v-identifier-value :: <gchar*>;
  sealed inline-only slot v-binary-value :: <gulong>;
  sealed inline-only slot v-octal-value  :: <gulong>;
  sealed inline-only slot v-int-value    :: <gulong>;
  sealed inline-only slot v-float-value  :: <gdouble>;
  sealed inline-only slot v-hex-value    :: <gulong>;
  sealed inline-only slot v-string-value :: <gchar*>;
  sealed inline-only slot v-comment-value :: <gchar*>;
  sealed inline-only slot v-char-value   :: <guchar>;
  sealed inline-only slot v-error-value  :: <guint>;
end;

define C-struct <_GScannerConfig>
  sealed inline-only slot cset-skip-characters-value :: <gchar*>;
  sealed inline-only slot cset-identifier-first-value :: <gchar*>;
  sealed inline-only slot cset-identifier-nth-value :: <gchar*>;
  sealed inline-only slot cpair-comment-single-value :: <gchar*>;
  sealed bitfield slot case-sensitive-value :: <guint>,
    width: 1;
  sealed bitfield slot skip-comment-multi-value ::
	<guint>,
    width: 1;
  sealed bitfield slot skip-comment-single-value ::
	<guint>,
    width: 1;
  sealed bitfield slot scan-comment-multi-value ::
	<guint>,
    width: 1;
  sealed bitfield slot scan-identifier-value ::
	<guint>,
    width: 1;
  sealed bitfield slot scan-identifier-1char-value ::
	<guint>,
    width: 1;
  sealed bitfield slot scan-identifier-NULL-value ::
	<guint>,
    width: 1;
  sealed bitfield slot scan-symbols-value :: <guint>,
    width: 1;
  sealed bitfield slot scan-binary-value :: <guint>,
    width: 1;
  sealed bitfield slot scan-octal-value  :: <guint>,
    width: 1;
  sealed bitfield slot scan-float-value  :: <guint>,
    width: 1;
  sealed bitfield slot scan-hex-value    :: <guint>,
    width: 1;
  sealed bitfield slot scan-hex-dollar-value ::
	<guint>,
    width: 1;
  sealed bitfield slot scan-string-sq-value :: <guint>,
    width: 1;
  sealed bitfield slot scan-string-dq-value :: <guint>,
    width: 1;
  sealed bitfield slot numbers-2-int-value :: <guint>,
    width: 1;
  sealed bitfield slot int-2-float-value :: <guint>,
    width: 1;
  sealed bitfield slot identifier-2-string-value ::
	<guint>,
    width: 1;
  sealed bitfield slot char-2-token-value :: <guint>,
    width: 1;
  sealed bitfield slot symbol-2-token-value :: <guint>,
    width: 1;
  sealed bitfield slot scope-0-fallback-value ::
	<guint>,
    width: 1;
  pointer-type-name: <_GScannerConfig*>;
  c-name: "struct _GScannerConfig";
end;

define C-struct <_GScanner>
  sealed inline-only slot user-data-value :: <gpointer>;
  sealed inline-only slot max-parse-errors-value :: <guint>;
  sealed inline-only slot parse-errors-value :: <guint>;
  sealed inline-only slot input-name-value ::  /* const */ <gchar*>;
  sealed inline-only slot derived-data-value :: <gpointer>;
  sealed inline-only slot config-value   :: <GScannerConfig*>;
  sealed inline-only slot token-value    :: <C-int>;
  sealed inline-only slot value-value    :: <GTokenValue>;
  sealed inline-only slot line-value     :: <guint>;
  sealed inline-only slot position-value :: <guint>;
  sealed inline-only slot next-token-value :: <C-int>;
  sealed inline-only slot next-value-value :: <GTokenValue>;
  sealed inline-only slot next-line-value :: <guint>;
  sealed inline-only slot next-position-value :: <guint>;
  sealed inline-only slot symbol-table-value :: <GHashTable*>;
  sealed inline-only slot input-fd-value :: <gint>;
  sealed inline-only slot text-value     ::  /* const */ <gchar*>;
  sealed inline-only slot text-end-value ::  /* const */ <gchar*>;
  sealed inline-only slot buffer-value   :: <gchar*>;
  sealed inline-only slot scope-id-value :: <guint>;
  sealed inline-only slot msg-handler-value :: <GScannerMsgFunc>;
  pointer-type-name: <_GScanner*>;
  c-name: "struct _GScanner";
end;

define inline-only C-function g-scanner-new
  parameter config_templ1 :: <GScannerConfig*>;
  result value :: <GScanner*>;
  c-name: "g_scanner_new";
end;

define inline-only C-function g-scanner-destroy
  parameter scanner1   :: <GScanner*>;
  c-name: "g_scanner_destroy";
end;

define inline-only C-function g-scanner-input-file
  parameter scanner1   :: <GScanner*>;
  parameter input_fd2  :: <gint>;
  c-name: "g_scanner_input_file";
end;

define inline-only C-function g-scanner-sync-file-offset
  parameter scanner1   :: <GScanner*>;
  c-name: "g_scanner_sync_file_offset";
end;

define inline-only C-function g-scanner-input-text
  parameter scanner1   :: <GScanner*>;
  parameter text2      ::  /* const */ <gchar*>;
  parameter text_len3  :: <guint>;
  c-name: "g_scanner_input_text";
end;

define inline-only C-function g-scanner-get-next-token
  parameter scanner1   :: <GScanner*>;
  result value :: <C-int>;
  c-name: "g_scanner_get_next_token";
end;

define inline-only C-function g-scanner-peek-next-token
  parameter scanner1   :: <GScanner*>;
  result value :: <C-int>;
  c-name: "g_scanner_peek_next_token";
end;

define inline-only C-function g-scanner-cur-token
  parameter scanner1   :: <GScanner*>;
  result value :: <C-int>;
  c-name: "g_scanner_cur_token";
end;

define inline-only C-function g-scanner-cur-value
  parameter scanner1   :: <GScanner*>;
  result value :: <GTokenValue>;
  c-name: "g_scanner_cur_value";
end;

define inline-only C-function g-scanner-cur-line
  parameter scanner1   :: <GScanner*>;
  result value :: <guint>;
  c-name: "g_scanner_cur_line";
end;

define inline-only C-function g-scanner-cur-position
  parameter scanner1   :: <GScanner*>;
  result value :: <guint>;
  c-name: "g_scanner_cur_position";
end;

define inline-only C-function g-scanner-eof
  parameter scanner1   :: <GScanner*>;
  result value :: <gboolean>;
  c-name: "g_scanner_eof";
end;

define inline-only C-function g-scanner-set-scope
  parameter scanner1   :: <GScanner*>;
  parameter scope_id2  :: <guint>;
  result value :: <guint>;
  c-name: "g_scanner_set_scope";
end;

define inline-only C-function g-scanner-scope-add-symbol
  parameter scanner1   :: <GScanner*>;
  parameter scope_id2  :: <guint>;
  parameter symbol3    ::  /* const */ <gchar*>;
  parameter value4     :: <gpointer>;
  c-name: "g_scanner_scope_add_symbol";
end;

define inline-only C-function g-scanner-scope-remove-symbol
  parameter scanner1   :: <GScanner*>;
  parameter scope_id2  :: <guint>;
  parameter symbol3    ::  /* const */ <gchar*>;
  c-name: "g_scanner_scope_remove_symbol";
end;

define inline-only C-function g-scanner-scope-lookup-symbol
  parameter scanner1   :: <GScanner*>;
  parameter scope_id2  :: <guint>;
  parameter symbol3    ::  /* const */ <gchar*>;
  result value :: <gpointer>;
  c-name: "g_scanner_scope_lookup_symbol";
end;

define inline-only C-function g-scanner-scope-foreach-symbol
  parameter scanner1   :: <GScanner*>;
  parameter scope_id2  :: <guint>;
  parameter func3      :: <GHFunc>;
  parameter user_data4 :: <gpointer>;
  c-name: "g_scanner_scope_foreach_symbol";
end;

define inline-only C-function g-scanner-lookup-symbol
  parameter scanner1   :: <GScanner*>;
  parameter symbol2    ::  /* const */ <gchar*>;
  result value :: <gpointer>;
  c-name: "g_scanner_lookup_symbol";
end;

define inline-only C-function g-scanner-freeze-symbol-table
  parameter scanner1   :: <GScanner*>;
  c-name: "g_scanner_freeze_symbol_table";
end;

define inline-only C-function g-scanner-thaw-symbol-table
  parameter scanner1   :: <GScanner*>;
  c-name: "g_scanner_thaw_symbol_table";
end;

define inline-only C-function g-scanner-unexp-token
  parameter scanner1   :: <GScanner*>;
  parameter expected_token2 :: <C-int>;
  parameter identifier_spec3 ::  /* const */ <gchar*>;
  parameter symbol_spec4 ::  /* const */ <gchar*>;
  parameter symbol_name5 ::  /* const */ <gchar*>;
  parameter message6   ::  /* const */ <gchar*>;
  parameter is_error7  :: <gint>;
  c-name: "g_scanner_unexp_token";
end;

define inline-only C-function g-scanner-stat-mode
  parameter filename1  ::  /* const */ <gchar*>;
  result value :: <gint>;
  c-name: "g_scanner_stat_mode";
end;

define C-struct <_GCompletion>
  sealed inline-only slot items-value    :: <GList*>;
  sealed inline-only slot func-value     :: <GCompletionFunc>;
  sealed inline-only slot prefix-value   :: <gchar*>;
  sealed inline-only slot cache-value    :: <GList*>;
  pointer-type-name: <_GCompletion*>;
  c-name: "struct _GCompletion";
end;

define inline-only C-function g-completion-new
  parameter func1      :: <GCompletionFunc>;
  result value :: <GCompletion*>;
  c-name: "g_completion_new";
end;

define inline-only C-function g-completion-add-items
  parameter cmp1       :: <GCompletion*>;
  parameter items2     :: <GList*>;
  c-name: "g_completion_add_items";
end;

define inline-only C-function g-completion-remove-items
  parameter cmp1       :: <GCompletion*>;
  parameter items2     :: <GList*>;
  c-name: "g_completion_remove_items";
end;

define inline-only C-function g-completion-clear-items
  parameter cmp1       :: <GCompletion*>;
  c-name: "g_completion_clear_items";
end;

define inline-only C-function g-completion-complete
  parameter cmp1       :: <GCompletion*>;
  parameter prefix2    :: <gchar*>;
  parameter new_prefix3 :: <gchar**>;
  result value :: <GList*>;
  c-name: "g_completion_complete";
end;

define inline-only C-function g-completion-free
  parameter cmp1       :: <GCompletion*>;
  c-name: "g_completion_free";
end;
define C-pointer-type <GDateYear*> => <GDateYear>;
define C-pointer-type <GDateYear**> => <GDateYear*>;
define C-pointer-type <GDateDay*> => <GDateDay>;
define C-pointer-type <GDateDay**> => <GDateDay*>;
define C-pointer-type <GDate*> => <GDate>;
define C-pointer-type <GDate**> => <GDate*>;
// enum GDateDMY:
define C-pointer-type <GDateDMY*> => <GDateDMY>;
define C-pointer-type <GDateDMY**> => <GDateDMY*>;
define inline-only constant $G-DATE-DAY = 0;
define inline-only constant $G-DATE-MONTH = 1;
define inline-only constant $G-DATE-YEAR = 2;

// enum GDateWeekday:
define C-pointer-type <GDateWeekday*> => <GDateWeekday>;
define C-pointer-type <GDateWeekday**> => <GDateWeekday*>;
define inline-only constant $G-DATE-BAD-WEEKDAY = 0;
define inline-only constant $G-DATE-MONDAY = 1;
define inline-only constant $G-DATE-TUESDAY = 2;
define inline-only constant $G-DATE-WEDNESDAY = 3;
define inline-only constant $G-DATE-THURSDAY = 4;
define inline-only constant $G-DATE-FRIDAY = 5;
define inline-only constant $G-DATE-SATURDAY = 6;
define inline-only constant $G-DATE-SUNDAY = 7;

// enum GDateMonth:
define C-pointer-type <GDateMonth*> => <GDateMonth>;
define C-pointer-type <GDateMonth**> => <GDateMonth*>;
define inline-only constant $G-DATE-BAD-MONTH = 0;
define inline-only constant $G-DATE-JANUARY = 1;
define inline-only constant $G-DATE-FEBRUARY = 2;
define inline-only constant $G-DATE-MARCH = 3;
define inline-only constant $G-DATE-APRIL = 4;
define inline-only constant $G-DATE-MAY = 5;
define inline-only constant $G-DATE-JUNE = 6;
define inline-only constant $G-DATE-JULY = 7;
define inline-only constant $G-DATE-AUGUST = 8;
define inline-only constant $G-DATE-SEPTEMBER = 9;
define inline-only constant $G-DATE-OCTOBER = 10;
define inline-only constant $G-DATE-NOVEMBER = 11;
define inline-only constant $G-DATE-DECEMBER = 12;

define inline-only constant $G-DATE-BAD-JULIAN             =    0;
define inline-only constant $G-DATE-BAD-DAY                =    0;
define inline-only constant $G-DATE-BAD-YEAR               =    0;

define C-struct <_GDate>
  sealed bitfield slot julian-days-value :: <guint>,
    width: 32;
  sealed bitfield slot julian-value      :: <guint>,
    width: 1;
  sealed bitfield slot dmy-value         :: <guint>,
    width: 1;
  sealed bitfield slot day-value         :: <guint>,
    width: 6;
  sealed bitfield slot month-value       :: <guint>,
    width: 4;
  sealed bitfield slot year-value        :: <guint>,
    width: 16;
  pointer-type-name: <_GDate*>;
  c-name: "struct _GDate";
end;

define inline-only C-function g-date-new
  result value :: <GDate*>;
  c-name: "g_date_new";
end;

define inline-only C-function g-date-new-dmy
  parameter day1       :: <GDateDay>;
  parameter month2     :: <C-int>;
  parameter year3      :: <GDateYear>;
  result value :: <GDate*>;
  c-name: "g_date_new_dmy";
end;

define inline-only C-function g-date-new-julian
  parameter julian_day1 :: <guint32>;
  result value :: <GDate*>;
  c-name: "g_date_new_julian";
end;

define inline-only C-function g-date-free
  parameter date1      :: <GDate*>;
  c-name: "g_date_free";
end;

define inline-only C-function g-date-valid
  parameter date1      :: <GDate*>;
  result value :: <gboolean>;
  c-name: "g_date_valid";
end;

define inline-only C-function g-date-valid-day
  parameter day1       :: <GDateDay>;
  result value :: <gboolean>;
  c-name: "g_date_valid_day";
end;

define inline-only C-function g-date-valid-month
  parameter month1     :: <C-int>;
  result value :: <gboolean>;
  c-name: "g_date_valid_month";
end;

define inline-only C-function g-date-valid-year
  parameter year1      :: <GDateYear>;
  result value :: <gboolean>;
  c-name: "g_date_valid_year";
end;

define inline-only C-function g-date-valid-weekday
  parameter weekday1   :: <C-int>;
  result value :: <gboolean>;
  c-name: "g_date_valid_weekday";
end;

define inline-only C-function g-date-valid-julian
  parameter julian_date1 :: <guint32>;
  result value :: <gboolean>;
  c-name: "g_date_valid_julian";
end;

define inline-only C-function g-date-valid-dmy
  parameter day1       :: <GDateDay>;
  parameter month2     :: <C-int>;
  parameter year3      :: <GDateYear>;
  result value :: <gboolean>;
  c-name: "g_date_valid_dmy";
end;

define inline-only C-function g-date-weekday
  parameter date1      :: <GDate*>;
  result value :: <C-int>;
  c-name: "g_date_weekday";
end;

define inline-only C-function g-date-month
  parameter date1      :: <GDate*>;
  result value :: <C-int>;
  c-name: "g_date_month";
end;

define inline-only C-function g-date-year
  parameter date1      :: <GDate*>;
  result value :: <GDateYear>;
  c-name: "g_date_year";
end;

define inline-only C-function g-date-day
  parameter date1      :: <GDate*>;
  result value :: <GDateDay>;
  c-name: "g_date_day";
end;

define inline-only C-function g-date-julian
  parameter date1      :: <GDate*>;
  result value :: <guint32>;
  c-name: "g_date_julian";
end;

define inline-only C-function g-date-day-of-year
  parameter date1      :: <GDate*>;
  result value :: <guint>;
  c-name: "g_date_day_of_year";
end;

define inline-only C-function g-date-monday-week-of-year
  parameter date1      :: <GDate*>;
  result value :: <guint>;
  c-name: "g_date_monday_week_of_year";
end;

define inline-only C-function g-date-sunday-week-of-year
  parameter date1      :: <GDate*>;
  result value :: <guint>;
  c-name: "g_date_sunday_week_of_year";
end;

define inline-only C-function g-date-clear
  parameter date1      :: <GDate*>;
  parameter n_dates2   :: <guint>;
  c-name: "g_date_clear";
end;

define inline-only C-function g-date-set-parse
  parameter date1      :: <GDate*>;
  parameter str2       ::  /* const */ <gchar*>;
  c-name: "g_date_set_parse";
end;

define inline-only C-function g-date-set-time
  parameter date1      :: <GDate*>;
  parameter time2      :: <GTime>;
  c-name: "g_date_set_time";
end;

define inline-only C-function g-date-set-month
  parameter date1      :: <GDate*>;
  parameter month2     :: <C-int>;
  c-name: "g_date_set_month";
end;

define inline-only C-function g-date-set-day
  parameter date1      :: <GDate*>;
  parameter day2       :: <GDateDay>;
  c-name: "g_date_set_day";
end;

define inline-only C-function g-date-set-year
  parameter date1      :: <GDate*>;
  parameter year2      :: <GDateYear>;
  c-name: "g_date_set_year";
end;

define inline-only C-function g-date-set-dmy
  parameter date1      :: <GDate*>;
  parameter day2       :: <GDateDay>;
  parameter month3     :: <C-int>;
  parameter y4         :: <GDateYear>;
  c-name: "g_date_set_dmy";
end;

define inline-only C-function g-date-set-julian
  parameter date1      :: <GDate*>;
  parameter julian_date2 :: <guint32>;
  c-name: "g_date_set_julian";
end;

define inline-only C-function g-date-is-first-of-month
  parameter date1      :: <GDate*>;
  result value :: <gboolean>;
  c-name: "g_date_is_first_of_month";
end;

define inline-only C-function g-date-is-last-of-month
  parameter date1      :: <GDate*>;
  result value :: <gboolean>;
  c-name: "g_date_is_last_of_month";
end;

define inline-only C-function g-date-add-days
  parameter date1      :: <GDate*>;
  parameter n_days2    :: <guint>;
  c-name: "g_date_add_days";
end;

define inline-only C-function g-date-subtract-days
  parameter date1      :: <GDate*>;
  parameter n_days2    :: <guint>;
  c-name: "g_date_subtract_days";
end;

define inline-only C-function g-date-add-months
  parameter date1      :: <GDate*>;
  parameter n_months2  :: <guint>;
  c-name: "g_date_add_months";
end;

define inline-only C-function g-date-subtract-months
  parameter date1      :: <GDate*>;
  parameter n_months2  :: <guint>;
  c-name: "g_date_subtract_months";
end;

define inline-only C-function g-date-add-years
  parameter date1      :: <GDate*>;
  parameter n_years2   :: <guint>;
  c-name: "g_date_add_years";
end;

define inline-only C-function g-date-subtract-years
  parameter date1      :: <GDate*>;
  parameter n_years2   :: <guint>;
  c-name: "g_date_subtract_years";
end;

define inline-only C-function g-date-is-leap-year
  parameter year1      :: <GDateYear>;
  result value :: <gboolean>;
  c-name: "g_date_is_leap_year";
end;

define inline-only C-function g-date-days-in-month
  parameter month1     :: <C-int>;
  parameter year2      :: <GDateYear>;
  result value :: <guint8>;
  c-name: "g_date_days_in_month";
end;

define inline-only C-function g-date-monday-weeks-in-year
  parameter year1      :: <GDateYear>;
  result value :: <guint8>;
  c-name: "g_date_monday_weeks_in_year";
end;

define inline-only C-function g-date-sunday-weeks-in-year
  parameter year1      :: <GDateYear>;
  result value :: <guint8>;
  c-name: "g_date_sunday_weeks_in_year";
end;

define inline-only C-function g-date-compare
  parameter lhs1       :: <GDate*>;
  parameter rhs2       :: <GDate*>;
  result value :: <gint>;
  c-name: "g_date_compare";
end;

define inline-only C-function g-date-strftime
  parameter s1         :: <gchar*>;
  parameter slen2      :: <gsize>;
  parameter format3    ::  /* const */ <gchar*>;
  parameter date4      :: <GDate*>;
  result value :: <gsize>;
  c-name: "g_date_strftime";
end;

define inline-only C-function g-relation-new
  parameter fields1    :: <gint>;
  result value :: <GRelation*>;
  c-name: "g_relation_new";
end;

define inline-only C-function g-relation-destroy
  parameter relation1  :: <GRelation*>;
  c-name: "g_relation_destroy";
end;

define inline-only C-function g-relation-index
  parameter relation1  :: <GRelation*>;
  parameter field2     :: <gint>;
  parameter hash_func3 :: <GHashFunc>;
  parameter key_compare_func4 :: <GCompareFunc>;
  c-name: "g_relation_index";
end;

define inline-only C-function g-relation-delete
  parameter relation1  :: <GRelation*>;
  parameter key2       :: <gconstpointer>;
  parameter field3     :: <gint>;
  result value :: <gint>;
  c-name: "g_relation_delete";
end;

define inline-only C-function g-relation-select
  parameter relation1  :: <GRelation*>;
  parameter key2       :: <gconstpointer>;
  parameter field3     :: <gint>;
  result value :: <GTuples*>;
  c-name: "g_relation_select";
end;

define inline-only C-function g-relation-count
  parameter relation1  :: <GRelation*>;
  parameter key2       :: <gconstpointer>;
  parameter field3     :: <gint>;
  result value :: <gint>;
  c-name: "g_relation_count";
end;

define inline-only C-function g-relation-print
  parameter relation1  :: <GRelation*>;
  c-name: "g_relation_print";
end;

define inline-only C-function g-tuples-destroy
  parameter tuples1    :: <GTuples*>;
  c-name: "g_tuples_destroy";
end;

define inline-only C-function g-tuples-index
  parameter tuples1    :: <GTuples*>;
  parameter index2     :: <gint>;
  parameter field3     :: <gint>;
  result value :: <gpointer>;
  c-name: "g_tuples_index";
end;

define inline-only C-function g-spaced-primes-closest
  parameter num1       :: <guint>;
  result value :: <guint>;
  c-name: "g_spaced_primes_closest";
end;
define C-pointer-type <GIOFuncs*> => <GIOFuncs>;
define C-pointer-type <GIOFuncs**> => <GIOFuncs*>;
// enum GIOError:
define C-pointer-type <GIOError*> => <GIOError>;
define C-pointer-type <GIOError**> => <GIOError*>;
define inline-only constant $G-IO-ERROR-NONE = -1 + 1;
define inline-only constant $G-IO-ERROR-AGAIN = $G-IO-ERROR-NONE + 1;
define inline-only constant $G-IO-ERROR-INVAL = $G-IO-ERROR-AGAIN + 1;
define inline-only constant $G-IO-ERROR-UNKNOWN = $G-IO-ERROR-INVAL + 1;

// enum GSeekType:
define C-pointer-type <GSeekType*> => <GSeekType>;
define C-pointer-type <GSeekType**> => <GSeekType*>;
define inline-only constant $G-SEEK-CUR = -1 + 1;
define inline-only constant $G-SEEK-SET = $G-SEEK-CUR + 1;
define inline-only constant $G-SEEK-END = $G-SEEK-SET + 1;

// enum GIOCondition:
define C-pointer-type <GIOCondition*> => <GIOCondition>;
define C-pointer-type <GIOCondition**> => <GIOCondition*>;
define inline-only constant $G-IO-IN = $GLIB-SYSDEF-POLLIN;
define inline-only constant $G-IO-OUT = $GLIB-SYSDEF-POLLOUT;
define inline-only constant $G-IO-PRI = $GLIB-SYSDEF-POLLPRI;
define inline-only constant $G-IO-ERR = $GLIB-SYSDEF-POLLERR;
define inline-only constant $G-IO-HUP = $GLIB-SYSDEF-POLLHUP;
define inline-only constant $G-IO-NVAL = $GLIB-SYSDEF-POLLNVAL;


define C-struct <_GIOChannel>
  sealed inline-only slot channel-flags-value :: <guint>;
  sealed inline-only slot ref-count-value :: <guint>;
  sealed inline-only slot funcs-value    :: <GIOFuncs*>;
  pointer-type-name: <_GIOChannel*>;
  c-name: "struct _GIOChannel";
end;
define C-pointer-type <GIOFunc*> => <GIOFunc>;
define C-pointer-type <GIOFunc**> => <GIOFunc*>;

define C-struct <_GIOFuncs>
  sealed inline-only slot io-read-value  :: <C-function-pointer>;
  sealed inline-only slot io-write-value :: <C-function-pointer>;
  sealed inline-only slot io-seek-value  :: <C-function-pointer>;
  sealed inline-only slot io-close-value :: <C-function-pointer>;
  sealed inline-only slot io-add-watch-value :: <C-function-pointer>;
  sealed inline-only slot io-free-value  :: <C-function-pointer>;
  pointer-type-name: <_GIOFuncs*>;
  c-name: "struct _GIOFuncs";
end;

define inline-only C-function g-io-channel-init
  parameter channel1   :: <GIOChannel*>;
  c-name: "g_io_channel_init";
end;

define inline-only C-function g-io-channel-ref
  parameter channel1   :: <GIOChannel*>;
  c-name: "g_io_channel_ref";
end;

define inline-only C-function g-io-channel-unref
  parameter channel1   :: <GIOChannel*>;
  c-name: "g_io_channel_unref";
end;

define inline-only C-function g-io-channel-read
  parameter channel1   :: <GIOChannel*>;
  parameter buf2       :: <gchar*>;
  parameter count3     :: <guint>;
  parameter bytes_read4 :: <guint*>;
  result value :: <C-int>;
  c-name: "g_io_channel_read";
end;

define inline-only C-function g-io-channel-write
  parameter channel1   :: <GIOChannel*>;
  parameter buf2       :: <gchar*>;
  parameter count3     :: <guint>;
  parameter bytes_written4 :: <guint*>;
  result value :: <C-int>;
  c-name: "g_io_channel_write";
end;

define inline-only C-function g-io-channel-seek
  parameter channel1   :: <GIOChannel*>;
  parameter offset2    :: <gint>;
  parameter type3      :: <C-int>;
  result value :: <C-int>;
  c-name: "g_io_channel_seek";
end;

define inline-only C-function g-io-channel-close
  parameter channel1   :: <GIOChannel*>;
  c-name: "g_io_channel_close";
end;

define inline-only C-function g-io-add-watch-full
  parameter channel1   :: <GIOChannel*>;
  parameter priority2  :: <gint>;
  parameter condition3 :: <C-int>;
  parameter func4      :: <GIOFunc>;
  parameter user_data5 :: <gpointer>;
  parameter notify6    :: <GDestroyNotify>;
  result value :: <guint>;
  c-name: "g_io_add_watch_full";
end;

define inline-only C-function g-io-add-watch
  parameter channel1   :: <GIOChannel*>;
  parameter condition2 :: <C-int>;
  parameter func3      :: <GIOFunc>;
  parameter user_data4 :: <gpointer>;
  result value :: <guint>;
  c-name: "g_io_add_watch";
end;
define C-pointer-type <GTimeVal*> => <GTimeVal>;
define C-pointer-type <GTimeVal**> => <GTimeVal*>;
define C-pointer-type <GSourceFuncs*> => <GSourceFuncs>;
define C-pointer-type <GSourceFuncs**> => <GSourceFuncs*>;

define C-struct <_GTimeVal>
  sealed inline-only slot tv-sec-value   :: <glong>;
  sealed inline-only slot tv-usec-value  :: <glong>;
  pointer-type-name: <_GTimeVal*>;
  c-name: "struct _GTimeVal";
end;

define C-struct <_GSourceFuncs>
  sealed inline-only slot prepare-value  :: <C-function-pointer>;
  sealed inline-only slot check-value    :: <C-function-pointer>;
  sealed inline-only slot dispatch-value :: <C-function-pointer>;
  sealed inline-only slot destroy-value  :: <GDestroyNotify>;
  pointer-type-name: <_GSourceFuncs*>;
  c-name: "struct _GSourceFuncs";
end;
define inline-only constant $G-PRIORITY-HIGH               = -100;
define inline-only constant $G-PRIORITY-DEFAULT            =    0;
define inline-only constant $G-PRIORITY-HIGH-IDLE          =  100;
define inline-only constant $G-PRIORITY-DEFAULT-IDLE       =  200;
define inline-only constant $G-PRIORITY-LOW                =  300;
define C-pointer-type <GSourceFunc*> => <GSourceFunc>;
define C-pointer-type <GSourceFunc**> => <GSourceFunc*>;

define inline-only C-function g-source-add
  parameter priority1  :: <gint>;
  parameter can_recurse2 :: <gboolean>;
  parameter funcs3     :: <GSourceFuncs*>;
  parameter source_data4 :: <gpointer>;
  parameter user_data5 :: <gpointer>;
  parameter notify6    :: <GDestroyNotify>;
  result value :: <guint>;
  c-name: "g_source_add";
end;

define inline-only C-function g-source-remove
  parameter tag1       :: <guint>;
  result value :: <gboolean>;
  c-name: "g_source_remove";
end;

define inline-only C-function g-source-remove-by-user-data
  parameter user_data1 :: <gpointer>;
  result value :: <gboolean>;
  c-name: "g_source_remove_by_user_data";
end;

define inline-only C-function g-source-remove-by-source-data
  parameter source_data1 :: <gpointer>;
  result value :: <gboolean>;
  c-name: "g_source_remove_by_source_data";
end;

define inline-only C-function g-source-remove-by-funcs-user-data
  parameter funcs1     :: <GSourceFuncs*>;
  parameter user_data2 :: <gpointer>;
  result value :: <gboolean>;
  c-name: "g_source_remove_by_funcs_user_data";
end;

define inline-only C-function g-get-current-time
  parameter result1    :: <GTimeVal*>;
  c-name: "g_get_current_time";
end;

define inline-only C-function g-main-new
  parameter is_running1 :: <gboolean>;
  result value :: <GMainLoop*>;
  c-name: "g_main_new";
end;

define inline-only C-function g-main-run
  parameter loop1      :: <GMainLoop*>;
  c-name: "g_main_run";
end;

define inline-only C-function g-main-quit
  parameter loop1      :: <GMainLoop*>;
  c-name: "g_main_quit";
end;

define inline-only C-function g-main-destroy
  parameter loop1      :: <GMainLoop*>;
  c-name: "g_main_destroy";
end;

define inline-only C-function g-main-is-running
  parameter loop1      :: <GMainLoop*>;
  result value :: <gboolean>;
  c-name: "g_main_is_running";
end;

define inline-only C-function g-main-iteration
  parameter may_block1 :: <gboolean>;
  result value :: <gboolean>;
  c-name: "g_main_iteration";
end;

define inline-only C-function g-main-pending
  result value :: <gboolean>;
  c-name: "g_main_pending";
end;

define inline-only C-function g-timeout-add-full
  parameter priority1  :: <gint>;
  parameter interval2  :: <guint>;
  parameter function3  :: <GSourceFunc>;
  parameter data4      :: <gpointer>;
  parameter notify5    :: <GDestroyNotify>;
  result value :: <guint>;
  c-name: "g_timeout_add_full";
end;

define inline-only C-function g-timeout-add
  parameter interval1  :: <guint>;
  parameter function2  :: <GSourceFunc>;
  parameter data3      :: <gpointer>;
  result value :: <guint>;
  c-name: "g_timeout_add";
end;

define inline-only C-function g-idle-add
  parameter function1  :: <GSourceFunc>;
  parameter data2      :: <gpointer>;
  result value :: <guint>;
  c-name: "g_idle_add";
end;

define inline-only C-function g-idle-add-full
  parameter priority1  :: <gint>;
  parameter function2  :: <GSourceFunc>;
  parameter data3      :: <gpointer>;
  parameter destroy4   :: <GDestroyNotify>;
  result value :: <guint>;
  c-name: "g_idle_add_full";
end;

define inline-only C-function g-idle-remove-by-data
  parameter data1      :: <gpointer>;
  result value :: <gboolean>;
  c-name: "g_idle_remove_by_data";
end;
define C-pointer-type <GPollFD*> => <GPollFD>;
define C-pointer-type <GPollFD**> => <GPollFD*>;
define C-pointer-type <GPollFunc*> => <GPollFunc>;
define C-pointer-type <GPollFunc**> => <GPollFunc*>;

define C-struct <_GPollFD>
  sealed inline-only slot fd-value       :: <gint>;
  sealed inline-only slot events-value   :: <gushort>;
  sealed inline-only slot revents-value  :: <gushort>;
  pointer-type-name: <_GPollFD*>;
  c-name: "struct _GPollFD";
end;

define inline-only C-function g-main-add-poll
  parameter fd1        :: <GPollFD*>;
  parameter priority2  :: <gint>;
  c-name: "g_main_add_poll";
end;

define inline-only C-function g-main-remove-poll
  parameter fd1        :: <GPollFD*>;
  c-name: "g_main_remove_poll";
end;

define inline-only C-function g-main-set-poll-func
  parameter func1      :: <GPollFunc>;
  c-name: "g_main_set_poll_func";
end;

define inline-only C-function g-io-channel-unix-new
  parameter fd1        :: <C-int>;
  result value :: <GIOChannel*>;
  c-name: "g_io_channel_unix_new";
end;

define inline-only C-function g-io-channel-unix-get-fd
  parameter channel1   :: <GIOChannel*>;
  result value :: <gint>;
  c-name: "g_io_channel_unix_get_fd";
end;
define inline-only constant $G-WIN32-MSG-HANDLE            =
	19981206;

define inline-only C-function g-main-poll-win32-msg-add
  parameter priority1  :: <gint>;
  parameter fd2        :: <GPollFD*>;
  parameter hwnd3      :: <guint>;
  c-name: "g_main_poll_win32_msg_add";
end;

define inline-only C-function g-io-channel-win32-new-messages
  parameter hwnd1      :: <guint>;
  result value :: <GIOChannel*>;
  c-name: "g_io_channel_win32_new_messages";
end;

define inline-only C-function g-io-channel-win32-new-pipe
  parameter fd1        :: <C-int>;
  result value :: <GIOChannel*>;
  c-name: "g_io_channel_win32_new_pipe";
end;

define inline-only C-function g-io-channel-win32-new-pipe-with-wakeups
  parameter fd1        :: <C-int>;
  parameter peer2      :: <guint>;
  parameter peer_fd3   :: <C-int>;
  result value :: <GIOChannel*>;
  c-name: "g_io_channel_win32_new_pipe_with_wakeups";
end;

define inline-only C-function g-io-channel-win32-pipe-request-wakeups
  parameter channel1   :: <GIOChannel*>;
  parameter peer2      :: <guint>;
  parameter peer_fd3   :: <C-int>;
  c-name: "g_io_channel_win32_pipe_request_wakeups";
end;

define inline-only C-function g-io-channel-win32-pipe-readable
  parameter fd1        :: <C-int>;
  parameter offset2    :: <guint>;
  c-name: "g_io_channel_win32_pipe_readable";
end;

define inline-only C-function g-io-channel-win32-get-fd
  parameter channel1   :: <GIOChannel*>;
  result value :: <gint>;
  c-name: "g_io_channel_win32_get_fd";
end;

define inline-only C-function g-io-channel-win32-new-stream-socket
  parameter socket1    :: <C-int>;
  result value :: <GIOChannel*>;
  c-name: "g_io_channel_win32_new_stream_socket";
end;
define inline-only constant $MAXPATHLEN                    = 1024;
define C-pointer-type <pid-t*> => <pid-t>;
define C-pointer-type <pid-t**> => <pid-t*>;
define inline-only constant $NAME-MAX                      =  255;

define C-struct <_DIR>
  sealed inline-only slot dir-name-value :: <gchar*>;
  sealed inline-only slot just-opened-value :: <gboolean>;
  sealed inline-only slot find-file-handle-value :: <guint>;
  sealed inline-only slot find-file-data-value :: <gpointer>;
  pointer-type-name: <_DIR*>;
  c-name: "struct _DIR";
end;
define C-pointer-type <DIR*> => <DIR>;
define C-pointer-type <DIR**> => <DIR*>;

define C-struct <_dirent>
  sealed inline-only array slot d-name-array :: <gchar>,
    length: $NAME-MAX + 1,
    address-getter: d-name-value;
  pointer-type-name: <_dirent*>;
  c-name: "struct _dirent";
end;
define C-pointer-type <dirent*> => <dirent>;
define C-pointer-type <dirent**> => <dirent*>;

define inline-only C-function gwin-ftruncate
  parameter f1         :: <gint>;
  parameter size2      :: <guint>;
  result value :: <C-int>;
  c-name: "gwin_ftruncate";
end;

define inline-only C-function gwin-opendir
  parameter dirname1   ::  /* const */ <gchar*>;
  result value :: <DIR*>;
  c-name: "gwin_opendir";
end;

define inline-only C-function gwin-readdir
  parameter dir1       :: <DIR*>;
  result value :: <dirent*>;
  c-name: "gwin_readdir";
end;

define inline-only C-function gwin-rewinddir
  parameter dir1       :: <DIR*>;
  c-name: "gwin_rewinddir";
end;

define inline-only C-function gwin-closedir
  parameter dir1       :: <DIR*>;
  result value :: <gint>;
  c-name: "gwin_closedir";
end;
define C-pointer-type <GStaticPrivate*> => <GStaticPrivate>;
define C-pointer-type <GStaticPrivate**> => <GStaticPrivate*>;
define C-pointer-type <GThreadFunctions*> => <GThreadFunctions>;
define C-pointer-type <GThreadFunctions**> => <GThreadFunctions*>;

define C-struct <_GThreadFunctions>
  sealed inline-only slot mutex-new-value :: <C-function-pointer>;
  sealed inline-only slot mutex-lock-value :: <C-function-pointer>;
  sealed inline-only slot mutex-trylock-value :: <C-function-pointer>;
  sealed inline-only slot mutex-unlock-value :: <C-function-pointer>;
  sealed inline-only slot mutex-free-value :: <C-function-pointer>;
  sealed inline-only slot cond-new-value :: <C-function-pointer>;
  sealed inline-only slot cond-signal-value :: <C-function-pointer>;
  sealed inline-only slot cond-broadcast-value :: <C-function-pointer>;
  sealed inline-only slot cond-wait-value :: <C-function-pointer>;
  sealed inline-only slot cond-timed-wait-value :: <C-function-pointer>;
  sealed inline-only slot cond-free-value :: <C-function-pointer>;
  sealed inline-only slot private-new-value :: <C-function-pointer>;
  sealed inline-only slot private-get-value :: <C-function-pointer>;
  sealed inline-only slot private-set-value :: <C-function-pointer>;
  pointer-type-name: <_GThreadFunctions*>;
  c-name: "struct _GThreadFunctions";
end;

define inline-only C-function g-thread-init
  parameter vtable1    :: <GThreadFunctions*>;
  c-name: "g_thread_init";
end;

define inline-only C-function g-static-mutex-get-mutex-impl
  parameter mutex1     :: <GMutex**>;
  result value :: <GMutex*>;
  c-name: "g_static_mutex_get_mutex_impl";
end;

define C-struct <_GStaticPrivate>
  sealed inline-only slot index-value    :: <guint>;
  pointer-type-name: <_GStaticPrivate*>;
  c-name: "struct _GStaticPrivate";
end;

define inline-only C-function g-static-private-get
  parameter private_key1 :: <GStaticPrivate*>;
  result value :: <gpointer>;
  c-name: "g_static_private_get";
end;

define inline-only C-function g-static-private-set
  parameter private_key1 :: <GStaticPrivate*>;
  parameter data2      :: <gpointer>;
  parameter notify3    :: <GDestroyNotify>;
  c-name: "g_static_private_set";
end;

define inline-only C-function glib-dummy-decl
  c-name: "glib_dummy_decl";
end;

define inline constant <gchar> = <C-char>;
define inline constant <gshort> = <C-short>;
define inline constant <glong> = <C-both-long>;
define inline constant <gint> = <C-int>;
define inline constant <gboolean> = <gint>;
define inline constant <guchar> = <C-unsigned-char>;
define inline constant <gushort> = <C-unsigned-short>;
define inline constant <gulong> = <C-both-unsigned-long>;
define inline constant <guint> = <C-unsigned-int>;
define inline constant <gfloat> = <C-float>;
define inline constant <gdouble> = <C-double>;
define inline constant <gpointer> = <C-void*>;
define inline constant <gconstpointer> =  /* const */ <C-void*>;
define inline constant <gssize> = <gint32>;
define inline constant <gsize> = <guint32>;
define inline constant <GQuark> = <guint32>;
define inline constant <GTime> = <gint32>;
define inline constant <GArray> = <_GArray>;
define inline constant <GByteArray> = <_GByteArray>;
define inline constant <GCompletion> = <_GCompletion>;
define inline constant <GDebugKey> = <_GDebugKey>;
define inline constant <GHook> = <_GHook>;
define inline constant <GHookList> = <_GHookList>;
define inline constant <GList> = <_GList>;
define inline constant <GNode> = <_GNode>;
define inline constant <GPtrArray> = <_GPtrArray>;
define inline constant <GScanner> = <_GScanner>;
define inline constant <GScannerConfig> = <_GScannerConfig>;
define inline constant <GSList> = <_GSList>;
define inline constant <GString> = <_GString>;
define inline constant <GTuples> = <_GTuples>;
define inline constant <GTokenValue> = <_GTokenValue>;
define inline constant <GIOChannel> = <_GIOChannel>;
define inline constant <GTraverseFlags> = <c-signed-int>;
define inline constant <GTraverseType> = <c-signed-int>;
define inline constant <GLogLevelFlags> = <c-signed-int>;
define inline constant <GCacheNewFunc> = <C-function-pointer>;
define inline constant <GCacheDupFunc> = <C-function-pointer>;
define inline constant <GCacheDestroyFunc> = <C-function-pointer>;
define inline constant <GCompareFunc> = <C-function-pointer>;
define inline constant <GCompletionFunc> = <C-function-pointer>;
define inline constant <GDestroyNotify> = <C-function-pointer>;
define inline constant <GDataForeachFunc> = <C-function-pointer>;
define inline constant <GFunc> = <C-function-pointer>;
define inline constant <GHashFunc> = <C-function-pointer>;
define inline constant <GFreeFunc> = <C-function-pointer>;
define inline constant <GHFunc> = <C-function-pointer>;
define inline constant <GHRFunc> = <C-function-pointer>;
define inline constant <GHookCompareFunc> = <C-function-pointer>;
define inline constant <GHookFindFunc> = <C-function-pointer>;
define inline constant <GHookMarshaller> = <C-function-pointer>;
define inline constant <GHookCheckMarshaller> = <C-function-pointer>;
define inline constant <GHookFunc> = <C-function-pointer>;
define inline constant <GHookCheckFunc> = <C-function-pointer>;
define inline constant <GHookFreeFunc> = <C-function-pointer>;
define inline constant <GLogFunc> = <C-function-pointer>;
define inline constant <GNodeTraverseFunc> = <C-function-pointer>;
define inline constant <GNodeForeachFunc> = <C-function-pointer>;
define inline constant <GSearchFunc> = <C-function-pointer>;
define inline constant <GScannerMsgFunc> = <C-function-pointer>;
define inline constant <GTraverseFunc> = <C-function-pointer>;
define inline constant <GVoidFunc> = <C-function-pointer>;
define sealed domain make (singleton(<_GList*>));
define sealed domain initialize (<_GList*>);
define sealed domain make (singleton(<_GSList*>));
define sealed domain initialize (<_GSList*>);
define sealed domain make (singleton(<_GString*>));
define sealed domain initialize (<_GString*>);
define sealed domain make (singleton(<_GArray*>));
define sealed domain initialize (<_GArray*>);
define sealed domain make (singleton(<_GByteArray*>));
define sealed domain initialize (<_GByteArray*>);
define sealed domain make (singleton(<_GPtrArray*>));
define sealed domain initialize (<_GPtrArray*>);
define sealed domain make (singleton(<_GTuples*>));
define sealed domain initialize (<_GTuples*>);
define sealed domain make (singleton(<_GDebugKey*>));
define sealed domain initialize (<_GDebugKey*>);
define sealed domain make (singleton(<_GNode*>));
define sealed domain initialize (<_GNode*>);
define inline constant <GHookFlagMask> = <c-signed-int>;
define sealed domain make (singleton(<_GHookList*>));
define sealed domain initialize (<_GHookList*>);
define sealed domain make (singleton(<_GHook*>));
define sealed domain initialize (<_GHook*>);
define inline constant <GPrintFunc> = <C-function-pointer>;
define inline constant <GErrorFunc> = <C-function-pointer>;
define inline constant <GWarningFunc> = <C-function-pointer>;
define inline constant <GErrorType> = <c-signed-int>;
define inline constant <GTokenType> = <c-signed-int>;
define sealed domain make (singleton(<_GScannerConfig*>));
define sealed domain initialize (<_GScannerConfig*>);
define sealed domain make (singleton(<_GScanner*>));
define sealed domain initialize (<_GScanner*>);
define sealed domain make (singleton(<_GCompletion*>));
define sealed domain initialize (<_GCompletion*>);
define inline constant <GDateYear> = <guint16>;
define inline constant <GDateDay> = <guint8>;
define inline constant <GDate> = <_GDate>;
define inline constant <GDateDMY> = <c-signed-int>;
define inline constant <GDateWeekday> = <c-signed-int>;
define inline constant <GDateMonth> = <c-signed-int>;
define sealed domain make (singleton(<_GDate*>));
define sealed domain initialize (<_GDate*>);
define inline constant <GIOFuncs> = <_GIOFuncs>;
define inline constant <GIOError> = <c-signed-int>;
define inline constant <GSeekType> = <c-signed-int>;
define inline constant <GIOCondition> = <c-signed-int>;
define sealed domain make (singleton(<_GIOChannel*>));
define sealed domain initialize (<_GIOChannel*>);
define inline constant <GIOFunc> = <C-function-pointer>;
define sealed domain make (singleton(<_GIOFuncs*>));
define sealed domain initialize (<_GIOFuncs*>);
define inline constant <GTimeVal> = <_GTimeVal>;
define inline constant <GSourceFuncs> = <_GSourceFuncs>;
define sealed domain make (singleton(<_GTimeVal*>));
define sealed domain initialize (<_GTimeVal*>);
define sealed domain make (singleton(<_GSourceFuncs*>));
define sealed domain initialize (<_GSourceFuncs*>);
define inline constant <GSourceFunc> = <C-function-pointer>;
define inline constant <GPollFD> = <_GPollFD>;
define inline constant <GPollFunc> = <C-function-pointer>;
define sealed domain make (singleton(<_GPollFD*>));
define sealed domain initialize (<_GPollFD*>);
define inline constant <pid-t> = <C-int>;
define sealed domain make (singleton(<_DIR*>));
define sealed domain initialize (<_DIR*>);
define inline constant <DIR> = <_DIR>;
define sealed domain make (singleton(<_dirent*>));
define sealed domain initialize (<_dirent*>);
define inline constant <dirent> = <_dirent>;
define inline constant <GStaticPrivate> = <_GStaticPrivate>;
define inline constant <GThreadFunctions> = <_GThreadFunctions>;
define sealed domain make (singleton(<_GThreadFunctions*>));
define sealed domain initialize (<_GThreadFunctions*>);
define sealed domain make (singleton(<_GStaticPrivate*>));
define sealed domain initialize (<_GStaticPrivate*>);