Integer representing a day of the month; between 1 and 31. The %G_DATE_BAD_DAY value represents an invalid day of the month.

Integer type representing a year. The %G_DATE_BAD_YEAR value is the invalid value. The year must be 1 or higher; negative ([BCE](https://en.wikipedia.org/wiki/Common_Era)) years are not allowed. The year is represented with four digits.

Opaque type. See g_main_context_pusher_new() for details.

Opaque type. See g_mutex_locker_new() for details.

A type which is used to hold a process identification. On UNIX, processes are identified by a process id (an integer), while Windows uses process handles (which are pointers). GPid is used in GLib only for descendant processes spawned with the g_spawn functions.

A GQuark is a non-zero integer which uniquely identifies a particular string. A GQuark value of zero is associated to %NULL.

Opaque type. See g_rw_lock_reader_locker_new() for details.

Opaque type. See g_rw_lock_writer_locker_new() for details.

Opaque type. See g_rec_mutex_locker_new() for details.

A typedef for a reference-counted string. A pointer to a #GRefString can be treated like a standard `char*` array by all code, but can additionally have `g_ref_string_*()` methods called on it. `g_ref_string_*()` methods cannot be called on `char*` arrays not allocated using g_ref_string_new(). If using #GRefString with autocleanups, g_autoptr() must be used rather than g_autofree(), so that the reference counting metadata is also freed.

A typedef alias for gchar**. This is mostly useful when used together with g_auto().

Simply a replacement for `time_t`. It has been deprecated since it is not equivalent to `time_t` on 64-bit platforms with a 64-bit `time_t`. Unrelated to #GTimer. Note that #GTime is defined to always be a 32-bit integer, unlike `time_t` which may be 64-bit on some systems. Therefore, #GTime will overflow in the year 2038, and you cannot use the address of a #GTime variable as argument to the UNIX time() function. Instead, do the following: |[ time_t ttime; GTime gtime; time (&ttime); gtime = (GTime)ttime; ]|

This is not [Y2038-safe](https://en.wikipedia.org/wiki/Year_2038_problem). Use #GDateTime or #time_t instead.

A value representing an interval of time, in microseconds.

Return the minimal alignment required by the platform ABI for values of the given type. The address of a variable or struct member of the given type must always be a multiple of this alignment. For example, most platforms require int variables to be aligned at a 4-byte boundary, so `G_ALIGNOF (int)` is 4 on most platforms. Note this is not necessarily the same as the value returned by GCC’s `__alignof__` operator, which returns the preferred alignment for a type. The preferred alignment may be a stricter alignment than the minimal alignment.

a type-name

Evaluates to a truth value if the absolute difference between @a and @b is smaller than @epsilon, and to a false value otherwise. For example, - `G_APPROX_VALUE (5, 6, 2)` evaluates to true - `G_APPROX_VALUE (3.14, 3.15, 0.001)` evaluates to false - `G_APPROX_VALUE (n, 0.f, FLT_EPSILON)` evaluates to true if `n` is within the single precision floating point epsilon from zero

a numeric value a numeric value a numeric value that expresses the tolerance between @a and @b

A good size for a buffer to be passed into g_ascii_dtostr(). It is guaranteed to be enough for all output of that function on systems with 64bit IEEE-compatible doubles. The typical usage would be something like: |[ char buf[G_ASCII_DTOSTR_BUF_SIZE]; fprintf (out, "value=%s\n", g_ascii_dtostr (buf, sizeof (buf), value)); ]|

Contains the public fields of a GArray.

a pointer to the element data. The data may be moved as elements are added to the #GArray. the number of elements in the #GArray not including the possible terminating zero element. Adds @len elements onto the end of the array.

the #GArray

a #GArray a pointer to the elements to append to the end of the array the number of elements to append

Checks whether @target exists in @array by performing a binary search based on the given comparison function @compare_func which get pointers to items as arguments. If the element is found, %TRUE is returned and the element’s index is returned in @out_match_index (if non-%NULL). Otherwise, %FALSE is returned and @out_match_index is undefined. If @target exists multiple times in @array, the index of the first instance is returned. This search is using a binary search, so the @array must absolutely be sorted to return a correct result (if not, the function may produce false-negative). This example defines a comparison function and search an element in a #GArray: |[ static gint* cmpint (gconstpointer a, gconstpointer b) { const gint *_a = a; const gint *_b = b; return *_a - *_b; } ... gint i = 424242; guint matched_index; gboolean result = g_array_binary_search (garray, &i, cmpint, &matched_index); ... ]|

%TRUE if @target is one of the elements of @array, %FALSE otherwise.

a #GArray. a pointer to the item to look up. A #GCompareFunc used to locate @target. return location for the index of the element, if found.

Create a shallow copy of a #GArray. If the array elements consist of pointers to data, the pointers are copied but the actual data is not.

A copy of @array.

A #GArray.

Frees the memory allocated for the #GArray. If @free_segment is %TRUE it frees the memory block holding the elements as well. Pass %FALSE if you want to free the #GArray wrapper but preserve the underlying array for use elsewhere. If the reference count of @array is greater than one, the #GArray wrapper is preserved but the size of @array will be set to zero. If array contents point to dynamically-allocated memory, they should be freed separately if @free_seg is %TRUE and no @clear_func function has been set for @array. This function is not thread-safe. If using a #GArray from multiple threads, use only the atomic g_array_ref() and g_array_unref() functions.

the element data if @free_segment is %FALSE, otherwise %NULL. The element data should be freed using g_free().

a #GArray if %TRUE the actual element data is freed as well

Gets the size of the elements in @array.

Size of each element, in bytes

A #GArray

Inserts @len elements into a #GArray at the given index. If @index_ is greater than the array’s current length, the array is expanded. The elements between the old end of the array and the newly inserted elements will be initialised to zero if the array was configured to clear elements; otherwise their values will be undefined. If @index_ is less than the array’s current length, new entries will be inserted into the array, and the existing entries above @index_ will be moved upwards. @data may be %NULL if (and only if) @len is zero. If @len is zero, this function is a no-op.

the #GArray

a #GArray the index to place the elements at a pointer to the elements to insert the number of elements to insert

Creates a new #GArray with a reference count of 1.

the new #GArray

%TRUE if the array should have an extra element at the end which is set to 0 %TRUE if #GArray elements should be automatically cleared to 0 when they are allocated the size of each element in bytes

Adds @len elements onto the start of the array. @data may be %NULL if (and only if) @len is zero. If @len is zero, this function is a no-op. This operation is slower than g_array_append_vals() since the existing elements in the array have to be moved to make space for the new elements.

the #GArray

a #GArray a pointer to the elements to prepend to the start of the array the number of elements to prepend, which may be zero

Atomically increments the reference count of @array by one. This function is thread-safe and may be called from any thread.

The passed in #GArray

A #GArray

Removes the element at the given index from a #GArray. The following elements are moved down one place.

the #GArray

a #GArray the index of the element to remove

Removes the element at the given index from a #GArray. The last element in the array is used to fill in the space, so this function does not preserve the order of the #GArray. But it is faster than g_array_remove_index().

the #GArray

a @GArray the index of the element to remove

Removes the given number of elements starting at the given index from a #GArray. The following elements are moved to close the gap.

the #GArray

a @GArray the index of the first element to remove the number of elements to remove

Sets a function to clear an element of @array. The @clear_func will be called when an element in the array data segment is removed and when the array is freed and data segment is deallocated as well. @clear_func will be passed a pointer to the element to clear, rather than the element itself. Note that in contrast with other uses of #GDestroyNotify functions, @clear_func is expected to clear the contents of the array element it is given, but not free the element itself. |[ typedef struct { gchar *str; GObject *obj; } ArrayElement; static void array_element_clear (ArrayElement *element) { g_clear_pointer (&element->str, g_free); g_clear_object (&element->obj); } // main code GArray *garray = g_array_new (FALSE, FALSE, sizeof (ArrayElement)); g_array_set_clear_func (garray, (GDestroyNotify) array_element_clear); // assign data to the structure g_array_free (garray, TRUE); ]|

A #GArray a function to clear an element of @array

Sets the size of the array, expanding it if necessary. If the array was created with @clear_ set to %TRUE, the new elements are set to 0.

the #GArray

a #GArray the new size of the #GArray

Creates a new #GArray with @reserved_size elements preallocated and a reference count of 1. This avoids frequent reallocation, if you are going to add many elements to the array. Note however that the size of the array is still 0.

the new #GArray

%TRUE if the array should have an extra element at the end with all bits cleared %TRUE if all bits in the array should be cleared to 0 on allocation size of each element in the array number of elements preallocated

Sorts a #GArray using @compare_func which should be a qsort()-style comparison function (returns less than zero for first arg is less than second arg, zero for equal, greater zero if first arg is greater than second arg). This is guaranteed to be a stable sort since version 2.32.

a #GArray comparison function

Like g_array_sort(), but the comparison function receives an extra user data argument. This is guaranteed to be a stable sort since version 2.32. There used to be a comment here about making the sort stable by using the addresses of the elements in the comparison function. This did not actually work, so any such code should be removed.

a #GArray comparison function data to pass to @compare_func

Frees the data in the array and resets the size to zero, while the underlying array is preserved for use elsewhere and returned to the caller. If the array was created with the @zero_terminate property set to %TRUE, the returned data is zero terminated too. If array elements contain dynamically-allocated memory, the array elements should also be freed by the caller. A short example of use: |[ ... gpointer data; gsize data_len; data = g_array_steal (some_array, &data_len); ... ]|

the element data, which should be freed using g_free().

a #GArray. pointer to retrieve the number of elements of the original array

Atomically decrements the reference count of @array by one. If the reference count drops to 0, all memory allocated by the array is released. This function is thread-safe and may be called from any thread.

A #GArray

An opaque data structure which represents an asynchronous queue. It should only be accessed through the `g_async_queue_*` functions.

Returns the length of the queue. Actually this function returns the number of data items in the queue minus the number of waiting threads, so a negative value means waiting threads, and a positive value means available entries in the @queue. A return value of 0 could mean n entries in the queue and n threads waiting. This can happen due to locking of the queue or due to scheduling.

the length of the @queue

a #GAsyncQueue.

the length of the @queue.

a #GAsyncQueue

Acquires the @queue's lock. If another thread is already holding the lock, this call will block until the lock becomes available. Call g_async_queue_unlock() to drop the lock again. While holding the lock, you can only call the g_async_queue_*_unlocked() functions on @queue. Otherwise, deadlock may occur.

a #GAsyncQueue

Pops data from the @queue. If @queue is empty, this function blocks until data becomes available.

data from the queue

a #GAsyncQueue

Pops data from the @queue. If @queue is empty, this function blocks until data becomes available. This function must be called while holding the @queue's lock.

data from the queue.

a #GAsyncQueue

Pushes the @data into the @queue. The @data parameter must not be %NULL.

a #GAsyncQueue

data to push onto the @queue

Pushes the @item into the @queue. @item must not be %NULL. In contrast to g_async_queue_push(), this function pushes the new item ahead of the items already in the queue, so that it will be the next one to be popped off the queue.

a #GAsyncQueue

data to push into the @queue

Pushes the @item into the @queue. @item must not be %NULL. In contrast to g_async_queue_push_unlocked(), this function pushes the new item ahead of the items already in the queue, so that it will be the next one to be popped off the queue. This function must be called while holding the @queue's lock.

a #GAsyncQueue

data to push into the @queue

Inserts @data into @queue using @func to determine the new position. This function requires that the @queue is sorted before pushing on new elements, see g_async_queue_sort(). This function will lock @queue before it sorts the queue and unlock it when it is finished. For an example of @func see g_async_queue_sort().

a #GAsyncQueue

the @data to push into the @queue the #GCompareDataFunc is used to sort @queue user data passed to @func.

Inserts @data into @queue using @func to determine the new position. The sort function @func is passed two elements of the @queue. It should return 0 if they are equal, a negative value if the first element should be higher in the @queue or a positive value if the first element should be lower in the @queue than the second element. This function requires that the @queue is sorted before pushing on new elements, see g_async_queue_sort(). This function must be called while holding the @queue's lock. For an example of @func see g_async_queue_sort().

a #GAsyncQueue

the data to push into the @queue the #GCompareDataFunc is used to sort @queue user data passed to @func.

Pushes the @data into the @queue. The @data parameter must not be %NULL. This function must be called while holding the @queue's lock.

a #GAsyncQueue

data to push onto the @queue

Increases the reference count of the asynchronous @queue by 1. You do not need to hold the lock to call this function.

the @queue that was passed in (since 2.6)

a #GAsyncQueue

Increases the reference count of the asynchronous @queue by 1.

Reference counting is done atomically. so g_async_queue_ref() can be used regardless of the @queue's lock.

a #GAsyncQueue

Remove an item from the queue.

%TRUE if the item was removed

a #GAsyncQueue

the data to remove from the @queue

Remove an item from the queue. This function must be called while holding the @queue's lock.

%TRUE if the item was removed

a #GAsyncQueue

the data to remove from the @queue

Sorts @queue using @func. The sort function @func is passed two elements of the @queue. It should return 0 if they are equal, a negative value if the first element should be higher in the @queue or a positive value if the first element should be lower in the @queue than the second element. This function will lock @queue before it sorts the queue and unlock it when it is finished. If you were sorting a list of priority numbers to make sure the lowest priority would be at the top of the queue, you could use: |[ gint32 id1; gint32 id2; id1 = GPOINTER_TO_INT (element1); id2 = GPOINTER_TO_INT (element2); return (id1 > id2 ? +1 : id1 == id2 ? 0 : -1); ]|

a #GAsyncQueue

the #GCompareDataFunc is used to sort @queue user data passed to @func

a #GAsyncQueue

the #GCompareDataFunc is used to sort @queue user data passed to @func

Pops data from the @queue. If the queue is empty, blocks until @end_time or until data becomes available. If no data is received before @end_time, %NULL is returned. To easily calculate @end_time, a combination of g_get_real_time() and g_time_val_add() can be used.

use g_async_queue_timeout_pop().

data from the queue or %NULL, when no data is received before @end_time.

a #GAsyncQueue

a #GTimeVal, determining the final time

use g_async_queue_timeout_pop_unlocked().

data from the queue or %NULL, when no data is received before @end_time.

a #GAsyncQueue

a #GTimeVal, determining the final time

Pops data from the @queue. If the queue is empty, blocks for @timeout microseconds, or until data becomes available. If no data is received before the timeout, %NULL is returned.

data from the queue or %NULL, when no data is received before the timeout.

a #GAsyncQueue

the number of microseconds to wait

Pops data from the @queue. If the queue is empty, blocks for @timeout microseconds, or until data becomes available. If no data is received before the timeout, %NULL is returned. This function must be called while holding the @queue's lock.

data from the queue or %NULL, when no data is received before the timeout.

a #GAsyncQueue

the number of microseconds to wait

Tries to pop data from the @queue. If no data is available, %NULL is returned.

data from the queue or %NULL, when no data is available immediately.

a #GAsyncQueue

Tries to pop data from the @queue. If no data is available, %NULL is returned. This function must be called while holding the @queue's lock.

data from the queue or %NULL, when no data is available immediately.

a #GAsyncQueue

Releases the queue's lock. Calling this function when you have not acquired the with g_async_queue_lock() leads to undefined behaviour.

a #GAsyncQueue

Decreases the reference count of the asynchronous @queue by 1. If the reference count went to 0, the @queue will be destroyed and the memory allocated will be freed. So you are not allowed to use the @queue afterwards, as it might have disappeared. You do not need to hold the lock to call this function.

a #GAsyncQueue.

Decreases the reference count of the asynchronous @queue by 1 and releases the lock. This function must be called while holding the @queue's lock. If the reference count went to 0, the @queue will be destroyed and the memory allocated will be freed.

Reference counting is done atomically. so g_async_queue_unref() can be used regardless of the @queue's lock.

a #GAsyncQueue

Creates a new asynchronous queue.

a new #GAsyncQueue. Free with g_async_queue_unref()

Creates a new asynchronous queue and sets up a destroy notify function that is used to free any remaining queue items when the queue is destroyed after the final unref.

a new #GAsyncQueue. Free with g_async_queue_unref()

function to free queue elements

Specifies one of the possible types of byte order. See %G_BYTE_ORDER.

Inserts a breakpoint instruction into the code. On architectures which support it, this is implemented as a soft interrupt and on other architectures it raises a `SIGTRAP` signal. `SIGTRAP` is used rather than abort() to allow breakpoints to be skipped past in a debugger if they are not the desired target of debugging.

An opaque data structure representing a set of bookmarks.

Creates a new empty #GBookmarkFile object. Use g_bookmark_file_load_from_file(), g_bookmark_file_load_from_data() or g_bookmark_file_load_from_data_dirs() to read an existing bookmark file.

an empty #GBookmarkFile

Adds the application with @name and @exec to the list of applications that have registered a bookmark for @uri into @bookmark. Every bookmark inside a #GBookmarkFile must have at least an application registered. Each application must provide a name, a command line useful for launching the bookmark, the number of times the bookmark has been registered by the application and the last time the application registered this bookmark. If @name is %NULL, the name of the application will be the same returned by g_get_application_name(); if @exec is %NULL, the command line will be a composition of the program name as returned by g_get_prgname() and the "\%u" modifier, which will be expanded to the bookmark's URI. This function will automatically take care of updating the registrations count and timestamping in case an application with the same @name had already registered a bookmark for @uri inside @bookmark. If no bookmark for @uri is found, one is created.

a #GBookmarkFile

a valid URI the name of the application registering the bookmark or %NULL command line to be used to launch the bookmark or %NULL

Adds @group to the list of groups to which the bookmark for @uri belongs to. If no bookmark for @uri is found then it is created.

a #GBookmarkFile

a valid URI the group name to be added

Deeply copies a @bookmark #GBookmarkFile object to a new one.

the copy of @bookmark. Use g_bookmark_free() when finished using it.

A #GBookmarkFile

Frees a #GBookmarkFile.

a #GBookmarkFile

Gets the time the bookmark for @uri was added to @bookmark In the event the URI cannot be found, -1 is returned and @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.

Use g_bookmark_file_get_added_date_time() instead, as `time_t` is deprecated due to the year 2038 problem.

a timestamp

a #GBookmarkFile

a valid URI

Gets the time the bookmark for @uri was added to @bookmark In the event the URI cannot be found, %NULL is returned and @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.

a #GDateTime

a #GBookmarkFile

a valid URI

Gets the registration information of @app_name for the bookmark for @uri. See g_bookmark_file_set_application_info() for more information about the returned data. The string returned in @app_exec must be freed. In the event the URI cannot be found, %FALSE is returned and @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. In the event that no application with name @app_name has registered a bookmark for @uri, %FALSE is returned and error is set to %G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED. In the event that unquoting the command line fails, an error of the %G_SHELL_ERROR domain is set and %FALSE is returned.

Use g_bookmark_file_get_application_info() instead, as `time_t` is deprecated due to the year 2038 problem.

%TRUE on success.

a #GBookmarkFile

a valid URI an application's name return location for the command line of the application, or %NULL return location for the registration count, or %NULL return location for the last registration time, or %NULL

%TRUE on success.

a #GBookmarkFile

Retrieves the names of the applications that have registered the bookmark for @uri. In the event the URI cannot be found, %NULL is returned and @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.

a newly allocated %NULL-terminated array of strings. Use g_strfreev() to free it.

a #GBookmarkFile

a valid URI return location of the length of the returned list, or %NULL

Retrieves the description of the bookmark for @uri. In the event the URI cannot be found, %NULL is returned and @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.

a newly allocated string or %NULL if the specified URI cannot be found.

a #GBookmarkFile

a valid URI

Retrieves the list of group names of the bookmark for @uri. In the event the URI cannot be found, %NULL is returned and @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. The returned array is %NULL terminated, so @length may optionally be %NULL.

a newly allocated %NULL-terminated array of group names. Use g_strfreev() to free it.

a #GBookmarkFile

a valid URI return location for the length of the returned string, or %NULL

Gets the icon of the bookmark for @uri. In the event the URI cannot be found, %FALSE is returned and @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.

%TRUE if the icon for the bookmark for the URI was found. You should free the returned strings.

a #GBookmarkFile

a valid URI return location for the icon's location or %NULL return location for the icon's MIME type or %NULL

Gets whether the private flag of the bookmark for @uri is set. In the event the URI cannot be found, %FALSE is returned and @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. In the event that the private flag cannot be found, %FALSE is returned and @error is set to %G_BOOKMARK_FILE_ERROR_INVALID_VALUE.

%TRUE if the private flag is set, %FALSE otherwise.

a #GBookmarkFile

a valid URI

Retrieves the MIME type of the resource pointed by @uri. In the event the URI cannot be found, %NULL is returned and @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. In the event that the MIME type cannot be found, %NULL is returned and @error is set to %G_BOOKMARK_FILE_ERROR_INVALID_VALUE.

a newly allocated string or %NULL if the specified URI cannot be found.

a #GBookmarkFile

a valid URI

Gets the time when the bookmark for @uri was last modified. In the event the URI cannot be found, -1 is returned and @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.

Use g_bookmark_file_get_modified_date_time() instead, as `time_t` is deprecated due to the year 2038 problem.

a timestamp

a #GBookmarkFile

a valid URI

Gets the time when the bookmark for @uri was last modified. In the event the URI cannot be found, %NULL is returned and @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.

a #GDateTime

a #GBookmarkFile

a valid URI

Gets the number of bookmarks inside @bookmark.

the number of bookmarks

a #GBookmarkFile

Returns the title of the bookmark for @uri. If @uri is %NULL, the title of @bookmark is returned. In the event the URI cannot be found, %NULL is returned and @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.

a newly allocated string or %NULL if the specified URI cannot be found.

a #GBookmarkFile

a valid URI or %NULL

Returns all URIs of the bookmarks in the bookmark file @bookmark. The array of returned URIs will be %NULL-terminated, so @length may optionally be %NULL.

a newly allocated %NULL-terminated array of strings. Use g_strfreev() to free it.

a #GBookmarkFile

return location for the number of returned URIs, or %NULL

Gets the time the bookmark for @uri was last visited. In the event the URI cannot be found, -1 is returned and @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.

Use g_bookmark_file_get_visited_date_time() instead, as `time_t` is deprecated due to the year 2038 problem.

a timestamp.

a #GBookmarkFile

a valid URI

Gets the time the bookmark for @uri was last visited. In the event the URI cannot be found, %NULL is returned and @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.

a #GDateTime

a #GBookmarkFile

a valid URI

Checks whether the bookmark for @uri inside @bookmark has been registered by application @name. In the event the URI cannot be found, %FALSE is returned and @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.

%TRUE if the application @name was found

a #GBookmarkFile

a valid URI the name of the application

Checks whether @group appears in the list of groups to which the bookmark for @uri belongs to. In the event the URI cannot be found, %FALSE is returned and @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.

%TRUE if @group was found.

a #GBookmarkFile

a valid URI the group name to be searched

Looks whether the desktop bookmark has an item with its URI set to @uri.

%TRUE if @uri is inside @bookmark, %FALSE otherwise

a #GBookmarkFile

a valid URI

Loads a bookmark file from memory into an empty #GBookmarkFile structure. If the object cannot be created then @error is set to a #GBookmarkFileError.

%TRUE if a desktop bookmark could be loaded.

an empty #GBookmarkFile struct

desktop bookmarks loaded in memory the length of @data in bytes

This function looks for a desktop bookmark file named @file in the paths returned from g_get_user_data_dir() and g_get_system_data_dirs(), loads the file into @bookmark and returns the file's full path in @full_path. If the file could not be loaded then @error is set to either a #GFileError or #GBookmarkFileError.

%TRUE if a key file could be loaded, %FALSE otherwise

a #GBookmarkFile

a relative path to a filename to open and parse return location for a string containing the full path of the file, or %NULL

Loads a desktop bookmark file into an empty #GBookmarkFile structure. If the file could not be loaded then @error is set to either a #GFileError or #GBookmarkFileError.

%TRUE if a desktop bookmark file could be loaded

an empty #GBookmarkFile struct

the path of a filename to load, in the GLib file name encoding

Changes the URI of a bookmark item from @old_uri to @new_uri. Any existing bookmark for @new_uri will be overwritten. If @new_uri is %NULL, then the bookmark is removed. In the event the URI cannot be found, %FALSE is returned and @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.

%TRUE if the URI was successfully changed

a #GBookmarkFile

a valid URI a valid URI, or %NULL

Removes application registered with @name from the list of applications that have registered a bookmark for @uri inside @bookmark. In the event the URI cannot be found, %FALSE is returned and @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. In the event that no application with name @app_name has registered a bookmark for @uri, %FALSE is returned and error is set to %G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED.

%TRUE if the application was successfully removed.

a #GBookmarkFile

a valid URI the name of the application

Removes @group from the list of groups to which the bookmark for @uri belongs to. In the event the URI cannot be found, %FALSE is returned and @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. In the event no group was defined, %FALSE is returned and @error is set to %G_BOOKMARK_FILE_ERROR_INVALID_VALUE.

%TRUE if @group was successfully removed.

a #GBookmarkFile

a valid URI the group name to be removed

Removes the bookmark for @uri from the bookmark file @bookmark.

%TRUE if the bookmark was removed successfully.

a #GBookmarkFile

a valid URI

Sets the time the bookmark for @uri was added into @bookmark. If no bookmark for @uri is found then it is created.

Use g_bookmark_file_set_added_date_time() instead, as `time_t` is deprecated due to the year 2038 problem.

a #GBookmarkFile

a valid URI a timestamp or -1 to use the current time

Sets the time the bookmark for @uri was added into @bookmark. If no bookmark for @uri is found then it is created.

a #GBookmarkFile

a valid URI a #GDateTime

Sets the meta-data of application @name inside the list of applications that have registered a bookmark for @uri inside @bookmark. You should rarely use this function; use g_bookmark_file_add_application() and g_bookmark_file_remove_application() instead. @name can be any UTF-8 encoded string used to identify an application. @exec can have one of these two modifiers: "\%f", which will be expanded as the local file name retrieved from the bookmark's URI; "\%u", which will be expanded as the bookmark's URI. The expansion is done automatically when retrieving the stored command line using the g_bookmark_file_get_application_info() function. @count is the number of times the application has registered the bookmark; if is < 0, the current registration count will be increased by one, if is 0, the application with @name will be removed from the list of registered applications. @stamp is the Unix time of the last registration; if it is -1, the current time will be used. If you try to remove an application by setting its registration count to zero, and no bookmark for @uri is found, %FALSE is returned and @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND; similarly, in the event that no application @name has registered a bookmark for @uri, %FALSE is returned and error is set to %G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED. Otherwise, if no bookmark for @uri is found, one is created.

Use g_bookmark_file_set_application_info() instead, as `time_t` is deprecated due to the year 2038 problem.

%TRUE if the application's meta-data was successfully changed.

a #GBookmarkFile

a valid URI an application's name an application's command line the number of registrations done for this application the time of the last registration for this application

Sets the meta-data of application @name inside the list of applications that have registered a bookmark for @uri inside @bookmark. You should rarely use this function; use g_bookmark_file_add_application() and g_bookmark_file_remove_application() instead. @name can be any UTF-8 encoded string used to identify an application. @exec can have one of these two modifiers: "\%f", which will be expanded as the local file name retrieved from the bookmark's URI; "\%u", which will be expanded as the bookmark's URI. The expansion is done automatically when retrieving the stored command line using the g_bookmark_file_get_application_info() function. @count is the number of times the application has registered the bookmark; if is < 0, the current registration count will be increased by one, if is 0, the application with @name will be removed from the list of registered applications. @stamp is the Unix time of the last registration. If you try to remove an application by setting its registration count to zero, and no bookmark for @uri is found, %FALSE is returned and @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND; similarly, in the event that no application @name has registered a bookmark for @uri, %FALSE is returned and error is set to %G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED. Otherwise, if no bookmark for @uri is found, one is created.

%TRUE if the application's meta-data was successfully changed.

a #GBookmarkFile

a valid URI an application's name an application's command line the number of registrations done for this application the time of the last registration for this application, which may be %NULL if @count is 0

Sets @description as the description of the bookmark for @uri. If @uri is %NULL, the description of @bookmark is set. If a bookmark for @uri cannot be found then it is created.

a #GBookmarkFile

a valid URI or %NULL a string

Sets a list of group names for the item with URI @uri. Each previously set group name list is removed. If @uri cannot be found then an item for it is created.

a #GBookmarkFile

an item's URI an array of group names, or %NULL to remove all groups number of group name values in @groups

Sets the icon for the bookmark for @uri. If @href is %NULL, unsets the currently set icon. @href can either be a full URL for the icon file or the icon name following the Icon Naming specification. If no bookmark for @uri is found one is created.

a #GBookmarkFile

a valid URI the URI of the icon for the bookmark, or %NULL the MIME type of the icon for the bookmark

Sets the private flag of the bookmark for @uri. If a bookmark for @uri cannot be found then it is created.

a #GBookmarkFile

a valid URI %TRUE if the bookmark should be marked as private

Sets @mime_type as the MIME type of the bookmark for @uri. If a bookmark for @uri cannot be found then it is created.

a #GBookmarkFile

a valid URI a MIME type

Sets the last time the bookmark for @uri was last modified. If no bookmark for @uri is found then it is created. The "modified" time should only be set when the bookmark's meta-data was actually changed. Every function of #GBookmarkFile that modifies a bookmark also changes the modification time, except for g_bookmark_file_set_visited_date_time().

Use g_bookmark_file_set_modified_date_time() instead, as `time_t` is deprecated due to the year 2038 problem.

a #GBookmarkFile

a valid URI a timestamp or -1 to use the current time

a #GBookmarkFile

a valid URI a #GDateTime

Sets @title as the title of the bookmark for @uri inside the bookmark file @bookmark. If @uri is %NULL, the title of @bookmark is set. If a bookmark for @uri cannot be found then it is created.

a #GBookmarkFile

a valid URI or %NULL a UTF-8 encoded string

Sets the time the bookmark for @uri was last visited. If no bookmark for @uri is found then it is created. The "visited" time should only be set if the bookmark was launched, either using the command line retrieved by g_bookmark_file_get_application_info() or by the default application for the bookmark's MIME type, retrieved using g_bookmark_file_get_mime_type(). Changing the "visited" time does not affect the "modified" time.

Use g_bookmark_file_set_visited_date_time() instead, as `time_t` is deprecated due to the year 2038 problem.

a #GBookmarkFile

a valid URI a timestamp or -1 to use the current time

a #GBookmarkFile

a valid URI a #GDateTime

This function outputs @bookmark as a string.

a newly allocated string holding the contents of the #GBookmarkFile

a #GBookmarkFile

return location for the length of the returned string, or %NULL

This function outputs @bookmark into a file. The write process is guaranteed to be atomic by using g_file_set_contents() internally.

%TRUE if the file was successfully written.

a #GBookmarkFile

path of the output file

Error codes returned by bookmark file parsing.

URI was ill-formed a requested field was not found a requested application did not register a bookmark a requested URI was not found document was ill formed the text being parsed was in an unknown encoding an error occurred while writing requested file was not found

Contains the public fields of a GByteArray.

a pointer to the element data. The data may be moved as elements are added to the #GByteArray the number of elements in the #GByteArray Adds the given bytes to the end of the #GByteArray. The array will grow in size automatically if necessary.

the #GByteArray

a #GByteArray the byte data to be added the number of bytes to add

Frees the memory allocated by the #GByteArray. If @free_segment is %TRUE it frees the actual byte data. If the reference count of @array is greater than one, the #GByteArray wrapper is preserved but the size of @array will be set to zero.

the element data if @free_segment is %FALSE, otherwise %NULL. The element data should be freed using g_free().

a #GByteArray if %TRUE the actual byte data is freed as well

Transfers the data from the #GByteArray into a new immutable #GBytes. The #GByteArray is freed unless the reference count of @array is greater than one, the #GByteArray wrapper is preserved but the size of @array will be set to zero. This is identical to using g_bytes_new_take() and g_byte_array_free() together.

a new immutable #GBytes representing same byte data that was in the array

a #GByteArray

Creates a new #GByteArray with a reference count of 1.

the new #GByteArray

Create byte array containing the data. The data will be owned by the array and will be freed with g_free(), i.e. it could be allocated using g_strdup(). Do not use it if @len is greater than %G_MAXUINT. #GByteArray stores the length of its data in #guint, which may be shorter than #gsize.

a new #GByteArray

byte data for the array length of @data

Adds the given data to the start of the #GByteArray. The array will grow in size automatically if necessary.

the #GByteArray

a #GByteArray the byte data to be added the number of bytes to add

Atomically increments the reference count of @array by one. This function is thread-safe and may be called from any thread.

The passed in #GByteArray

A #GByteArray

Removes the byte at the given index from a #GByteArray. The following bytes are moved down one place.

the #GByteArray

a #GByteArray the index of the byte to remove

Removes the byte at the given index from a #GByteArray. The last element in the array is used to fill in the space, so this function does not preserve the order of the #GByteArray. But it is faster than g_byte_array_remove_index().

the #GByteArray

a #GByteArray the index of the byte to remove

Removes the given number of bytes starting at the given index from a #GByteArray. The following elements are moved to close the gap.

the #GByteArray

a @GByteArray the index of the first byte to remove the number of bytes to remove

Sets the size of the #GByteArray, expanding it if necessary.

the #GByteArray

a #GByteArray the new size of the #GByteArray

Creates a new #GByteArray with @reserved_size bytes preallocated. This avoids frequent reallocation, if you are going to add many bytes to the array. Note however that the size of the array is still 0.

the new #GByteArray

number of bytes preallocated

Sorts a byte array, using @compare_func which should be a qsort()-style comparison function (returns less than zero for first arg is less than second arg, zero for equal, greater than zero if first arg is greater than second arg). If two array elements compare equal, their order in the sorted array is undefined. If you want equal elements to keep their order (i.e. you want a stable sort) you can write a comparison function that, if two elements would otherwise compare equal, compares them by their addresses.

a #GByteArray comparison function

Like g_byte_array_sort(), but the comparison function takes an extra user data argument.

a #GByteArray comparison function data to pass to @compare_func

Frees the data in the array and resets the size to zero, while the underlying array is preserved for use elsewhere and returned to the caller.

the element data, which should be freed using g_free().

a #GByteArray. pointer to retrieve the number of elements of the original array

A #GByteArray

A simple refcounted data type representing an immutable sequence of zero or more bytes from an unspecified origin. The purpose of a #GBytes is to keep the memory region that it holds alive for as long as anyone holds a reference to the bytes. When the last reference count is dropped, the memory is released. Multiple unrelated callers can use byte data in the #GBytes without coordinating their activities, resting assured that the byte data will not change or move while they hold a reference. A #GBytes can come from many different origins that may have different procedures for freeing the memory region. Examples are memory from g_malloc(), from memory slices, from a #GMappedFile or memory from other allocators. #GBytes work well as keys in #GHashTable. Use g_bytes_equal() and g_bytes_hash() as parameters to g_hash_table_new() or g_hash_table_new_full(). #GBytes can also be used as keys in a #GTree by passing the g_bytes_compare() function to g_tree_new(). The data pointed to by this bytes must not be modified. For a mutable array of bytes see #GByteArray. Use g_bytes_unref_to_array() to create a mutable array for a #GBytes sequence. To create an immutable #GBytes from a mutable #GByteArray, use the g_byte_array_free_to_bytes() function.

Creates a new #GBytes from @data. @data is copied. If @size is 0, @data may be %NULL.

a new #GBytes

the data to be used for the bytes the size of @data

Creates a new #GBytes from static data. @data must be static (ie: never modified or freed). It may be %NULL if @size is 0.

a new #GBytes

the data to be used for the bytes the size of @data

Creates a new #GBytes from @data. After this call, @data belongs to the bytes and may no longer be modified by the caller. g_free() will be called on @data when the bytes is no longer in use. Because of this @data must have been created by a call to g_malloc(), g_malloc0() or g_realloc() or by one of the many functions that wrap these calls (such as g_new(), g_strdup(), etc). For creating #GBytes with memory from other allocators, see g_bytes_new_with_free_func(). @data may be %NULL if @size is 0.

a new #GBytes

the data to be used for the bytes the size of @data

Creates a #GBytes from @data. When the last reference is dropped, @free_func will be called with the @user_data argument. @data must not be modified after this call is made until @free_func has been called to indicate that the bytes is no longer in use. @data may be %NULL if @size is 0.

a new #GBytes

the data to be used for the bytes the size of @data the function to call to release the data data to pass to @free_func

Compares the two #GBytes values. This function can be used to sort GBytes instances in lexicographical order. If @bytes1 and @bytes2 have different length but the shorter one is a prefix of the longer one then the shorter one is considered to be less than the longer one. Otherwise the first byte where both differ is used for comparison. If @bytes1 has a smaller value at that position it is considered less, otherwise greater than @bytes2.

a negative value if @bytes1 is less than @bytes2, a positive value if @bytes1 is greater than @bytes2, and zero if @bytes1 is equal to @bytes2

a pointer to a #GBytes

a pointer to a #GBytes to compare with @bytes1

Compares the two #GBytes values being pointed to and returns %TRUE if they are equal. This function can be passed to g_hash_table_new() as the @key_equal_func parameter, when using non-%NULL #GBytes pointers as keys in a #GHashTable.

%TRUE if the two keys match.

a pointer to a #GBytes

a pointer to a #GBytes to compare with @bytes1

Get the byte data in the #GBytes. This data should not be modified. This function will always return the same pointer for a given #GBytes. %NULL may be returned if @size is 0. This is not guaranteed, as the #GBytes may represent an empty string with @data non-%NULL and @size as 0. %NULL will not be returned if @size is non-zero.

a pointer to the byte data, or %NULL

a #GBytes

location to return size of byte data

Gets a pointer to a region in @bytes. The region starts at @offset many bytes from the start of the data and contains @n_elements many elements of @element_size size. @n_elements may be zero, but @element_size must always be non-zero. Ideally, @element_size is a static constant (eg: sizeof a struct). This function does careful bounds checking (including checking for arithmetic overflows) and returns a non-%NULL pointer if the specified region lies entirely within the @bytes. If the region is in some way out of range, or if an overflow has occurred, then %NULL is returned. Note: it is possible to have a valid zero-size region. In this case, the returned pointer will be equal to the base pointer of the data of @bytes, plus @offset. This will be non-%NULL except for the case where @bytes itself was a zero-sized region. Since it is unlikely that you will be using this function to check for a zero-sized region in a zero-sized @bytes, %NULL effectively always means "error".

the requested region, or %NULL in case of an error

a #GBytes

a non-zero element size an offset to the start of the region within the @bytes the number of elements in the region

Get the size of the byte data in the #GBytes. This function will always return the same value for a given #GBytes.

the size

a #GBytes

Creates an integer hash code for the byte data in the #GBytes. This function can be passed to g_hash_table_new() as the @key_hash_func parameter, when using non-%NULL #GBytes pointers as keys in a #GHashTable.

a hash value corresponding to the key.

a pointer to a #GBytes key

Creates a #GBytes which is a subsection of another #GBytes. The @offset + @length may not be longer than the size of @bytes. A reference to @bytes will be held by the newly created #GBytes until the byte data is no longer needed. Since 2.56, if @offset is 0 and @length matches the size of @bytes, then @bytes will be returned with the reference count incremented by 1. If @bytes is a slice of another #GBytes, then the resulting #GBytes will reference the same #GBytes instead of @bytes. This allows consumers to simplify the usage of #GBytes when asynchronously writing to streams.

a new #GBytes

a #GBytes

offset which subsection starts at length of subsection

Increase the reference count on @bytes.

the #GBytes

a #GBytes

Releases a reference on @bytes. This may result in the bytes being freed. If @bytes is %NULL, it will return immediately.

a #GBytes

Unreferences the bytes, and returns a new mutable #GByteArray containing the same byte data. As an optimization, the byte data is transferred to the array without copying if this was the last reference to bytes and bytes was created with g_bytes_new(), g_bytes_new_take() or g_byte_array_free_to_bytes(). In all other cases the data is copied. Do not use it if @bytes contains more than %G_MAXUINT bytes. #GByteArray stores the length of its data in #guint, which may be shorter than #gsize, that @bytes is using.

a new mutable #GByteArray containing the same byte data

a #GBytes

Unreferences the bytes, and returns a pointer the same byte data contents. As an optimization, the byte data is returned without copying if this was the last reference to bytes and bytes was created with g_bytes_new(), g_bytes_new_take() or g_byte_array_free_to_bytes(). In all other cases the data is copied.

a pointer to the same byte data, which should be freed with g_free()

a #GBytes

location to place the length of the returned data

Checks whether the version of the GLib library that is being compiled against is greater than or equal to the given one. See glib_check_version() for a runtime check.

the major version to check for the minor version to check for the micro version to check for

The set of uppercase ASCII alphabet characters. Used for specifying valid identifier characters in #GScannerConfig.

The set of ASCII digits. Used for specifying valid identifier characters in #GScannerConfig.

The set of lowercase ASCII alphabet characters. Used for specifying valid identifier characters in #GScannerConfig.

An opaque structure representing a checksumming operation. To create a new GChecksum, use g_checksum_new(). To free a GChecksum, use g_checksum_free().

Creates a new #GChecksum, using the checksum algorithm @checksum_type. If the @checksum_type is not known, %NULL is returned. A #GChecksum can be used to compute the checksum, or digest, of an arbitrary binary blob, using different hashing algorithms. A #GChecksum works by feeding a binary blob through g_checksum_update() until there is data to be checked; the digest can then be extracted using g_checksum_get_string(), which will return the checksum as a hexadecimal string; or g_checksum_get_digest(), which will return a vector of raw bytes. Once either g_checksum_get_string() or g_checksum_get_digest() have been called on a #GChecksum, the checksum will be closed and it won't be possible to call g_checksum_update() on it anymore.

the newly created #GChecksum, or %NULL. Use g_checksum_free() to free the memory allocated by it.

the desired type of checksum

Copies a #GChecksum. If @checksum has been closed, by calling g_checksum_get_string() or g_checksum_get_digest(), the copied checksum will be closed as well.

the copy of the passed #GChecksum. Use g_checksum_free() when finished using it.

the #GChecksum to copy

Frees the memory allocated for @checksum.

a #GChecksum

Gets the digest from @checksum as a raw binary vector and places it into @buffer. The size of the digest depends on the type of checksum. Once this function has been called, the #GChecksum is closed and can no longer be updated with g_checksum_update().

a #GChecksum

output buffer an inout parameter. The caller initializes it to the size of @buffer. After the call it contains the length of the digest.

Gets the digest as a hexadecimal string. Once this function has been called the #GChecksum can no longer be updated with g_checksum_update(). The hexadecimal characters will be lower case.

the hexadecimal representation of the checksum. The returned string is owned by the checksum and should not be modified or freed.

a #GChecksum

Resets the state of the @checksum back to its initial state.

the #GChecksum to reset

Feeds @data into an existing #GChecksum. The checksum must still be open, that is g_checksum_get_string() or g_checksum_get_digest() must not have been called on @checksum.

a #GChecksum

buffer used to compute the checksum size of the buffer, or -1 if it is a null-terminated string.

Gets the length in bytes of digests of type @checksum_type

the checksum length, or -1 if @checksum_type is not supported.

a #GChecksumType

The hashing algorithm to be used by #GChecksum when performing the digest of some data. Note that the #GChecksumType enumeration may be extended at a later date to include new hashing algorithm types.

Use the MD5 hashing algorithm Use the SHA-1 hashing algorithm Use the SHA-256 hashing algorithm Use the SHA-512 hashing algorithm (Since: 2.36) Use the SHA-384 hashing algorithm (Since: 2.51)

Prototype of a #GChildWatchSource callback, called when a child process has exited. To interpret @wait_status, see the documentation for g_spawn_check_wait_status(). In particular, on Unix platforms, note that it is usually not equal to the integer passed to `exit()` or returned from `main()`.

the process id of the child process Status information about the child process, encoded in a platform-specific manner user data passed to g_child_watch_add()

Specifies the type of function passed to g_clear_handle_id(). The implementation is expected to free the resource identified by @handle_id; for instance, if @handle_id is a #GSource ID, g_source_remove() can be used.

the handle ID to clear

Specifies the type of a comparison function used to compare two values. The function should return a negative integer if the first value comes before the second, 0 if they are equal, or a positive integer if the first value comes after the second.

negative value if @a < @b; zero if @a = @b; positive value if @a > @b

a value a value to compare with user data

negative value if @a < @b; zero if @a = @b; positive value if @a > @b

a value a value to compare with

The #GCond struct is an opaque data structure that represents a condition. Threads can block on a #GCond if they find a certain condition to be false. If other threads change the state of this condition they signal the #GCond, and that causes the waiting threads to be woken up. Consider the following example of a shared variable. One or more threads can wait for data to be published to the variable and when another thread publishes the data, it can signal one of the waiting threads to wake up to collect the data. Here is an example for using GCond to block a thread until a condition is satisfied: |[ gpointer current_data = NULL; GMutex data_mutex; GCond data_cond; void push_data (gpointer data) { g_mutex_lock (&data_mutex); current_data = data; g_cond_signal (&data_cond); g_mutex_unlock (&data_mutex); } gpointer pop_data (void) { gpointer data; g_mutex_lock (&data_mutex); while (!current_data) g_cond_wait (&data_cond, &data_mutex); data = current_data; current_data = NULL; g_mutex_unlock (&data_mutex); return data; } ]| Whenever a thread calls pop_data() now, it will wait until current_data is non-%NULL, i.e. until some other thread has called push_data(). The example shows that use of a condition variable must always be paired with a mutex. Without the use of a mutex, there would be a race between the check of @current_data by the while loop in pop_data() and waiting. Specifically, another thread could set @current_data after the check, and signal the cond (with nobody waiting on it) before the first thread goes to sleep. #GCond is specifically useful for its ability to release the mutex and go to sleep atomically. It is also important to use the g_cond_wait() and g_cond_wait_until() functions only inside a loop which checks for the condition to be true. See g_cond_wait() for an explanation of why the condition may not be true even after it returns. If a #GCond is allocated in static storage then it can be used without initialisation. Otherwise, you should call g_cond_init() on it and g_cond_clear() when done. A #GCond should only be accessed via the g_cond_ functions.

If threads are waiting for @cond, all of them are unblocked. If no threads are waiting for @cond, this function has no effect. It is good practice to lock the same mutex as the waiting threads while calling this function, though not required.

a #GCond

Frees the resources allocated to a #GCond with g_cond_init(). This function should not be used with a #GCond that has been statically allocated. Calling g_cond_clear() for a #GCond on which threads are blocking leads to undefined behaviour.

an initialised #GCond

Initialises a #GCond so that it can be used. This function is useful to initialise a #GCond that has been allocated as part of a larger structure. It is not necessary to initialise a #GCond that has been statically allocated. To undo the effect of g_cond_init() when a #GCond is no longer needed, use g_cond_clear(). Calling g_cond_init() on an already-initialised #GCond leads to undefined behaviour.

an uninitialized #GCond

If threads are waiting for @cond, at least one of them is unblocked. If no threads are waiting for @cond, this function has no effect. It is good practice to hold the same lock as the waiting thread while calling this function, though not required.

a #GCond

Atomically releases @mutex and waits until @cond is signalled. When this function returns, @mutex is locked again and owned by the calling thread. When using condition variables, it is possible that a spurious wakeup may occur (ie: g_cond_wait() returns even though g_cond_signal() was not called). It's also possible that a stolen wakeup may occur. This is when g_cond_signal() is called, but another thread acquires @mutex before this thread and modifies the state of the program in such a way that when g_cond_wait() is able to return, the expected condition is no longer met. For this reason, g_cond_wait() must always be used in a loop. See the documentation for #GCond for a complete example.

a #GCond

a #GMutex that is currently locked

Waits until either @cond is signalled or @end_time has passed. As with g_cond_wait() it is possible that a spurious or stolen wakeup could occur. For that reason, waiting on a condition variable should always be in a loop, based on an explicitly-checked predicate. %TRUE is returned if the condition variable was signalled (or in the case of a spurious wakeup). %FALSE is returned if @end_time has passed. The following code shows how to correctly perform a timed wait on a condition variable (extending the example presented in the documentation for #GCond): |[ gpointer pop_data_timed (void) { gint64 end_time; gpointer data; g_mutex_lock (&data_mutex); end_time = g_get_monotonic_time () + 5 * G_TIME_SPAN_SECOND; while (!current_data) if (!g_cond_wait_until (&data_cond, &data_mutex, end_time)) { // timeout has passed. g_mutex_unlock (&data_mutex); return NULL; } // there is data for us data = current_data; current_data = NULL; g_mutex_unlock (&data_mutex); return data; } ]| Notice that the end time is calculated once, before entering the loop and reused. This is the motivation behind the use of absolute time on this API -- if a relative time of 5 seconds were passed directly to the call and a spurious wakeup occurred, the program would have to start over waiting again (which would lead to a total wait time of more than 5 seconds).

%TRUE on a signal, %FALSE on a timeout

a #GCond

a #GMutex that is currently locked the monotonic time to wait until

Error codes returned by character set conversion routines.

Conversion between the requested character sets is not supported. Invalid byte sequence in conversion input; or the character sequence could not be represented in the target character set. Conversion failed for some reason. Partial character sequence at end of input. URI is invalid. Pathname is not an absolute path. No memory available. Since: 2.40 An embedded NUL character is present in conversion output where a NUL-terminated string is expected. Since: 2.56

A function of this signature is used to copy the node data when doing a deep-copy of a tree.

A pointer to the copy

A pointer to the data which should be copied Additional data

A bitmask that restricts the possible flags passed to g_datalist_set_flags(). Passing a flags value where flags & ~G_DATALIST_FLAGS_MASK != 0 is an error.

Represents an invalid #GDateDay.

Represents an invalid Julian day number.

Represents an invalid year.

A convenience form of g_log_structured(), recommended to be added to functions when debugging. It prints the current monotonic time and the code location using %G_STRLOC.

Defines the appropriate cleanup function for a pointer type. The function will not be called if the variable to be cleaned up contains %NULL. This will typically be the `_free()` or `_unref()` function for the given type. With this definition, it will be possible to use g_autoptr() with @TypeName. |[ G_DEFINE_AUTOPTR_CLEANUP_FUNC(GObject, g_object_unref) ]| This macro should be used unconditionally; it is a no-op on compilers where cleanup is not supported.

a type name to define a g_autoptr() cleanup function for the cleanup function

Defines the appropriate cleanup function for a type. This will typically be the `_clear()` function for the given type. With this definition, it will be possible to use g_auto() with @TypeName. |[ G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC(GQueue, g_queue_clear) ]| This macro should be used unconditionally; it is a no-op on compilers where cleanup is not supported.

a type name to define a g_auto() cleanup function for the clear function

Defines the appropriate cleanup function for a type. With this definition, it will be possible to use g_auto() with @TypeName. This function will be rarely used. It is used with pointer-based typedefs and non-pointer types where the value of the variable represents a resource that must be freed. Two examples are #GStrv and file descriptors. @none specifies the "none" value for the type in question. It is probably something like %NULL or `-1`. If the variable is found to contain this value then the free function will not be called. |[ G_DEFINE_AUTO_CLEANUP_FREE_FUNC(GStrv, g_strfreev, NULL) ]| This macro should be used unconditionally; it is a no-op on compilers where cleanup is not supported.

a type name to define a g_auto() cleanup function for the free function the "none" value for the type

A convenience macro which defines two functions. First, returning the #GQuark for the extended error type @ErrorType; it is called `error_type_quark()`. Second, returning the private data from a passed #GError; it is called `error_type_get_private()`. For this macro to work, a type named `ErrorTypePrivate` should be defined, `error_type_private_init()`, `error_type_private_copy()` and `error_type_private_clear()` functions need to be either declared or defined. The functions should be similar to #GErrorInitFunc, #GErrorCopyFunc and #GErrorClearFunc, respectively, but they should receive the private data type instead of #GError. See [Extended #GError Domains][gerror-extended-domains] for an example.

name to return a #GQuark for prefix for the function name

A convenience macro which defines a function returning the #GQuark for the name @QN. The function will be named @q_n_quark(). Note that the quark name will be stringified automatically in the macro, so you shouldn't use double quotes.

the name to return a #GQuark for prefix for the function name

The directory separator character. This is '/' on UNIX machines and '\' under Windows.

The directory separator as a string. This is "/" on UNIX machines and "\" under Windows.

An opaque data structure that represents a keyed data list. See also: [Keyed data lists][glib-Keyed-Data-Lists].

Specifies the type of function passed to g_dataset_foreach(). It is called with each #GQuark id and associated data element, together with the @user_data parameter supplied to g_dataset_foreach().

the #GQuark id to identifying the data element. the data element. user data passed to g_dataset_foreach().

Represents a day between January 1, Year 1 and a few thousand years in the future. None of its members should be accessed directly. If the `GDate` is obtained from g_date_new(), it will be safe to mutate but invalid and thus not safe for calendrical computations. If it's declared on the stack, it will contain garbage so must be initialized with g_date_clear(). g_date_clear() makes the date invalid but safe. An invalid date doesn't represent a day, it's "empty." A date becomes valid after you set it to a Julian day or you set a day, month, and year.

the Julian representation of the date this bit is set if @julian_days is valid this is set if @day, @month and @year are valid the day of the day-month-year representation of the date, as a number between 1 and 31 the day of the day-month-year representation of the date, as a number between 1 and 12 the day of the day-month-year representation of the date Allocates a #GDate and initializes it to a safe state. The new date will be cleared (as if you'd called g_date_clear()) but invalid (it won't represent an existing day). Free the return value with g_date_free().

a newly-allocated #GDate

Create a new #GDate representing the given day-month-year triplet. The triplet you pass in must represent a valid date. Use g_date_valid_dmy() if needed to validate it. The returned #GDate is guaranteed to be non-%NULL and valid.

a newly-allocated #GDate initialized with @day, @month, and @year

day of the month month of the year year

Create a new #GDate representing the given Julian date. The @julian_day you pass in must be valid. Use g_date_valid_julian() if needed to validate it. The returned #GDate is guaranteed to be non-%NULL and valid.

a newly-allocated #GDate initialized with @julian_day

days since January 1, Year 1

Increments a date some number of days. To move forward by weeks, add weeks*7 days. The date must be valid.

a #GDate to increment

number of days to move the date forward

Increments a date by some number of months. If the day of the month is greater than 28, this routine may change the day of the month (because the destination month may not have the current day in it). The date must be valid.

a #GDate to increment

number of months to move forward

Increments a date by some number of years. If the date is February 29, and the destination year is not a leap year, the date will be changed to February 28. The date must be valid.

a #GDate to increment

number of years to move forward

If @date is prior to @min_date, sets @date equal to @min_date. If @date falls after @max_date, sets @date equal to @max_date. Otherwise, @date is unchanged. Either of @min_date and @max_date may be %NULL. All non-%NULL dates must be valid.

a #GDate to clamp

minimum accepted value for @date maximum accepted value for @date

Initializes one or more #GDate structs to a safe but invalid state. The cleared dates will not represent an existing date, but will not contain garbage. Useful to init a date declared on the stack. Validity can be tested with g_date_valid().

pointer to one or more dates to clear

number of dates to clear

qsort()-style comparison function for dates. Both dates must be valid.

0 for equal, less than zero if @lhs is less than @rhs, greater than zero if @lhs is greater than @rhs

first date to compare

second date to compare

Copies a GDate to a newly-allocated GDate. If the input was invalid (as determined by g_date_valid()), the invalid state will be copied as is into the new object.

a newly-allocated #GDate initialized from @date

a #GDate to copy

Computes the number of days between two dates. If @date2 is prior to @date1, the returned value is negative. Both dates must be valid.

the number of days between @date1 and @date2

the first date

the second date

Frees a #GDate returned from g_date_new().

a #GDate to free

Returns the day of the month. The date must be valid.

day of the month

a #GDate to extract the day of the month from

Returns the day of the year, where Jan 1 is the first day of the year. The date must be valid.

day of the year

a #GDate to extract day of year from

Returns the week of the year, where weeks are interpreted according to ISO 8601.

ISO 8601 week number of the year.

a valid #GDate

Returns the Julian day or "serial number" of the #GDate. The Julian day is simply the number of days since January 1, Year 1; i.e., January 1, Year 1 is Julian day 1; January 2, Year 1 is Julian day 2, etc. The date must be valid.

Julian day

a #GDate to extract the Julian day from

Returns the week of the year, where weeks are understood to start on Monday. If the date is before the first Monday of the year, return 0. The date must be valid.

week of the year

a #GDate

Returns the month of the year. The date must be valid.

month of the year as a #GDateMonth

a #GDate to get the month from

Returns the week of the year during which this date falls, if weeks are understood to begin on Sunday. The date must be valid. Can return 0 if the day is before the first Sunday of the year.

week number

a #GDate

Returns the day of the week for a #GDate. The date must be valid.

day of the week as a #GDateWeekday.

a #GDate

Returns the year of a #GDate. The date must be valid.

year in which the date falls

a #GDate

Returns %TRUE if the date is on the first of a month. The date must be valid.

%TRUE if the date is the first of the month

a #GDate to check

Returns %TRUE if the date is the last day of the month. The date must be valid.

%TRUE if the date is the last day of the month

a #GDate to check

Checks if @date1 is less than or equal to @date2, and swap the values if this is not the case.

the first date

the second date

Sets the day of the month for a #GDate. If the resulting day-month-year triplet is invalid, the date will be invalid.

a #GDate

day to set

Sets the value of a #GDate from a day, month, and year. The day-month-year triplet must be valid; if you aren't sure it is, call g_date_valid_dmy() to check before you set it.

a #GDate

day month year

Sets the value of a #GDate from a Julian day number.

a #GDate

Julian day number (days since January 1, Year 1)

Sets the month of the year for a #GDate. If the resulting day-month-year triplet is invalid, the date will be invalid.

a #GDate

month to set

Parses a user-inputted string @str, and try to figure out what date it represents, taking the [current locale][setlocale] into account. If the string is successfully parsed, the date will be valid after the call. Otherwise, it will be invalid. You should check using g_date_valid() to see whether the parsing succeeded. This function is not appropriate for file formats and the like; it isn't very precise, and its exact behavior varies with the locale. It's intended to be a heuristic routine that guesses what the user means by a given string (and it does work pretty well in that capacity).

a #GDate to fill in

string to parse

Sets the value of a date from a #GTime value. The time to date conversion is done using the user's current timezone.

Use g_date_set_time_t() instead.

a #GDate.

#GTime value to set.

Sets the value of a date to the date corresponding to a time specified as a time_t. The time to date conversion is done using the user's current timezone. To set the value of a date to the current day, you could write: |[ time_t now = time (NULL); if (now == (time_t) -1) // handle the error g_date_set_time_t (date, now); ]|

a #GDate

time_t value to set

Sets the value of a date from a #GTimeVal value. Note that the @tv_usec member is ignored, because #GDate can't make use of the additional precision. The time to date conversion is done using the user's current timezone.

#GTimeVal is not year-2038-safe. Use g_date_set_time_t() instead.

a #GDate

#GTimeVal value to set

Sets the year for a #GDate. If the resulting day-month-year triplet is invalid, the date will be invalid.

a #GDate

year to set

Moves a date some number of days into the past. To move by weeks, just move by weeks*7 days. The date must be valid.

a #GDate to decrement

number of days to move

Moves a date some number of months into the past. If the current day of the month doesn't exist in the destination month, the day of the month may change. The date must be valid.

a #GDate to decrement

number of months to move

Moves a date some number of years into the past. If the current day doesn't exist in the destination year (i.e. it's February 29 and you move to a non-leap-year) then the day is changed to February 29. The date must be valid.

a #GDate to decrement

number of years to move

Fills in the date-related bits of a struct tm using the @date value. Initializes the non-date parts with something safe but meaningless.

a #GDate to set the struct tm from

struct tm to fill

Returns %TRUE if the #GDate represents an existing day. The date must not contain garbage; it should have been initialized with g_date_clear() if it wasn't allocated by one of the g_date_new() variants.

Whether the date is valid

a #GDate to check

Returns the number of days in a month, taking leap years into account.

number of days in @month during the @year

month year

Returns the number of weeks in the year, where weeks are taken to start on Monday. Will be 52 or 53. The date must be valid. (Years always have 52 7-day periods, plus 1 or 2 extra days depending on whether it's a leap year. This function is basically telling you how many Mondays are in the year, i.e. there are 53 Mondays if one of the extra days happens to be a Monday.)

number of Mondays in the year

a year

Returns the number of weeks in the year, where weeks are taken to start on Sunday. Will be 52 or 53. The date must be valid. (Years always have 52 7-day periods, plus 1 or 2 extra days depending on whether it's a leap year. This function is basically telling you how many Sundays are in the year, i.e. there are 53 Sundays if one of the extra days happens to be a Sunday.)

the number of weeks in @year

year to count weeks in

Returns %TRUE if the year is a leap year. For the purposes of this function, leap year is every year divisible by 4 unless that year is divisible by 100. If it is divisible by 100 it would be a leap year only if that year is also divisible by 400.

%TRUE if the year is a leap year

year to check

Generates a printed representation of the date, in a [locale][setlocale]-specific way. Works just like the platform's C library strftime() function, but only accepts date-related formats; time-related formats give undefined results. Date must be valid. Unlike strftime() (which uses the locale encoding), works on a UTF-8 format string and stores a UTF-8 result. This function does not provide any conversion specifiers in addition to those implemented by the platform's C library. For example, don't expect that using g_date_strftime() would make the \%F provided by the C99 strftime() work on Windows where the C library only complies to C89.

number of characters written to the buffer, or 0 the buffer was too small

destination buffer buffer size format string valid #GDate

Returns %TRUE if the day of the month is valid (a day is valid if it's between 1 and 31 inclusive).

%TRUE if the day is valid

day to check

Returns %TRUE if the day-month-year triplet forms a valid, existing day in the range of days #GDate understands (Year 1 or later, no more than a few thousand years in the future).

%TRUE if the date is a valid one

day month year

Returns %TRUE if the Julian day is valid. Anything greater than zero is basically a valid Julian, though there is a 32-bit limit.

%TRUE if the Julian day is valid

Julian day to check

Returns %TRUE if the month value is valid. The 12 #GDateMonth enumeration values are the only valid months.

%TRUE if the month is valid

month

Returns %TRUE if the weekday is valid. The seven #GDateWeekday enumeration values are the only valid weekdays.

%TRUE if the weekday is valid

weekday

Returns %TRUE if the year is valid. Any year greater than 0 is valid, though there is a 16-bit limit to what #GDate will understand.

%TRUE if the year is valid

year

This enumeration isn't used in the API, but may be useful if you need to mark a number as a day, month, or year.

a day a month a year

Enumeration representing a month; values are %G_DATE_JANUARY, %G_DATE_FEBRUARY, etc. %G_DATE_BAD_MONTH is the invalid value.

invalid value January February March April May June July August September October November December

An opaque structure that represents a date and time, including a time zone.

Creates a new #GDateTime corresponding to the given date and time in the time zone @tz. The @year must be between 1 and 9999, @month between 1 and 12 and @day between 1 and 28, 29, 30 or 31 depending on the month and the year. @hour must be between 0 and 23 and @minute must be between 0 and 59. @seconds must be at least 0.0 and must be strictly less than 60.0. It will be rounded down to the nearest microsecond. If the given time is not representable in the given time zone (for example, 02:30 on March 14th 2010 in Toronto, due to daylight savings time) then the time will be rounded up to the nearest existing time (in this case, 03:00). If this matters to you then you should verify the return value for containing the same as the numbers you gave. In the case that the given time is ambiguous in the given time zone (for example, 01:30 on November 7th 2010 in Toronto, due to daylight savings time) then the time falling within standard (ie: non-daylight) time is taken. It not considered a programmer error for the values to this function to be out of range, but in the case that they are, the function will return %NULL. You should release the return value by calling g_date_time_unref() when you are done with it.

a new #GDateTime, or %NULL

a #GTimeZone the year component of the date the month component of the date the day component of the date the hour component of the date the minute component of the date the number of seconds past the minute

Creates a #GDateTime corresponding to the given [ISO 8601 formatted string](https://en.wikipedia.org/wiki/ISO_8601) @text. ISO 8601 strings of the form <date><sep><time><tz> are supported, with some extensions from [RFC 3339](https://tools.ietf.org/html/rfc3339) as mentioned below. Note that as #GDateTime "is oblivious to leap seconds", leap seconds information in an ISO-8601 string will be ignored, so a `23:59:60` time would be parsed as `23:59:59`. <sep> is the separator and can be either 'T', 't' or ' '. The latter two separators are an extension from [RFC 3339](https://tools.ietf.org/html/rfc3339#section-5.6). <date> is in the form: - `YYYY-MM-DD` - Year/month/day, e.g. 2016-08-24. - `YYYYMMDD` - Same as above without dividers. - `YYYY-DDD` - Ordinal day where DDD is from 001 to 366, e.g. 2016-237. - `YYYYDDD` - Same as above without dividers. - `YYYY-Www-D` - Week day where ww is from 01 to 52 and D from 1-7, e.g. 2016-W34-3. - `YYYYWwwD` - Same as above without dividers. <time> is in the form: - `hh:mm:ss(.sss)` - Hours, minutes, seconds (subseconds), e.g. 22:10:42.123. - `hhmmss(.sss)` - Same as above without dividers. <tz> is an optional timezone suffix of the form: - `Z` - UTC. - `+hh:mm` or `-hh:mm` - Offset from UTC in hours and minutes, e.g. +12:00. - `+hh` or `-hh` - Offset from UTC in hours, e.g. +12. If the timezone is not provided in @text it must be provided in @default_tz (this field is otherwise ignored). This call can fail (returning %NULL) if @text is not a valid ISO 8601 formatted string. You should release the return value by calling g_date_time_unref() when you are done with it.

a new #GDateTime, or %NULL

an ISO 8601 formatted time string. a #GTimeZone to use if the text doesn't contain a timezone, or %NULL.

Creates a #GDateTime corresponding to the given #GTimeVal @tv in the local time zone. The time contained in a #GTimeVal is always stored in the form of seconds elapsed since 1970-01-01 00:00:00 UTC, regardless of the local time offset. This call can fail (returning %NULL) if @tv represents a time outside of the supported range of #GDateTime. You should release the return value by calling g_date_time_unref() when you are done with it.

#GTimeVal is not year-2038-safe. Use g_date_time_new_from_unix_local() instead.

a new #GDateTime, or %NULL

a #GTimeVal

Creates a #GDateTime corresponding to the given #GTimeVal @tv in UTC. The time contained in a #GTimeVal is always stored in the form of seconds elapsed since 1970-01-01 00:00:00 UTC. This call can fail (returning %NULL) if @tv represents a time outside of the supported range of #GDateTime. You should release the return value by calling g_date_time_unref() when you are done with it.

#GTimeVal is not year-2038-safe. Use g_date_time_new_from_unix_utc() instead.

a new #GDateTime, or %NULL

a #GTimeVal

Creates a #GDateTime corresponding to the given Unix time @t in the local time zone. Unix time is the number of seconds that have elapsed since 1970-01-01 00:00:00 UTC, regardless of the local time offset. This call can fail (returning %NULL) if @t represents a time outside of the supported range of #GDateTime. You should release the return value by calling g_date_time_unref() when you are done with it.

a new #GDateTime, or %NULL

the Unix time

Creates a #GDateTime corresponding to the given Unix time @t in UTC. Unix time is the number of seconds that have elapsed since 1970-01-01 00:00:00 UTC. This call can fail (returning %NULL) if @t represents a time outside of the supported range of #GDateTime. You should release the return value by calling g_date_time_unref() when you are done with it.

a new #GDateTime, or %NULL

the Unix time

Creates a new #GDateTime corresponding to the given date and time in the local time zone. This call is equivalent to calling g_date_time_new() with the time zone returned by g_time_zone_new_local().

a #GDateTime, or %NULL

the year component of the date the month component of the date the day component of the date the hour component of the date the minute component of the date the number of seconds past the minute

Creates a #GDateTime corresponding to this exact instant in the given time zone @tz. The time is as accurate as the system allows, to a maximum accuracy of 1 microsecond. This function will always succeed unless GLib is still being used after the year 9999. You should release the return value by calling g_date_time_unref() when you are done with it.

a new #GDateTime, or %NULL

a #GTimeZone

Creates a #GDateTime corresponding to this exact instant in the local time zone. This is equivalent to calling g_date_time_new_now() with the time zone returned by g_time_zone_new_local().

a new #GDateTime, or %NULL

Creates a #GDateTime corresponding to this exact instant in UTC. This is equivalent to calling g_date_time_new_now() with the time zone returned by g_time_zone_new_utc().

a new #GDateTime, or %NULL

Creates a new #GDateTime corresponding to the given date and time in UTC. This call is equivalent to calling g_date_time_new() with the time zone returned by g_time_zone_new_utc().

a #GDateTime, or %NULL

the year component of the date the month component of the date the day component of the date the hour component of the date the minute component of the date the number of seconds past the minute

Creates a copy of @datetime and adds the specified timespan to the copy.

the newly created #GDateTime which should be freed with g_date_time_unref(), or %NULL

a #GDateTime

a #GTimeSpan

Creates a copy of @datetime and adds the specified number of days to the copy. Add negative values to subtract days.

the newly created #GDateTime which should be freed with g_date_time_unref(), or %NULL

a #GDateTime

the number of days

Creates a new #GDateTime adding the specified values to the current date and time in @datetime. Add negative values to subtract.

the newly created #GDateTime which should be freed with g_date_time_unref(), or %NULL

a #GDateTime

the number of years to add the number of months to add the number of days to add the number of hours to add the number of minutes to add the number of seconds to add

Creates a copy of @datetime and adds the specified number of hours. Add negative values to subtract hours.

the newly created #GDateTime which should be freed with g_date_time_unref(), or %NULL

a #GDateTime

the number of hours to add

Creates a copy of @datetime adding the specified number of minutes. Add negative values to subtract minutes.

the newly created #GDateTime which should be freed with g_date_time_unref(), or %NULL

a #GDateTime

the number of minutes to add

Creates a copy of @datetime and adds the specified number of months to the copy. Add negative values to subtract months. The day of the month of the resulting #GDateTime is clamped to the number of days in the updated calendar month. For example, if adding 1 month to 31st January 2018, the result would be 28th February 2018. In 2020 (a leap year), the result would be 29th February.

the newly created #GDateTime which should be freed with g_date_time_unref(), or %NULL

a #GDateTime

the number of months

Creates a copy of @datetime and adds the specified number of seconds. Add negative values to subtract seconds.

the newly created #GDateTime which should be freed with g_date_time_unref(), or %NULL

a #GDateTime

the number of seconds to add

Creates a copy of @datetime and adds the specified number of weeks to the copy. Add negative values to subtract weeks.

the newly created #GDateTime which should be freed with g_date_time_unref(), or %NULL

a #GDateTime

the number of weeks

Creates a copy of @datetime and adds the specified number of years to the copy. Add negative values to subtract years. As with g_date_time_add_months(), if the resulting date would be 29th February on a non-leap year, the day will be clamped to 28th February.

the newly created #GDateTime which should be freed with g_date_time_unref(), or %NULL

a #GDateTime

the number of years

A comparison function for #GDateTimes that is suitable as a #GCompareFunc. Both #GDateTimes must be non-%NULL.

-1, 0 or 1 if @dt1 is less than, equal to or greater than @dt2.

first #GDateTime to compare

second #GDateTime to compare

Calculates the difference in time between @end and @begin. The #GTimeSpan that is returned is effectively @end - @begin (ie: positive if the first parameter is larger).

the difference between the two #GDateTime, as a time span expressed in microseconds.

a #GDateTime

Checks to see if @dt1 and @dt2 are equal. Equal here means that they represent the same moment after converting them to the same time zone.

%TRUE if @dt1 and @dt2 are equal

a #GDateTime

Creates a newly allocated string representing the requested @format. The format strings understood by this function are a subset of the strftime() format language as specified by C99. The \%D, \%U and \%W conversions are not supported, nor is the 'E' modifier. The GNU extensions \%k, \%l, \%s and \%P are supported, however, as are the '0', '_' and '-' modifiers. The Python extension \%f is also supported. In contrast to strftime(), this function always produces a UTF-8 string, regardless of the current locale. Note that the rendering of many formats is locale-dependent and may not match the strftime() output exactly. The following format specifiers are supported: - \%a: the abbreviated weekday name according to the current locale - \%A: the full weekday name according to the current locale - \%b: the abbreviated month name according to the current locale - \%B: the full month name according to the current locale - \%c: the preferred date and time representation for the current locale - \%C: the century number (year/100) as a 2-digit integer (00-99) - \%d: the day of the month as a decimal number (range 01 to 31) - \%e: the day of the month as a decimal number (range 1 to 31); single digits are preceded by a figure space - \%F: equivalent to `%Y-%m-%d` (the ISO 8601 date format) - \%g: the last two digits of the ISO 8601 week-based year as a decimal number (00-99). This works well with \%V and \%u. - \%G: the ISO 8601 week-based year as a decimal number. This works well with \%V and \%u. - \%h: equivalent to \%b - \%H: the hour as a decimal number using a 24-hour clock (range 00 to 23) - \%I: the hour as a decimal number using a 12-hour clock (range 01 to 12) - \%j: the day of the year as a decimal number (range 001 to 366) - \%k: the hour (24-hour clock) as a decimal number (range 0 to 23); single digits are preceded by a figure space - \%l: the hour (12-hour clock) as a decimal number (range 1 to 12); single digits are preceded by a figure space - \%m: the month as a decimal number (range 01 to 12) - \%M: the minute as a decimal number (range 00 to 59) - \%f: the microsecond as a decimal number (range 000000 to 999999) - \%p: either "AM" or "PM" according to the given time value, or the corresponding strings for the current locale. Noon is treated as "PM" and midnight as "AM". Use of this format specifier is discouraged, as many locales have no concept of AM/PM formatting. Use \%c or \%X instead. - \%P: like \%p but lowercase: "am" or "pm" or a corresponding string for the current locale. Use of this format specifier is discouraged, as many locales have no concept of AM/PM formatting. Use \%c or \%X instead. - \%r: the time in a.m. or p.m. notation. Use of this format specifier is discouraged, as many locales have no concept of AM/PM formatting. Use \%c or \%X instead. - \%R: the time in 24-hour notation (\%H:\%M) - \%s: the number of seconds since the Epoch, that is, since 1970-01-01 00:00:00 UTC - \%S: the second as a decimal number (range 00 to 60) - \%t: a tab character - \%T: the time in 24-hour notation with seconds (\%H:\%M:\%S) - \%u: the ISO 8601 standard day of the week as a decimal, range 1 to 7, Monday being 1. This works well with \%G and \%V. - \%V: the ISO 8601 standard week number of the current year as a decimal number, range 01 to 53, where week 1 is the first week that has at least 4 days in the new year. See g_date_time_get_week_of_year(). This works well with \%G and \%u. - \%w: the day of the week as a decimal, range 0 to 6, Sunday being 0. This is not the ISO 8601 standard format -- use \%u instead. - \%x: the preferred date representation for the current locale without the time - \%X: the preferred time representation for the current locale without the date - \%y: the year as a decimal number without the century - \%Y: the year as a decimal number including the century - \%z: the time zone as an offset from UTC (+hhmm) - \%:z: the time zone as an offset from UTC (+hh:mm). This is a gnulib strftime() extension. Since: 2.38 - \%::z: the time zone as an offset from UTC (+hh:mm:ss). This is a gnulib strftime() extension. Since: 2.38 - \%:::z: the time zone as an offset from UTC, with : to necessary precision (e.g., -04, +05:30). This is a gnulib strftime() extension. Since: 2.38 - \%Z: the time zone or name or abbreviation - \%\%: a literal \% character Some conversion specifications can be modified by preceding the conversion specifier by one or more modifier characters. The following modifiers are supported for many of the numeric conversions: - O: Use alternative numeric symbols, if the current locale supports those. - _: Pad a numeric result with spaces. This overrides the default padding for the specifier. - -: Do not pad a numeric result. This overrides the default padding for the specifier. - 0: Pad a numeric result with zeros. This overrides the default padding for the specifier. Additionally, when O is used with B, b, or h, it produces the alternative form of a month name. The alternative form should be used when the month name is used without a day number (e.g., standalone). It is required in some languages (Baltic, Slavic, Greek, and more) due to their grammatical rules. For other languages there is no difference. \%OB is a GNU and BSD strftime() extension expected to be added to the future POSIX specification, \%Ob and \%Oh are GNU strftime() extensions. Since: 2.56

a newly allocated string formatted to the requested format or %NULL in the case that there was an error (such as a format specifier not being supported in the current locale). The string should be freed with g_free().

A #GDateTime

a valid UTF-8 string, containing the format for the #GDateTime

Format @datetime in [ISO 8601 format](https://en.wikipedia.org/wiki/ISO_8601), including the date, time and time zone, and return that as a UTF-8 encoded string. Since GLib 2.66, this will output to sub-second precision if needed.

a newly allocated string formatted in ISO 8601 format or %NULL in the case that there was an error. The string should be freed with g_free().

A #GDateTime

Retrieves the day of the month represented by @datetime in the gregorian calendar.

the day of the month

a #GDateTime

Retrieves the ISO 8601 day of the week on which @datetime falls (1 is Monday, 2 is Tuesday... 7 is Sunday).

the day of the week

a #GDateTime

Retrieves the day of the year represented by @datetime in the Gregorian calendar.

the day of the year

a #GDateTime

Retrieves the hour of the day represented by @datetime

the hour of the day

a #GDateTime

Retrieves the microsecond of the date represented by @datetime

the microsecond of the second

a #GDateTime

Retrieves the minute of the hour represented by @datetime

the minute of the hour

a #GDateTime

Retrieves the month of the year represented by @datetime in the Gregorian calendar.

the month represented by @datetime

a #GDateTime

Retrieves the second of the minute represented by @datetime

the second represented by @datetime

a #GDateTime

Retrieves the number of seconds since the start of the last minute, including the fractional part.

the number of seconds

a #GDateTime

Get the time zone for this @datetime.

the time zone

a #GDateTime

Determines the time zone abbreviation to be used at the time and in the time zone of @datetime. For example, in Toronto this is currently "EST" during the winter months and "EDT" during the summer months when daylight savings time is in effect.

the time zone abbreviation. The returned string is owned by the #GDateTime and it should not be modified or freed

a #GDateTime

Determines the offset to UTC in effect at the time and in the time zone of @datetime. The offset is the number of microseconds that you add to UTC time to arrive at local time for the time zone (ie: negative numbers for time zones west of GMT, positive numbers for east). If @datetime represents UTC time, then the offset is always zero.

the number of microseconds that should be added to UTC to get the local time

a #GDateTime

Returns the ISO 8601 week-numbering year in which the week containing @datetime falls. This function, taken together with g_date_time_get_week_of_year() and g_date_time_get_day_of_week() can be used to determine the full ISO week date on which @datetime falls. This is usually equal to the normal Gregorian year (as returned by g_date_time_get_year()), except as detailed below: For Thursday, the week-numbering year is always equal to the usual calendar year. For other days, the number is such that every day within a complete week (Monday to Sunday) is contained within the same week-numbering year. For Monday, Tuesday and Wednesday occurring near the end of the year, this may mean that the week-numbering year is one greater than the calendar year (so that these days have the same week-numbering year as the Thursday occurring early in the next year). For Friday, Saturday and Sunday occurring near the start of the year, this may mean that the week-numbering year is one less than the calendar year (so that these days have the same week-numbering year as the Thursday occurring late in the previous year). An equivalent description is that the week-numbering year is equal to the calendar year containing the majority of the days in the current week (Monday to Sunday). Note that January 1 0001 in the proleptic Gregorian calendar is a Monday, so this function never returns 0.

the ISO 8601 week-numbering year for @datetime

a #GDateTime

Returns the ISO 8601 week number for the week containing @datetime. The ISO 8601 week number is the same for every day of the week (from Moday through Sunday). That can produce some unusual results (described below). The first week of the year is week 1. This is the week that contains the first Thursday of the year. Equivalently, this is the first week that has more than 4 of its days falling within the calendar year. The value 0 is never returned by this function. Days contained within a year but occurring before the first ISO 8601 week of that year are considered as being contained in the last week of the previous year. Similarly, the final days of a calendar year may be considered as being part of the first ISO 8601 week of the next year if 4 or more days of that week are contained within the new year.

the ISO 8601 week number for @datetime.

a #GDateTime

Retrieves the year represented by @datetime in the Gregorian calendar.

the year represented by @datetime

A #GDateTime

Retrieves the Gregorian day, month, and year of a given #GDateTime.

a #GDateTime.

the return location for the gregorian year, or %NULL. the return location for the month of the year, or %NULL. the return location for the day of the month, or %NULL.

Hashes @datetime into a #guint, suitable for use within #GHashTable.

a #guint containing the hash

a #GDateTime

Determines if daylight savings time is in effect at the time and in the time zone of @datetime.

%TRUE if daylight savings time is in effect

a #GDateTime

Atomically increments the reference count of @datetime by one.

the #GDateTime with the reference count increased

a #GDateTime

Creates a new #GDateTime corresponding to the same instant in time as @datetime, but in the local time zone. This call is equivalent to calling g_date_time_to_timezone() with the time zone returned by g_time_zone_new_local().

the newly created #GDateTime which should be freed with g_date_time_unref(), or %NULL

a #GDateTime

Stores the instant in time that @datetime represents into @tv. The time contained in a #GTimeVal is always stored in the form of seconds elapsed since 1970-01-01 00:00:00 UTC, regardless of the time zone associated with @datetime. On systems where 'long' is 32bit (ie: all 32bit systems and all Windows systems), a #GTimeVal is incapable of storing the entire range of values that #GDateTime is capable of expressing. On those systems, this function returns %FALSE to indicate that the time is out of range. On systems where 'long' is 64bit, this function never fails.

#GTimeVal is not year-2038-safe. Use g_date_time_to_unix() instead.

%TRUE if successful, else %FALSE

a #GDateTime

a #GTimeVal to modify

Create a new #GDateTime corresponding to the same instant in time as @datetime, but in the time zone @tz. This call can fail in the case that the time goes out of bounds. For example, converting 0001-01-01 00:00:00 UTC to a time zone west of Greenwich will fail (due to the year 0 being out of range).

the newly created #GDateTime which should be freed with g_date_time_unref(), or %NULL

a #GDateTime

the new #GTimeZone

Gives the Unix time corresponding to @datetime, rounding down to the nearest second. Unix time is the number of seconds that have elapsed since 1970-01-01 00:00:00 UTC, regardless of the time zone associated with @datetime.

the Unix time corresponding to @datetime

a #GDateTime

Creates a new #GDateTime corresponding to the same instant in time as @datetime, but in UTC. This call is equivalent to calling g_date_time_to_timezone() with the time zone returned by g_time_zone_new_utc().

the newly created #GDateTime which should be freed with g_date_time_unref(), or %NULL

a #GDateTime

Atomically decrements the reference count of @datetime by one. When the reference count reaches zero, the resources allocated by @datetime are freed

a #GDateTime

Enumeration representing a day of the week; %G_DATE_MONDAY, %G_DATE_TUESDAY, etc. %G_DATE_BAD_WEEKDAY is an invalid weekday.

invalid value Monday Tuesday Wednesday Thursday Friday Saturday Sunday

Associates a string with a bit flag. Used in g_parse_debug_string().

the string the flag

Specifies the type of function which is called when a data element is destroyed. It is passed the pointer to the data element and should free any memory and resources allocated for it.

the data element.

An opaque structure representing an opened directory.

Closes the directory and deallocates all related resources.

a #GDir* created by g_dir_open()

Retrieves the name of another entry in the directory, or %NULL. The order of entries returned from this function is not defined, and may vary by file system or other operating-system dependent factors. %NULL may also be returned in case of errors. On Unix, you can check `errno` to find out if %NULL was returned because of an error. On Unix, the '.' and '..' entries are omitted, and the returned name is in the on-disk encoding. On Windows, as is true of all GLib functions which operate on filenames, the returned name is in UTF-8.

The entry's name or %NULL if there are no more entries. The return value is owned by GLib and must not be modified or freed.

a #GDir* created by g_dir_open()

Resets the given directory. The next call to g_dir_read_name() will return the first entry again.

a #GDir* created by g_dir_open()

Creates a subdirectory in the preferred directory for temporary files (as returned by g_get_tmp_dir()). @tmpl should be a string in the GLib file name encoding containing a sequence of six 'X' characters, as the parameter to g_mkstemp(). However, unlike these functions, the template should only be a basename, no directory components are allowed. If template is %NULL, a default template is used. Note that in contrast to g_mkdtemp() (and mkdtemp()) @tmpl is not modified, and might thus be a read-only literal string.

The actual name used. This string should be freed with g_free() when not needed any longer and is is in the GLib file name encoding. In case of errors, %NULL is returned and @error will be set.

Template for directory name, as in g_mkdtemp(), basename only, or %NULL for a default template

Opens a directory for reading. The names of the files in the directory can then be retrieved using g_dir_read_name(). Note that the ordering is not defined.

a newly allocated #GDir on success, %NULL on failure. If non-%NULL, you must free the result with g_dir_close() when you are finished with it.

the path to the directory you are interested in. On Unix in the on-disk encoding. On Windows in UTF-8 Currently must be set to 0. Reserved for future use.

The #GFloatIEEE754 and #GDoubleIEEE754 unions are used to access the sign, mantissa and exponent of IEEE floats and doubles. These unions are defined as appropriate for a given platform. IEEE floats and doubles are supported (used for storage) by at least Intel, PPC and Sparc.

the double value

The type of functions that are used to 'duplicate' an object. What this means depends on the context, it could just be incrementing the reference count, if @data is a ref-counted object.

a duplicate of data

the data to duplicate user data that was specified in g_datalist_id_dup_data()

The base of natural logarithms.

Specifies the type of a function used to test two values for equality. The function should return %TRUE if both values are equal and %FALSE otherwise.

%TRUE if @a = @b; %FALSE otherwise

a value a value to compare with

Specifies the type of a function used to test two values for equality. The function should return %TRUE if both values are equal and %FALSE otherwise. This is a version of #GEqualFunc which provides a @user_data closure from the caller.

%TRUE if @a = @b; %FALSE otherwise

a value a value to compare with user data provided by the caller

The `GError` structure contains information about an error that has occurred.

error domain, e.g. %G_FILE_ERROR error code, e.g. %G_FILE_ERROR_NOENT human-readable informative error message Creates a new #GError with the given @domain and @code, and a message formatted with @format.

a new #GError

error domain error code printf()-style format for error message parameters for message format

Creates a new #GError; unlike g_error_new(), @message is not a printf()-style format string. Use this function if @message contains text you don't have control over, that could include printf() escape sequences.

a new #GError

error domain error code error message

Creates a new #GError with the given @domain and @code, and a message formatted with @format.

a new #GError

error domain error code printf()-style format for error message #va_list of parameters for the message format

Makes a copy of @error.

a new #GError

a #GError

Frees a #GError and associated resources.

a #GError

Returns %TRUE if @error matches @domain and @code, %FALSE otherwise. In particular, when @error is %NULL, %FALSE will be returned. If @domain contains a `FAILED` (or otherwise generic) error code, you should generally not check for it explicitly, but should instead treat any not-explicitly-recognized error code as being equivalent to the `FAILED` code. This way, if the domain is extended in the future to provide a more specific error code for a certain case, your code will still work.

whether @error has @domain and @code

a #GError

an error domain an error code

This function registers an extended #GError domain. @error_type_name will be duplicated. Otherwise does the same as g_error_domain_register_static().

#GQuark representing the error domain

string to create a #GQuark from size of the private error data in bytes function initializing fields of the private error data function copying fields of the private error data function freeing fields of the private error data

This function registers an extended #GError domain. @error_type_name should not be freed. @error_type_private_size must be greater than 0. @error_type_init receives an initialized #GError and should then initialize the private data. @error_type_copy is a function that receives both original and a copy #GError and should copy the fields of the private error data. The standard #GError fields are already handled. @error_type_clear receives the pointer to the error, and it should free the fields of the private error data. It should not free the struct itself though. Normally, it is better to use G_DEFINE_EXTENDED_ERROR(), as it already takes care of passing valid information to this function.

#GQuark representing the error domain

static string to create a #GQuark from size of the private error data in bytes function initializing fields of the private error data function copying fields of the private error data function freeing fields of the private error data

Specifies the type of function which is called when an extended error instance is freed. It is passed the error pointer about to be freed, and should free the error's private data fields. Normally, it is better to use G_DEFINE_EXTENDED_ERROR(), as it already takes care of getting the private data from @error.

extended error to clear

Specifies the type of function which is called when an extended error instance is copied. It is passed the pointer to the destination error and source error, and should copy only the fields of the private data from @src_error to @dest_error. Normally, it is better to use G_DEFINE_EXTENDED_ERROR(), as it already takes care of getting the private data from @src_error and @dest_error.

source extended error destination extended error

Specifies the type of function which is called just after an extended error instance is created and its fields filled. It should only initialize the fields in the private data, which can be received with the generated `*_get_private()` function. Normally, it is better to use G_DEFINE_EXTENDED_ERROR(), as it already takes care of getting the private data from @error.

extended error

The possible errors, used in the @v_error field of #GTokenValue, when the token is a %G_TOKEN_ERROR.

unknown error unexpected end of file unterminated string constant unterminated comment non-digit character in a number digit beyond radix in a number non-decimal floating point number malformed floating point number

Values corresponding to @errno codes returned from file operations on UNIX. Unlike @errno codes, GFileError values are available on all systems, even Windows. The exact meaning of each code depends on what sort of file operation you were performing; the UNIX documentation gives more details. The following error code descriptions come from the GNU C Library manual, and are under the copyright of that manual. It's not very portable to make detailed assumptions about exactly which errors will be returned from a given operation. Some errors don't occur on some systems, etc., sometimes there are subtle differences in when a system will report a given error, etc.

Operation not permitted; only the owner of the file (or other resource) or processes with special privileges can perform the operation. File is a directory; you cannot open a directory for writing, or create or remove hard links to it. Permission denied; the file permissions do not allow the attempted operation. Filename too long. No such file or directory. This is a "file doesn't exist" error for ordinary files that are referenced in contexts where they are expected to already exist. A file that isn't a directory was specified when a directory is required. No such device or address. The system tried to use the device represented by a file you specified, and it couldn't find the device. This can mean that the device file was installed incorrectly, or that the physical device is missing or not correctly attached to the computer. The underlying file system of the specified file does not support memory mapping. The directory containing the new link can't be modified because it's on a read-only file system. Text file busy. You passed in a pointer to bad memory. (GLib won't reliably return this, don't pass in pointers to bad memory.) Too many levels of symbolic links were encountered in looking up a file name. This often indicates a cycle of symbolic links. No space left on device; write operation on a file failed because the disk is full. No memory available. The system cannot allocate more virtual memory because its capacity is full. The current process has too many files open and can't open any more. Duplicate descriptors do count toward this limit. There are too many distinct file openings in the entire system. Bad file descriptor; for example, I/O on a descriptor that has been closed or reading from a descriptor open only for writing (or vice versa). Invalid argument. This is used to indicate various kinds of problems with passing the wrong argument to a library function. Broken pipe; there is no process reading from the other end of a pipe. Every library function that returns this error code also generates a 'SIGPIPE' signal; this signal terminates the program if not handled or blocked. Thus, your program will never actually see this code unless it has handled or blocked 'SIGPIPE'. Resource temporarily unavailable; the call might work if you try again later. Interrupted function call; an asynchronous signal occurred and prevented completion of the call. When this happens, you should try the call again. Input/output error; usually used for physical read or write errors. i.e. the disk or other physical device hardware is returning errors. Operation not permitted; only the owner of the file (or other resource) or processes with special privileges can perform the operation. Function not implemented; this indicates that the system is missing some functionality. Does not correspond to a UNIX error code; this is the standard "failed for unspecified reason" error code present in all #GError error code enumerations. Returned if no specific code applies.

Flags to pass to g_file_set_contents_full() to affect its safety and performance.

No guarantees about file consistency or durability. The most dangerous setting, which is slightly faster than other settings. Guarantee file consistency: after a crash, either the old version of the file or the new version of the file will be available, but not a mixture. On Unix systems this equates to an `fsync()` on the file and use of an atomic `rename()` of the new version of the file over the old. Guarantee file durability: after a crash, the new version of the file will be available. On Unix systems this equates to an `fsync()` on the file (if %G_FILE_SET_CONTENTS_CONSISTENT is unset), or the effects of %G_FILE_SET_CONTENTS_CONSISTENT plus an `fsync()` on the directory containing the file after calling `rename()`. Only apply consistency and durability guarantees if the file already exists. This may speed up file operations if the file doesn’t currently exist, but may result in a corrupted version of the new file if the system crashes while writing it.

A test to perform on a file using g_file_test().

%TRUE if the file is a regular file (not a directory). Note that this test will also return %TRUE if the tested file is a symlink to a regular file. %TRUE if the file is a symlink. %TRUE if the file is a directory. %TRUE if the file is executable. %TRUE if the file exists. It may or may not be a regular file.

the double value

Flags to modify the format of the string returned by g_format_size_full().

behave the same as g_format_size() include the exact number of bytes as part of the returned string. For example, "45.6 kB (45,612 bytes)". use IEC (base 1024) units with "KiB"-style suffixes. IEC units should only be used for reporting things with a strong "power of 2" basis, like RAM sizes or RAID stripe sizes. Network and storage sizes should be reported in the normal SI units. set the size as a quantity in bits, rather than bytes, and return units in bits. For example, ‘Mb’ rather than ‘MB’. return only value, without unit; this should not be used together with @G_FORMAT_SIZE_LONG_FORMAT nor @G_FORMAT_SIZE_ONLY_UNIT. Since: 2.74 return only unit, without value; this should not be used together with @G_FORMAT_SIZE_LONG_FORMAT nor @G_FORMAT_SIZE_ONLY_VALUE. Since: 2.74

Declares a type of function which takes an arbitrary data pointer argument and has no return value. It is not currently used in GLib or GTK+.

a data pointer

Specifies the type of functions passed to g_list_foreach() and g_slist_foreach().

the element's data user data passed to g_list_foreach() or g_slist_foreach()

This is the platform dependent conversion specifier for scanning and printing values of type #gint16. It is a string literal, but doesn't include the percent-sign, such that you can add precision and length modifiers between percent-sign and conversion specifier. |[ gint16 in; gint32 out; sscanf ("42", "%" G_GINT16_FORMAT, &in) out = in * 1000; g_print ("%" G_GINT32_FORMAT, out); This is not necessarily the correct format for printing and scanning `int16_t` values, even though the in-memory representation is the same. Standard C macros like `PRId16` and `SCNd16` should be used for `int16_t`. ]|

The platform dependent length modifier for conversion specifiers for scanning and printing values of type #gint16 or #guint16. It is a string literal, but doesn't include the percent-sign, such that you can add precision and length modifiers between percent-sign and conversion specifier and append a conversion specifier. The following example prints "0x7b"; |[ gint16 value = 123; g_print ("%#" G_GINT16_MODIFIER "x", value); ]| This is not necessarily the correct modifier for printing and scanning `int16_t` values, even though the in-memory representation is the same. Standard C macros like `PRId16` and `SCNd16` should be used for `int16_t`.

This is the platform dependent conversion specifier for scanning and printing values of type #gint32. See also %G_GINT16_FORMAT. This is not necessarily the correct modifier for printing and scanning `int32_t` values, even though the in-memory representation is the same. Standard C macros like `PRId32` and `SCNd32` should be used for `int32_t`.

The platform dependent length modifier for conversion specifiers for scanning and printing values of type #gint32 or #guint32. It is a string literal. See also %G_GINT16_MODIFIER. This is not necessarily the correct modifier for printing and scanning `int32_t` values, even though the in-memory representation is the same. Standard C macros like `PRId32` and `SCNd32` should be used for `int32_t`.

This macro is used to insert 64-bit integer literals into the source code. It is similar to the standard C `INT64_C` macro, which should be preferred in new code.

a literal integer value, e.g. 0x1d636b02300a7aa7

This is the platform dependent conversion specifier for scanning and printing values of type #gint64. See also %G_GINT16_FORMAT. Some platforms do not support scanning and printing 64-bit integers, even though the types are supported. On such platforms %G_GINT64_FORMAT is not defined. Note that scanf() may not support 64-bit integers, even if %G_GINT64_FORMAT is defined. Due to its weak error handling, scanf() is not recommended for parsing anyway; consider using g_ascii_strtoull() instead. This is not necessarily the correct format for printing and scanning `int64_t` values, even though the in-memory representation is the same. Standard C macros like `PRId64` and `SCNd64` should be used for `int64_t`.

The platform dependent length modifier for conversion specifiers for scanning and printing values of type #gint64 or #guint64. It is a string literal. Some platforms do not support printing 64-bit integers, even though the types are supported. On such platforms %G_GINT64_MODIFIER is not defined. This is not necessarily the correct modifier for printing and scanning `int64_t` values, even though the in-memory representation is the same. Standard C macros like `PRId64` and `SCNd64` should be used for `int64_t`.

This is the platform dependent conversion specifier for scanning and printing values of type #gintptr. Note that this is not necessarily the correct format to scan or print an `intptr_t`, even though the in-memory representation is the same. Standard C macros like `PRIdPTR` and `SCNdPTR` should be used for `intptr_t`.

The platform dependent length modifier for conversion specifiers for scanning and printing values of type #gintptr or #guintptr. It is a string literal. Note that this is not necessarily the correct modifier to scan or print an `intptr_t`, even though the in-memory representation is the same. Standard C macros like `PRIdPTR` and `SCNdPTR` should be used for `intptr_t`.

Expands to the GNU C `alloc_size` function attribute if the compiler is a new enough gcc. This attribute tells the compiler that the function returns a pointer to memory of a size that is specified by the @xth function parameter. Place the attribute after the function declaration, just before the semicolon. |[ gpointer g_malloc (gsize n_bytes) G_GNUC_MALLOC G_GNUC_ALLOC_SIZE(1); ]| See the [GNU C documentation](https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-alloc_005fsize-function-attribute) for more details.

the index of the argument specifying the allocation size

Expands to the GNU C `alloc_size` function attribute if the compiler is a new enough gcc. This attribute tells the compiler that the function returns a pointer to memory of a size that is specified by the product of two function parameters. Place the attribute after the function declaration, just before the semicolon. |[ gpointer g_malloc_n (gsize n_blocks, gsize n_block_bytes) G_GNUC_MALLOC G_GNUC_ALLOC_SIZE2(1, 2); ]| See the [GNU C documentation](https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-alloc_005fsize-function-attribute) for more details.

the index of the argument specifying one factor of the allocation size the index of the argument specifying the second factor of the allocation size

Expands to a check for a compiler with __GNUC__ defined and a version greater than or equal to the major and minor numbers provided. For example, the following would only match on compilers such as GCC 4.8 or newer. |[ #if G_GNUC_CHECK_VERSION(4, 8) #endif ]|

major version to check against minor version to check against

Like %G_GNUC_DEPRECATED, but names the intended replacement for the deprecated symbol if the version of gcc in use is new enough to support custom deprecation messages. Place the attribute after the declaration, just before the semicolon. |[ int my_mistake (void) G_GNUC_DEPRECATED_FOR(my_replacement); ]| See the [GNU C documentation](https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-deprecated-function-attribute) for more details. Note that if @f is a macro, it will be expanded in the warning message. You can enclose it in quotes to prevent this. (The quotes will show up in the warning, but it's better than showing the macro expansion.)

the intended replacement for the deprecated symbol, such as the name of a function

Expands to the GNU C `format_arg` function attribute if the compiler is gcc. This function attribute specifies that a function takes a format string for a `printf()`, `scanf()`, `strftime()` or `strfmon()` style function and modifies it, so that the result can be passed to a `printf()`, `scanf()`, `strftime()` or `strfmon()` style function (with the remaining arguments to the format function the same as they would have been for the unmodified string). Place the attribute after the function declaration, just before the semicolon. See the [GNU C documentation](https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-Wformat-nonliteral-1) for more details. |[ gchar *g_dgettext (gchar *domain_name, gchar *msgid) G_GNUC_FORMAT (2); ]|

the index of the argument

Expands to "" on all modern compilers, and to __FUNCTION__ on gcc version 2.x. Don't use it.

Use G_STRFUNC() instead

Expands to "" on all modern compilers, and to __PRETTY_FUNCTION__ on gcc version 2.x. Don't use it.

Use G_STRFUNC() instead

Expands to the GNU C `format` function attribute if the compiler is gcc. This is used for declaring functions which take a variable number of arguments, with the same syntax as `printf()`. It allows the compiler to type-check the arguments passed to the function. Place the attribute after the function declaration, just before the semicolon. See the [GNU C documentation](https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-Wformat-3288) for more details. |[ gint g_snprintf (gchar *string, gulong n, gchar const *format, ...) G_GNUC_PRINTF (3, 4); ]|

the index of the argument corresponding to the format string (the arguments are numbered from 1) the index of the first of the format arguments, or 0 if there are no format arguments

Expands to the GNU C `format` function attribute if the compiler is gcc. This is used for declaring functions which take a variable number of arguments, with the same syntax as `scanf()`. It allows the compiler to type-check the arguments passed to the function. |[ int my_scanf (MyStream *stream, const char *format, ...) G_GNUC_SCANF (2, 3); int my_vscanf (MyStream *stream, const char *format, va_list ap) G_GNUC_SCANF (2, 0); ]| See the [GNU C documentation](https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-Wformat-3288) for details.

the index of the argument corresponding to the format string (the arguments are numbered from 1) the index of the first of the format arguments, or 0 if there are no format arguments

Expands to the GNU C `strftime` format function attribute if the compiler is gcc. This is used for declaring functions which take a format argument which is passed to `strftime()` or an API implementing its formats. It allows the compiler check the format passed to the function. |[ gsize my_strftime (MyBuffer *buffer, const char *format, const struct tm *tm) G_GNUC_STRFTIME (2); ]| See the [GNU C documentation](https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-Wformat-3288) for details.

the index of the argument corresponding to the format string (the arguments are numbered from 1)

This macro is used to insert #goffset 64-bit integer literals into the source code. See also G_GINT64_CONSTANT().

a literal integer value, e.g. 0x1d636b02300a7aa7

This is the platform dependent conversion specifier for scanning and printing values of type #gsize. See also %G_GINT16_FORMAT. Note that this is not necessarily the correct format to scan or print a `size_t`, even though the in-memory representation is the same. The standard C `"zu"` format should be used for `size_t`, assuming a C99-compliant `printf` implementation is available.

The platform dependent length modifier for conversion specifiers for scanning and printing values of type #gsize. It is a string literal. Note that this is not necessarily the correct modifier to scan or print a `size_t`, even though the in-memory representation is the same. The Standard C `"z"` modifier should be used for `size_t`, assuming a C99-compliant `printf` implementation is available.

This is the platform dependent conversion specifier for scanning and printing values of type #gssize. See also %G_GINT16_FORMAT. Note that this is not necessarily the correct format to scan or print a POSIX `ssize_t` or a Windows `SSIZE_T`, even though the in-memory representation is the same. On POSIX platforms, the `"zd"` format should be used for `ssize_t`.

The platform dependent length modifier for conversion specifiers for scanning and printing values of type #gssize. It is a string literal. Note that this is not necessarily the correct modifier to scan or print a POSIX `ssize_t` or a Windows `SSIZE_T`, even though the in-memory representation is the same. On POSIX platforms, the `"z"` modifier should be used for `ssize_t`.

This is the platform dependent conversion specifier for scanning and printing values of type #guint16. See also %G_GINT16_FORMAT This is not necessarily the correct modifier for printing and scanning `uint16_t` values, even though the in-memory representation is the same. Standard C macros like `PRIu16` and `SCNu16` should be used for `uint16_t`.

This is the platform dependent conversion specifier for scanning and printing values of type #guint32. See also %G_GINT16_FORMAT. This is not necessarily the correct modifier for printing and scanning `uint32_t` values, even though the in-memory representation is the same. Standard C macros like `PRIu32` and `SCNu32` should be used for `uint32_t`.

This macro is used to insert 64-bit unsigned integer literals into the source code. It is similar to the standard C `UINT64_C` macro, which should be preferred in new code.

a literal integer value, e.g. 0x1d636b02300a7aa7U

This is the platform dependent conversion specifier for scanning and printing values of type #guint64. See also %G_GINT16_FORMAT. Some platforms do not support scanning and printing 64-bit integers, even though the types are supported. On such platforms %G_GUINT64_FORMAT is not defined. Note that scanf() may not support 64-bit integers, even if %G_GINT64_FORMAT is defined. Due to its weak error handling, scanf() is not recommended for parsing anyway; consider using g_ascii_strtoull() instead. This is not necessarily the correct modifier for printing and scanning `uint64_t` values, even though the in-memory representation is the same. Standard C macros like `PRIu64` and `SCNu64` should be used for `uint64_t`.

This is the platform dependent conversion specifier for scanning and printing values of type #guintptr. Note that this is not necessarily the correct format to scan or print a `uintptr_t`, even though the in-memory representation is the same. Standard C macros like `PRIuPTR` and `SCNuPTR` should be used for `uintptr_t`.

Defined to 1 if gcc-style visibility handling is supported.

Specifies the type of the function passed to g_hash_table_foreach(). It is called with each key/value pair, together with the @user_data parameter which is passed to g_hash_table_foreach().

a key the value corresponding to the key user data passed to g_hash_table_foreach()

Casts a pointer to a `GHook*`.

a pointer

Returns %TRUE if the #GHook is active, which is normally the case until the #GHook is destroyed.

a #GHook

Gets the flags of a hook.

a #GHook

The position of the first bit which is not reserved for internal use be the #GHook implementation, i.e. `1 << G_HOOK_FLAG_USER_SHIFT` is the first bit which can be used for application-defined flags.

Returns %TRUE if the #GHook function is currently executing.

a #GHook

Returns %TRUE if the #GHook is not in a #GHookList.

a #GHook

Returns %TRUE if the #GHook is valid, i.e. it is in a #GHookList, it is active and it has not been destroyed.

a #GHook

Specifies the type of the function passed to g_hash_table_foreach_remove(). It is called with each key/value pair, together with the @user_data parameter passed to g_hash_table_foreach_remove(). It should return %TRUE if the key/value pair should be removed from the #GHashTable.

%TRUE if the key/value pair should be removed from the #GHashTable

a key the value associated with the key user data passed to g_hash_table_remove()

Specifies the type of the hash function which is passed to g_hash_table_new() when a #GHashTable is created. The function is passed a key and should return a #guint hash value. The functions g_direct_hash(), g_int_hash() and g_str_hash() provide hash functions which can be used when the key is a #gpointer, #gint*, and #gchar* respectively. g_direct_hash() is also the appropriate hash function for keys of the form `GINT_TO_POINTER (n)` (or similar macros). A good hash functions should produce hash values that are evenly distributed over a fairly large range. The modulus is taken with the hash table size (a prime number) to find the 'bucket' to place each key into. The function should also be very fast, since it is called for each key lookup. Note that the hash functions provided by GLib have these qualities, but are not particularly robust against manufactured keys that cause hash collisions. Therefore, you should consider choosing a more secure hash function when using a GHashTable with keys that originate in untrusted data (such as HTTP requests). Using g_str_hash() in that situation might make your application vulnerable to [Algorithmic Complexity Attacks](https://lwn.net/Articles/474912/). The key to choosing a good hash is unpredictability. Even cryptographic hashes are very easy to find collisions for when the remainder is taken modulo a somewhat predictable prime number. There must be an element of randomness that an attacker is unable to guess.

the hash value corresponding to the key

a key

The #GHashTable struct is an opaque data structure to represent a [Hash Table][glib-Hash-Tables]. It should only be accessed via the following functions.

This is a convenience function for using a #GHashTable as a set. It is equivalent to calling g_hash_table_replace() with @key as both the key and the value. In particular, this means that if @key already exists in the hash table, then the old copy of @key in the hash table is freed and @key replaces it in the table. When a hash table only ever contains keys that have themselves as the corresponding value it is able to be stored more efficiently. See the discussion in the section description. Starting from GLib 2.40, this function returns a boolean value to indicate whether the newly added value was already in the hash table or not.

%TRUE if the key did not exist yet

a #GHashTable a key to insert

Checks if @key is in @hash_table.

%TRUE if @key is in @hash_table, %FALSE otherwise.

a #GHashTable a key to check

Destroys all keys and values in the #GHashTable and decrements its reference count by 1. If keys and/or values are dynamically allocated, you should either free them first or create the #GHashTable with destroy notifiers using g_hash_table_new_full(). In the latter case the destroy functions you supplied will be called on all keys and values during the destruction phase.

a #GHashTable

Calls the given function for key/value pairs in the #GHashTable until @predicate returns %TRUE. The function is passed the key and value of each pair, and the given @user_data parameter. The hash table may not be modified while iterating over it (you can't add/remove items). Note, that hash tables are really only optimized for forward lookups, i.e. g_hash_table_lookup(). So code that frequently issues g_hash_table_find() or g_hash_table_foreach() (e.g. in the order of once per every entry in a hash table) should probably be reworked to use additional or different data structures for reverse lookups (keep in mind that an O(n) find/foreach operation issued for all n values in a hash table ends up needing O(n*n) operations).

The value of the first key/value pair is returned, for which @predicate evaluates to %TRUE. If no pair with the requested property is found, %NULL is returned.

a #GHashTable function to test the key/value pairs for a certain property user data to pass to the function

Calls the given function for each of the key/value pairs in the #GHashTable. The function is passed the key and value of each pair, and the given @user_data parameter. The hash table may not be modified while iterating over it (you can't add/remove items). To remove all items matching a predicate, use g_hash_table_foreach_remove(). The order in which g_hash_table_foreach() iterates over the keys/values in the hash table is not defined. See g_hash_table_find() for performance caveats for linear order searches in contrast to g_hash_table_lookup().

a #GHashTable the function to call for each key/value pair user data to pass to the function

Calls the given function for each key/value pair in the #GHashTable. If the function returns %TRUE, then the key/value pair is removed from the #GHashTable. If you supplied key or value destroy functions when creating the #GHashTable, they are used to free the memory allocated for the removed keys and values. See #GHashTableIter for an alternative way to loop over the key/value pairs in the hash table.

the number of key/value pairs removed

a #GHashTable the function to call for each key/value pair user data to pass to the function

Calls the given function for each key/value pair in the #GHashTable. If the function returns %TRUE, then the key/value pair is removed from the #GHashTable, but no key or value destroy functions are called. See #GHashTableIter for an alternative way to loop over the key/value pairs in the hash table.

the number of key/value pairs removed.

a #GHashTable the function to call for each key/value pair user data to pass to the function

Retrieves every key inside @hash_table. The returned data is valid until changes to the hash release those keys. This iterates over every entry in the hash table to build its return value. To iterate over the entries in a #GHashTable more efficiently, use a #GHashTableIter.

a #GList containing all the keys inside the hash table. The content of the list is owned by the hash table and should not be modified or freed. Use g_list_free() when done using the list.

a #GHashTable

Retrieves every key inside @hash_table, as an array. The returned array is %NULL-terminated but may contain %NULL as a key. Use @length to determine the true length if it's possible that %NULL was used as the value for a key. Note: in the common case of a string-keyed #GHashTable, the return value of this function can be conveniently cast to (const gchar **). This iterates over every entry in the hash table to build its return value. To iterate over the entries in a #GHashTable more efficiently, use a #GHashTableIter. You should always free the return result with g_free(). In the above-mentioned case of a string-keyed hash table, it may be appropriate to use g_strfreev() if you call g_hash_table_steal_all() first to transfer ownership of the keys.

a %NULL-terminated array containing each key from the table.

a #GHashTable the length of the returned array

Retrieves every value inside @hash_table. The returned data is valid until @hash_table is modified. This iterates over every entry in the hash table to build its return value. To iterate over the entries in a #GHashTable more efficiently, use a #GHashTableIter.

a #GList containing all the values inside the hash table. The content of the list is owned by the hash table and should not be modified or freed. Use g_list_free() when done using the list.

a #GHashTable

Inserts a new key and value into a #GHashTable. If the key already exists in the #GHashTable its current value is replaced with the new value. If you supplied a @value_destroy_func when creating the #GHashTable, the old value is freed using that function. If you supplied a @key_destroy_func when creating the #GHashTable, the passed key is freed using that function. Starting from GLib 2.40, this function returns a boolean value to indicate whether the newly added value was already in the hash table or not.

%TRUE if the key did not exist yet

a #GHashTable a key to insert the value to associate with the key

Looks up a key in a #GHashTable. Note that this function cannot distinguish between a key that is not present and one which is present and has the value %NULL. If you need this distinction, use g_hash_table_lookup_extended().

the associated value, or %NULL if the key is not found

a #GHashTable the key to look up

Looks up a key in the #GHashTable, returning the original key and the associated value and a #gboolean which is %TRUE if the key was found. This is useful if you need to free the memory allocated for the original key, for example before calling g_hash_table_remove(). You can actually pass %NULL for @lookup_key to test whether the %NULL key exists, provided the hash and equal functions of @hash_table are %NULL-safe.

%TRUE if the key was found in the #GHashTable

a #GHashTable the key to look up return location for the original key return location for the value associated with the key

Creates a new #GHashTable with a reference count of 1. Hash values returned by @hash_func are used to determine where keys are stored within the #GHashTable data structure. The g_direct_hash(), g_int_hash(), g_int64_hash(), g_double_hash() and g_str_hash() functions are provided for some common types of keys. If @hash_func is %NULL, g_direct_hash() is used. @key_equal_func is used when looking up keys in the #GHashTable. The g_direct_equal(), g_int_equal(), g_int64_equal(), g_double_equal() and g_str_equal() functions are provided for the most common types of keys. If @key_equal_func is %NULL, keys are compared directly in a similar fashion to g_direct_equal(), but without the overhead of a function call. @key_equal_func is called with the key from the hash table as its first parameter, and the user-provided key to check against as its second.

a new #GHashTable

a function to create a hash value from a key a function to check two keys for equality

Creates a new #GHashTable like g_hash_table_new() with a reference count of 1 and allows to specify functions to free the memory allocated for the key and value that get called when removing the entry from the #GHashTable. Since version 2.42 it is permissible for destroy notify functions to recursively remove further items from the hash table. This is only permissible if the application still holds a reference to the hash table. This means that you may need to ensure that the hash table is empty by calling g_hash_table_remove_all() before releasing the last reference using g_hash_table_unref().

a new #GHashTable

a function to create a hash value from a key a function to check two keys for equality a function to free the memory allocated for the key used when removing the entry from the #GHashTable, or %NULL if you don't want to supply such a function. a function to free the memory allocated for the value used when removing the entry from the #GHashTable, or %NULL if you don't want to supply such a function.

Creates a new #GHashTable like g_hash_table_new_full() with a reference count of 1. It inherits the hash function, the key equal function, the key destroy function, as well as the value destroy function, from @other_hash_table. The returned hash table will be empty; it will not contain the keys or values from @other_hash_table.

a new #GHashTable

Another #GHashTable

Atomically increments the reference count of @hash_table by one. This function is MT-safe and may be called from any thread.

the passed in #GHashTable

a valid #GHashTable

Removes a key and its associated value from a #GHashTable. If the #GHashTable was created using g_hash_table_new_full(), the key and value are freed using the supplied destroy functions, otherwise you have to make sure that any dynamically allocated values are freed yourself.

%TRUE if the key was found and removed from the #GHashTable

a #GHashTable the key to remove

Removes all keys and their associated values from a #GHashTable. If the #GHashTable was created using g_hash_table_new_full(), the keys and values are freed using the supplied destroy functions, otherwise you have to make sure that any dynamically allocated values are freed yourself.

a #GHashTable

Inserts a new key and value into a #GHashTable similar to g_hash_table_insert(). The difference is that if the key already exists in the #GHashTable, it gets replaced by the new key. If you supplied a @value_destroy_func when creating the #GHashTable, the old value is freed using that function. If you supplied a @key_destroy_func when creating the #GHashTable, the old key is freed using that function. Starting from GLib 2.40, this function returns a boolean value to indicate whether the newly added value was already in the hash table or not.

%TRUE if the key did not exist yet

a #GHashTable a key to insert the value to associate with the key

Returns the number of elements contained in the #GHashTable.

the number of key/value pairs in the #GHashTable.

a #GHashTable

Removes a key and its associated value from a #GHashTable without calling the key and value destroy functions.

%TRUE if the key was found and removed from the #GHashTable

a #GHashTable the key to remove

Removes all keys and their associated values from a #GHashTable without calling the key and value destroy functions.

a #GHashTable

Looks up a key in the #GHashTable, stealing the original key and the associated value and returning %TRUE if the key was found. If the key was not found, %FALSE is returned. If found, the stolen key and value are removed from the hash table without calling the key and value destroy functions, and ownership is transferred to the caller of this method, as with g_hash_table_steal(). That is the case regardless whether @stolen_key or @stolen_value output parameters are requested. You can pass %NULL for @lookup_key, provided the hash and equal functions of @hash_table are %NULL-safe. The dictionary implementation optimizes for having all values identical to their keys, for example by using g_hash_table_add(). When stealing both the key and the value from such a dictionary, the value will be %NULL.

%TRUE if the key was found in the #GHashTable

a #GHashTable the key to look up return location for the original key return location for the value associated with the key

Atomically decrements the reference count of @hash_table by one. If the reference count drops to 0, all keys and values will be destroyed, and all memory allocated by the hash table is released. This function is MT-safe and may be called from any thread.

a valid #GHashTable

A GHashTableIter structure represents an iterator that can be used to iterate over the elements of a #GHashTable. GHashTableIter structures are typically allocated on the stack and then initialized with g_hash_table_iter_init(). The iteration order of a #GHashTableIter over the keys/values in a hash table is not defined.

Returns the #GHashTable associated with @iter.

the #GHashTable associated with @iter.

an initialized #GHashTableIter

Initializes a key/value pair iterator and associates it with @hash_table. Modifying the hash table after calling this function invalidates the returned iterator. The iteration order of a #GHashTableIter over the keys/values in a hash table is not defined. |[ GHashTableIter iter; gpointer key, value; g_hash_table_iter_init (&iter, hash_table); while (g_hash_table_iter_next (&iter, &key, &value)) { // do something with key and value } ]|

an uninitialized #GHashTableIter

a #GHashTable

Advances @iter and retrieves the key and/or value that are now pointed to as a result of this advancement. If %FALSE is returned, @key and @value are not set, and the iterator becomes invalid.

%FALSE if the end of the #GHashTable has been reached.

an initialized #GHashTableIter

a location to store the key a location to store the value

Removes the key/value pair currently pointed to by the iterator from its associated #GHashTable. Can only be called after g_hash_table_iter_next() returned %TRUE, and cannot be called more than once for the same key/value pair. If the #GHashTable was created using g_hash_table_new_full(), the key and value are freed using the supplied destroy functions, otherwise you have to make sure that any dynamically allocated values are freed yourself. It is safe to continue iterating the #GHashTable afterward: |[ while (g_hash_table_iter_next (&iter, &key, &value)) { if (condition) g_hash_table_iter_remove (&iter); } ]|

an initialized #GHashTableIter

Replaces the value currently pointed to by the iterator from its associated #GHashTable. Can only be called after g_hash_table_iter_next() returned %TRUE. If you supplied a @value_destroy_func when creating the #GHashTable, the old value is freed using that function.

an initialized #GHashTableIter

the value to replace with

Removes the key/value pair currently pointed to by the iterator from its associated #GHashTable, without calling the key and value destroy functions. Can only be called after g_hash_table_iter_next() returned %TRUE, and cannot be called more than once for the same key/value pair.

an initialized #GHashTableIter

An opaque structure representing a HMAC operation. To create a new GHmac, use g_hmac_new(). To free a GHmac, use g_hmac_unref().

Copies a #GHmac. If @hmac has been closed, by calling g_hmac_get_string() or g_hmac_get_digest(), the copied HMAC will be closed as well.

the copy of the passed #GHmac. Use g_hmac_unref() when finished using it.

the #GHmac to copy

Gets the digest from @checksum as a raw binary array and places it into @buffer. The size of the digest depends on the type of checksum. Once this function has been called, the #GHmac is closed and can no longer be updated with g_checksum_update().

a #GHmac

output buffer an inout parameter. The caller initializes it to the size of @buffer. After the call it contains the length of the digest

Gets the HMAC as a hexadecimal string. Once this function has been called the #GHmac can no longer be updated with g_hmac_update(). The hexadecimal characters will be lower case.

the hexadecimal representation of the HMAC. The returned string is owned by the HMAC and should not be modified or freed.

a #GHmac

Atomically increments the reference count of @hmac by one. This function is MT-safe and may be called from any thread.

the passed in #GHmac.

a valid #GHmac

Atomically decrements the reference count of @hmac by one. If the reference count drops to 0, all keys and values will be destroyed, and all memory allocated by the hash table is released. This function is MT-safe and may be called from any thread. Frees the memory allocated for @hmac.

a #GHmac

Feeds @data into an existing #GHmac. The HMAC must still be open, that is g_hmac_get_string() or g_hmac_get_digest() must not have been called on @hmac.

a #GHmac

buffer used to compute the checksum size of the buffer, or -1 if it is a nul-terminated string

Creates a new #GHmac, using the digest algorithm @digest_type. If the @digest_type is not known, %NULL is returned. A #GHmac can be used to compute the HMAC of a key and an arbitrary binary blob, using different hashing algorithms. A #GHmac works by feeding a binary blob through g_hmac_update() until the data is complete; the digest can then be extracted using g_hmac_get_string(), which will return the checksum as a hexadecimal string; or g_hmac_get_digest(), which will return a array of raw bytes. Once either g_hmac_get_string() or g_hmac_get_digest() have been called on a #GHmac, the HMAC will be closed and it won't be possible to call g_hmac_update() on it anymore. Support for digests of type %G_CHECKSUM_SHA512 has been added in GLib 2.42. Support for %G_CHECKSUM_SHA384 was added in GLib 2.52.

the newly created #GHmac, or %NULL. Use g_hmac_unref() to free the memory allocated by it.

the desired type of digest the key for the HMAC the length of the keys

The #GHook struct represents a single hook function in a #GHookList.

data which is passed to func when this hook is invoked pointer to the next hook in the list pointer to the previous hook in the list the reference count of this hook the id of this hook, which is unique within its list flags which are set for this hook. See #GHookFlagMask for predefined flags the function to call when this hook is invoked. The possible signatures for this function are #GHookFunc and #GHookCheckFunc the default @finalize_hook function of a #GHookList calls this member of the hook that is being finalized Compares the ids of two #GHook elements, returning a negative value if the second id is greater than the first.

a value <= 0 if the id of @sibling is >= the id of @new_hook

a #GHook

a #GHook to compare with @new_hook

Allocates space for a #GHook and initializes it.

a new #GHook

a #GHookList

Destroys a #GHook, given its ID.

%TRUE if the #GHook was found in the #GHookList and destroyed

a #GHookList a hook ID

Removes one #GHook from a #GHookList, marking it inactive and calling g_hook_unref() on it.

a #GHookList the #GHook to remove

Finds a #GHook in a #GHookList using the given function to test for a match.

the found #GHook or %NULL if no matching #GHook is found

a #GHookList %TRUE if #GHook elements which have been destroyed should be skipped the function to call for each #GHook, which should return %TRUE when the #GHook has been found the data to pass to @func

Finds a #GHook in a #GHookList with the given data.

the #GHook with the given @data or %NULL if no matching #GHook is found

a #GHookList %TRUE if #GHook elements which have been destroyed should be skipped the data to find

Finds a #GHook in a #GHookList with the given function.

the #GHook with the given @func or %NULL if no matching #GHook is found

a #GHookList %TRUE if #GHook elements which have been destroyed should be skipped the function to find

Finds a #GHook in a #GHookList with the given function and data.

the #GHook with the given @func and @data or %NULL if no matching #GHook is found

a #GHookList %TRUE if #GHook elements which have been destroyed should be skipped the function to find the data to find

Returns the first #GHook in a #GHookList which has not been destroyed. The reference count for the #GHook is incremented, so you must call g_hook_unref() to restore it when no longer needed. (Or call g_hook_next_valid() if you are stepping through the #GHookList.)

the first valid #GHook, or %NULL if none are valid

a #GHookList %TRUE if hooks which are currently running (e.g. in another thread) are considered valid. If set to %FALSE, these are skipped

Calls the #GHookList @finalize_hook function if it exists, and frees the memory allocated for the #GHook.

a #GHookList the #GHook to free

Returns the #GHook with the given id, or %NULL if it is not found.

the #GHook with the given id, or %NULL if it is not found

a #GHookList a hook id

Inserts a #GHook into a #GHookList, before a given #GHook.

a #GHookList the #GHook to insert the new #GHook before the #GHook to insert

Inserts a #GHook into a #GHookList, sorted by the given function.

a #GHookList the #GHook to insert the comparison function used to sort the #GHook elements

Returns the next #GHook in a #GHookList which has not been destroyed. The reference count for the #GHook is incremented, so you must call g_hook_unref() to restore it when no longer needed. (Or continue to call g_hook_next_valid() until %NULL is returned.)

the next valid #GHook, or %NULL if none are valid

a #GHookList the current #GHook %TRUE if hooks which are currently running (e.g. in another thread) are considered valid. If set to %FALSE, these are skipped

Prepends a #GHook on the start of a #GHookList.

a #GHookList the #GHook to add to the start of @hook_list

Increments the reference count for a #GHook.

the @hook that was passed in (since 2.6)

a #GHookList the #GHook to increment the reference count of

Decrements the reference count of a #GHook. If the reference count falls to 0, the #GHook is removed from the #GHookList and g_hook_free() is called to free it.

a #GHookList the #GHook to unref

Defines the type of a hook function that can be invoked by g_hook_list_invoke_check().

%FALSE if the #GHook should be destroyed

the data field of the #GHook is passed to the hook function here

Defines the type of function used by g_hook_list_marshal_check().

%FALSE if @hook should be destroyed

a #GHook user data

Defines the type of function used to compare #GHook elements in g_hook_insert_sorted().

a value <= 0 if @new_hook should be before @sibling

the #GHook being inserted the #GHook to compare with @new_hook

Defines the type of function to be called when a hook in a list of hooks gets finalized.

a #GHookList the hook in @hook_list that gets finalized

Defines the type of the function passed to g_hook_find().

%TRUE if the required #GHook has been found

a #GHook user data passed to g_hook_find_func()

Flags used internally in the #GHook implementation.

set if the hook has not been destroyed set if the hook is currently being run A mask covering all bits reserved for hook flags; see %G_HOOK_FLAG_USER_SHIFT

Defines the type of a hook function that can be invoked by g_hook_list_invoke().

the data field of the #GHook is passed to the hook function here

The #GHookList struct represents a list of hook functions.

the next free #GHook id the size of the #GHookList elements, in bytes 1 if the #GHookList has been initialized the first #GHook element in the list unused the function to call to finalize a #GHook element. The default behaviour is to call the hooks @destroy function unused Removes all the #GHook elements from a #GHookList.

a #GHookList

Initializes a #GHookList. This must be called before the #GHookList is used.

a #GHookList

the size of each element in the #GHookList, typically `sizeof (GHook)`.

Calls all of the #GHook functions in a #GHookList.

a #GHookList

%TRUE if functions which are already running (e.g. in another thread) can be called. If set to %FALSE, these are skipped

Calls all of the #GHook functions in a #GHookList. Any function which returns %FALSE is removed from the #GHookList.

a #GHookList

%TRUE if functions which are already running (e.g. in another thread) can be called. If set to %FALSE, these are skipped

Calls a function on each valid #GHook.

a #GHookList

%TRUE if hooks which are currently running (e.g. in another thread) are considered valid. If set to %FALSE, these are skipped the function to call for each #GHook data to pass to @marshaller

Calls a function on each valid #GHook and destroys it if the function returns %FALSE.

a #GHookList

%TRUE if hooks which are currently running (e.g. in another thread) are considered valid. If set to %FALSE, these are skipped the function to call for each #GHook data to pass to @marshaller

Defines the type of function used by g_hook_list_marshal().

a #GHook user data

The GIConv struct wraps an iconv() conversion descriptor. It contains private data and should only be accessed using the following functions.

Same as the standard UNIX routine iconv(), but may be implemented via libiconv on UNIX flavors that lack a native implementation. GLib provides g_convert() and g_locale_to_utf8() which are likely more convenient than the raw iconv wrappers. Note that the behaviour of iconv() for characters which are valid in the input character set, but which have no representation in the output character set, is implementation defined. This function may return success (with a positive number of non-reversible conversions as replacement characters were used), or it may return -1 and set an error such as %EILSEQ, in such a situation.

count of non-reversible conversions, or -1 on error

conversion descriptor from g_iconv_open()

bytes to convert inout parameter, bytes remaining to convert in @inbuf converted output bytes inout parameter, bytes available to fill in @outbuf

Same as the standard UNIX routine iconv_close(), but may be implemented via libiconv on UNIX flavors that lack a native implementation. Should be called to clean up the conversion descriptor from g_iconv_open() when you are done converting things. GLib provides g_convert() and g_locale_to_utf8() which are likely more convenient than the raw iconv wrappers.

-1 on error, 0 on success

a conversion descriptor from g_iconv_open()

Same as the standard UNIX routine iconv_open(), but may be implemented via libiconv on UNIX flavors that lack a native implementation. GLib provides g_convert() and g_locale_to_utf8() which are likely more convenient than the raw iconv wrappers.

a "conversion descriptor", or (GIConv)-1 if opening the converter failed.

destination codeset source codeset

The bias by which exponents in double-precision floats are offset.

The bias by which exponents in single-precision floats are offset.

A data structure representing an IO Channel. The fields should be considered private and should only be accessed with the following functions.

Open a file @filename as a #GIOChannel using mode @mode. This channel will be closed when the last reference to it is dropped, so there is no need to call g_io_channel_close() (though doing so will not cause problems, as long as no attempt is made to access the channel after it is closed).

A #GIOChannel on success, %NULL on failure.

A string containing the name of a file One of "r", "w", "a", "r+", "w+", "a+". These have the same meaning as in fopen()

Creates a new #GIOChannel given a file descriptor. On UNIX systems this works for plain files, pipes, and sockets. The returned #GIOChannel has a reference count of 1. The default encoding for #GIOChannel is UTF-8. If your application is reading output from a command using via pipe, you may need to set the encoding to the encoding of the current locale (see g_get_charset()) with the g_io_channel_set_encoding() function. By default, the fd passed will not be closed when the final reference to the #GIOChannel data structure is dropped. If you want to read raw binary data without interpretation, then call the g_io_channel_set_encoding() function with %NULL for the encoding argument. This function is available in GLib on Windows, too, but you should avoid using it on Windows. The domain of file descriptors and sockets overlap. There is no way for GLib to know which one you mean in case the argument you pass to this function happens to be both a valid file descriptor and socket. If that happens a warning is issued, and GLib assumes that it is the file descriptor you mean.

a new #GIOChannel.

a file descriptor.

Close an IO channel. Any pending data to be written will be flushed, ignoring errors. The channel will not be freed until the last reference is dropped using g_io_channel_unref().

Use g_io_channel_shutdown() instead.

A #GIOChannel

Flushes the write buffer for the GIOChannel.

the status of the operation: One of %G_IO_STATUS_NORMAL, %G_IO_STATUS_AGAIN, or %G_IO_STATUS_ERROR.

a #GIOChannel

This function returns a #GIOCondition depending on whether there is data to be read/space to write data in the internal buffers in the #GIOChannel. Only the flags %G_IO_IN and %G_IO_OUT may be set.

A #GIOCondition

A #GIOChannel

Gets the buffer size.

the size of the buffer.

a #GIOChannel

Returns whether @channel is buffered.

%TRUE if the @channel is buffered.

a #GIOChannel

Returns whether the file/socket/whatever associated with @channel will be closed when @channel receives its final unref and is destroyed. The default value of this is %TRUE for channels created by g_io_channel_new_file (), and %FALSE for all other channels.

%TRUE if the channel will be closed, %FALSE otherwise.

a #GIOChannel.

Gets the encoding for the input/output of the channel. The internal encoding is always UTF-8. The encoding %NULL makes the channel safe for binary data.

A string containing the encoding, this string is owned by GLib and must not be freed.

a #GIOChannel

Gets the current flags for a #GIOChannel, including read-only flags such as %G_IO_FLAG_IS_READABLE. The values of the flags %G_IO_FLAG_IS_READABLE and %G_IO_FLAG_IS_WRITABLE are cached for internal use by the channel when it is created. If they should change at some later point (e.g. partial shutdown of a socket with the UNIX shutdown() function), the user should immediately call g_io_channel_get_flags() to update the internal values of these flags.

the flags which are set on the channel

a #GIOChannel

This returns the string that #GIOChannel uses to determine where in the file a line break occurs. A value of %NULL indicates autodetection.

The line termination string. This value is owned by GLib and must not be freed.

a #GIOChannel

a location to return the length of the line terminator

Initializes a #GIOChannel struct. This is called by each of the above functions when creating a #GIOChannel, and so is not often needed by the application programmer (unless you are creating a new type of #GIOChannel).

a #GIOChannel

Reads data from a #GIOChannel.

Use g_io_channel_read_chars() instead.

%G_IO_ERROR_NONE if the operation was successful.

a #GIOChannel

a buffer to read the data into (which should be at least count bytes long) the number of bytes to read from the #GIOChannel returns the number of bytes actually read

Replacement for g_io_channel_read() with the new API.

the status of the operation.

a #GIOChannel

a buffer to read data into the size of the buffer. Note that the buffer may not be completely filled even if there is data in the buffer if the remaining data is not a complete character. The number of bytes read. This may be zero even on success if count < 6 and the channel's encoding is non-%NULL. This indicates that the next UTF-8 character is too wide for the buffer.

Reads a line, including the terminating character(s), from a #GIOChannel into a newly-allocated string. @str_return will contain allocated memory if the return is %G_IO_STATUS_NORMAL.

the status of the operation.

a #GIOChannel

The line read from the #GIOChannel, including the line terminator. This data should be freed with g_free() when no longer needed. This is a nul-terminated string. If a @length of zero is returned, this will be %NULL instead. location to store length of the read data, or %NULL location to store position of line terminator, or %NULL

Reads a line from a #GIOChannel, using a #GString as a buffer.

the status of the operation.

a #GIOChannel

a #GString into which the line will be written. If @buffer already contains data, the old data will be overwritten. location to store position of line terminator, or %NULL

Reads all the remaining data from the file.

%G_IO_STATUS_NORMAL on success. This function never returns %G_IO_STATUS_EOF.

a #GIOChannel

Location to store a pointer to a string holding the remaining data in the #GIOChannel. This data should be freed with g_free() when no longer needed. This data is terminated by an extra nul character, but there may be other nuls in the intervening data. location to store length of the data

Reads a Unicode character from @channel. This function cannot be called on a channel with %NULL encoding.

a #GIOStatus

a #GIOChannel

a location to return a character

Increments the reference count of a #GIOChannel.

the @channel that was passed in (since 2.6)

a #GIOChannel

Sets the current position in the #GIOChannel, similar to the standard library function fseek().

Use g_io_channel_seek_position() instead.

%G_IO_ERROR_NONE if the operation was successful.

a #GIOChannel

an offset, in bytes, which is added to the position specified by @type the position in the file, which can be %G_SEEK_CUR (the current position), %G_SEEK_SET (the start of the file), or %G_SEEK_END (the end of the file)

Replacement for g_io_channel_seek() with the new API.

the status of the operation.

a #GIOChannel

The offset in bytes from the position specified by @type a #GSeekType. The type %G_SEEK_CUR is only allowed in those cases where a call to g_io_channel_set_encoding () is allowed. See the documentation for g_io_channel_set_encoding () for details.

Sets the buffer size.

a #GIOChannel

the size of the buffer, or 0 to let GLib pick a good size

The buffering state can only be set if the channel's encoding is %NULL. For any other encoding, the channel must be buffered. A buffered channel can only be set unbuffered if the channel's internal buffers have been flushed. Newly created channels or channels which have returned %G_IO_STATUS_EOF not require such a flush. For write-only channels, a call to g_io_channel_flush () is sufficient. For all other channels, the buffers may be flushed by a call to g_io_channel_seek_position (). This includes the possibility of seeking with seek type %G_SEEK_CUR and an offset of zero. Note that this means that socket-based channels cannot be set unbuffered once they have had data read from them. On unbuffered channels, it is safe to mix read and write calls from the new and old APIs, if this is necessary for maintaining old code. The default state of the channel is buffered.

a #GIOChannel

whether to set the channel buffered or unbuffered

Whether to close the channel on the final unref of the #GIOChannel data structure. The default value of this is %TRUE for channels created by g_io_channel_new_file (), and %FALSE for all other channels. Setting this flag to %TRUE for a channel you have already closed can cause problems when the final reference to the #GIOChannel is dropped.

a #GIOChannel

Whether to close the channel on the final unref of the GIOChannel data structure.

Sets the encoding for the input/output of the channel. The internal encoding is always UTF-8. The default encoding for the external file is UTF-8. The encoding %NULL is safe to use with binary data. The encoding can only be set if one of the following conditions is true: - The channel was just created, and has not been written to or read from yet. - The channel is write-only. - The channel is a file, and the file pointer was just repositioned by a call to g_io_channel_seek_position(). (This flushes all the internal buffers.) - The current encoding is %NULL or UTF-8. - One of the (new API) read functions has just returned %G_IO_STATUS_EOF (or, in the case of g_io_channel_read_to_end(), %G_IO_STATUS_NORMAL). - One of the functions g_io_channel_read_chars() or g_io_channel_read_unichar() has returned %G_IO_STATUS_AGAIN or %G_IO_STATUS_ERROR. This may be useful in the case of %G_CONVERT_ERROR_ILLEGAL_SEQUENCE. Returning one of these statuses from g_io_channel_read_line(), g_io_channel_read_line_string(), or g_io_channel_read_to_end() does not guarantee that the encoding can be changed. Channels which do not meet one of the above conditions cannot call g_io_channel_seek_position() with an offset of %G_SEEK_CUR, and, if they are "seekable", cannot call g_io_channel_write_chars() after calling one of the API "read" functions.

%G_IO_STATUS_NORMAL if the encoding was successfully set

a #GIOChannel

the encoding type

Sets the (writeable) flags in @channel to (@flags & %G_IO_FLAG_SET_MASK).

the status of the operation.

a #GIOChannel

the flags to set on the IO channel

This sets the string that #GIOChannel uses to determine where in the file a line break occurs.

a #GIOChannel

The line termination string. Use %NULL for autodetect. Autodetection breaks on "\n", "\r\n", "\r", "\0", and the Unicode paragraph separator. Autodetection should not be used for anything other than file-based channels. The length of the termination string. If -1 is passed, the string is assumed to be nul-terminated. This option allows termination strings with embedded nuls.

Close an IO channel. Any pending data to be written will be flushed if @flush is %TRUE. The channel will not be freed until the last reference is dropped using g_io_channel_unref().

the status of the operation.

a #GIOChannel

if %TRUE, flush pending

Returns the file descriptor of the #GIOChannel. On Windows this function returns the file descriptor or socket of the #GIOChannel.

the file descriptor of the #GIOChannel.

a #GIOChannel, created with g_io_channel_unix_new().

Decrements the reference count of a #GIOChannel.

a #GIOChannel

Writes data to a #GIOChannel.

Use g_io_channel_write_chars() instead.

%G_IO_ERROR_NONE if the operation was successful.

a #GIOChannel

the buffer containing the data to write the number of bytes to write the number of bytes actually written

Replacement for g_io_channel_write() with the new API. On seekable channels with encodings other than %NULL or UTF-8, generic mixing of reading and writing is not allowed. A call to g_io_channel_write_chars () may only be made on a channel from which data has been read in the cases described in the documentation for g_io_channel_set_encoding ().

the status of the operation.

a #GIOChannel

a buffer to write data from the size of the buffer. If -1, the buffer is taken to be a nul-terminated string. The number of bytes written. This can be nonzero even if the return value is not %G_IO_STATUS_NORMAL. If the return value is %G_IO_STATUS_NORMAL and the channel is blocking, this will always be equal to @count if @count >= 0.

Writes a Unicode character to @channel. This function cannot be called on a channel with %NULL encoding.

a #GIOStatus

a #GIOChannel

a character

Converts an `errno` error number to a #GIOChannelError.

a #GIOChannelError error number, e.g. %G_IO_CHANNEL_ERROR_INVAL.

an `errno` error number, e.g. `EINVAL`

Error codes returned by #GIOChannel operations.

File too large. Invalid argument. IO error. File is a directory. No space left on device. No such device or address. Value too large for defined datatype. Broken pipe. Some other error.

A bitwise combination representing a condition to watch for on an event source. There is data to read. Data can be written (without blocking). There is urgent data to read. Error condition. Hung up (the connection has been broken, usually for pipes and sockets). Invalid request. The file descriptor is not open. #GIOError is only used by the deprecated functions g_io_channel_read(), g_io_channel_write(), and g_io_channel_seek().

no error an EAGAIN error occurred an EINVAL error occurred another error occurred

Specifies properties of a #GIOChannel. Some of the flags can only be read with g_io_channel_get_flags(), but not changed with g_io_channel_set_flags().

no special flags set. Since: 2.74 turns on append mode, corresponds to %O_APPEND (see the documentation of the UNIX open() syscall) turns on nonblocking mode, corresponds to %O_NONBLOCK/%O_NDELAY (see the documentation of the UNIX open() syscall) indicates that the io channel is readable. This flag cannot be changed. indicates that the io channel is writable. This flag cannot be changed. a misspelled version of @G_IO_FLAG_IS_WRITABLE that existed before the spelling was fixed in GLib 2.30. It is kept here for compatibility reasons. Deprecated since 2.30 indicates that the io channel is seekable, i.e. that g_io_channel_seek_position() can be used on it. This flag cannot be changed. the mask that specifies all the valid flags. the mask of the flags that are returned from g_io_channel_get_flags() the mask of the flags that the user can modify with g_io_channel_set_flags()

Specifies the type of function passed to g_io_add_watch() or g_io_add_watch_full(), which is called when the requested condition on a #GIOChannel is satisfied.

the function should return %FALSE if the event source should be removed

the #GIOChannel event source the condition which has been satisfied user data set in g_io_add_watch() or g_io_add_watch_full()

A table of functions used to handle different types of #GIOChannel in a generic way.

Statuses returned by most of the #GIOFuncs functions.

An error occurred. Success. End of file. Resource temporarily unavailable.

Checks whether a character is a directory separator. It returns %TRUE for '/' on UNIX machines and for '\' or '/' under Windows.

a character

The name of the main group of a desktop entry file, as defined in the [Desktop Entry Specification](http://freedesktop.org/Standards/desktop-entry-spec). Consult the specification for more details about the meanings of the keys below.

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string list giving the available application actions.

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a list of strings giving the categories in which the desktop entry should be shown in a menu.

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a localized string giving the tooltip for the desktop entry.

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean set to true if the application is D-Bus activatable.

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string giving the command line to execute. It is only valid for desktop entries with the `Application` type.

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a localized string giving the generic name of the desktop entry.

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean stating whether the desktop entry has been deleted by the user.

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a localized string giving the name of the icon to be displayed for the desktop entry.

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a list of strings giving the MIME types supported by this desktop entry.

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a localized string giving the specific name of the desktop entry.

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a list of strings identifying the environments that should not display the desktop entry.

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean stating whether the desktop entry should be shown in menus.

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a list of strings identifying the environments that should display the desktop entry.

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string containing the working directory to run the program in. It is only valid for desktop entries with the `Application` type.

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean stating whether the application supports the [Startup Notification Protocol Specification](http://www.freedesktop.org/Standards/startup-notification-spec).

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is string identifying the WM class or name hint of a window that the application will create, which can be used to emulate Startup Notification with older applications.

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean stating whether the program should be run in a terminal window. It is only valid for desktop entries with the `Application` type.

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string giving the file name of a binary on disk used to determine if the program is actually installed. It is only valid for desktop entries with the `Application` type.

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string giving the type of the desktop entry. Usually %G_KEY_FILE_DESKTOP_TYPE_APPLICATION, %G_KEY_FILE_DESKTOP_TYPE_LINK, or %G_KEY_FILE_DESKTOP_TYPE_DIRECTORY.

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string giving the URL to access. It is only valid for desktop entries with the `Link` type.

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string giving the version of the Desktop Entry Specification used for the desktop entry file.

The value of the %G_KEY_FILE_DESKTOP_KEY_TYPE, key for desktop entries representing applications.

The value of the %G_KEY_FILE_DESKTOP_KEY_TYPE, key for desktop entries representing directories.

The value of the %G_KEY_FILE_DESKTOP_KEY_TYPE, key for desktop entries representing links to documents.

The GKeyFile struct contains only private data and should not be accessed directly.

Creates a new empty #GKeyFile object. Use g_key_file_load_from_file(), g_key_file_load_from_data(), g_key_file_load_from_dirs() or g_key_file_load_from_data_dirs() to read an existing key file.

an empty #GKeyFile.

Clears all keys and groups from @key_file, and decreases the reference count by 1. If the reference count reaches zero, frees the key file and all its allocated memory.

a #GKeyFile

Returns the value associated with @key under @group_name as a boolean. If @key cannot be found then %FALSE is returned and @error is set to %G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the value associated with @key cannot be interpreted as a boolean then %FALSE is returned and @error is set to %G_KEY_FILE_ERROR_INVALID_VALUE.

the value associated with the key as a boolean, or %FALSE if the key was not found or could not be parsed.

a #GKeyFile

a group name a key

Returns the values associated with @key under @group_name as booleans. If @key cannot be found then %NULL is returned and @error is set to %G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the values associated with @key cannot be interpreted as booleans then %NULL is returned and @error is set to %G_KEY_FILE_ERROR_INVALID_VALUE.

the values associated with the key as a list of booleans, or %NULL if the key was not found or could not be parsed. The returned list of booleans should be freed with g_free() when no longer needed.

a #GKeyFile

a group name a key the number of booleans returned

Retrieves a comment above @key from @group_name. If @key is %NULL then @comment will be read from above @group_name. If both @key and @group_name are %NULL, then @comment will be read from above the first group in the file. Note that the returned string does not include the '#' comment markers, but does include any whitespace after them (on each line). It includes the line breaks between lines, but does not include the final line break.

a comment that should be freed with g_free()

a #GKeyFile

a group name, or %NULL a key

Returns the value associated with @key under @group_name as a double. If @group_name is %NULL, the start_group is used. If @key cannot be found then 0.0 is returned and @error is set to %G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the value associated with @key cannot be interpreted as a double then 0.0 is returned and @error is set to %G_KEY_FILE_ERROR_INVALID_VALUE.

the value associated with the key as a double, or 0.0 if the key was not found or could not be parsed.

a #GKeyFile

a group name a key

Returns the values associated with @key under @group_name as doubles. If @key cannot be found then %NULL is returned and @error is set to %G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the values associated with @key cannot be interpreted as doubles then %NULL is returned and @error is set to %G_KEY_FILE_ERROR_INVALID_VALUE.

the values associated with the key as a list of doubles, or %NULL if the key was not found or could not be parsed. The returned list of doubles should be freed with g_free() when no longer needed.

a #GKeyFile

a group name a key the number of doubles returned

Returns all groups in the key file loaded with @key_file. The array of returned groups will be %NULL-terminated, so @length may optionally be %NULL.

a newly-allocated %NULL-terminated array of strings. Use g_strfreev() to free it.

a #GKeyFile

return location for the number of returned groups, or %NULL

Returns the value associated with @key under @group_name as a signed 64-bit integer. This is similar to g_key_file_get_integer() but can return 64-bit results without truncation.

the value associated with the key as a signed 64-bit integer, or 0 if the key was not found or could not be parsed.

a non-%NULL #GKeyFile

a non-%NULL group name a non-%NULL key

Returns the value associated with @key under @group_name as an integer. If @key cannot be found then 0 is returned and @error is set to %G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the value associated with @key cannot be interpreted as an integer, or is out of range for a #gint, then 0 is returned and @error is set to %G_KEY_FILE_ERROR_INVALID_VALUE.

the value associated with the key as an integer, or 0 if the key was not found or could not be parsed.

a #GKeyFile

a group name a key

Returns the values associated with @key under @group_name as integers. If @key cannot be found then %NULL is returned and @error is set to %G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the values associated with @key cannot be interpreted as integers, or are out of range for #gint, then %NULL is returned and @error is set to %G_KEY_FILE_ERROR_INVALID_VALUE.

the values associated with the key as a list of integers, or %NULL if the key was not found or could not be parsed. The returned list of integers should be freed with g_free() when no longer needed.

a #GKeyFile

a group name a key the number of integers returned

Returns all keys for the group name @group_name. The array of returned keys will be %NULL-terminated, so @length may optionally be %NULL. In the event that the @group_name cannot be found, %NULL is returned and @error is set to %G_KEY_FILE_ERROR_GROUP_NOT_FOUND.

a newly-allocated %NULL-terminated array of strings. Use g_strfreev() to free it.

a #GKeyFile

a group name return location for the number of keys returned, or %NULL

Returns the actual locale which the result of g_key_file_get_locale_string() or g_key_file_get_locale_string_list() came from. If calling g_key_file_get_locale_string() or g_key_file_get_locale_string_list() with exactly the same @key_file, @group_name, @key and @locale, the result of those functions will have originally been tagged with the locale that is the result of this function.

the locale from the file, or %NULL if the key was not found or the entry in the file was was untranslated

a #GKeyFile

a group name a key a locale identifier or %NULL

Returns the value associated with @key under @group_name translated in the given @locale if available. If @locale is %NULL then the current locale is assumed. If @locale is to be non-%NULL, or if the current locale will change over the lifetime of the #GKeyFile, it must be loaded with %G_KEY_FILE_KEEP_TRANSLATIONS in order to load strings for all locales. If @key cannot be found then %NULL is returned and @error is set to %G_KEY_FILE_ERROR_KEY_NOT_FOUND. If the value associated with @key cannot be interpreted or no suitable translation can be found then the untranslated value is returned.

a newly allocated string or %NULL if the specified key cannot be found.

a #GKeyFile

a group name a key a locale identifier or %NULL

Returns the values associated with @key under @group_name translated in the given @locale if available. If @locale is %NULL then the current locale is assumed. If @locale is to be non-%NULL, or if the current locale will change over the lifetime of the #GKeyFile, it must be loaded with %G_KEY_FILE_KEEP_TRANSLATIONS in order to load strings for all locales. If @key cannot be found then %NULL is returned and @error is set to %G_KEY_FILE_ERROR_KEY_NOT_FOUND. If the values associated with @key cannot be interpreted or no suitable translations can be found then the untranslated values are returned. The returned array is %NULL-terminated, so @length may optionally be %NULL.

a newly allocated %NULL-terminated string array or %NULL if the key isn't found. The string array should be freed with g_strfreev().

a #GKeyFile

a group name a key a locale identifier or %NULL return location for the number of returned strings or %NULL

Returns the name of the start group of the file.

The start group of the key file.

a #GKeyFile

Returns the string value associated with @key under @group_name. Unlike g_key_file_get_value(), this function handles escape sequences like \s. In the event the key cannot be found, %NULL is returned and @error is set to %G_KEY_FILE_ERROR_KEY_NOT_FOUND. In the event that the @group_name cannot be found, %NULL is returned and @error is set to %G_KEY_FILE_ERROR_GROUP_NOT_FOUND.

a newly allocated string or %NULL if the specified key cannot be found.

a #GKeyFile

a group name a key

Returns the values associated with @key under @group_name. In the event the key cannot be found, %NULL is returned and @error is set to %G_KEY_FILE_ERROR_KEY_NOT_FOUND. In the event that the @group_name cannot be found, %NULL is returned and @error is set to %G_KEY_FILE_ERROR_GROUP_NOT_FOUND.

a %NULL-terminated string array or %NULL if the specified key cannot be found. The array should be freed with g_strfreev().

a #GKeyFile

a group name a key return location for the number of returned strings, or %NULL

Returns the value associated with @key under @group_name as an unsigned 64-bit integer. This is similar to g_key_file_get_integer() but can return large positive results without truncation.

the value associated with the key as an unsigned 64-bit integer, or 0 if the key was not found or could not be parsed.

a non-%NULL #GKeyFile

a non-%NULL group name a non-%NULL key

Returns the raw value associated with @key under @group_name. Use g_key_file_get_string() to retrieve an unescaped UTF-8 string. In the event the key cannot be found, %NULL is returned and @error is set to %G_KEY_FILE_ERROR_KEY_NOT_FOUND. In the event that the @group_name cannot be found, %NULL is returned and @error is set to %G_KEY_FILE_ERROR_GROUP_NOT_FOUND.

a newly allocated string or %NULL if the specified key cannot be found.

a #GKeyFile

a group name a key

Looks whether the key file has the group @group_name.

%TRUE if @group_name is a part of @key_file, %FALSE otherwise.

a #GKeyFile

a group name

Looks whether the key file has the key @key in the group @group_name. Note that this function does not follow the rules for #GError strictly; the return value both carries meaning and signals an error. To use this function, you must pass a #GError pointer in @error, and check whether it is not %NULL to see if an error occurred. Language bindings should use g_key_file_get_value() to test whether or not a key exists.

%TRUE if @key is a part of @group_name, %FALSE otherwise

a #GKeyFile

a group name a key name

Loads a key file from the data in @bytes into an empty #GKeyFile structure. If the object cannot be created then %error is set to a #GKeyFileError.

%TRUE if a key file could be loaded, %FALSE otherwise

an empty #GKeyFile struct

a #GBytes flags from #GKeyFileFlags

Loads a key file from memory into an empty #GKeyFile structure. If the object cannot be created then %error is set to a #GKeyFileError.

%TRUE if a key file could be loaded, %FALSE otherwise

an empty #GKeyFile struct

key file loaded in memory the length of @data in bytes (or (gsize)-1 if data is nul-terminated) flags from #GKeyFileFlags

This function looks for a key file named @file in the paths returned from g_get_user_data_dir() and g_get_system_data_dirs(), loads the file into @key_file and returns the file's full path in @full_path. If the file could not be loaded then an %error is set to either a #GFileError or #GKeyFileError.

%TRUE if a key file could be loaded, %FALSE otherwise

an empty #GKeyFile struct

a relative path to a filename to open and parse return location for a string containing the full path of the file, or %NULL flags from #GKeyFileFlags

This function looks for a key file named @file in the paths specified in @search_dirs, loads the file into @key_file and returns the file's full path in @full_path. If the file could not be found in any of the @search_dirs, %G_KEY_FILE_ERROR_NOT_FOUND is returned. If the file is found but the OS returns an error when opening or reading the file, a %G_FILE_ERROR is returned. If there is a problem parsing the file, a %G_KEY_FILE_ERROR is returned.

%TRUE if a key file could be loaded, %FALSE otherwise

an empty #GKeyFile struct

a relative path to a filename to open and parse %NULL-terminated array of directories to search return location for a string containing the full path of the file, or %NULL flags from #GKeyFileFlags

Loads a key file into an empty #GKeyFile structure. If the OS returns an error when opening or reading the file, a %G_FILE_ERROR is returned. If there is a problem parsing the file, a %G_KEY_FILE_ERROR is returned. This function will never return a %G_KEY_FILE_ERROR_NOT_FOUND error. If the @file is not found, %G_FILE_ERROR_NOENT is returned.

%TRUE if a key file could be loaded, %FALSE otherwise

an empty #GKeyFile struct

the path of a filename to load, in the GLib filename encoding flags from #GKeyFileFlags

Increases the reference count of @key_file.

the same @key_file.

a #GKeyFile

Removes a comment above @key from @group_name. If @key is %NULL then @comment will be removed above @group_name. If both @key and @group_name are %NULL, then @comment will be removed above the first group in the file.

%TRUE if the comment was removed, %FALSE otherwise

a #GKeyFile

a group name, or %NULL a key

Removes the specified group, @group_name, from the key file.

%TRUE if the group was removed, %FALSE otherwise

a #GKeyFile

a group name

Removes @key in @group_name from the key file.

%TRUE if the key was removed, %FALSE otherwise

a #GKeyFile

a group name a key name to remove

Writes the contents of @key_file to @filename using g_file_set_contents(). If you need stricter guarantees about durability of the written file than are provided by g_file_set_contents(), use g_file_set_contents_full() with the return value of g_key_file_to_data(). This function can fail for any of the reasons that g_file_set_contents() may fail.

%TRUE if successful, else %FALSE with @error set

a #GKeyFile

the name of the file to write to

Associates a new boolean value with @key under @group_name. If @key cannot be found then it is created.

a #GKeyFile

a group name a key %TRUE or %FALSE

Associates a list of boolean values with @key under @group_name. If @key cannot be found then it is created. If @group_name is %NULL, the start_group is used.

a #GKeyFile

a group name a key an array of boolean values length of @list

Places a comment above @key from @group_name. If @key is %NULL then @comment will be written above @group_name. If both @key and @group_name are %NULL, then @comment will be written above the first group in the file. Note that this function prepends a '#' comment marker to each line of @comment.

%TRUE if the comment was written, %FALSE otherwise

a #GKeyFile

a group name, or %NULL a key a comment

Associates a new double value with @key under @group_name. If @key cannot be found then it is created.

a #GKeyFile

a group name a key a double value

Associates a list of double values with @key under @group_name. If @key cannot be found then it is created.

a #GKeyFile

a group name a key an array of double values number of double values in @list

Associates a new integer value with @key under @group_name. If @key cannot be found then it is created.

a #GKeyFile

a group name a key an integer value

Associates a new integer value with @key under @group_name. If @key cannot be found then it is created.

a #GKeyFile

a group name a key an integer value

Associates a list of integer values with @key under @group_name. If @key cannot be found then it is created.

a #GKeyFile

a group name a key an array of integer values number of integer values in @list

Sets the character which is used to separate values in lists. Typically ';' or ',' are used as separators. The default list separator is ';'.

a #GKeyFile

the separator

Associates a string value for @key and @locale under @group_name. If the translation for @key cannot be found then it is created.

a #GKeyFile

a group name a key a locale identifier a string

Associates a list of string values for @key and @locale under @group_name. If the translation for @key cannot be found then it is created.

a #GKeyFile

a group name a key a locale identifier a %NULL-terminated array of locale string values the length of @list

Associates a new string value with @key under @group_name. If @key cannot be found then it is created. If @group_name cannot be found then it is created. Unlike g_key_file_set_value(), this function handles characters that need escaping, such as newlines.

a #GKeyFile

a group name a key a string

Associates a list of string values for @key under @group_name. If @key cannot be found then it is created. If @group_name cannot be found then it is created.

a #GKeyFile

a group name a key an array of string values number of string values in @list

Associates a new integer value with @key under @group_name. If @key cannot be found then it is created.

a #GKeyFile

a group name a key an integer value

Associates a new value with @key under @group_name. If @key cannot be found then it is created. If @group_name cannot be found then it is created. To set an UTF-8 string which may contain characters that need escaping (such as newlines or spaces), use g_key_file_set_string().

a #GKeyFile

a group name a key a string

This function outputs @key_file as a string. Note that this function never reports an error, so it is safe to pass %NULL as @error.

a newly allocated string holding the contents of the #GKeyFile

a #GKeyFile

return location for the length of the returned string, or %NULL

Decreases the reference count of @key_file by 1. If the reference count reaches zero, frees the key file and all its allocated memory.

a #GKeyFile

Error codes returned by key file parsing.

the text being parsed was in an unknown encoding document was ill-formed the file was not found a requested key was not found a requested group was not found a value could not be parsed

Flags which influence the parsing.

No flags, default behaviour Use this flag if you plan to write the (possibly modified) contents of the key file back to a file; otherwise all comments will be lost when the key file is written back. Use this flag if you plan to write the (possibly modified) contents of the key file back to a file; otherwise only the translations for the current language will be written back.

Hints the compiler that the expression is likely to evaluate to a true value. The compiler may use this information for optimizations. |[ if (G_LIKELY (random () != 1)) g_print ("not one"); ]|

the expression

Specifies one of the possible types of byte order. See %G_BYTE_ORDER.

The natural logarithm of 10.

The natural logarithm of 2.

Works like g_mutex_lock(), but for a lock defined with %G_LOCK_DEFINE.

the name of the lock

The `G_LOCK_` macros provide a convenient interface to #GMutex. %G_LOCK_DEFINE defines a lock. It can appear in any place where variable definitions may appear in programs, i.e. in the first block of a function or outside of functions. The @name parameter will be mangled to get the name of the #GMutex. This means that you can use names of existing variables as the parameter - e.g. the name of the variable you intend to protect with the lock. Look at our give_me_next_number() example using the `G_LOCK` macros: Here is an example for using the `G_LOCK` convenience macros: |[ G_LOCK_DEFINE (current_number); int give_me_next_number (void) { static int current_number = 0; int ret_val; G_LOCK (current_number); ret_val = current_number = calc_next_number (current_number); G_UNLOCK (current_number); return ret_val; } ]|

the name of the lock

This works like %G_LOCK_DEFINE, but it creates a static object.

the name of the lock

This declares a lock, that is defined with %G_LOCK_DEFINE in another module.

the name of the lock

Multiplying the base 2 exponent by this number yields the base 10 exponent.

Defines the log domain. See [Log Domains](#log-domains). Libraries should define this so that any messages which they log can be differentiated from messages from other libraries and application code. But be careful not to define it in any public header files. Log domains must be unique, and it is recommended that they are the application or library name, optionally followed by a hyphen and a sub-domain name. For example, `bloatpad` or `bloatpad-io`. If undefined, it defaults to the default %NULL (or `""`) log domain; this is not advisable, as it cannot be filtered against using the `G_MESSAGES_DEBUG` environment variable. For example, GTK+ uses this in its `Makefile.am`: |[ AM_CPPFLAGS = -DG_LOG_DOMAIN=\"Gtk\" ]| Applications can choose to leave it as the default %NULL (or `""`) domain. However, defining the domain offers the same advantages as above.

GLib log levels that are considered fatal by default. This is not used if structured logging is enabled; see [Using Structured Logging][using-structured-logging].

Log levels below 1<<G_LOG_LEVEL_USER_SHIFT are used by GLib. Higher bits can be used for user-defined log levels.

The #GList struct is used for each element in a doubly-linked list.

holds the element's data, which can be a pointer to any kind of data, or any integer value using the [Type Conversion Macros][glib-Type-Conversion-Macros] contains the link to the next element in the list contains the link to the previous element in the list Allocates space for one #GList element. It is called by g_list_append(), g_list_prepend(), g_list_insert() and g_list_insert_sorted() and so is rarely used on its own.

a pointer to the newly-allocated #GList element

Adds a new element on to the end of the list. Note that the return value is the new start of the list, if @list was empty; make sure you store the new value. g_list_append() has to traverse the entire list to find the end, which is inefficient when adding multiple elements. A common idiom to avoid the inefficiency is to use g_list_prepend() and reverse the list with g_list_reverse() when all elements have been added. |[ // Notice that these are initialized to the empty list. GList *string_list = NULL, *number_list = NULL; // This is a list of strings. string_list = g_list_append (string_list, "first"); string_list = g_list_append (string_list, "second"); // This is a list of integers. number_list = g_list_append (number_list, GINT_TO_POINTER (27)); number_list = g_list_append (number_list, GINT_TO_POINTER (14)); ]|

either @list or the new start of the #GList if @list was %NULL

a pointer to a #GList the data for the new element

Adds the second #GList onto the end of the first #GList. Note that the elements of the second #GList are not copied. They are used directly. This function is for example used to move an element in the list. The following example moves an element to the top of the list: |[ list = g_list_remove_link (list, llink); list = g_list_concat (llink, list); ]|

the start of the new #GList, which equals @list1 if not %NULL

a #GList, this must point to the top of the list the #GList to add to the end of the first #GList, this must point to the top of the list

Copies a #GList. Note that this is a "shallow" copy. If the list elements consist of pointers to data, the pointers are copied but the actual data is not. See g_list_copy_deep() if you need to copy the data as well.

the start of the new list that holds the same data as @list

a #GList, this must point to the top of the list

Makes a full (deep) copy of a #GList. In contrast with g_list_copy(), this function uses @func to make a copy of each list element, in addition to copying the list container itself. @func, as a #GCopyFunc, takes two arguments, the data to be copied and a @user_data pointer. On common processor architectures, it's safe to pass %NULL as @user_data if the copy function takes only one argument. You may get compiler warnings from this though if compiling with GCC’s `-Wcast-function-type` warning. For instance, if @list holds a list of GObjects, you can do: |[ another_list = g_list_copy_deep (list, (GCopyFunc) g_object_ref, NULL); ]| And, to entirely free the new list, you could do: |[ g_list_free_full (another_list, g_object_unref); ]|

the start of the new list that holds a full copy of @list, use g_list_free_full() to free it

a #GList, this must point to the top of the list a copy function used to copy every element in the list user data passed to the copy function @func, or %NULL

Removes the node link_ from the list and frees it. Compare this to g_list_remove_link() which removes the node without freeing it.

the (possibly changed) start of the #GList

a #GList, this must point to the top of the list node to delete from @list

Finds the element in a #GList which contains the given data.

the found #GList element, or %NULL if it is not found

a #GList, this must point to the top of the list the element data to find

Finds an element in a #GList, using a supplied function to find the desired element. It iterates over the list, calling the given function which should return 0 when the desired element is found. The function takes two #gconstpointer arguments, the #GList element's data as the first argument and the given user data.

the found #GList element, or %NULL if it is not found

a #GList, this must point to the top of the list user data passed to the function the function to call for each element. It should return 0 when the desired element is found

Gets the first element in a #GList.

the first element in the #GList, or %NULL if the #GList has no elements

any #GList element

Calls a function for each element of a #GList. It is safe for @func to remove the element from @list, but it must not modify any part of the list after that element.

a #GList, this must point to the top of the list the function to call with each element's data user data to pass to the function

Frees all of the memory used by a #GList. The freed elements are returned to the slice allocator. If list elements contain dynamically-allocated memory, you should either use g_list_free_full() or free them manually first. It can be combined with g_steal_pointer() to ensure the list head pointer is not left dangling: |[ GList *list_of_borrowed_things = …; /* (transfer container) */ g_list_free (g_steal_pointer (&list_of_borrowed_things)); ]|

the first link of a #GList

Frees one #GList element, but does not update links from the next and previous elements in the list, so you should not call this function on an element that is currently part of a list. It is usually used after g_list_remove_link().

a #GList element

Convenience method, which frees all the memory used by a #GList, and calls @free_func on every element's data. @free_func must not modify the list (eg, by removing the freed element from it). It can be combined with g_steal_pointer() to ensure the list head pointer is not left dangling — this also has the nice property that the head pointer is cleared before any of the list elements are freed, to prevent double frees from @free_func: |[ GList *list_of_owned_things = …; /* (transfer full) (element-type GObject) */ g_list_free_full (g_steal_pointer (&list_of_owned_things), g_object_unref); ]|

the first link of a #GList the function to be called to free each element's data

Gets the position of the element containing the given data (starting from 0).

the index of the element containing the data, or -1 if the data is not found

a #GList, this must point to the top of the list the data to find

Inserts a new element into the list at the given position.

the (possibly changed) start of the #GList

a pointer to a #GList, this must point to the top of the list the data for the new element the position to insert the element. If this is negative, or is larger than the number of elements in the list, the new element is added on to the end of the list.

Inserts a new element into the list before the given position.

the (possibly changed) start of the #GList

a pointer to a #GList, this must point to the top of the list the list element before which the new element is inserted or %NULL to insert at the end of the list the data for the new element

Inserts @link_ into the list before the given position.

the (possibly changed) start of the #GList

a pointer to a #GList, this must point to the top of the list the list element before which the new element is inserted or %NULL to insert at the end of the list the list element to be added, which must not be part of any other list

Inserts a new element into the list, using the given comparison function to determine its position. If you are adding many new elements to a list, and the number of new elements is much larger than the length of the list, use g_list_prepend() to add the new items and sort the list afterwards with g_list_sort().

the (possibly changed) start of the #GList

a pointer to a #GList, this must point to the top of the already sorted list the data for the new element the function to compare elements in the list. It should return a number > 0 if the first parameter comes after the second parameter in the sort order.

the (possibly changed) start of the #GList

Gets the last element in a #GList.

the last element in the #GList, or %NULL if the #GList has no elements

any #GList element

Gets the number of elements in a #GList. This function iterates over the whole list to count its elements. Use a #GQueue instead of a GList if you regularly need the number of items. To check whether the list is non-empty, it is faster to check @list against %NULL.

the number of elements in the #GList

a #GList, this must point to the top of the list

Gets the element at the given position in a #GList. This iterates over the list until it reaches the @n-th position. If you intend to iterate over every element, it is better to use a for-loop as described in the #GList introduction.

the element, or %NULL if the position is off the end of the #GList

a #GList, this must point to the top of the list the position of the element, counting from 0

Gets the data of the element at the given position. This iterates over the list until it reaches the @n-th position. If you intend to iterate over every element, it is better to use a for-loop as described in the #GList introduction.

the element's data, or %NULL if the position is off the end of the #GList

a #GList, this must point to the top of the list the position of the element

Gets the element @n places before @list.

the element, or %NULL if the position is off the end of the #GList

a #GList the position of the element, counting from 0

Gets the position of the given element in the #GList (starting from 0).

the position of the element in the #GList, or -1 if the element is not found

a #GList, this must point to the top of the list an element in the #GList

Prepends a new element on to the start of the list. Note that the return value is the new start of the list, which will have changed, so make sure you store the new value. |[ // Notice that it is initialized to the empty list. GList *list = NULL; list = g_list_prepend (list, "last"); list = g_list_prepend (list, "first"); ]| Do not use this function to prepend a new element to a different element than the start of the list. Use g_list_insert_before() instead.

a pointer to the newly prepended element, which is the new start of the #GList

a pointer to a #GList, this must point to the top of the list the data for the new element

Removes an element from a #GList. If two elements contain the same data, only the first is removed. If none of the elements contain the data, the #GList is unchanged.

the (possibly changed) start of the #GList

a #GList, this must point to the top of the list the data of the element to remove

Removes all list nodes with data equal to @data. Returns the new head of the list. Contrast with g_list_remove() which removes only the first node matching the given data.

the (possibly changed) start of the #GList

a #GList, this must point to the top of the list data to remove

Removes an element from a #GList, without freeing the element. The removed element's prev and next links are set to %NULL, so that it becomes a self-contained list with one element. This function is for example used to move an element in the list (see the example for g_list_concat()) or to remove an element in the list before freeing its data: |[ list = g_list_remove_link (list, llink); free_some_data_that_may_access_the_list_again (llink->data); g_list_free (llink); ]|

the (possibly changed) start of the #GList

a #GList, this must point to the top of the list an element in the #GList

Reverses a #GList. It simply switches the next and prev pointers of each element.

the start of the reversed #GList

a #GList, this must point to the top of the list

Sorts a #GList using the given comparison function. The algorithm used is a stable sort.

the (possibly changed) start of the #GList

a #GList, this must point to the top of the list the comparison function used to sort the #GList. This function is passed the data from 2 elements of the #GList and should return 0 if they are equal, a negative value if the first element comes before the second, or a positive value if the first element comes after the second.

Like g_list_sort(), but the comparison function accepts a user data argument.

the (possibly changed) start of the #GList

a #GList, this must point to the top of the list comparison function user data to pass to comparison function

Structure representing a single field in a structured log entry. See g_log_structured() for details. Log fields may contain arbitrary values, including binary with embedded nul bytes. If the field contains a string, the string must be UTF-8 encoded and have a trailing nul byte. Otherwise, @length must be set to a non-negative value.

field name (UTF-8 string) field value (arbitrary bytes) length of @value, in bytes, or -1 if it is nul-terminated

Specifies the prototype of log handler functions. The default log handler, g_log_default_handler(), automatically appends a new-line character to @message when printing it. It is advised that any custom log handler functions behave similarly, so that logging calls in user code do not need modifying to add a new-line character to the message if the log handler is changed. This is not used if structured logging is enabled; see [Using Structured Logging][using-structured-logging].

the log domain of the message the log level of the message (including the fatal and recursion flags) the message to process user data, set in g_log_set_handler()

Flags specifying the level of log messages. It is possible to change how GLib treats messages of the various levels using g_log_set_handler() and g_log_set_fatal_mask().

internal flag internal flag log level for errors, see g_error(). This level is also used for messages produced by g_assert(). log level for critical warning messages, see g_critical(). This level is also used for messages produced by g_return_if_fail() and g_return_val_if_fail(). log level for warnings, see g_warning() log level for messages, see g_message() log level for informational messages, see g_info() log level for debug messages, see g_debug() a mask including all log levels

Writer function for log entries. A log entry is a collection of one or more #GLogFields, using the standard [field names from journal specification](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html). See g_log_structured() for more information. Writer functions must ignore fields which they do not recognise, unless they can write arbitrary binary output, as field values may be arbitrary binary. @log_level is guaranteed to be included in @fields as the `PRIORITY` field, but is provided separately for convenience of deciding whether or where to output the log entry. Writer functions should return %G_LOG_WRITER_HANDLED if they handled the log message successfully or if they deliberately ignored it. If there was an error handling the message (for example, if the writer function is meant to send messages to a remote logging server and there is a network error), it should return %G_LOG_WRITER_UNHANDLED. This allows writer functions to be chained and fall back to simpler handlers in case of failure.

%G_LOG_WRITER_HANDLED if the log entry was handled successfully; %G_LOG_WRITER_UNHANDLED otherwise

log level of the message fields forming the message number of @fields user data passed to g_log_set_writer_func()

Return values from #GLogWriterFuncs to indicate whether the given log entry was successfully handled by the writer, or whether there was an error in handling it (and hence a fallback writer should be used). If a #GLogWriterFunc ignores a log entry, it should return %G_LOG_WRITER_HANDLED.

Log writer has handled the log entry. Log writer could not handle the log entry.

The major version number of the GLib library. Like #glib_major_version, but from the headers used at application compile time, rather than from the library linked against at application run time.

The maximum value which can be held in a #gint16. This is the same as standard C `INT16_MAX`, which should be preferred in new code.

The maximum value which can be held in a #gint32. This is the same as standard C `INT32_MAX`, which should be preferred in new code.

The maximum value which can be held in a #gint64.

The maximum value which can be held in a #gint8. This is the same as standard C `INT8_MAX`, which should be preferred in new code.

The maximum value which can be held in a #guint16. This is the same as standard C `UINT16_MAX`, which should be preferred in new code.

The maximum value which can be held in a #guint32. This is the same as standard C `UINT32_MAX`, which should be preferred in new code.

The maximum value which can be held in a #guint64. This is the same as standard C `UINT64_MAX`, which should be preferred in new code.

The maximum value which can be held in a #guint8. This is the same as standard C `UINT8_MAX`, which should be preferred in new code.

The micro version number of the GLib library. Like #gtk_micro_version, but from the headers used at application compile time, rather than from the library linked against at application run time.

The minimum value which can be held in a #gint16.

The minimum value which can be held in a #gint32.

The minimum value which can be held in a #gint64.

The minimum value which can be held in a #gint8.

The minor version number of the GLib library. Like #gtk_minor_version, but from the headers used at application compile time, rather than from the library linked against at application run time.

The `GMainContext` struct is an opaque data type representing a set of sources to be handled in a main loop.

Creates a new #GMainContext structure.

the new #GMainContext

Creates a new #GMainContext structure.

the new #GMainContext

a bitwise-OR combination of #GMainContextFlags flags that can only be set at creation time.

Tries to become the owner of the specified context. If some other thread is the owner of the context, returns %FALSE immediately. Ownership is properly recursive: the owner can require ownership again and will release ownership when g_main_context_release() is called as many times as g_main_context_acquire(). You must be the owner of a context before you can call g_main_context_prepare(), g_main_context_query(), g_main_context_check(), g_main_context_dispatch().

%TRUE if the operation succeeded, and this thread is now the owner of @context.

a #GMainContext

Adds a file descriptor to the set of file descriptors polled for this context. This will very seldom be used directly. Instead a typical event source will use g_source_add_unix_fd() instead.

a #GMainContext (or %NULL for the default context)

a #GPollFD structure holding information about a file descriptor to watch. the priority for this file descriptor which should be the same as the priority used for g_source_attach() to ensure that the file descriptor is polled whenever the results may be needed.

Passes the results of polling back to the main loop. You should be careful to pass @fds and its length @n_fds as received from g_main_context_query(), as this functions relies on assumptions on how @fds is filled. You must have successfully acquired the context with g_main_context_acquire() before you may call this function.

%TRUE if some sources are ready to be dispatched.

a #GMainContext

the maximum numerical priority of sources to check array of #GPollFD's that was passed to the last call to g_main_context_query() return value of g_main_context_query()

Dispatches all pending sources. You must have successfully acquired the context with g_main_context_acquire() before you may call this function.

a #GMainContext

Finds a source with the given source functions and user data. If multiple sources exist with the same source function and user data, the first one found will be returned.

the source, if one was found, otherwise %NULL

a #GMainContext (if %NULL, the default context will be used).

the @source_funcs passed to g_source_new(). the user data from the callback.

Finds a #GSource given a pair of context and ID. It is a programmer error to attempt to look up a non-existent source. More specifically: source IDs can be reissued after a source has been destroyed and therefore it is never valid to use this function with a source ID which may have already been removed. An example is when scheduling an idle to run in another thread with g_idle_add(): the idle may already have run and been removed by the time this function is called on its (now invalid) source ID. This source ID may have been reissued, leading to the operation being performed against the wrong source.

the #GSource

a #GMainContext (if %NULL, the default context will be used)

the source ID, as returned by g_source_get_id().

Finds a source with the given user data for the callback. If multiple sources exist with the same user data, the first one found will be returned.

the source, if one was found, otherwise %NULL

a #GMainContext

the user_data for the callback.

Gets the poll function set by g_main_context_set_poll_func().

the poll function

a #GMainContext

Invokes a function in such a way that @context is owned during the invocation of @function. If @context is %NULL then the global default main context — as returned by g_main_context_default() — is used. If @context is owned by the current thread, @function is called directly. Otherwise, if @context is the thread-default main context of the current thread and g_main_context_acquire() succeeds, then @function is called and g_main_context_release() is called afterwards. In any other case, an idle source is created to call @function and that source is attached to @context (presumably to be run in another thread). The idle source is attached with %G_PRIORITY_DEFAULT priority. If you want a different priority, use g_main_context_invoke_full(). Note that, as with normal idle functions, @function should probably return %FALSE. If it returns %TRUE, it will be continuously run in a loop (and may prevent this call from returning).

a #GMainContext, or %NULL

function to call data to pass to @function

Invokes a function in such a way that @context is owned during the invocation of @function. This function is the same as g_main_context_invoke() except that it lets you specify the priority in case @function ends up being scheduled as an idle and also lets you give a #GDestroyNotify for @data. @notify should not assume that it is called from any particular thread or with any particular context acquired.

a #GMainContext, or %NULL

the priority at which to run @function function to call data to pass to @function a function to call when @data is no longer in use, or %NULL.

Determines whether this thread holds the (recursive) ownership of this #GMainContext. This is useful to know before waiting on another thread that may be blocking to get ownership of @context.

%TRUE if current thread is owner of @context.

a #GMainContext

Runs a single iteration for the given main loop. This involves checking to see if any event sources are ready to be processed, then if no events sources are ready and @may_block is %TRUE, waiting for a source to become ready, then dispatching the highest priority events sources that are ready. Otherwise, if @may_block is %FALSE sources are not waited to become ready, only those highest priority events sources will be dispatched (if any), that are ready at this given moment without further waiting. Note that even when @may_block is %TRUE, it is still possible for g_main_context_iteration() to return %FALSE, since the wait may be interrupted for other reasons than an event source becoming ready.

%TRUE if events were dispatched.

a #GMainContext (if %NULL, the default context will be used)

whether the call may block.

Checks if any sources have pending events for the given context.

%TRUE if events are pending.

a #GMainContext (if %NULL, the default context will be used)

Pops @context off the thread-default context stack (verifying that it was on the top of the stack).

a #GMainContext object, or %NULL

Prepares to poll sources within a main loop. The resulting information for polling is determined by calling g_main_context_query (). You must have successfully acquired the context with g_main_context_acquire() before you may call this function.

%TRUE if some source is ready to be dispatched prior to polling.

a #GMainContext

location to store priority of highest priority source already ready.

Acquires @context and sets it as the thread-default context for the current thread. This will cause certain asynchronous operations (such as most [gio][gio]-based I/O) which are started in this thread to run under @context and deliver their results to its main loop, rather than running under the global default context in the main thread. Note that calling this function changes the context returned by g_main_context_get_thread_default(), not the one returned by g_main_context_default(), so it does not affect the context used by functions like g_idle_add(). Normally you would call this function shortly after creating a new thread, passing it a #GMainContext which will be run by a #GMainLoop in that thread, to set a new default context for all async operations in that thread. In this case you may not need to ever call g_main_context_pop_thread_default(), assuming you want the new #GMainContext to be the default for the whole lifecycle of the thread. If you don't have control over how the new thread was created (e.g. in the new thread isn't newly created, or if the thread life cycle is managed by a #GThreadPool), it is always suggested to wrap the logic that needs to use the new #GMainContext inside a g_main_context_push_thread_default() / g_main_context_pop_thread_default() pair, otherwise threads that are re-used will end up never explicitly releasing the #GMainContext reference they hold. In some cases you may want to schedule a single operation in a non-default context, or temporarily use a non-default context in the main thread. In that case, you can wrap the call to the asynchronous operation inside a g_main_context_push_thread_default() / g_main_context_pop_thread_default() pair, but it is up to you to ensure that no other asynchronous operations accidentally get started while the non-default context is active. Beware that libraries that predate this function may not correctly handle being used from a thread with a thread-default context. Eg, see g_file_supports_thread_contexts().

a #GMainContext, or %NULL for the global default context

Determines information necessary to poll this main loop. You should be careful to pass the resulting @fds array and its length @n_fds as is when calling g_main_context_check(), as this function relies on assumptions made when the array is filled. You must have successfully acquired the context with g_main_context_acquire() before you may call this function.

the number of records actually stored in @fds, or, if more than @n_fds records need to be stored, the number of records that need to be stored.

a #GMainContext

maximum priority source to check location to store timeout to be used in polling location to store #GPollFD records that need to be polled. length of @fds.

Increases the reference count on a #GMainContext object by one.

the @context that was passed in (since 2.6)

a #GMainContext

Releases ownership of a context previously acquired by this thread with g_main_context_acquire(). If the context was acquired multiple times, the ownership will be released only when g_main_context_release() is called as many times as it was acquired.

a #GMainContext

Removes file descriptor from the set of file descriptors to be polled for a particular context.

a #GMainContext

a #GPollFD descriptor previously added with g_main_context_add_poll()

Sets the function to use to handle polling of file descriptors. It will be used instead of the poll() system call (or GLib's replacement function, which is used where poll() isn't available). This function could possibly be used to integrate the GLib event loop with an external event loop.

a #GMainContext

the function to call to poll all file descriptors

Decreases the reference count on a #GMainContext object by one. If the result is zero, free the context and free all associated memory.

a #GMainContext

Tries to become the owner of the specified context, as with g_main_context_acquire(). But if another thread is the owner, atomically drop @mutex and wait on @cond until that owner releases ownership or until @cond is signaled, then try again (once) to become the owner.

Use g_main_context_is_owner() and separate locking instead.

%TRUE if the operation succeeded, and this thread is now the owner of @context.

a #GMainContext

a condition variable a mutex, currently held

If @context is currently blocking in g_main_context_iteration() waiting for a source to become ready, cause it to stop blocking and return. Otherwise, cause the next invocation of g_main_context_iteration() to return without blocking. This API is useful for low-level control over #GMainContext; for example, integrating it with main loop implementations such as #GMainLoop. Another related use for this function is when implementing a main loop with a termination condition, computed from multiple threads: |[ #define NUM_TASKS 10 static gint tasks_remaining = NUM_TASKS; // (atomic) ... while (g_atomic_int_get (&tasks_remaining) != 0) g_main_context_iteration (NULL, TRUE); ]| Then in a thread: |[ perform_work(); if (g_atomic_int_dec_and_test (&tasks_remaining)) g_main_context_wakeup (NULL); ]|

a #GMainContext

Returns the global default main context. This is the main context used for main loop functions when a main loop is not explicitly specified, and corresponds to the "main" main loop. See also g_main_context_get_thread_default().

the global default main context.

Gets the thread-default #GMainContext for this thread. Asynchronous operations that want to be able to be run in contexts other than the default one should call this method or g_main_context_ref_thread_default() to get a #GMainContext to add their #GSources to. (Note that even in single-threaded programs applications may sometimes want to temporarily push a non-default context, so it is not safe to assume that this will always return %NULL if you are running in the default thread.) If you need to hold a reference on the context, use g_main_context_ref_thread_default() instead.

the thread-default #GMainContext, or %NULL if the thread-default context is the global default context.

Gets the thread-default #GMainContext for this thread, as with g_main_context_get_thread_default(), but also adds a reference to it with g_main_context_ref(). In addition, unlike g_main_context_get_thread_default(), if the thread-default context is the global default context, this will return that #GMainContext (with a ref added to it) rather than returning %NULL.

the thread-default #GMainContext. Unref with g_main_context_unref() when you are done with it.

Flags to pass to g_main_context_new_with_flags() which affect the behaviour of a #GMainContext.

Default behaviour. Assume that polling for events will free the thread to process other jobs. That's useful if you're using `g_main_context_{prepare,query,check,dispatch}` to integrate GMainContext in other event loops.

The `GMainLoop` struct is an opaque data type representing the main event loop of a GLib or GTK+ application.

Creates a new #GMainLoop structure.

a new #GMainLoop.

a #GMainContext (if %NULL, the default context will be used). set to %TRUE to indicate that the loop is running. This is not very important since calling g_main_loop_run() will set this to %TRUE anyway.

Returns the #GMainContext of @loop.

the #GMainContext of @loop

a #GMainLoop.

Checks to see if the main loop is currently being run via g_main_loop_run().

%TRUE if the mainloop is currently being run.

a #GMainLoop.

Stops a #GMainLoop from running. Any calls to g_main_loop_run() for the loop will return. Note that sources that have already been dispatched when g_main_loop_quit() is called will still be executed.

a #GMainLoop

Increases the reference count on a #GMainLoop object by one.

@loop

a #GMainLoop

Runs a main loop until g_main_loop_quit() is called on the loop. If this is called for the thread of the loop's #GMainContext, it will process events from the loop, otherwise it will simply wait.

a #GMainLoop

Decreases the reference count on a #GMainLoop object by one. If the result is zero, free the loop and free all associated memory.

a #GMainLoop

The #GMappedFile represents a file mapping created with g_mapped_file_new(). It has only private members and should not be accessed directly.

Maps a file into memory. On UNIX, this is using the mmap() function. If @writable is %TRUE, the mapped buffer may be modified, otherwise it is an error to modify the mapped buffer. Modifications to the buffer are not visible to other processes mapping the same file, and are not written back to the file. Note that modifications of the underlying file might affect the contents of the #GMappedFile. Therefore, mapping should only be used if the file will not be modified, or if all modifications of the file are done atomically (e.g. using g_file_set_contents()). If @filename is the name of an empty, regular file, the function will successfully return an empty #GMappedFile. In other cases of size 0 (e.g. device files such as /dev/null), @error will be set to the #GFileError value %G_FILE_ERROR_INVAL.

a newly allocated #GMappedFile which must be unref'd with g_mapped_file_unref(), or %NULL if the mapping failed.

The path of the file to load, in the GLib filename encoding whether the mapping should be writable

a newly allocated #GMappedFile which must be unref'd with g_mapped_file_unref(), or %NULL if the mapping failed.

The file descriptor of the file to load whether the mapping should be writable

This call existed before #GMappedFile had refcounting and is currently exactly the same as g_mapped_file_unref().

Use g_mapped_file_unref() instead.

a #GMappedFile

Creates a new #GBytes which references the data mapped from @file. The mapped contents of the file must not be modified after creating this bytes object, because a #GBytes should be immutable.

A newly allocated #GBytes referencing data from @file

a #GMappedFile

Returns the contents of a #GMappedFile. Note that the contents may not be zero-terminated, even if the #GMappedFile is backed by a text file. If the file is empty then %NULL is returned.

the contents of @file, or %NULL.

a #GMappedFile

Returns the length of the contents of a #GMappedFile.

the length of the contents of @file.

a #GMappedFile

Increments the reference count of @file by one. It is safe to call this function from any thread.

the passed in #GMappedFile.

a #GMappedFile

Decrements the reference count of @file by one. If the reference count drops to 0, unmaps the buffer of @file and frees it. It is safe to call this function from any thread. Since 2.22

a #GMappedFile

A mixed enumerated type and flags field. You must specify one type (string, strdup, boolean, tristate). Additionally, you may optionally bitwise OR the type with the flag %G_MARKUP_COLLECT_OPTIONAL. It is likely that this enum will be extended in the future to support other types.

used to terminate the list of attributes to collect collect the string pointer directly from the attribute_values[] array. Expects a parameter of type (const char **). If %G_MARKUP_COLLECT_OPTIONAL is specified and the attribute isn't present then the pointer will be set to %NULL as with %G_MARKUP_COLLECT_STRING, but expects a parameter of type (char **) and g_strdup()s the returned pointer. The pointer must be freed with g_free() expects a parameter of type (gboolean *) and parses the attribute value as a boolean. Sets %FALSE if the attribute isn't present. Valid boolean values consist of (case-insensitive) "false", "f", "no", "n", "0" and "true", "t", "yes", "y", "1" as with %G_MARKUP_COLLECT_BOOLEAN, but in the case of a missing attribute a value is set that compares equal to neither %FALSE nor %TRUE G_MARKUP_COLLECT_OPTIONAL is implied can be bitwise ORed with the other fields. If present, allows the attribute not to appear. A default value is set depending on what value type is used

Error codes returned by markup parsing.

text being parsed was not valid UTF-8 document contained nothing, or only whitespace document was ill-formed error should be set by #GMarkupParser functions; element wasn't known error should be set by #GMarkupParser functions; attribute wasn't known error should be set by #GMarkupParser functions; content was invalid error should be set by #GMarkupParser functions; a required attribute was missing

A parse context is used to parse a stream of bytes that you expect to contain marked-up text. See g_markup_parse_context_new(), #GMarkupParser, and so on for more details.

Creates a new parse context. A parse context is used to parse marked-up documents. You can feed any number of documents into a context, as long as no errors occur; once an error occurs, the parse context can't continue to parse text (you have to free it and create a new parse context).

a new #GMarkupParseContext

a #GMarkupParser one or more #GMarkupParseFlags user data to pass to #GMarkupParser functions user data destroy notifier called when the parse context is freed

Signals to the #GMarkupParseContext that all data has been fed into the parse context with g_markup_parse_context_parse(). This function reports an error if the document isn't complete, for example if elements are still open.

%TRUE on success, %FALSE if an error was set

a #GMarkupParseContext

Frees a #GMarkupParseContext. This function can't be called from inside one of the #GMarkupParser functions or while a subparser is pushed.

a #GMarkupParseContext

Retrieves the name of the currently open element. If called from the start_element or end_element handlers this will give the element_name as passed to those functions. For the parent elements, see g_markup_parse_context_get_element_stack().

the name of the currently open element, or %NULL

a #GMarkupParseContext

Retrieves the element stack from the internal state of the parser. The returned #GSList is a list of strings where the first item is the currently open tag (as would be returned by g_markup_parse_context_get_element()) and the next item is its immediate parent. This function is intended to be used in the start_element and end_element handlers where g_markup_parse_context_get_element() would merely return the name of the element that is being processed.

the element stack, which must not be modified

a #GMarkupParseContext

Retrieves the current line number and the number of the character on that line. Intended for use in error messages; there are no strict semantics for what constitutes the "current" line number other than "the best number we could come up with for error messages."

a #GMarkupParseContext

return location for a line number, or %NULL return location for a char-on-line number, or %NULL

Returns the user_data associated with @context. This will either be the user_data that was provided to g_markup_parse_context_new() or to the most recent call of g_markup_parse_context_push().

the provided user_data. The returned data belongs to the markup context and will be freed when g_markup_parse_context_free() is called.

a #GMarkupParseContext

Feed some data to the #GMarkupParseContext. The data need not be valid UTF-8; an error will be signaled if it's invalid. The data need not be an entire document; you can feed a document into the parser incrementally, via multiple calls to this function. Typically, as you receive data from a network connection or file, you feed each received chunk of data into this function, aborting the process if an error occurs. Once an error is reported, no further data may be fed to the #GMarkupParseContext; all errors are fatal.

%FALSE if an error occurred, %TRUE on success

a #GMarkupParseContext

chunk of text to parse length of @text in bytes

Completes the process of a temporary sub-parser redirection. This function exists to collect the user_data allocated by a matching call to g_markup_parse_context_push(). It must be called in the end_element handler corresponding to the start_element handler during which g_markup_parse_context_push() was called. You must not call this function from the error callback -- the @user_data is provided directly to the callback in that case. This function is not intended to be directly called by users interested in invoking subparsers. Instead, it is intended to be used by the subparsers themselves to implement a higher-level interface.

the user data passed to g_markup_parse_context_push()

a #GMarkupParseContext

Temporarily redirects markup data to a sub-parser. This function may only be called from the start_element handler of a #GMarkupParser. It must be matched with a corresponding call to g_markup_parse_context_pop() in the matching end_element handler (except in the case that the parser aborts due to an error). All tags, text and other data between the matching tags is redirected to the subparser given by @parser. @user_data is used as the user_data for that parser. @user_data is also passed to the error callback in the event that an error occurs. This includes errors that occur in subparsers of the subparser. The end tag matching the start tag for which this call was made is handled by the previous parser (which is given its own user_data) which is why g_markup_parse_context_pop() is provided to allow "one last access" to the @user_data provided to this function. In the case of error, the @user_data provided here is passed directly to the error callback of the subparser and g_markup_parse_context_pop() should not be called. In either case, if @user_data was allocated then it ought to be freed from both of these locations. This function is not intended to be directly called by users interested in invoking subparsers. Instead, it is intended to be used by the subparsers themselves to implement a higher-level interface. As an example, see the following implementation of a simple parser that counts the number of tags encountered. |[ typedef struct { gint tag_count; } CounterData; static void counter_start_element (GMarkupParseContext *context, const gchar *element_name, const gchar **attribute_names, const gchar **attribute_values, gpointer user_data, GError **error) { CounterData *data = user_data; data->tag_count++; } static void counter_error (GMarkupParseContext *context, GError *error, gpointer user_data) { CounterData *data = user_data; g_slice_free (CounterData, data); } static GMarkupParser counter_subparser = { counter_start_element, NULL, NULL, NULL, counter_error }; ]| In order to allow this parser to be easily used as a subparser, the following interface is provided: |[ void start_counting (GMarkupParseContext *context) { CounterData *data = g_slice_new (CounterData); data->tag_count = 0; g_markup_parse_context_push (context, &counter_subparser, data); } gint end_counting (GMarkupParseContext *context) { CounterData *data = g_markup_parse_context_pop (context); int result; result = data->tag_count; g_slice_free (CounterData, data); return result; } ]| The subparser would then be used as follows: |[ static void start_element (context, element_name, ...) { if (strcmp (element_name, "count-these") == 0) start_counting (context); // else, handle other tags... } static void end_element (context, element_name, ...) { if (strcmp (element_name, "count-these") == 0) g_print ("Counted %d tags\n", end_counting (context)); // else, handle other tags... } ]|

a #GMarkupParseContext

a #GMarkupParser user data to pass to #GMarkupParser functions

Increases the reference count of @context.

the same @context

a #GMarkupParseContext

Decreases the reference count of @context. When its reference count drops to 0, it is freed.

a #GMarkupParseContext

Flags that affect the behaviour of the parser.

No special behaviour. Since: 2.74 flag you should not use When this flag is set, CDATA marked sections are not passed literally to the @passthrough function of the parser. Instead, the content of the section (without the `<![CDATA[` and `]]>`) is passed to the @text function. This flag was added in GLib 2.12 Normally errors caught by GMarkup itself have line/column information prefixed to them to let the caller know the location of the error. When this flag is set the location information is also prefixed to errors generated by the #GMarkupParser implementation functions Ignore (don't report) qualified attributes and tags, along with their contents. A qualified attribute or tag is one that contains ':' in its name (ie: is in another namespace). Since: 2.40.

Any of the fields in #GMarkupParser can be %NULL, in which case they will be ignored. Except for the @error function, any of these callbacks can set an error; in particular the %G_MARKUP_ERROR_UNKNOWN_ELEMENT, %G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE, and %G_MARKUP_ERROR_INVALID_CONTENT errors are intended to be set from these callbacks. If you set an error from a callback, g_markup_parse_context_parse() will report that error back to its caller.

A GMatchInfo is an opaque struct used to return information about matches.

Returns a new string containing the text in @string_to_expand with references and escape sequences expanded. References refer to the last match done with @string against @regex and have the same syntax used by g_regex_replace(). The @string_to_expand must be UTF-8 encoded even if %G_REGEX_RAW was passed to g_regex_new(). The backreferences are extracted from the string passed to the match function, so you cannot call this function after freeing the string. @match_info may be %NULL in which case @string_to_expand must not contain references. For instance "foo\n" does not refer to an actual pattern and '\n' merely will be replaced with \n character, while to expand "\0" (whole match) one needs the result of a match. Use g_regex_check_replacement() to find out whether @string_to_expand contains references.

the expanded string, or %NULL if an error occurred

a #GMatchInfo or %NULL

the string to expand

Retrieves the text matching the @match_num'th capturing parentheses. 0 is the full text of the match, 1 is the first paren set, 2 the second, and so on. If @match_num is a valid sub pattern but it didn't match anything (e.g. sub pattern 1, matching "b" against "(a)?b") then an empty string is returned. If the match was obtained using the DFA algorithm, that is using g_regex_match_all() or g_regex_match_all_full(), the retrieved string is not that of a set of parentheses but that of a matched substring. Substrings are matched in reverse order of length, so 0 is the longest match. The string is fetched from the string passed to the match function, so you cannot call this function after freeing the string.

The matched substring, or %NULL if an error occurred. You have to free the string yourself

#GMatchInfo structure

number of the sub expression

Bundles up pointers to each of the matching substrings from a match and stores them in an array of gchar pointers. The first element in the returned array is the match number 0, i.e. the entire matched text. If a sub pattern didn't match anything (e.g. sub pattern 1, matching "b" against "(a)?b") then an empty string is inserted. If the last match was obtained using the DFA algorithm, that is using g_regex_match_all() or g_regex_match_all_full(), the retrieved strings are not that matched by sets of parentheses but that of the matched substring. Substrings are matched in reverse order of length, so the first one is the longest match. The strings are fetched from the string passed to the match function, so you cannot call this function after freeing the string.

a %NULL-terminated array of gchar * pointers. It must be freed using g_strfreev(). If the previous match failed %NULL is returned

a #GMatchInfo structure

Retrieves the text matching the capturing parentheses named @name. If @name is a valid sub pattern name but it didn't match anything (e.g. sub pattern "X", matching "b" against "(?P<X>a)?b") then an empty string is returned. The string is fetched from the string passed to the match function, so you cannot call this function after freeing the string.

The matched substring, or %NULL if an error occurred. You have to free the string yourself

#GMatchInfo structure

name of the subexpression

Retrieves the position in bytes of the capturing parentheses named @name. If @name is a valid sub pattern name but it didn't match anything (e.g. sub pattern "X", matching "b" against "(?P<X>a)?b") then @start_pos and @end_pos are set to -1 and %TRUE is returned.

%TRUE if the position was fetched, %FALSE otherwise. If the position cannot be fetched, @start_pos and @end_pos are left unchanged.

#GMatchInfo structure

name of the subexpression pointer to location where to store the start position, or %NULL pointer to location where to store the end position, or %NULL

Retrieves the position in bytes of the @match_num'th capturing parentheses. 0 is the full text of the match, 1 is the first paren set, 2 the second, and so on. If @match_num is a valid sub pattern but it didn't match anything (e.g. sub pattern 1, matching "b" against "(a)?b") then @start_pos and @end_pos are set to -1 and %TRUE is returned. If the match was obtained using the DFA algorithm, that is using g_regex_match_all() or g_regex_match_all_full(), the retrieved position is not that of a set of parentheses but that of a matched substring. Substrings are matched in reverse order of length, so 0 is the longest match.

%TRUE if the position was fetched, %FALSE otherwise. If the position cannot be fetched, @start_pos and @end_pos are left unchanged

#GMatchInfo structure

number of the sub expression pointer to location where to store the start position, or %NULL pointer to location where to store the end position, or %NULL

If @match_info is not %NULL, calls g_match_info_unref(); otherwise does nothing.

a #GMatchInfo, or %NULL

Retrieves the number of matched substrings (including substring 0, that is the whole matched text), so 1 is returned if the pattern has no substrings in it and 0 is returned if the match failed. If the last match was obtained using the DFA algorithm, that is using g_regex_match_all() or g_regex_match_all_full(), the retrieved count is not that of the number of capturing parentheses but that of the number of matched substrings.

Number of matched substrings, or -1 if an error occurred

a #GMatchInfo structure

Returns #GRegex object used in @match_info. It belongs to Glib and must not be freed. Use g_regex_ref() if you need to keep it after you free @match_info object.

#GRegex object used in @match_info

a #GMatchInfo

Returns the string searched with @match_info. This is the string passed to g_regex_match() or g_regex_replace() so you may not free it before calling this function.

the string searched with @match_info

a #GMatchInfo

Usually if the string passed to g_regex_match*() matches as far as it goes, but is too short to match the entire pattern, %FALSE is returned. There are circumstances where it might be helpful to distinguish this case from other cases in which there is no match. Consider, for example, an application where a human is required to type in data for a field with specific formatting requirements. An example might be a date in the form ddmmmyy, defined by the pattern "^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$". If the application sees the user’s keystrokes one by one, and can check that what has been typed so far is potentially valid, it is able to raise an error as soon as a mistake is made. GRegex supports the concept of partial matching by means of the %G_REGEX_MATCH_PARTIAL_SOFT and %G_REGEX_MATCH_PARTIAL_HARD flags. When they are used, the return code for g_regex_match() or g_regex_match_full() is, as usual, %TRUE for a complete match, %FALSE otherwise. But, when these functions return %FALSE, you can check if the match was partial calling g_match_info_is_partial_match(). The difference between %G_REGEX_MATCH_PARTIAL_SOFT and %G_REGEX_MATCH_PARTIAL_HARD is that when a partial match is encountered with %G_REGEX_MATCH_PARTIAL_SOFT, matching continues to search for a possible complete match, while with %G_REGEX_MATCH_PARTIAL_HARD matching stops at the partial match. When both %G_REGEX_MATCH_PARTIAL_SOFT and %G_REGEX_MATCH_PARTIAL_HARD are set, the latter takes precedence. There were formerly some restrictions on the pattern for partial matching. The restrictions no longer apply. See pcrepartial(3) for more information on partial matching.

%TRUE if the match was partial, %FALSE otherwise

a #GMatchInfo structure

Returns whether the previous match operation succeeded.

%TRUE if the previous match operation succeeded, %FALSE otherwise

a #GMatchInfo structure

Scans for the next match using the same parameters of the previous call to g_regex_match_full() or g_regex_match() that returned @match_info. The match is done on the string passed to the match function, so you cannot free it before calling this function.

%TRUE is the string matched, %FALSE otherwise

a #GMatchInfo structure

Increases reference count of @match_info by 1.

@match_info

a #GMatchInfo

Decreases reference count of @match_info by 1. When reference count drops to zero, it frees all the memory associated with the match_info structure.

a #GMatchInfo

A set of functions used to perform memory allocation. The same #GMemVTable must be used for all allocations in the same program; a call to g_mem_set_vtable(), if it exists, should be prior to any use of GLib. This functions related to this has been deprecated in 2.46, and no longer work.

The #GMutex struct is an opaque data structure to represent a mutex (mutual exclusion). It can be used to protect data against shared access. Take for example the following function: |[ int give_me_next_number (void) { static int current_number = 0; // now do a very complicated calculation to calculate the new // number, this might for example be a random number generator current_number = calc_next_number (current_number); return current_number; } ]| It is easy to see that this won't work in a multi-threaded application. There current_number must be protected against shared access. A #GMutex can be used as a solution to this problem: |[ int give_me_next_number (void) { static GMutex mutex; static int current_number = 0; int ret_val; g_mutex_lock (&mutex); ret_val = current_number = calc_next_number (current_number); g_mutex_unlock (&mutex); return ret_val; } ]| Notice that the #GMutex is not initialised to any particular value. Its placement in static storage ensures that it will be initialised to all-zeros, which is appropriate. If a #GMutex is placed in other contexts (eg: embedded in a struct) then it must be explicitly initialised using g_mutex_init(). A #GMutex should only be accessed via g_mutex_ functions.

Frees the resources allocated to a mutex with g_mutex_init(). This function should not be used with a #GMutex that has been statically allocated. Calling g_mutex_clear() on a locked mutex leads to undefined behaviour.

an initialized #GMutex

Initializes a #GMutex so that it can be used. This function is useful to initialize a mutex that has been allocated on the stack, or as part of a larger structure. It is not necessary to initialize a mutex that has been statically allocated. |[ typedef struct { GMutex m; ... } Blob; Blob *b; b = g_new (Blob, 1); g_mutex_init (&b->m); ]| To undo the effect of g_mutex_init() when a mutex is no longer needed, use g_mutex_clear(). Calling g_mutex_init() on an already initialized #GMutex leads to undefined behaviour.

an uninitialized #GMutex

Locks @mutex. If @mutex is already locked by another thread, the current thread will block until @mutex is unlocked by the other thread. #GMutex is neither guaranteed to be recursive nor to be non-recursive. As such, calling g_mutex_lock() on a #GMutex that has already been locked by the same thread results in undefined behaviour (including but not limited to deadlocks).

a #GMutex

Tries to lock @mutex. If @mutex is already locked by another thread, it immediately returns %FALSE. Otherwise it locks @mutex and returns %TRUE. #GMutex is neither guaranteed to be recursive nor to be non-recursive. As such, calling g_mutex_lock() on a #GMutex that has already been locked by the same thread results in undefined behaviour (including but not limited to deadlocks or arbitrary return values).

%TRUE if @mutex could be locked

a #GMutex

Unlocks @mutex. If another thread is blocked in a g_mutex_lock() call for @mutex, it will become unblocked and can lock @mutex itself. Calling g_mutex_unlock() on a mutex that is not locked by the current thread leads to undefined behaviour.

a #GMutex

Returns %TRUE if a #GNode is a leaf node.

a #GNode

Returns %TRUE if a #GNode is the root of a tree.

a #GNode

Determines the number of elements in an array. The array must be declared so the compiler knows its size at compile-time; this macro will not work on an array allocated on the heap, only static arrays or arrays on the stack.

the array

The #GNode struct represents one node in a [n-ary tree][glib-N-ary-Trees].

contains the actual data of the node. points to the node's next sibling (a sibling is another #GNode with the same parent). points to the node's previous sibling. points to the parent of the #GNode, or is %NULL if the #GNode is the root of the tree. points to the first child of the #GNode. The other children are accessed by using the @next pointer of each child. Gets the position of the first child of a #GNode which contains the given data.

the index of the child of @node which contains @data, or -1 if the data is not found

a #GNode

the data to find

Gets the position of a #GNode with respect to its siblings. @child must be a child of @node. The first child is numbered 0, the second 1, and so on.

the position of @child with respect to its siblings

a #GNode

a child of @node

Calls a function for each of the children of a #GNode. Note that it doesn't descend beneath the child nodes. @func must not do anything that would modify the structure of the tree.

a #GNode

which types of children are to be visited, one of %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES the function to call for each visited node user data to pass to the function

Recursively copies a #GNode (but does not deep-copy the data inside the nodes, see g_node_copy_deep() if you need that).

a new #GNode containing the same data pointers

a #GNode

Recursively copies a #GNode and its data.

a new #GNode containing copies of the data in @node.

a #GNode

the function which is called to copy the data inside each node, or %NULL to use the original data. data to pass to @copy_func

Gets the depth of a #GNode. If @node is %NULL the depth is 0. The root node has a depth of 1. For the children of the root node the depth is 2. And so on.

the depth of the #GNode

a #GNode

Removes @root and its children from the tree, freeing any memory allocated.

the root of the tree/subtree to destroy

Finds a #GNode in a tree.

the found #GNode, or %NULL if the data is not found

the root #GNode of the tree to search

the order in which nodes are visited - %G_IN_ORDER, %G_PRE_ORDER, %G_POST_ORDER, or %G_LEVEL_ORDER which types of children are to be searched, one of %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES the data to find

Finds the first child of a #GNode with the given data.

the found child #GNode, or %NULL if the data is not found

a #GNode

which types of children are to be searched, one of %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES the data to find

Gets the first sibling of a #GNode. This could possibly be the node itself.

the first sibling of @node

a #GNode

Gets the root of a tree.

the root of the tree

a #GNode

Inserts a #GNode beneath the parent at the given position.

the inserted #GNode

the #GNode to place @node under

the position to place @node at, with respect to its siblings If position is -1, @node is inserted as the last child of @parent the #GNode to insert

Inserts a #GNode beneath the parent after the given sibling.

the inserted #GNode

the #GNode to place @node under

the sibling #GNode to place @node after. If sibling is %NULL, the node is inserted as the first child of @parent. the #GNode to insert

Inserts a #GNode beneath the parent before the given sibling.

the inserted #GNode

the #GNode to place @node under

the sibling #GNode to place @node before. If sibling is %NULL, the node is inserted as the last child of @parent. the #GNode to insert

Returns %TRUE if @node is an ancestor of @descendant. This is true if node is the parent of @descendant, or if node is the grandparent of @descendant etc.

%TRUE if @node is an ancestor of @descendant

a #GNode

Gets the last child of a #GNode.

the last child of @node, or %NULL if @node has no children

a #GNode (must not be %NULL)

Gets the last sibling of a #GNode. This could possibly be the node itself.

the last sibling of @node

a #GNode

Gets the maximum height of all branches beneath a #GNode. This is the maximum distance from the #GNode to all leaf nodes. If @root is %NULL, 0 is returned. If @root has no children, 1 is returned. If @root has children, 2 is returned. And so on.

the maximum height of the tree beneath @root

a #GNode

Gets the number of children of a #GNode.

the number of children of @node

a #GNode

Gets the number of nodes in a tree.

the number of nodes in the tree

a #GNode

which types of children are to be counted, one of %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES

Gets a child of a #GNode, using the given index. The first child is at index 0. If the index is too big, %NULL is returned.

the child of @node at index @n

a #GNode

the index of the desired child

Inserts a #GNode as the first child of the given parent.

the inserted #GNode

the #GNode to place the new #GNode under

the #GNode to insert

Reverses the order of the children of a #GNode. (It doesn't change the order of the grandchildren.)

a #GNode.

Traverses a tree starting at the given root #GNode. It calls the given function for each node visited. The traversal can be halted at any point by returning %TRUE from @func. @func must not do anything that would modify the structure of the tree.

the root #GNode of the tree to traverse

the order in which nodes are visited - %G_IN_ORDER, %G_PRE_ORDER, %G_POST_ORDER, or %G_LEVEL_ORDER. which types of children are to be visited, one of %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES the maximum depth of the traversal. Nodes below this depth will not be visited. If max_depth is -1 all nodes in the tree are visited. If depth is 1, only the root is visited. If depth is 2, the root and its children are visited. And so on. the function to call for each visited #GNode user data to pass to the function

Unlinks a #GNode from a tree, resulting in two separate trees.

the #GNode to unlink, which becomes the root of a new tree

Creates a new #GNode containing the given data. Used to create the first node in a tree.

a new #GNode

the data of the new node

Specifies the type of function passed to g_node_children_foreach(). The function is called with each child node, together with the user data passed to g_node_children_foreach().

a #GNode. user data passed to g_node_children_foreach().

Specifies the type of function passed to g_node_traverse(). The function is called with each of the nodes visited, together with the user data passed to g_node_traverse(). If the function returns %TRUE, then the traversal is stopped.

%TRUE to stop the traversal.

a #GNode. user data passed to g_node_traverse().

Defines how a Unicode string is transformed in a canonical form, standardizing such issues as whether a character with an accent is represented as a base character and combining accent or as a single precomposed character. Unicode strings should generally be normalized before comparing them. standardize differences that do not affect the text content, such as the above-mentioned accent representation another name for %G_NORMALIZE_DEFAULT like %G_NORMALIZE_DEFAULT, but with composed forms rather than a maximally decomposed form another name for %G_NORMALIZE_DEFAULT_COMPOSE beyond %G_NORMALIZE_DEFAULT also standardize the "compatibility" characters in Unicode, such as SUPERSCRIPT THREE to the standard forms (in this case DIGIT THREE). Formatting information may be lost but for most text operations such characters should be considered the same another name for %G_NORMALIZE_ALL like %G_NORMALIZE_ALL, but with composed forms rather than a maximally decomposed form another name for %G_NORMALIZE_ALL_COMPOSE Error codes returned by functions converting a string to a number.

String was not a valid number. String was a number, but out of bounds.

If a long option in the main group has this name, it is not treated as a regular option. Instead it collects all non-option arguments which would otherwise be left in `argv`. The option must be of type %G_OPTION_ARG_CALLBACK, %G_OPTION_ARG_STRING_ARRAY or %G_OPTION_ARG_FILENAME_ARRAY. Using %G_OPTION_REMAINING instead of simply scanning `argv` for leftover arguments has the advantage that GOption takes care of necessary encoding conversions for strings or filenames.

A #GOnce struct controls a one-time initialization function. Any one-time initialization function must have its own unique #GOnce struct.

the status of the #GOnce the value returned by the call to the function, if @status is %G_ONCE_STATUS_READY

Function to be called when starting a critical initialization section. The argument @location must point to a static 0-initialized variable that will be set to a value other than 0 at the end of the initialization section. In combination with g_once_init_leave() and the unique address @value_location, it can be ensured that an initialization section will be executed only once during a program's life time, and that concurrent threads are blocked until initialization completed. To be used in constructs like this: |[ static gsize initialization_value = 0; if (g_once_init_enter (&initialization_value)) { gsize setup_value = 42; // initialization code here g_once_init_leave (&initialization_value, setup_value); } // use initialization_value here ]| While @location has a `volatile` qualifier, this is a historical artifact and the pointer passed to it should not be `volatile`.

%TRUE if the initialization section should be entered, %FALSE and blocks otherwise

location of a static initializable variable containing 0

Counterpart to g_once_init_enter(). Expects a location of a static 0-initialized initialization variable, and an initialization value other than 0. Sets the variable to the initialization value, and releases concurrent threads blocking in g_once_init_enter() on this initialization variable. While @location has a `volatile` qualifier, this is a historical artifact and the pointer passed to it should not be `volatile`.

location of a static initializable variable containing 0 new non-0 value for *@value_location

The possible statuses of a one-time initialization function controlled by a #GOnce struct.

the function has not been called yet. the function call is currently in progress. the function has been called.

The #GOptionArg enum values determine which type of extra argument the options expect to find. If an option expects an extra argument, it can be specified in several ways; with a short option: `-x arg`, with a long option: `--name arg` or combined in a single argument: `--name=arg`.

No extra argument. This is useful for simple flags or booleans. The option takes a UTF-8 string argument. The option takes an integer argument. The option provides a callback (of type #GOptionArgFunc) to parse the extra argument. The option takes a filename as argument, which will be in the GLib filename encoding rather than UTF-8. The option takes a string argument, multiple uses of the option are collected into an array of strings. The option takes a filename as argument, multiple uses of the option are collected into an array of strings. The option takes a double argument. The argument can be formatted either for the user's locale or for the "C" locale. Since 2.12 The option takes a 64-bit integer. Like %G_OPTION_ARG_INT but for larger numbers. The number can be in decimal base, or in hexadecimal (when prefixed with `0x`, for example, `0xffffffff`). Since 2.12

The type of function to be passed as callback for %G_OPTION_ARG_CALLBACK options.

%TRUE if the option was successfully parsed, %FALSE if an error occurred, in which case @error should be set with g_set_error()

The name of the option being parsed. This will be either a single dash followed by a single letter (for a short name) or two dashes followed by a long option name. The value to be parsed. User data added to the #GOptionGroup containing the option when it was created with g_option_group_new()

A `GOptionContext` struct defines which options are accepted by the commandline option parser. The struct has only private fields and should not be directly accessed.

Adds a #GOptionGroup to the @context, so that parsing with @context will recognize the options in the group. Note that this will take ownership of the @group and thus the @group should not be freed.

a #GOptionContext

the group to add

A convenience function which creates a main group if it doesn't exist, adds the @entries to it and sets the translation domain.

a #GOptionContext

a %NULL-terminated array of #GOptionEntrys a translation domain to use for translating the `--help` output for the options in @entries with gettext(), or %NULL

Frees context and all the groups which have been added to it. Please note that parsed arguments need to be freed separately (see #GOptionEntry).

a #GOptionContext

Returns the description. See g_option_context_set_description().

the description

a #GOptionContext

Returns a formatted, translated help text for the given context. To obtain the text produced by `--help`, call `g_option_context_get_help (context, TRUE, NULL)`. To obtain the text produced by `--help-all`, call `g_option_context_get_help (context, FALSE, NULL)`. To obtain the help text for an option group, call `g_option_context_get_help (context, FALSE, group)`.

A newly allocated string containing the help text

a #GOptionContext

if %TRUE, only include the main group the #GOptionGroup to create help for, or %NULL

Returns whether automatic `--help` generation is turned on for @context. See g_option_context_set_help_enabled().

%TRUE if automatic help generation is turned on.

a #GOptionContext

Returns whether unknown options are ignored or not. See g_option_context_set_ignore_unknown_options().

%TRUE if unknown options are ignored.

a #GOptionContext

Returns a pointer to the main group of @context.

the main group of @context, or %NULL if @context doesn't have a main group. Note that group belongs to @context and should not be modified or freed.

a #GOptionContext

Returns whether strict POSIX code is enabled. See g_option_context_set_strict_posix() for more information.

%TRUE if strict POSIX is enabled, %FALSE otherwise.

a #GOptionContext

Returns the summary. See g_option_context_set_summary().

the summary

a #GOptionContext

Parses the command line arguments, recognizing options which have been added to @context. A side-effect of calling this function is that g_set_prgname() will be called. If the parsing is successful, any parsed arguments are removed from the array and @argc and @argv are updated accordingly. A '--' option is stripped from @argv unless there are unparsed options before and after it, or some of the options after it start with '-'. In case of an error, @argc and @argv are left unmodified. If automatic `--help` support is enabled (see g_option_context_set_help_enabled()), and the @argv array contains one of the recognized help options, this function will produce help output to stdout and call `exit (0)`. Note that function depends on the [current locale][setlocale] for automatic character set conversion of string and filename arguments.

%TRUE if the parsing was successful, %FALSE if an error occurred

a #GOptionContext

a pointer to the number of command line arguments a pointer to the array of command line arguments

Parses the command line arguments. This function is similar to g_option_context_parse() except that it respects the normal memory rules when dealing with a strv instead of assuming that the passed-in array is the argv of the main function. In particular, strings that are removed from the arguments list will be freed using g_free(). On Windows, the strings are expected to be in UTF-8. This is in contrast to g_option_context_parse() which expects them to be in the system codepage, which is how they are passed as @argv to main(). See g_win32_get_command_line() for a solution. This function is useful if you are trying to use #GOptionContext with #GApplication.

%TRUE if the parsing was successful, %FALSE if an error occurred

a #GOptionContext

a pointer to the command line arguments (which must be in UTF-8 on Windows). Starting with GLib 2.62, @arguments can be %NULL, which matches g_option_context_parse().

Adds a string to be displayed in `--help` output after the list of options. This text often includes a bug reporting address. Note that the summary is translated (see g_option_context_set_translate_func()).

a #GOptionContext

a string to be shown in `--help` output after the list of options, or %NULL

Enables or disables automatic generation of `--help` output. By default, g_option_context_parse() recognizes `--help`, `-h`, `-?`, `--help-all` and `--help-groupname` and creates suitable output to stdout.

a #GOptionContext

%TRUE to enable `--help`, %FALSE to disable it

Sets whether to ignore unknown options or not. If an argument is ignored, it is left in the @argv array after parsing. By default, g_option_context_parse() treats unknown options as error. This setting does not affect non-option arguments (i.e. arguments which don't start with a dash). But note that GOption cannot reliably determine whether a non-option belongs to a preceding unknown option.

a #GOptionContext

%TRUE to ignore unknown options, %FALSE to produce an error when unknown options are met

Sets a #GOptionGroup as main group of the @context. This has the same effect as calling g_option_context_add_group(), the only difference is that the options in the main group are treated differently when generating `--help` output.

a #GOptionContext

the group to set as main group

Sets strict POSIX mode. By default, this mode is disabled. In strict POSIX mode, the first non-argument parameter encountered (eg: filename) terminates argument processing. Remaining arguments are treated as non-options and are not attempted to be parsed. If strict POSIX mode is disabled then parsing is done in the GNU way where option arguments can be freely mixed with non-options. As an example, consider "ls foo -l". With GNU style parsing, this will list "foo" in long mode. In strict POSIX style, this will list the files named "foo" and "-l". It may be useful to force strict POSIX mode when creating "verb style" command line tools. For example, the "gsettings" command line tool supports the global option "--schemadir" as well as many subcommands ("get", "set", etc.) which each have their own set of arguments. Using strict POSIX mode will allow parsing the global options up to the verb name while leaving the remaining options to be parsed by the relevant subcommand (which can be determined by examining the verb name, which should be present in argv[1] after parsing).

a #GOptionContext

the new value

Adds a string to be displayed in `--help` output before the list of options. This is typically a summary of the program functionality. Note that the summary is translated (see g_option_context_set_translate_func() and g_option_context_set_translation_domain()).

a #GOptionContext

a string to be shown in `--help` output before the list of options, or %NULL

Sets the function which is used to translate the contexts user-visible strings, for `--help` output. If @func is %NULL, strings are not translated. Note that option groups have their own translation functions, this function only affects the @parameter_string (see g_option_context_new()), the summary (see g_option_context_set_summary()) and the description (see g_option_context_set_description()). If you are using gettext(), you only need to set the translation domain, see g_option_context_set_translation_domain().

a #GOptionContext

the #GTranslateFunc, or %NULL user data to pass to @func, or %NULL a function which gets called to free @data, or %NULL

A convenience function to use gettext() for translating user-visible strings.

a #GOptionContext

the domain to use

Creates a new option context. The @parameter_string can serve multiple purposes. It can be used to add descriptions for "rest" arguments, which are not parsed by the #GOptionContext, typically something like "FILES" or "FILE1 FILE2...". If you are using %G_OPTION_REMAINING for collecting "rest" arguments, GLib handles this automatically by using the @arg_description of the corresponding #GOptionEntry in the usage summary. Another usage is to give a short summary of the program functionality, like " - frob the strings", which will be displayed in the same line as the usage. For a longer description of the program functionality that should be displayed as a paragraph below the usage line, use g_option_context_set_summary(). Note that the @parameter_string is translated using the function set with g_option_context_set_translate_func(), so it should normally be passed untranslated.

a newly created #GOptionContext, which must be freed with g_option_context_free() after use.

a string which is displayed in the first line of `--help` output, after the usage summary `programname [OPTION...]`

A GOptionEntry struct defines a single option. To have an effect, they must be added to a #GOptionGroup with g_option_context_add_main_entries() or g_option_group_add_entries().

The long name of an option can be used to specify it in a commandline as `--long_name`. Every option must have a long name. To resolve conflicts if multiple option groups contain the same long name, it is also possible to specify the option as `--groupname-long_name`. If an option has a short name, it can be specified `-short_name` in a commandline. @short_name must be a printable ASCII character different from '-', or zero if the option has no short name. Flags from #GOptionFlags The type of the option, as a #GOptionArg If the @arg type is %G_OPTION_ARG_CALLBACK, then @arg_data must point to a #GOptionArgFunc callback function, which will be called to handle the extra argument. Otherwise, @arg_data is a pointer to a location to store the value, the required type of the location depends on the @arg type: - %G_OPTION_ARG_NONE: %gboolean - %G_OPTION_ARG_STRING: %gchar* - %G_OPTION_ARG_INT: %gint - %G_OPTION_ARG_FILENAME: %gchar* - %G_OPTION_ARG_STRING_ARRAY: %gchar** - %G_OPTION_ARG_FILENAME_ARRAY: %gchar** - %G_OPTION_ARG_DOUBLE: %gdouble If @arg type is %G_OPTION_ARG_STRING or %G_OPTION_ARG_FILENAME, the location will contain a newly allocated string if the option was given. That string needs to be freed by the callee using g_free(). Likewise if @arg type is %G_OPTION_ARG_STRING_ARRAY or %G_OPTION_ARG_FILENAME_ARRAY, the data should be freed using g_strfreev(). the description for the option in `--help` output. The @description is translated using the @translate_func of the group, see g_option_group_set_translation_domain(). The placeholder to use for the extra argument parsed by the option in `--help` output. The @arg_description is translated using the @translate_func of the group, see g_option_group_set_translation_domain().

Error codes returned by option parsing.

An option was not known to the parser. This error will only be reported, if the parser hasn't been instructed to ignore unknown options, see g_option_context_set_ignore_unknown_options(). A value couldn't be parsed. A #GOptionArgFunc callback failed.

The type of function to be used as callback when a parse error occurs.

The active #GOptionContext The group to which the function belongs User data added to the #GOptionGroup containing the option when it was created with g_option_group_new()

Flags which modify individual options.

No flags. Since: 2.42. The option doesn't appear in `--help` output. The option appears in the main section of the `--help` output, even if it is defined in a group. For options of the %G_OPTION_ARG_NONE kind, this flag indicates that the sense of the option is reversed. i.e. %FALSE will be stored into the argument rather than %TRUE. For options of the %G_OPTION_ARG_CALLBACK kind, this flag indicates that the callback does not take any argument (like a %G_OPTION_ARG_NONE option). Since 2.8 For options of the %G_OPTION_ARG_CALLBACK kind, this flag indicates that the argument should be passed to the callback in the GLib filename encoding rather than UTF-8. Since 2.8 For options of the %G_OPTION_ARG_CALLBACK kind, this flag indicates that the argument supply is optional. If no argument is given then data of %GOptionParseFunc will be set to NULL. Since 2.8 This flag turns off the automatic conflict resolution which prefixes long option names with `groupname-` if there is a conflict. This option should only be used in situations where aliasing is necessary to model some legacy commandline interface. It is not safe to use this option, unless all option groups are under your direct control. Since 2.8.

A `GOptionGroup` struct defines the options in a single group. The struct has only private fields and should not be directly accessed. All options in a group share the same translation function. Libraries which need to parse commandline options are expected to provide a function for getting a `GOptionGroup` holding their options, which the application can then add to its #GOptionContext.

Creates a new #GOptionGroup.

a newly created option group. It should be added to a #GOptionContext or freed with g_option_group_unref().

the name for the option group, this is used to provide help for the options in this group with `--help-`@name a description for this group to be shown in `--help`. This string is translated using the translation domain or translation function of the group a description for the `--help-`@name option. This string is translated using the translation domain or translation function of the group user data that will be passed to the pre- and post-parse hooks, the error hook and to callbacks of %G_OPTION_ARG_CALLBACK options, or %NULL a function that will be called to free @user_data, or %NULL

Adds the options specified in @entries to @group.

a #GOptionGroup

a %NULL-terminated array of #GOptionEntrys

Frees a #GOptionGroup. Note that you must not free groups which have been added to a #GOptionContext.

Use g_option_group_unref() instead.

a #GOptionGroup

Increments the reference count of @group by one.

a #GOptionGroup

Associates a function with @group which will be called from g_option_context_parse() when an error occurs. Note that the user data to be passed to @error_func can be specified when constructing the group with g_option_group_new().

a #GOptionGroup

a function to call when an error occurs

Associates two functions with @group which will be called from g_option_context_parse() before the first option is parsed and after the last option has been parsed, respectively. Note that the user data to be passed to @pre_parse_func and @post_parse_func can be specified when constructing the group with g_option_group_new().

a #GOptionGroup

a function to call before parsing, or %NULL a function to call after parsing, or %NULL

Sets the function which is used to translate user-visible strings, for `--help` output. Different groups can use different #GTranslateFuncs. If @func is %NULL, strings are not translated. If you are using gettext(), you only need to set the translation domain, see g_option_group_set_translation_domain().

a #GOptionGroup

the #GTranslateFunc, or %NULL user data to pass to @func, or %NULL a function which gets called to free @data, or %NULL

A convenience function to use gettext() for translating user-visible strings.

a #GOptionGroup

the domain to use

Decrements the reference count of @group by one. If the reference count drops to 0, the @group will be freed. and all memory allocated by the @group is released.

a #GOptionGroup

The type of function that can be called before and after parsing.

%TRUE if the function completed successfully, %FALSE if an error occurred, in which case @error should be set with g_set_error()

The active #GOptionContext The group to which the function belongs User data added to the #GOptionGroup containing the option when it was created with g_option_group_new()

Specifies one of the possible types of byte order (currently unused). See %G_BYTE_ORDER.

The value of pi (ratio of circle's circumference to its diameter).

A format specifier that can be used in printf()-style format strings when printing a #GPid.

Pi divided by 2.

Pi divided by 4.

A format specifier that can be used in printf()-style format strings when printing the @fd member of a #GPollFD.

Use this for default priority event sources. In GLib this priority is used when adding timeout functions with g_timeout_add(). In GDK this priority is used for events from the X server.

Use this for default priority idle functions. In GLib this priority is used when adding idle functions with g_idle_add().

Use this for high priority event sources. It is not used within GLib or GTK+.

Use this for high priority idle functions. GTK+ uses %G_PRIORITY_HIGH_IDLE + 10 for resizing operations, and %G_PRIORITY_HIGH_IDLE + 20 for redrawing operations. (This is done to ensure that any pending resizes are processed before any pending redraws, so that widgets are not redrawn twice unnecessarily.)

Use this for very low priority background tasks. It is not used within GLib or GTK+.

A macro to assist with the static initialisation of a #GPrivate. This macro is useful for the case that a #GDestroyNotify function should be associated with the key. This is needed when the key will be used to point at memory that should be deallocated when the thread exits. Additionally, the #GDestroyNotify will also be called on the previous value stored in the key when g_private_replace() is used. If no #GDestroyNotify is needed, then use of this macro is not required -- if the #GPrivate is declared in static scope then it will be properly initialised by default (ie: to all zeros). See the examples below. |[ static GPrivate name_key = G_PRIVATE_INIT (g_free); // return value should not be freed const gchar * get_local_name (void) { return g_private_get (&name_key); } void set_local_name (const gchar *name) { g_private_replace (&name_key, g_strdup (name)); } static GPrivate count_key; // no free function gint get_local_count (void) { return GPOINTER_TO_INT (g_private_get (&count_key)); } void set_local_count (gint count) { g_private_set (&count_key, GINT_TO_POINTER (count)); } ]|

a #GDestroyNotify

A GPatternSpec struct is the 'compiled' form of a pattern. This structure is opaque and its fields cannot be accessed directly.

Compiles a pattern to a #GPatternSpec.

a newly-allocated #GPatternSpec

a zero-terminated UTF-8 encoded string

Copies @pspec in a new #GPatternSpec.

a copy of @pspec.

a #GPatternSpec

Compares two compiled pattern specs and returns whether they will match the same set of strings.

Whether the compiled patterns are equal

a #GPatternSpec

another #GPatternSpec

Frees the memory allocated for the #GPatternSpec.

a #GPatternSpec

Matches a string against a compiled pattern. Passing the correct length of the string given is mandatory. The reversed string can be omitted by passing %NULL, this is more efficient if the reversed version of the string to be matched is not at hand, as g_pattern_match() will only construct it if the compiled pattern requires reverse matches. Note that, if the user code will (possibly) match a string against a multitude of patterns containing wildcards, chances are high that some patterns will require a reversed string. In this case, it's more efficient to provide the reversed string to avoid multiple constructions thereof in the various calls to g_pattern_match(). Note also that the reverse of a UTF-8 encoded string can in general not be obtained by g_strreverse(). This works only if the string does not contain any multibyte characters. GLib offers the g_utf8_strreverse() function to reverse UTF-8 encoded strings.

%TRUE if @string matches @pspec

a #GPatternSpec

the length of @string (in bytes, i.e. strlen(), not g_utf8_strlen()) the UTF-8 encoded string to match the reverse of @string or %NULL

Matches a string against a compiled pattern. If the string is to be matched against more than one pattern, consider using g_pattern_match() instead while supplying the reversed string.

%TRUE if @string matches @pspec

a #GPatternSpec

the UTF-8 encoded string to match

Represents a file descriptor, which events to poll for, and which events occurred.

the file descriptor to poll (or a HANDLE on Win32) a bitwise combination from #GIOCondition, specifying which events should be polled for. Typically for reading from a file descriptor you would use %G_IO_IN | %G_IO_HUP | %G_IO_ERR, and for writing you would use %G_IO_OUT | %G_IO_ERR. a bitwise combination of flags from #GIOCondition, returned from the poll() function to indicate which events occurred.

Specifies the type of function passed to g_main_context_set_poll_func(). The semantics of the function should match those of the poll() system call.

the number of #GPollFD elements which have events or errors reported, or -1 if an error occurred.

an array of #GPollFD elements the number of elements in @ufds the maximum time to wait for an event of the file descriptors. A negative value indicates an infinite timeout.

Specifies the type of the print handler functions. These are called with the complete formatted string to output.

the message to output

The #GPrivate struct is an opaque data structure to represent a thread-local data key. It is approximately equivalent to the pthread_setspecific()/pthread_getspecific() APIs on POSIX and to TlsSetValue()/TlsGetValue() on Windows. If you don't already know why you might want this functionality, then you probably don't need it. #GPrivate is a very limited resource (as far as 128 per program, shared between all libraries). It is also not possible to destroy a #GPrivate after it has been used. As such, it is only ever acceptable to use #GPrivate in static scope, and even then sparingly so. See G_PRIVATE_INIT() for a couple of examples. The #GPrivate structure should be considered opaque. It should only be accessed via the g_private_ functions.

Returns the current value of the thread local variable @key. If the value has not yet been set in this thread, %NULL is returned. Values are never copied between threads (when a new thread is created, for example).

the thread-local value

a #GPrivate

Sets the thread local variable @key to have the value @value in the current thread. This function differs from g_private_set() in the following way: if the previous value was non-%NULL then the #GDestroyNotify handler for @key is run on it.

a #GPrivate

the new value

Sets the thread local variable @key to have the value @value in the current thread. This function differs from g_private_replace() in the following way: the #GDestroyNotify for @key is not called on the old value.

a #GPrivate

the new value

Contains the public fields of a pointer array.

points to the array of pointers, which may be moved when the array grows number of pointers in the array Adds a pointer to the end of the pointer array. The array will grow in size automatically if necessary.

a #GPtrArray the pointer to add

Makes a full (deep) copy of a #GPtrArray. @func, as a #GCopyFunc, takes two arguments, the data to be copied and a @user_data pointer. On common processor architectures, it's safe to pass %NULL as @user_data if the copy function takes only one argument. You may get compiler warnings from this though if compiling with GCC’s `-Wcast-function-type` warning. If @func is %NULL, then only the pointers (and not what they are pointing to) are copied to the new #GPtrArray. The copy of @array will have the same #GDestroyNotify for its elements as @array. The copy will also be %NULL terminated if (and only if) the source array is.

a deep copy of the initial #GPtrArray.

#GPtrArray to duplicate a copy function used to copy every element in the array user data passed to the copy function @func, or %NULL

Adds all pointers of @array to the end of the array @array_to_extend. The array will grow in size automatically if needed. @array_to_extend is modified in-place. @func, as a #GCopyFunc, takes two arguments, the data to be copied and a @user_data pointer. On common processor architectures, it's safe to pass %NULL as @user_data if the copy function takes only one argument. You may get compiler warnings from this though if compiling with GCC’s `-Wcast-function-type` warning. If @func is %NULL, then only the pointers (and not what they are pointing to) are copied to the new #GPtrArray. Whether @array_to_extend is %NULL terminated stays unchanged by this function.

a #GPtrArray. a #GPtrArray to add to the end of @array_to_extend. a copy function used to copy every element in the array user data passed to the copy function @func, or %NULL

Adds all the pointers in @array to the end of @array_to_extend, transferring ownership of each element from @array to @array_to_extend and modifying @array_to_extend in-place. @array is then freed. As with g_ptr_array_free(), @array will be destroyed if its reference count is 1. If its reference count is higher, it will be decremented and the length of @array set to zero.

a #GPtrArray. a #GPtrArray to add to the end of @array_to_extend.

Checks whether @needle exists in @haystack. If the element is found, %TRUE is returned and the element’s index is returned in @index_ (if non-%NULL). Otherwise, %FALSE is returned and @index_ is undefined. If @needle exists multiple times in @haystack, the index of the first instance is returned. This does pointer comparisons only. If you want to use more complex equality checks, such as string comparisons, use g_ptr_array_find_with_equal_func().

%TRUE if @needle is one of the elements of @haystack

pointer array to be searched pointer to look for return location for the index of the element, if found

Checks whether @needle exists in @haystack, using the given @equal_func. If the element is found, %TRUE is returned and the element’s index is returned in @index_ (if non-%NULL). Otherwise, %FALSE is returned and @index_ is undefined. If @needle exists multiple times in @haystack, the index of the first instance is returned. @equal_func is called with the element from the array as its first parameter, and @needle as its second parameter. If @equal_func is %NULL, pointer equality is used.

%TRUE if @needle is one of the elements of @haystack

pointer array to be searched pointer to look for the function to call for each element, which should return %TRUE when the desired element is found; or %NULL to use pointer equality return location for the index of the element, if found

Calls a function for each element of a #GPtrArray. @func must not add elements to or remove elements from the array.

a #GPtrArray the function to call for each array element user data to pass to the function

Frees the memory allocated for the #GPtrArray. If @free_seg is %TRUE it frees the memory block holding the elements as well. Pass %FALSE if you want to free the #GPtrArray wrapper but preserve the underlying array for use elsewhere. If the reference count of @array is greater than one, the #GPtrArray wrapper is preserved but the size of @array will be set to zero. If array contents point to dynamically-allocated memory, they should be freed separately if @free_seg is %TRUE and no #GDestroyNotify function has been set for @array. Note that if the array is %NULL terminated and @free_seg is %FALSE then this will always return an allocated %NULL terminated buffer. If pdata is previously %NULL, a new buffer will be allocated. This function is not thread-safe. If using a #GPtrArray from multiple threads, use only the atomic g_ptr_array_ref() and g_ptr_array_unref() functions.

the pointer array if @free_seg is %FALSE, otherwise %NULL. The pointer array should be freed using g_free().

a #GPtrArray if %TRUE the actual pointer array is freed as well

Inserts an element into the pointer array at the given index. The array will grow in size automatically if necessary.

a #GPtrArray the index to place the new element at, or -1 to append the pointer to add.

Gets whether the @array was constructed as %NULL-terminated. This will only return %TRUE for arrays constructed by passing %TRUE to the `null_terminated` argument of g_ptr_array_new_null_terminated(). It will not return %TRUE for normal arrays which have had a %NULL element appended to them.

%TRUE if the array is made to be %NULL terminated.

the #GPtrArray

Creates a new #GPtrArray with a reference count of 1.

the new #GPtrArray

Creates a new #GPtrArray with @reserved_size pointers preallocated and a reference count of 1. This avoids frequent reallocation, if you are going to add many pointers to the array. Note however that the size of the array is still 0. It also set @element_free_func for freeing each element when the array is destroyed either via g_ptr_array_unref(), when g_ptr_array_free() is called with @free_segment set to %TRUE or when removing elements.

A new #GPtrArray

number of pointers preallocated A function to free elements with destroy @array or %NULL

Like g_ptr_array_new_full() but also allows to set the array to be %NULL terminated. A %NULL terminated pointer array has an additional %NULL pointer after the last element, beyond the current length. #GPtrArray created by other constructors are not automatically %NULL terminated. Note that if the @array's length is zero and currently no data array is allocated, then pdata will still be %NULL. %GPtrArray will only %NULL terminate pdata, if an actual array is allocated. It does not guarantee that an array is always allocated. In other words, if the length is zero, then pdata may either point to a %NULL terminated array of length zero or be %NULL.

A new #GPtrArray

number of pointers preallocated. If @null_terminated is %TRUE, the actually allocated buffer size is @reserved_size plus 1, unless @reserved_size is zero, in which case no initial buffer gets allocated. A function to free elements with destroy @array or %NULL whether to make the array as %NULL terminated.

Creates a new #GPtrArray with a reference count of 1 and use @element_free_func for freeing each element when the array is destroyed either via g_ptr_array_unref(), when g_ptr_array_free() is called with @free_segment set to %TRUE or when removing elements.

A new #GPtrArray

A function to free elements with destroy @array or %NULL

Atomically increments the reference count of @array by one. This function is thread-safe and may be called from any thread.

The passed in #GPtrArray

a #GPtrArray

Removes the first occurrence of the given pointer from the pointer array. The following elements are moved down one place. If @array has a non-%NULL #GDestroyNotify function it is called for the removed element. It returns %TRUE if the pointer was removed, or %FALSE if the pointer was not found.

%TRUE if the pointer is removed, %FALSE if the pointer is not found in the array

a #GPtrArray the pointer to remove

Removes the first occurrence of the given pointer from the pointer array. The last element in the array is used to fill in the space, so this function does not preserve the order of the array. But it is faster than g_ptr_array_remove(). If @array has a non-%NULL #GDestroyNotify function it is called for the removed element. It returns %TRUE if the pointer was removed, or %FALSE if the pointer was not found.

%TRUE if the pointer was found in the array

a #GPtrArray the pointer to remove

Removes the pointer at the given index from the pointer array. The following elements are moved down one place. If @array has a non-%NULL #GDestroyNotify function it is called for the removed element. If so, the return value from this function will potentially point to freed memory (depending on the #GDestroyNotify implementation).

the pointer which was removed

a #GPtrArray the index of the pointer to remove

Removes the pointer at the given index from the pointer array. The last element in the array is used to fill in the space, so this function does not preserve the order of the array. But it is faster than g_ptr_array_remove_index(). If @array has a non-%NULL #GDestroyNotify function it is called for the removed element. If so, the return value from this function will potentially point to freed memory (depending on the #GDestroyNotify implementation).

the pointer which was removed

a #GPtrArray the index of the pointer to remove

Removes the given number of pointers starting at the given index from a #GPtrArray. The following elements are moved to close the gap. If @array has a non-%NULL #GDestroyNotify function it is called for the removed elements.

the @array

a @GPtrArray the index of the first pointer to remove the number of pointers to remove

Sets a function for freeing each element when @array is destroyed either via g_ptr_array_unref(), when g_ptr_array_free() is called with @free_segment set to %TRUE or when removing elements.

A #GPtrArray A function to free elements with destroy @array or %NULL

Sets the size of the array. When making the array larger, newly-added elements will be set to %NULL. When making it smaller, if @array has a non-%NULL #GDestroyNotify function then it will be called for the removed elements.

a #GPtrArray the new length of the pointer array

the new #GPtrArray

number of pointers preallocated

Sorts the array, using @compare_func which should be a qsort()-style comparison function (returns less than zero for first arg is less than second arg, zero for equal, greater than zero if irst arg is greater than second arg). Note that the comparison function for g_ptr_array_sort() doesn't take the pointers from the array as arguments, it takes pointers to the pointers in the array. Here is a full example of usage: |[ typedef struct { gchar *name; gint size; } FileListEntry; static gint sort_filelist (gconstpointer a, gconstpointer b) { const FileListEntry *entry1 = *((FileListEntry **) a); const FileListEntry *entry2 = *((FileListEntry **) b); return g_ascii_strcasecmp (entry1->name, entry2->name); } … g_autoptr (GPtrArray) file_list = NULL; // initialize file_list array and load with many FileListEntry entries ... // now sort it with g_ptr_array_sort (file_list, sort_filelist); ]| This is guaranteed to be a stable sort since version 2.32.

a #GPtrArray comparison function

Like g_ptr_array_sort(), but the comparison function has an extra user data argument. Note that the comparison function for g_ptr_array_sort_with_data() doesn't take the pointers from the array as arguments, it takes pointers to the pointers in the array. Here is a full example of use: |[ typedef enum { SORT_NAME, SORT_SIZE } SortMode; typedef struct { gchar *name; gint size; } FileListEntry; static gint sort_filelist (gconstpointer a, gconstpointer b, gpointer user_data) { gint order; const SortMode sort_mode = GPOINTER_TO_INT (user_data); const FileListEntry *entry1 = *((FileListEntry **) a); const FileListEntry *entry2 = *((FileListEntry **) b); switch (sort_mode) { case SORT_NAME: order = g_ascii_strcasecmp (entry1->name, entry2->name); break; case SORT_SIZE: order = entry1->size - entry2->size; break; default: order = 0; break; } return order; } ... g_autoptr (GPtrArray) file_list = NULL; SortMode sort_mode; // initialize file_list array and load with many FileListEntry entries ... // now sort it with sort_mode = SORT_NAME; g_ptr_array_sort_with_data (file_list, sort_filelist, GINT_TO_POINTER (sort_mode)); ]| This is guaranteed to be a stable sort since version 2.32.

a #GPtrArray comparison function data to pass to @compare_func

Frees the data in the array and resets the size to zero, while the underlying array is preserved for use elsewhere and returned to the caller. Note that if the array is %NULL terminated this may still return %NULL if the length of the array was zero and pdata was not yet allocated. Even if set, the #GDestroyNotify function will never be called on the current contents of the array and the caller is responsible for freeing the array elements. An example of use: |[ g_autoptr(GPtrArray) chunk_buffer = g_ptr_array_new_with_free_func (g_bytes_unref); // Some part of your application appends a number of chunks to the pointer array. g_ptr_array_add (chunk_buffer, g_bytes_new_static ("hello", 5)); g_ptr_array_add (chunk_buffer, g_bytes_new_static ("world", 5)); … // Periodically, the chunks need to be sent as an array-and-length to some // other part of the program. GBytes **chunks; gsize n_chunks; chunks = g_ptr_array_steal (chunk_buffer, &n_chunks); for (gsize i = 0; i < n_chunks; i++) { // Do something with each chunk here, and then free them, since // g_ptr_array_steal() transfers ownership of all the elements and the // array to the caller. … g_bytes_unref (chunks[i]); } g_free (chunks); // After calling g_ptr_array_steal(), the pointer array can be reused for the // next set of chunks. g_assert (chunk_buffer->len == 0); ]|

the element data, which should be freed using g_free(). This may be %NULL if the array doesn’t have any elements (i.e. if `*len` is zero).

a #GPtrArray. pointer to retrieve the number of elements of the original array

Removes the pointer at the given index from the pointer array. The following elements are moved down one place. The #GDestroyNotify for @array is *not* called on the removed element; ownership is transferred to the caller of this function.

the pointer which was removed

a #GPtrArray the index of the pointer to steal

Removes the pointer at the given index from the pointer array. The last element in the array is used to fill in the space, so this function does not preserve the order of the array. But it is faster than g_ptr_array_steal_index(). The #GDestroyNotify for @array is *not* called on the removed element; ownership is transferred to the caller of this function.

the pointer which was removed

a #GPtrArray the index of the pointer to steal

Atomically decrements the reference count of @array by one. If the reference count drops to 0, the effect is the same as calling g_ptr_array_free() with @free_segment set to %TRUE. This function is thread-safe and may be called from any thread.

A #GPtrArray

Contains the public fields of a [Queue][glib-Double-ended-Queues].

a pointer to the first element of the queue a pointer to the last element of the queue the number of elements in the queue Removes all the elements in @queue. If queue elements contain dynamically-allocated memory, they should be freed first.

a #GQueue

Convenience method, which frees all the memory used by a #GQueue, and calls the provided @free_func on each item in the #GQueue.

a pointer to a #GQueue

the function to be called to free memory allocated

Copies a @queue. Note that is a shallow copy. If the elements in the queue consist of pointers to data, the pointers are copied, but the actual data is not.

a copy of @queue

a #GQueue

Removes @link_ from @queue and frees it. @link_ must be part of @queue.

a #GQueue

a #GList link that must be part of @queue

Finds the first link in @queue which contains @data.

the first link in @queue which contains @data

a #GQueue

data to find

Finds an element in a #GQueue, using a supplied function to find the desired element. It iterates over the queue, calling the given function which should return 0 when the desired element is found. The function takes two gconstpointer arguments, the #GQueue element's data as the first argument and the given user data as the second argument.

the found link, or %NULL if it wasn't found

a #GQueue

user data passed to @func a #GCompareFunc to call for each element. It should return 0 when the desired element is found

Calls @func for each element in the queue passing @user_data to the function. It is safe for @func to remove the element from @queue, but it must not modify any part of the queue after that element.

a #GQueue

the function to call for each element's data user data to pass to @func

Frees the memory allocated for the #GQueue. Only call this function if @queue was created with g_queue_new(). If queue elements contain dynamically-allocated memory, they should be freed first. If queue elements contain dynamically-allocated memory, you should either use g_queue_free_full() or free them manually first.

a #GQueue

Convenience method, which frees all the memory used by a #GQueue, and calls the specified destroy function on every element's data. @free_func should not modify the queue (eg, by removing the freed element from it).

a pointer to a #GQueue

the function to be called to free each element's data

Returns the number of items in @queue.

the number of items in @queue

a #GQueue

Returns the position of the first element in @queue which contains @data.

the position of the first element in @queue which contains @data, or -1 if no element in @queue contains @data

a #GQueue

the data to find

A statically-allocated #GQueue must be initialized with this function before it can be used. Alternatively you can initialize it with %G_QUEUE_INIT. It is not necessary to initialize queues created with g_queue_new().

an uninitialized #GQueue

Inserts @data into @queue after @sibling. @sibling must be part of @queue. Since GLib 2.44 a %NULL sibling pushes the data at the head of the queue.

a #GQueue

a #GList link that must be part of @queue, or %NULL to push at the head of the queue. the data to insert

Inserts @link_ into @queue after @sibling. @sibling must be part of @queue.

a #GQueue

a #GList link that must be part of @queue, or %NULL to push at the head of the queue. a #GList link to insert which must not be part of any other list.

Inserts @data into @queue before @sibling. @sibling must be part of @queue. Since GLib 2.44 a %NULL sibling pushes the data at the tail of the queue.

a #GQueue

a #GList link that must be part of @queue, or %NULL to push at the tail of the queue. the data to insert

Inserts @link_ into @queue before @sibling. @sibling must be part of @queue.

a #GQueue

a #GList link that must be part of @queue, or %NULL to push at the tail of the queue. a #GList link to insert which must not be part of any other list.

Inserts @data into @queue using @func to determine the new position.

a #GQueue

the data to insert the #GCompareDataFunc used to compare elements in the queue. It is called with two elements of the @queue and @user_data. It should return 0 if the elements are equal, a negative value if the first element comes before the second, and a positive value if the second element comes before the first. user data passed to @func

Returns %TRUE if the queue is empty.

%TRUE if the queue is empty

a #GQueue.

Returns the position of @link_ in @queue.

the position of @link_, or -1 if the link is not part of @queue

a #GQueue

a #GList link

Returns the first element of the queue.

the data of the first element in the queue, or %NULL if the queue is empty

a #GQueue

Returns the first link in @queue.

the first link in @queue, or %NULL if @queue is empty

a #GQueue

Returns the @n'th element of @queue.

the data for the @n'th element of @queue, or %NULL if @n is off the end of @queue

a #GQueue

the position of the element

Returns the link at the given position

the link at the @n'th position, or %NULL if @n is off the end of the list

a #GQueue

the position of the link

Returns the last element of the queue.

the data of the last element in the queue, or %NULL if the queue is empty

a #GQueue

Returns the last link in @queue.

the last link in @queue, or %NULL if @queue is empty

a #GQueue

Removes the first element of the queue and returns its data.

the data of the first element in the queue, or %NULL if the queue is empty

a #GQueue

Removes and returns the first element of the queue.

the #GList element at the head of the queue, or %NULL if the queue is empty

a #GQueue

Removes the @n'th element of @queue and returns its data.

the element's data, or %NULL if @n is off the end of @queue

a #GQueue

the position of the element

Removes and returns the link at the given position.

the @n'th link, or %NULL if @n is off the end of @queue

a #GQueue

the link's position

Removes the last element of the queue and returns its data.

the data of the last element in the queue, or %NULL if the queue is empty

a #GQueue

Removes and returns the last element of the queue.

the #GList element at the tail of the queue, or %NULL if the queue is empty

a #GQueue

Adds a new element at the head of the queue.

a #GQueue.

the data for the new element.

Adds a new element at the head of the queue.

a #GQueue

a single #GList element, not a list with more than one element

Inserts a new element into @queue at the given position.

a #GQueue

the data for the new element the position to insert the new element. If @n is negative or larger than the number of elements in the @queue, the element is added to the end of the queue.

Inserts @link into @queue at the given position.

a #GQueue

the position to insert the link. If this is negative or larger than the number of elements in @queue, the link is added to the end of @queue. the link to add to @queue

Adds a new element at the tail of the queue.

a #GQueue

the data for the new element

Adds a new element at the tail of the queue.

a #GQueue

a single #GList element, not a list with more than one element

Removes the first element in @queue that contains @data.

%TRUE if @data was found and removed from @queue

a #GQueue

the data to remove

Remove all elements whose data equals @data from @queue.

the number of elements removed from @queue

a #GQueue

the data to remove

Reverses the order of the items in @queue.

a #GQueue

Sorts @queue using @compare_func.

a #GQueue

the #GCompareDataFunc used to sort @queue. This function is passed two elements of the queue and should return 0 if they are equal, a negative value if the first comes before the second, and a positive value if the second comes before the first. user data passed to @compare_func

Unlinks @link_ so that it will no longer be part of @queue. The link is not freed. @link_ must be part of @queue.

a #GQueue

a #GList link that must be part of @queue

Creates a new #GQueue.

a newly allocated #GQueue

The GRWLock struct is an opaque data structure to represent a reader-writer lock. It is similar to a #GMutex in that it allows multiple threads to coordinate access to a shared resource. The difference to a mutex is that a reader-writer lock discriminates between read-only ('reader') and full ('writer') access. While only one thread at a time is allowed write access (by holding the 'writer' lock via g_rw_lock_writer_lock()), multiple threads can gain simultaneous read-only access (by holding the 'reader' lock via g_rw_lock_reader_lock()). It is unspecified whether readers or writers have priority in acquiring the lock when a reader already holds the lock and a writer is queued to acquire it. Here is an example for an array with access functions: |[ GRWLock lock; GPtrArray *array; gpointer my_array_get (guint index) { gpointer retval = NULL; if (!array) return NULL; g_rw_lock_reader_lock (&lock); if (index < array->len) retval = g_ptr_array_index (array, index); g_rw_lock_reader_unlock (&lock); return retval; } void my_array_set (guint index, gpointer data) { g_rw_lock_writer_lock (&lock); if (!array) array = g_ptr_array_new (); if (index >= array->len) g_ptr_array_set_size (array, index+1); g_ptr_array_index (array, index) = data; g_rw_lock_writer_unlock (&lock); } ]| This example shows an array which can be accessed by many readers (the my_array_get() function) simultaneously, whereas the writers (the my_array_set() function) will only be allowed one at a time and only if no readers currently access the array. This is because of the potentially dangerous resizing of the array. Using these functions is fully multi-thread safe now. If a #GRWLock is allocated in static storage then it can be used without initialisation. Otherwise, you should call g_rw_lock_init() on it and g_rw_lock_clear() when done. A GRWLock should only be accessed with the g_rw_lock_ functions.

Frees the resources allocated to a lock with g_rw_lock_init(). This function should not be used with a #GRWLock that has been statically allocated. Calling g_rw_lock_clear() when any thread holds the lock leads to undefined behaviour.

an initialized #GRWLock

Initializes a #GRWLock so that it can be used. This function is useful to initialize a lock that has been allocated on the stack, or as part of a larger structure. It is not necessary to initialise a reader-writer lock that has been statically allocated. |[ typedef struct { GRWLock l; ... } Blob; Blob *b; b = g_new (Blob, 1); g_rw_lock_init (&b->l); ]| To undo the effect of g_rw_lock_init() when a lock is no longer needed, use g_rw_lock_clear(). Calling g_rw_lock_init() on an already initialized #GRWLock leads to undefined behaviour.

an uninitialized #GRWLock

Obtain a read lock on @rw_lock. If another thread currently holds the write lock on @rw_lock, the current thread will block until the write lock was (held and) released. If another thread does not hold the write lock, but is waiting for it, it is implementation defined whether the reader or writer will block. Read locks can be taken recursively. Calling g_rw_lock_reader_lock() while the current thread already owns a write lock leads to undefined behaviour. Read locks however can be taken recursively, in which case you need to make sure to call g_rw_lock_reader_unlock() the same amount of times. It is implementation-defined how many read locks are allowed to be held on the same lock simultaneously. If the limit is hit, or if a deadlock is detected, a critical warning will be emitted.

a #GRWLock

Tries to obtain a read lock on @rw_lock and returns %TRUE if the read lock was successfully obtained. Otherwise it returns %FALSE.

%TRUE if @rw_lock could be locked

a #GRWLock

Release a read lock on @rw_lock. Calling g_rw_lock_reader_unlock() on a lock that is not held by the current thread leads to undefined behaviour.

a #GRWLock

Obtain a write lock on @rw_lock. If another thread currently holds a read or write lock on @rw_lock, the current thread will block until all other threads have dropped their locks on @rw_lock. Calling g_rw_lock_writer_lock() while the current thread already owns a read or write lock on @rw_lock leads to undefined behaviour.

a #GRWLock

Tries to obtain a write lock on @rw_lock. If another thread currently holds a read or write lock on @rw_lock, it immediately returns %FALSE. Otherwise it locks @rw_lock and returns %TRUE.

%TRUE if @rw_lock could be locked

a #GRWLock

Release a write lock on @rw_lock. Calling g_rw_lock_writer_unlock() on a lock that is not held by the current thread leads to undefined behaviour.

a #GRWLock

The GRand struct is an opaque data structure. It should only be accessed through the g_rand_* functions.

Copies a #GRand into a new one with the same exact state as before. This way you can take a snapshot of the random number generator for replaying later.

the new #GRand

a #GRand

Returns the next random #gdouble from @rand_ equally distributed over the range [0..1).

a random number

a #GRand

Returns the next random #gdouble from @rand_ equally distributed over the range [@begin..@end).

a random number

a #GRand

lower closed bound of the interval upper open bound of the interval

Frees the memory allocated for the #GRand.

a #GRand

Returns the next random #guint32 from @rand_ equally distributed over the range [0..2^32-1].

a random number

a #GRand

Returns the next random #gint32 from @rand_ equally distributed over the range [@begin..@end-1].

a random number

a #GRand

lower closed bound of the interval upper open bound of the interval

Sets the seed for the random number generator #GRand to @seed.

a #GRand

a value to reinitialize the random number generator

Initializes the random number generator by an array of longs. Array can be of arbitrary size, though only the first 624 values are taken. This function is useful if you have many low entropy seeds, or if you require more then 32 bits of actual entropy for your application.

a #GRand

array to initialize with length of array

Creates a new random number generator initialized with a seed taken either from `/dev/urandom` (if existing) or from the current time (as a fallback). On Windows, the seed is taken from rand_s().

the new #GRand

Creates a new random number generator initialized with @seed.

the new #GRand

a value to initialize the random number generator

Creates a new random number generator initialized with @seed.

the new #GRand

an array of seeds to initialize the random number generator an array of seeds to initialize the random number generator

The GRecMutex struct is an opaque data structure to represent a recursive mutex. It is similar to a #GMutex with the difference that it is possible to lock a GRecMutex multiple times in the same thread without deadlock. When doing so, care has to be taken to unlock the recursive mutex as often as it has been locked. If a #GRecMutex is allocated in static storage then it can be used without initialisation. Otherwise, you should call g_rec_mutex_init() on it and g_rec_mutex_clear() when done. A GRecMutex should only be accessed with the g_rec_mutex_ functions.

Frees the resources allocated to a recursive mutex with g_rec_mutex_init(). This function should not be used with a #GRecMutex that has been statically allocated. Calling g_rec_mutex_clear() on a locked recursive mutex leads to undefined behaviour.

an initialized #GRecMutex

Initializes a #GRecMutex so that it can be used. This function is useful to initialize a recursive mutex that has been allocated on the stack, or as part of a larger structure. It is not necessary to initialise a recursive mutex that has been statically allocated. |[ typedef struct { GRecMutex m; ... } Blob; Blob *b; b = g_new (Blob, 1); g_rec_mutex_init (&b->m); ]| Calling g_rec_mutex_init() on an already initialized #GRecMutex leads to undefined behaviour. To undo the effect of g_rec_mutex_init() when a recursive mutex is no longer needed, use g_rec_mutex_clear().

an uninitialized #GRecMutex

Locks @rec_mutex. If @rec_mutex is already locked by another thread, the current thread will block until @rec_mutex is unlocked by the other thread. If @rec_mutex is already locked by the current thread, the 'lock count' of @rec_mutex is increased. The mutex will only become available again when it is unlocked as many times as it has been locked.

a #GRecMutex

Tries to lock @rec_mutex. If @rec_mutex is already locked by another thread, it immediately returns %FALSE. Otherwise it locks @rec_mutex and returns %TRUE.

%TRUE if @rec_mutex could be locked

a #GRecMutex

Unlocks @rec_mutex. If another thread is blocked in a g_rec_mutex_lock() call for @rec_mutex, it will become unblocked and can lock @rec_mutex itself. Calling g_rec_mutex_unlock() on a recursive mutex that is not locked by the current thread leads to undefined behaviour.

a #GRecMutex

The g_regex_*() functions implement regular expression pattern matching using syntax and semantics similar to Perl regular expression. Some functions accept a @start_position argument, setting it differs from just passing over a shortened string and setting %G_REGEX_MATCH_NOTBOL in the case of a pattern that begins with any kind of lookbehind assertion. For example, consider the pattern "\Biss\B" which finds occurrences of "iss" in the middle of words. ("\B" matches only if the current position in the subject is not a word boundary.) When applied to the string "Mississipi" from the fourth byte, namely "issipi", it does not match, because "\B" is always false at the start of the subject, which is deemed to be a word boundary. However, if the entire string is passed , but with @start_position set to 4, it finds the second occurrence of "iss" because it is able to look behind the starting point to discover that it is preceded by a letter. Note that, unless you set the %G_REGEX_RAW flag, all the strings passed to these functions must be encoded in UTF-8. The lengths and the positions inside the strings are in bytes and not in characters, so, for instance, "\xc3\xa0" (i.e. "à") is two bytes long but it is treated as a single character. If you set %G_REGEX_RAW the strings can be non-valid UTF-8 strings and a byte is treated as a character, so "\xc3\xa0" is two bytes and two characters long. When matching a pattern, "\n" matches only against a "\n" character in the string, and "\r" matches only a "\r" character. To match any newline sequence use "\R". This particular group matches either the two-character sequence CR + LF ("\r\n"), or one of the single characters LF (linefeed, U+000A, "\n"), VT vertical tab, U+000B, "\v"), FF (formfeed, U+000C, "\f"), CR (carriage return, U+000D, "\r"), NEL (next line, U+0085), LS (line separator, U+2028), or PS (paragraph separator, U+2029). The behaviour of the dot, circumflex, and dollar metacharacters are affected by newline characters, the default is to recognize any newline character (the same characters recognized by "\R"). This can be changed with %G_REGEX_NEWLINE_CR, %G_REGEX_NEWLINE_LF and %G_REGEX_NEWLINE_CRLF compile options, and with %G_REGEX_MATCH_NEWLINE_ANY, %G_REGEX_MATCH_NEWLINE_CR, %G_REGEX_MATCH_NEWLINE_LF and %G_REGEX_MATCH_NEWLINE_CRLF match options. These settings are also relevant when compiling a pattern if %G_REGEX_EXTENDED is set, and an unescaped "#" outside a character class is encountered. This indicates a comment that lasts until after the next newline. Creating and manipulating the same #GRegex structure from different threads is not a problem as #GRegex does not modify its internal state between creation and destruction, on the other hand #GMatchInfo is not threadsafe. The regular expressions low-level functionalities are obtained through the excellent [PCRE](http://www.pcre.org/) library written by Philip Hazel.

Compiles the regular expression to an internal form, and does the initial setup of the #GRegex structure.

a #GRegex structure or %NULL if an error occurred. Call g_regex_unref() when you are done with it

the regular expression compile options for the regular expression, or 0 match options for the regular expression, or 0

Returns the number of capturing subpatterns in the pattern.

the number of capturing subpatterns

a #GRegex

Returns the compile options that @regex was created with. Depending on the version of PCRE that is used, this may or may not include flags set by option expressions such as `(?i)` found at the top-level within the compiled pattern.

flags from #GRegexCompileFlags

a #GRegex

Checks whether the pattern contains explicit CR or LF references.

%TRUE if the pattern contains explicit CR or LF references

a #GRegex structure

Returns the match options that @regex was created with.

flags from #GRegexMatchFlags

a #GRegex

Returns the number of the highest back reference in the pattern, or 0 if the pattern does not contain back references.

the number of the highest back reference

a #GRegex

Gets the number of characters in the longest lookbehind assertion in the pattern. This information is useful when doing multi-segment matching using the partial matching facilities.

the number of characters in the longest lookbehind assertion.

a #GRegex structure

Gets the pattern string associated with @regex, i.e. a copy of the string passed to g_regex_new().

the pattern of @regex

a #GRegex structure

Retrieves the number of the subexpression named @name.

The number of the subexpression or -1 if @name does not exists

#GRegex structure

name of the subexpression

Scans for a match in @string for the pattern in @regex. The @match_options are combined with the match options specified when the @regex structure was created, letting you have more flexibility in reusing #GRegex structures. Unless %G_REGEX_RAW is specified in the options, @string must be valid UTF-8. A #GMatchInfo structure, used to get information on the match, is stored in @match_info if not %NULL. Note that if @match_info is not %NULL then it is created even if the function returns %FALSE, i.e. you must free it regardless if regular expression actually matched. To retrieve all the non-overlapping matches of the pattern in string you can use g_match_info_next(). |[ static void print_uppercase_words (const gchar *string) { // Print all uppercase-only words. GRegex *regex; GMatchInfo *match_info; regex = g_regex_new ("[A-Z]+", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, NULL); g_regex_match (regex, string, 0, &match_info); while (g_match_info_matches (match_info)) { gchar *word = g_match_info_fetch (match_info, 0); g_print ("Found: %s\n", word); g_free (word); g_match_info_next (match_info, NULL); } g_match_info_free (match_info); g_regex_unref (regex); } ]| @string is not copied and is used in #GMatchInfo internally. If you use any #GMatchInfo method (except g_match_info_free()) after freeing or modifying @string then the behaviour is undefined.

%TRUE is the string matched, %FALSE otherwise

a #GRegex structure from g_regex_new()

the string to scan for matches match options pointer to location where to store the #GMatchInfo, or %NULL if you do not need it

Using the standard algorithm for regular expression matching only the longest match in the string is retrieved. This function uses a different algorithm so it can retrieve all the possible matches. For more documentation see g_regex_match_all_full(). A #GMatchInfo structure, used to get information on the match, is stored in @match_info if not %NULL. Note that if @match_info is not %NULL then it is created even if the function returns %FALSE, i.e. you must free it regardless if regular expression actually matched. @string is not copied and is used in #GMatchInfo internally. If you use any #GMatchInfo method (except g_match_info_free()) after freeing or modifying @string then the behaviour is undefined.

%TRUE is the string matched, %FALSE otherwise

a #GRegex structure from g_regex_new()

the string to scan for matches match options pointer to location where to store the #GMatchInfo, or %NULL if you do not need it

Using the standard algorithm for regular expression matching only the longest match in the @string is retrieved, it is not possible to obtain all the available matches. For instance matching "<a> <c>" against the pattern "<.*>" you get "<a> <c>". This function uses a different algorithm (called DFA, i.e. deterministic finite automaton), so it can retrieve all the possible matches, all starting at the same point in the string. For instance matching "<a> <c>" against the pattern "<.*>;" you would obtain three matches: "<a> <c>", "<a> " and "<a>". The number of matched strings is retrieved using g_match_info_get_match_count(). To obtain the matched strings and their position you can use, respectively, g_match_info_fetch() and g_match_info_fetch_pos(). Note that the strings are returned in reverse order of length; that is, the longest matching string is given first. Note that the DFA algorithm is slower than the standard one and it is not able to capture substrings, so backreferences do not work. Setting @start_position differs from just passing over a shortened string and setting %G_REGEX_MATCH_NOTBOL in the case of a pattern that begins with any kind of lookbehind assertion, such as "\b". Unless %G_REGEX_RAW is specified in the options, @string must be valid UTF-8. A #GMatchInfo structure, used to get information on the match, is stored in @match_info if not %NULL. Note that if @match_info is not %NULL then it is created even if the function returns %FALSE, i.e. you must free it regardless if regular expression actually matched. @string is not copied and is used in #GMatchInfo internally. If you use any #GMatchInfo method (except g_match_info_free()) after freeing or modifying @string then the behaviour is undefined.

%TRUE is the string matched, %FALSE otherwise

a #GRegex structure from g_regex_new()

the string to scan for matches the length of @string, in bytes, or -1 if @string is nul-terminated starting index of the string to match, in bytes match options pointer to location where to store the #GMatchInfo, or %NULL if you do not need it

Scans for a match in @string for the pattern in @regex. The @match_options are combined with the match options specified when the @regex structure was created, letting you have more flexibility in reusing #GRegex structures. Setting @start_position differs from just passing over a shortened string and setting %G_REGEX_MATCH_NOTBOL in the case of a pattern that begins with any kind of lookbehind assertion, such as "\b". Unless %G_REGEX_RAW is specified in the options, @string must be valid UTF-8. A #GMatchInfo structure, used to get information on the match, is stored in @match_info if not %NULL. Note that if @match_info is not %NULL then it is created even if the function returns %FALSE, i.e. you must free it regardless if regular expression actually matched. @string is not copied and is used in #GMatchInfo internally. If you use any #GMatchInfo method (except g_match_info_free()) after freeing or modifying @string then the behaviour is undefined. To retrieve all the non-overlapping matches of the pattern in string you can use g_match_info_next(). |[ static void print_uppercase_words (const gchar *string) { // Print all uppercase-only words. GRegex *regex; GMatchInfo *match_info; GError *error = NULL; regex = g_regex_new ("[A-Z]+", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, NULL); g_regex_match_full (regex, string, -1, 0, 0, &match_info, &error); while (g_match_info_matches (match_info)) { gchar *word = g_match_info_fetch (match_info, 0); g_print ("Found: %s\n", word); g_free (word); g_match_info_next (match_info, &error); } g_match_info_free (match_info); g_regex_unref (regex); if (error != NULL) { g_printerr ("Error while matching: %s\n", error->message); g_error_free (error); } } ]|

%TRUE is the string matched, %FALSE otherwise

a #GRegex structure from g_regex_new()

Increases reference count of @regex by 1.

@regex

a #GRegex

Replaces all occurrences of the pattern in @regex with the replacement text. Backreferences of the form '\number' or '\g<number>' in the replacement text are interpolated by the number-th captured subexpression of the match, '\g<name>' refers to the captured subexpression with the given name. '\0' refers to the complete match, but '\0' followed by a number is the octal representation of a character. To include a literal '\' in the replacement, write '\\\\'. There are also escapes that changes the case of the following text: - \l: Convert to lower case the next character - \u: Convert to upper case the next character - \L: Convert to lower case till \E - \U: Convert to upper case till \E - \E: End case modification If you do not need to use backreferences use g_regex_replace_literal(). The @replacement string must be UTF-8 encoded even if %G_REGEX_RAW was passed to g_regex_new(). If you want to use not UTF-8 encoded strings you can use g_regex_replace_literal(). Setting @start_position differs from just passing over a shortened string and setting %G_REGEX_MATCH_NOTBOL in the case of a pattern that begins with any kind of lookbehind assertion, such as "\b".

a newly allocated string containing the replacements

a #GRegex structure

the string to perform matches against the length of @string, in bytes, or -1 if @string is nul-terminated starting index of the string to match, in bytes text to replace each match with options for the match

Replaces occurrences of the pattern in regex with the output of @eval for that occurrence. Setting @start_position differs from just passing over a shortened string and setting %G_REGEX_MATCH_NOTBOL in the case of a pattern that begins with any kind of lookbehind assertion, such as "\b". The following example uses g_regex_replace_eval() to replace multiple strings at once: |[ static gboolean eval_cb (const GMatchInfo *info, GString *res, gpointer data) { gchar *match; gchar *r; match = g_match_info_fetch (info, 0); r = g_hash_table_lookup ((GHashTable *)data, match); g_string_append (res, r); g_free (match); return FALSE; } ... GRegex *reg; GHashTable *h; gchar *res; h = g_hash_table_new (g_str_hash, g_str_equal); g_hash_table_insert (h, "1", "ONE"); g_hash_table_insert (h, "2", "TWO"); g_hash_table_insert (h, "3", "THREE"); g_hash_table_insert (h, "4", "FOUR"); reg = g_regex_new ("1|2|3|4", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, NULL); res = g_regex_replace_eval (reg, text, -1, 0, 0, eval_cb, h, NULL); g_hash_table_destroy (h); ... ]|

a newly allocated string containing the replacements

a #GRegex structure from g_regex_new()

string to perform matches against the length of @string, in bytes, or -1 if @string is nul-terminated starting index of the string to match, in bytes options for the match a function to call for each match user data to pass to the function

Replaces all occurrences of the pattern in @regex with the replacement text. @replacement is replaced literally, to include backreferences use g_regex_replace(). Setting @start_position differs from just passing over a shortened string and setting %G_REGEX_MATCH_NOTBOL in the case of a pattern that begins with any kind of lookbehind assertion, such as "\b".

a newly allocated string containing the replacements

a #GRegex structure

a %NULL-terminated gchar ** array. Free it using g_strfreev()

a #GRegex structure

the string to split with the pattern match time option flags

Breaks the string on the pattern, and returns an array of the tokens. If the pattern contains capturing parentheses, then the text for each of the substrings will also be returned. If the pattern does not match anywhere in the string, then the whole string is returned as the first token. As a special case, the result of splitting the empty string "" is an empty vector, not a vector containing a single string. The reason for this special case is that being able to represent an empty vector is typically more useful than consistent handling of empty elements. If you do need to represent empty elements, you'll need to check for the empty string before calling this function. A pattern that can match empty strings splits @string into separate characters wherever it matches the empty string between characters. For example splitting "ab c" using as a separator "\s*", you will get "a", "b" and "c". Setting @start_position differs from just passing over a shortened string and setting %G_REGEX_MATCH_NOTBOL in the case of a pattern that begins with any kind of lookbehind assertion, such as "\b".

a %NULL-terminated gchar ** array. Free it using g_strfreev()

a #GRegex structure

the string to split with the pattern the length of @string, in bytes, or -1 if @string is nul-terminated starting index of the string to match, in bytes match time option flags the maximum number of tokens to split @string into. If this is less than 1, the string is split completely

Decreases reference count of @regex by 1. When reference count drops to zero, it frees all the memory associated with the regex structure.

a #GRegex

Checks whether @replacement is a valid replacement string (see g_regex_replace()), i.e. that all escape sequences in it are valid. If @has_references is not %NULL then @replacement is checked for pattern references. For instance, replacement text 'foo\n' does not contain references and may be evaluated without information about actual match, but '\0\1' (whole match followed by first subpattern) requires valid #GMatchInfo object.

whether @replacement is a valid replacement string

the replacement string location to store information about references in @replacement or %NULL

Escapes the nul characters in @string to "\x00". It can be used to compile a regex with embedded nul characters. For completeness, @length can be -1 for a nul-terminated string. In this case the output string will be of course equal to @string.

a newly-allocated escaped string

the string to escape the length of @string

Escapes the special characters used for regular expressions in @string, for instance "a.b*c" becomes "a\.b\*c". This function is useful to dynamically generate regular expressions. @string can contain nul characters that are replaced with "\0", in this case remember to specify the correct length of @string in @length.

a newly-allocated escaped string

the string to escape the length of @string, in bytes, or -1 if @string is nul-terminated

Scans for a match in @string for @pattern. This function is equivalent to g_regex_match() but it does not require to compile the pattern with g_regex_new(), avoiding some lines of code when you need just to do a match without extracting substrings, capture counts, and so on. If this function is to be called on the same @pattern more than once, it's more efficient to compile the pattern once with g_regex_new() and then use g_regex_match().

%TRUE if the string matched, %FALSE otherwise

the regular expression the string to scan for matches compile options for the regular expression, or 0 match options, or 0

Breaks the string on the pattern, and returns an array of the tokens. If the pattern contains capturing parentheses, then the text for each of the substrings will also be returned. If the pattern does not match anywhere in the string, then the whole string is returned as the first token. This function is equivalent to g_regex_split() but it does not require to compile the pattern with g_regex_new(), avoiding some lines of code when you need just to do a split without extracting substrings, capture counts, and so on. If this function is to be called on the same @pattern more than once, it's more efficient to compile the pattern once with g_regex_new() and then use g_regex_split(). As a special case, the result of splitting the empty string "" is an empty vector, not a vector containing a single string. The reason for this special case is that being able to represent an empty vector is typically more useful than consistent handling of empty elements. If you do need to represent empty elements, you'll need to check for the empty string before calling this function. A pattern that can match empty strings splits @string into separate characters wherever it matches the empty string between characters. For example splitting "ab c" using as a separator "\s*", you will get "a", "b" and "c".

a %NULL-terminated array of strings. Free it using g_strfreev()

the regular expression the string to scan for matches compile options for the regular expression, or 0 match options, or 0

Flags specifying compile-time options.

No special options set. Since: 2.74 Letters in the pattern match both upper- and lowercase letters. This option can be changed within a pattern by a "(?i)" option setting. By default, GRegex treats the strings as consisting of a single line of characters (even if it actually contains newlines). The "start of line" metacharacter ("^") matches only at the start of the string, while the "end of line" metacharacter ("$") matches only at the end of the string, or before a terminating newline (unless %G_REGEX_DOLLAR_ENDONLY is set). When %G_REGEX_MULTILINE is set, the "start of line" and "end of line" constructs match immediately following or immediately before any newline in the string, respectively, as well as at the very start and end. This can be changed within a pattern by a "(?m)" option setting. A dot metacharacter (".") in the pattern matches all characters, including newlines. Without it, newlines are excluded. This option can be changed within a pattern by a ("?s") option setting. Whitespace data characters in the pattern are totally ignored except when escaped or inside a character class. Whitespace does not include the VT character (code 11). In addition, characters between an unescaped "#" outside a character class and the next newline character, inclusive, are also ignored. This can be changed within a pattern by a "(?x)" option setting. The pattern is forced to be "anchored", that is, it is constrained to match only at the first matching point in the string that is being searched. This effect can also be achieved by appropriate constructs in the pattern itself such as the "^" metacharacter. A dollar metacharacter ("$") in the pattern matches only at the end of the string. Without this option, a dollar also matches immediately before the final character if it is a newline (but not before any other newlines). This option is ignored if %G_REGEX_MULTILINE is set. Inverts the "greediness" of the quantifiers so that they are not greedy by default, but become greedy if followed by "?". It can also be set by a "(?U)" option setting within the pattern. Usually strings must be valid UTF-8 strings, using this flag they are considered as a raw sequence of bytes. Disables the use of numbered capturing parentheses in the pattern. Any opening parenthesis that is not followed by "?" behaves as if it were followed by "?:" but named parentheses can still be used for capturing (and they acquire numbers in the usual way). Since 2.74 and the port to pcre2, requests JIT compilation, which, if the just-in-time compiler is available, further processes a compiled pattern into machine code that executes much faster. However, it comes at the cost of extra processing before the match is performed, so it is most beneficial to use this when the same compiled pattern is used for matching many times. Before 2.74 this option used the built-in non-JIT optimizations in pcre1. Limits an unanchored pattern to match before (or at) the first newline. Since: 2.34 Names used to identify capturing subpatterns need not be unique. This can be helpful for certain types of pattern when it is known that only one instance of the named subpattern can ever be matched. Usually any newline character or character sequence is recognized. If this option is set, the only recognized newline character is '\r'. Usually any newline character or character sequence is recognized. If this option is set, the only recognized newline character is '\n'. Usually any newline character or character sequence is recognized. If this option is set, the only recognized newline character sequence is '\r\n'. Usually any newline character or character sequence is recognized. If this option is set, the only recognized newline character sequences are '\r', '\n', and '\r\n'. Since: 2.34 Usually any newline character or character sequence is recognised. If this option is set, then "\R" only recognizes the newline characters '\r', '\n' and '\r\n'. Since: 2.34 Changes behaviour so that it is compatible with JavaScript rather than PCRE. Since GLib 2.74 this is no longer supported, as libpcre2 does not support it. Since: 2.34 Deprecated: 2.74

Error codes returned by regular expressions functions.

Compilation of the regular expression failed. Optimization of the regular expression failed. Replacement failed due to an ill-formed replacement string. The match process failed. Internal error of the regular expression engine. Since 2.16 "\\" at end of pattern. Since 2.16 "\\c" at end of pattern. Since 2.16 Unrecognized character follows "\\". Since 2.16 Numbers out of order in "{}" quantifier. Since 2.16 Number too big in "{}" quantifier. Since 2.16 Missing terminating "]" for character class. Since 2.16 Invalid escape sequence in character class. Since 2.16 Range out of order in character class. Since 2.16 Nothing to repeat. Since 2.16 Unrecognized character after "(?", "(?<" or "(?P". Since 2.16 POSIX named classes are supported only within a class. Since 2.16 Missing terminating ")" or ")" without opening "(". Since 2.16 Reference to non-existent subpattern. Since 2.16 Missing terminating ")" after comment. Since 2.16 Regular expression too large. Since 2.16 Failed to get memory. Since 2.16 Lookbehind assertion is not fixed length. Since 2.16 Malformed number or name after "(?(". Since 2.16 Conditional group contains more than two branches. Since 2.16 Assertion expected after "(?(". Since 2.16 Unknown POSIX class name. Since 2.16 POSIX collating elements are not supported. Since 2.16 Character value in "\\x{...}" sequence is too large. Since 2.16 Invalid condition "(?(0)". Since 2.16 \\C not allowed in lookbehind assertion. Since 2.16 Recursive call could loop indefinitely. Since 2.16 Missing terminator in subpattern name. Since 2.16 Two named subpatterns have the same name. Since 2.16 Malformed "\\P" or "\\p" sequence. Since 2.16 Unknown property name after "\\P" or "\\p". Since 2.16 Subpattern name is too long (maximum 32 characters). Since 2.16 Too many named subpatterns (maximum 10,000). Since 2.16 Octal value is greater than "\\377". Since 2.16 "DEFINE" group contains more than one branch. Since 2.16 Repeating a "DEFINE" group is not allowed. This error is never raised. Since: 2.16 Deprecated: 2.34 Inconsistent newline options. Since 2.16 "\\g" is not followed by a braced, angle-bracketed, or quoted name or number, or by a plain number. Since: 2.16 relative reference must not be zero. Since: 2.34 the backtracing control verb used does not allow an argument. Since: 2.34 unknown backtracing control verb. Since: 2.34 number is too big in escape sequence. Since: 2.34 Missing subpattern name. Since: 2.34 Missing digit. Since 2.34 In JavaScript compatibility mode, "[" is an invalid data character. Since: 2.34 different names for subpatterns of the same number are not allowed. Since: 2.34 the backtracing control verb requires an argument. Since: 2.34 "\\c" must be followed by an ASCII character. Since: 2.34 "\\k" is not followed by a braced, angle-bracketed, or quoted name. Since: 2.34 "\\N" is not supported in a class. Since: 2.34 too many forward references. Since: 2.34 the name is too long in "(*MARK)", "(*PRUNE)", "(*SKIP)", or "(*THEN)". Since: 2.34 the character value in the \\u sequence is too large. Since: 2.34

Specifies the type of the function passed to g_regex_replace_eval(). It is called for each occurrence of the pattern in the string passed to g_regex_replace_eval(), and it should append the replacement to @result.

%FALSE to continue the replacement process, %TRUE to stop it

the #GMatchInfo generated by the match. Use g_match_info_get_regex() and g_match_info_get_string() if you need the #GRegex or the matched string. a #GString containing the new string user data passed to g_regex_replace_eval()

Flags specifying match-time options.

No special options set. Since: 2.74 The pattern is forced to be "anchored", that is, it is constrained to match only at the first matching point in the string that is being searched. This effect can also be achieved by appropriate constructs in the pattern itself such as the "^" metacharacter. Specifies that first character of the string is not the beginning of a line, so the circumflex metacharacter should not match before it. Setting this without %G_REGEX_MULTILINE (at compile time) causes circumflex never to match. This option affects only the behaviour of the circumflex metacharacter, it does not affect "\A". Specifies that the end of the subject string is not the end of a line, so the dollar metacharacter should not match it nor (except in multiline mode) a newline immediately before it. Setting this without %G_REGEX_MULTILINE (at compile time) causes dollar never to match. This option affects only the behaviour of the dollar metacharacter, it does not affect "\Z" or "\z". An empty string is not considered to be a valid match if this option is set. If there are alternatives in the pattern, they are tried. If all the alternatives match the empty string, the entire match fails. For example, if the pattern "a?b?" is applied to a string not beginning with "a" or "b", it matches the empty string at the start of the string. With this flag set, this match is not valid, so GRegex searches further into the string for occurrences of "a" or "b". Turns on the partial matching feature, for more documentation on partial matching see g_match_info_is_partial_match(). Overrides the newline definition set when creating a new #GRegex, setting the '\r' character as line terminator. Overrides the newline definition set when creating a new #GRegex, setting the '\n' character as line terminator. Overrides the newline definition set when creating a new #GRegex, setting the '\r\n' characters sequence as line terminator. Overrides the newline definition set when creating a new #GRegex, any Unicode newline sequence is recognised as a newline. These are '\r', '\n' and '\rn', and the single characters U+000B LINE TABULATION, U+000C FORM FEED (FF), U+0085 NEXT LINE (NEL), U+2028 LINE SEPARATOR and U+2029 PARAGRAPH SEPARATOR. Overrides the newline definition set when creating a new #GRegex; any '\r', '\n', or '\r\n' character sequence is recognized as a newline. Since: 2.34 Overrides the newline definition for "\R" set when creating a new #GRegex; only '\r', '\n', or '\r\n' character sequences are recognized as a newline by "\R". Since: 2.34 Overrides the newline definition for "\R" set when creating a new #GRegex; any Unicode newline character or character sequence are recognized as a newline by "\R". These are '\r', '\n' and '\rn', and the single characters U+000B LINE TABULATION, U+000C FORM FEED (FF), U+0085 NEXT LINE (NEL), U+2028 LINE SEPARATOR and U+2029 PARAGRAPH SEPARATOR. Since: 2.34 An alias for %G_REGEX_MATCH_PARTIAL. Since: 2.34 Turns on the partial matching feature. In contrast to to %G_REGEX_MATCH_PARTIAL_SOFT, this stops matching as soon as a partial match is found, without continuing to search for a possible complete match. See g_match_info_is_partial_match() for more information. Since: 2.34 Like %G_REGEX_MATCH_NOTEMPTY, but only applied to the start of the matched string. For anchored patterns this can only happen for pattern containing "\K". Since: 2.34

The search path separator character. This is ':' on UNIX machines and ';' under Windows.

The search path separator as a string. This is ":" on UNIX machines and ";" under Windows.

Returns the size of @member in the struct definition without having a declared instance of @struct_type.

a structure type, e.g. #GOutputVector a field in the structure, e.g. `size`

The #GSList struct is used for each element in the singly-linked list.

holds the element's data, which can be a pointer to any kind of data, or any integer value using the [Type Conversion Macros][glib-Type-Conversion-Macros] contains the link to the next element in the list. Allocates space for one #GSList element. It is called by the g_slist_append(), g_slist_prepend(), g_slist_insert() and g_slist_insert_sorted() functions and so is rarely used on its own.

a pointer to the newly-allocated #GSList element.

Adds a new element on to the end of the list. The return value is the new start of the list, which may have changed, so make sure you store the new value. Note that g_slist_append() has to traverse the entire list to find the end, which is inefficient when adding multiple elements. A common idiom to avoid the inefficiency is to prepend the elements and reverse the list when all elements have been added. |[ // Notice that these are initialized to the empty list. GSList *list = NULL, *number_list = NULL; // This is a list of strings. list = g_slist_append (list, "first"); list = g_slist_append (list, "second"); // This is a list of integers. number_list = g_slist_append (number_list, GINT_TO_POINTER (27)); number_list = g_slist_append (number_list, GINT_TO_POINTER (14)); ]|

the new start of the #GSList

a #GSList the data for the new element

Adds the second #GSList onto the end of the first #GSList. Note that the elements of the second #GSList are not copied. They are used directly.

the start of the new #GSList

a #GSList the #GSList to add to the end of the first #GSList

Copies a #GSList. Note that this is a "shallow" copy. If the list elements consist of pointers to data, the pointers are copied but the actual data isn't. See g_slist_copy_deep() if you need to copy the data as well.

a copy of @list

a #GSList

Makes a full (deep) copy of a #GSList. In contrast with g_slist_copy(), this function uses @func to make a copy of each list element, in addition to copying the list container itself. @func, as a #GCopyFunc, takes two arguments, the data to be copied and a @user_data pointer. On common processor architectures, it's safe to pass %NULL as @user_data if the copy function takes only one argument. You may get compiler warnings from this though if compiling with GCC’s `-Wcast-function-type` warning. For instance, if @list holds a list of GObjects, you can do: |[ another_list = g_slist_copy_deep (list, (GCopyFunc) g_object_ref, NULL); ]| And, to entirely free the new list, you could do: |[ g_slist_free_full (another_list, g_object_unref); ]|

a full copy of @list, use g_slist_free_full() to free it

a #GSList a copy function used to copy every element in the list user data passed to the copy function @func, or #NULL

Removes the node link_ from the list and frees it. Compare this to g_slist_remove_link() which removes the node without freeing it. Removing arbitrary nodes from a singly-linked list requires time that is proportional to the length of the list (ie. O(n)). If you find yourself using g_slist_delete_link() frequently, you should consider a different data structure, such as the doubly-linked #GList.

the new head of @list

a #GSList node to delete

Finds the element in a #GSList which contains the given data.

the found #GSList element, or %NULL if it is not found

a #GSList the element data to find

Finds an element in a #GSList, using a supplied function to find the desired element. It iterates over the list, calling the given function which should return 0 when the desired element is found. The function takes two #gconstpointer arguments, the #GSList element's data as the first argument and the given user data.

the found #GSList element, or %NULL if it is not found

a #GSList user data passed to the function the function to call for each element. It should return 0 when the desired element is found

Calls a function for each element of a #GSList. It is safe for @func to remove the element from @list, but it must not modify any part of the list after that element.

a #GSList the function to call with each element's data user data to pass to the function

Frees all of the memory used by a #GSList. The freed elements are returned to the slice allocator. If list elements contain dynamically-allocated memory, you should either use g_slist_free_full() or free them manually first. It can be combined with g_steal_pointer() to ensure the list head pointer is not left dangling: |[ GSList *list_of_borrowed_things = …; /* (transfer container) */ g_slist_free (g_steal_pointer (&list_of_borrowed_things)); ]|

the first link of a #GSList

Frees one #GSList element. It is usually used after g_slist_remove_link().

a #GSList element

Convenience method, which frees all the memory used by a #GSList, and calls the specified destroy function on every element's data. @free_func must not modify the list (eg, by removing the freed element from it). It can be combined with g_steal_pointer() to ensure the list head pointer is not left dangling — this also has the nice property that the head pointer is cleared before any of the list elements are freed, to prevent double frees from @free_func: |[ GSList *list_of_owned_things = …; /* (transfer full) (element-type GObject) */ g_slist_free_full (g_steal_pointer (&list_of_owned_things), g_object_unref); ]|

the first link of a #GSList the function to be called to free each element's data

Gets the position of the element containing the given data (starting from 0).

the index of the element containing the data, or -1 if the data is not found

a #GSList the data to find

Inserts a new element into the list at the given position.

the new start of the #GSList

a #GSList the data for the new element the position to insert the element. If this is negative, or is larger than the number of elements in the list, the new element is added on to the end of the list.

Inserts a node before @sibling containing @data.

the new head of the list.

a #GSList node to insert @data before data to put in the newly-inserted node

Inserts a new element into the list, using the given comparison function to determine its position.

the new start of the #GSList

a #GSList the data for the new element the function to compare elements in the list. It should return a number > 0 if the first parameter comes after the second parameter in the sort order.

Inserts a new element into the list, using the given comparison function to determine its position.

the new start of the #GSList

a #GSList the data for the new element the function to compare elements in the list. It should return a number > 0 if the first parameter comes after the second parameter in the sort order. data to pass to comparison function

Gets the last element in a #GSList. This function iterates over the whole list.

the last element in the #GSList, or %NULL if the #GSList has no elements

a #GSList

Gets the number of elements in a #GSList. This function iterates over the whole list to count its elements. To check whether the list is non-empty, it is faster to check @list against %NULL.

the number of elements in the #GSList

a #GSList

Gets the element at the given position in a #GSList.

the element, or %NULL if the position is off the end of the #GSList

a #GSList the position of the element, counting from 0

Gets the data of the element at the given position.

the element's data, or %NULL if the position is off the end of the #GSList

a #GSList the position of the element

Gets the position of the given element in the #GSList (starting from 0).

the position of the element in the #GSList, or -1 if the element is not found

a #GSList an element in the #GSList

Adds a new element on to the start of the list. The return value is the new start of the list, which may have changed, so make sure you store the new value. |[ // Notice that it is initialized to the empty list. GSList *list = NULL; list = g_slist_prepend (list, "last"); list = g_slist_prepend (list, "first"); ]|

the new start of the #GSList

a #GSList the data for the new element

Removes an element from a #GSList. If two elements contain the same data, only the first is removed. If none of the elements contain the data, the #GSList is unchanged.

the new start of the #GSList

a #GSList the data of the element to remove

Removes all list nodes with data equal to @data. Returns the new head of the list. Contrast with g_slist_remove() which removes only the first node matching the given data.

new head of @list

a #GSList data to remove

Removes an element from a #GSList, without freeing the element. The removed element's next link is set to %NULL, so that it becomes a self-contained list with one element. Removing arbitrary nodes from a singly-linked list requires time that is proportional to the length of the list (ie. O(n)). If you find yourself using g_slist_remove_link() frequently, you should consider a different data structure, such as the doubly-linked #GList.

the new start of the #GSList, without the element

a #GSList an element in the #GSList

Reverses a #GSList.

the start of the reversed #GSList

a #GSList

Sorts a #GSList using the given comparison function. The algorithm used is a stable sort.

the start of the sorted #GSList

a #GSList the comparison function used to sort the #GSList. This function is passed the data from 2 elements of the #GSList and should return 0 if they are equal, a negative value if the first element comes before the second, or a positive value if the first element comes after the second.

Like g_slist_sort(), but the sort function accepts a user data argument.

new head of the list

a #GSList comparison function data to pass to comparison function

Use this macro as the return value of a #GSourceFunc to leave the #GSource in the main loop.

Cast a function pointer to a #GSourceFunc, suppressing warnings from GCC 8 onwards with `-Wextra` or `-Wcast-function-type` enabled about the function types being incompatible. For example, the correct type of callback for a source created by g_child_watch_source_new() is #GChildWatchFunc, which accepts more arguments than #GSourceFunc. Casting the function with `(GSourceFunc)` to call g_source_set_callback() will trigger a warning, even though it will be cast back to the correct type before it is called by the source.

a function pointer.

Use this macro as the return value of a #GSourceFunc to remove the #GSource from the main loop.

The square root of two.

Accepts a macro or a string and converts it into a string after preprocessor argument expansion. For example, the following code: |[ #define AGE 27 const gchar *greeting = G_STRINGIFY (AGE) " today!"; ]| is transformed by the preprocessor into (code equivalent to): |[ const gchar *greeting = "27 today!"; ]|

a macro or a string

Returns a member of a structure at a given offset, using the given type.

the type of the struct field a pointer to a struct the offset of the field from the start of the struct, in bytes

Returns an untyped pointer to a given offset of a struct.

a pointer to a struct the offset from the start of the struct, in bytes

Returns the offset, in bytes, of a member of a struct. Consider using standard C `offsetof()`, available since at least C89 and C++98, in new code (but note that `offsetof()` returns a `size_t` rather than a `long`).

a structure type, e.g. #GtkWidget a field in the structure, e.g. @window

The standard delimiters, used in g_strdelimit().

The data structure representing a lexical scanner. You should set @input_name after creating the scanner, since it is used by the default message handler when displaying warnings and errors. If you are scanning a file, the filename would be a good choice. The @user_data and @max_parse_errors fields are not used. If you need to associate extra data with the scanner you can place them here. If you want to use your own message handler you can set the @msg_handler field. The type of the message handler function is declared by #GScannerMsgFunc.

unused unused g_scanner_error() increments this field name of input stream, featured by the default message handler quarked data link into the scanner configuration token parsed by the last g_scanner_get_next_token() value of the last token from g_scanner_get_next_token() line number of the last token from g_scanner_get_next_token() char number of the last token from g_scanner_get_next_token() token parsed by the last g_scanner_peek_next_token() value of the last token from g_scanner_peek_next_token() line number of the last token from g_scanner_peek_next_token() char number of the last token from g_scanner_peek_next_token() handler function for _warn and _error Returns the current line in the input stream (counting from 1). This is the line of the last token parsed via g_scanner_get_next_token().

the current line

a #GScanner

Returns the current position in the current line (counting from 0). This is the position of the last token parsed via g_scanner_get_next_token().

the current position on the line

a #GScanner

Gets the current token type. This is simply the @token field in the #GScanner structure.

the current token type

a #GScanner

Gets the current token value. This is simply the @value field in the #GScanner structure.

the current token value

a #GScanner

Frees all memory used by the #GScanner.

a #GScanner

Returns %TRUE if the scanner has reached the end of the file or text buffer.

%TRUE if the scanner has reached the end of the file or text buffer

a #GScanner

Outputs an error message, via the #GScanner message handler.

a #GScanner

the message format. See the printf() documentation the parameters to insert into the format string

Parses the next token just like g_scanner_peek_next_token() and also removes it from the input stream. The token data is placed in the @token, @value, @line, and @position fields of the #GScanner structure.

the type of the token

a #GScanner

Prepares to scan a file.

a #GScanner

a file descriptor

Prepares to scan a text buffer.

a #GScanner

the text buffer to scan the length of the text buffer

Looks up a symbol in the current scope and return its value. If the symbol is not bound in the current scope, %NULL is returned.

the value of @symbol in the current scope, or %NULL if @symbol is not bound in the current scope

a #GScanner

the symbol to look up

Parses the next token, without removing it from the input stream. The token data is placed in the @next_token, @next_value, @next_line, and @next_position fields of the #GScanner structure. Note that, while the token is not removed from the input stream (i.e. the next call to g_scanner_get_next_token() will return the same token), it will not be reevaluated. This can lead to surprising results when changing scope or the scanner configuration after peeking the next token. Getting the next token after switching the scope or configuration will return whatever was peeked before, regardless of any symbols that may have been added or removed in the new scope.

the type of the token

a #GScanner

Adds a symbol to the given scope.

a #GScanner

the scope id the symbol to add the value of the symbol

Calls the given function for each of the symbol/value pairs in the given scope of the #GScanner. The function is passed the symbol and value of each pair, and the given @user_data parameter.

a #GScanner

the scope id the function to call for each symbol/value pair user data to pass to the function

Looks up a symbol in a scope and return its value. If the symbol is not bound in the scope, %NULL is returned.

the value of @symbol in the given scope, or %NULL if @symbol is not bound in the given scope.

a #GScanner

the scope id the symbol to look up

Removes a symbol from a scope.

a #GScanner

the scope id the symbol to remove

Sets the current scope.

the old scope id

a #GScanner

the new scope id

Rewinds the filedescriptor to the current buffer position and blows the file read ahead buffer. This is useful for third party uses of the scanners filedescriptor, which hooks onto the current scanning position.

a #GScanner

Outputs a message through the scanner's msg_handler, resulting from an unexpected token in the input stream. Note that you should not call g_scanner_peek_next_token() followed by g_scanner_unexp_token() without an intermediate call to g_scanner_get_next_token(), as g_scanner_unexp_token() evaluates the scanner's current token (not the peeked token) to construct part of the message.

a #GScanner

the expected token a string describing how the scanner's user refers to identifiers (%NULL defaults to "identifier"). This is used if @expected_token is %G_TOKEN_IDENTIFIER or %G_TOKEN_IDENTIFIER_NULL. a string describing how the scanner's user refers to symbols (%NULL defaults to "symbol"). This is used if @expected_token is %G_TOKEN_SYMBOL or any token value greater than %G_TOKEN_LAST. the name of the symbol, if the scanner's current token is a symbol. a message string to output at the end of the warning/error, or %NULL. if %TRUE it is output as an error. If %FALSE it is output as a warning.

Outputs a warning message, via the #GScanner message handler.

a #GScanner

the message format. See the printf() documentation the parameters to insert into the format string

Creates a new #GScanner. The @config_templ structure specifies the initial settings of the scanner, which are copied into the #GScanner @config field. If you pass %NULL then the default settings are used.

the new #GScanner

the initial scanner settings

Specifies the #GScanner parser configuration. Most settings can be changed during the parsing phase and will affect the lexical parsing of the next unpeeked token.

specifies which characters should be skipped by the scanner (the default is the whitespace characters: space, tab, carriage-return and line-feed). specifies the characters which can start identifiers (the default is %G_CSET_a_2_z, "_", and %G_CSET_A_2_Z). specifies the characters which can be used in identifiers, after the first character (the default is %G_CSET_a_2_z, "_0123456789", %G_CSET_A_2_Z, %G_CSET_LATINS, %G_CSET_LATINC). specifies the characters at the start and end of single-line comments. The default is "#\n" which means that single-line comments start with a '#' and continue until a '\n' (end of line). specifies if symbols are case sensitive (the default is %FALSE). specifies if multi-line comments are skipped and not returned as tokens (the default is %TRUE). specifies if single-line comments are skipped and not returned as tokens (the default is %TRUE). specifies if multi-line comments are recognized (the default is %TRUE). specifies if identifiers are recognized (the default is %TRUE). specifies if single-character identifiers are recognized (the default is %FALSE). specifies if %NULL is reported as %G_TOKEN_IDENTIFIER_NULL (the default is %FALSE). specifies if symbols are recognized (the default is %TRUE). specifies if binary numbers are recognized (the default is %FALSE). specifies if octal numbers are recognized (the default is %TRUE). specifies if floating point numbers are recognized (the default is %TRUE). specifies if hexadecimal numbers are recognized (the default is %TRUE). specifies if '$' is recognized as a prefix for hexadecimal numbers (the default is %FALSE). specifies if strings can be enclosed in single quotes (the default is %TRUE). specifies if strings can be enclosed in double quotes (the default is %TRUE). specifies if binary, octal and hexadecimal numbers are reported as %G_TOKEN_INT (the default is %TRUE). specifies if all numbers are reported as %G_TOKEN_FLOAT (the default is %FALSE). specifies if identifiers are reported as strings (the default is %FALSE). specifies if characters are reported by setting `token = ch` or as %G_TOKEN_CHAR (the default is %TRUE). specifies if symbols are reported by setting `token = v_symbol` or as %G_TOKEN_SYMBOL (the default is %FALSE). specifies if a symbol is searched for in the default scope in addition to the current scope (the default is %FALSE). use value.v_int64 rather than v_int

Specifies the type of the message handler function.

a #GScanner the message %TRUE if the message signals an error, %FALSE if it signals a warning.

An enumeration specifying the base position for a g_io_channel_seek_position() operation.

the current position in the file. the start of the file. the end of the file.

The #GSequence struct is an opaque data type representing a [sequence][glib-Sequences] data type.

Adds a new item to the end of @seq.

an iterator pointing to the new item

a #GSequence

the data for the new item

Calls @func for each item in the sequence passing @user_data to the function. @func must not modify the sequence itself.

a #GSequence

the function to call for each item in @seq user data passed to @func

Frees the memory allocated for @seq. If @seq has a data destroy function associated with it, that function is called on all items in @seq.

a #GSequence

Returns the begin iterator for @seq.

the begin iterator for @seq.

a #GSequence

Returns the end iterator for @seg

the end iterator for @seq

a #GSequence

Returns the iterator at position @pos. If @pos is negative or larger than the number of items in @seq, the end iterator is returned.

The #GSequenceIter at position @pos

a #GSequence

a position in @seq, or -1 for the end

Returns the positive length (>= 0) of @seq. Note that this method is O(h) where `h' is the height of the tree. It is thus more efficient to use g_sequence_is_empty() when comparing the length to zero.

the length of @seq

a #GSequence

Inserts @data into @seq using @cmp_func to determine the new position. The sequence must already be sorted according to @cmp_func; otherwise the new position of @data is undefined. @cmp_func is called with two items of the @seq, and @cmp_data. It should return 0 if the items are equal, a negative value if the first item comes before the second, and a positive value if the second item comes before the first. Note that when adding a large amount of data to a #GSequence, it is more efficient to do unsorted insertions and then call g_sequence_sort() or g_sequence_sort_iter().

a #GSequenceIter pointing to the new item.

a #GSequence

the data to insert the function used to compare items in the sequence user data passed to @cmp_func.

Like g_sequence_insert_sorted(), but uses a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as the compare function. @iter_cmp is called with two iterators pointing into @seq. It should return 0 if the iterators are equal, a negative value if the first iterator comes before the second, and a positive value if the second iterator comes before the first. Note that when adding a large amount of data to a #GSequence, it is more efficient to do unsorted insertions and then call g_sequence_sort() or g_sequence_sort_iter().

a #GSequenceIter pointing to the new item

a #GSequence

data for the new item the function used to compare iterators in the sequence user data passed to @iter_cmp

Returns %TRUE if the sequence contains zero items. This function is functionally identical to checking the result of g_sequence_get_length() being equal to zero. However this function is implemented in O(1) running time.

%TRUE if the sequence is empty, otherwise %FALSE.

a #GSequence

Returns an iterator pointing to the position of the first item found equal to @data according to @cmp_func and @cmp_data. If more than one item is equal, it is not guaranteed that it is the first which is returned. In that case, you can use g_sequence_iter_next() and g_sequence_iter_prev() to get others. @cmp_func is called with two items of the @seq, and @cmp_data. It should return 0 if the items are equal, a negative value if the first item comes before the second, and a positive value if the second item comes before the first. This function will fail if the data contained in the sequence is unsorted.

an #GSequenceIter pointing to the position of the first item found equal to @data according to @cmp_func and @cmp_data, or %NULL if no such item exists

a #GSequence

data to look up the function used to compare items in the sequence user data passed to @cmp_func

Like g_sequence_lookup(), but uses a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as the compare function. @iter_cmp is called with two iterators pointing into @seq. It should return 0 if the iterators are equal, a negative value if the first iterator comes before the second, and a positive value if the second iterator comes before the first. This function will fail if the data contained in the sequence is unsorted.

an #GSequenceIter pointing to the position of the first item found equal to @data according to @iter_cmp and @cmp_data, or %NULL if no such item exists

a #GSequence

data to look up the function used to compare iterators in the sequence user data passed to @iter_cmp

Adds a new item to the front of @seq

an iterator pointing to the new item

a #GSequence

the data for the new item

Returns an iterator pointing to the position where @data would be inserted according to @cmp_func and @cmp_data. @cmp_func is called with two items of the @seq, and @cmp_data. It should return 0 if the items are equal, a negative value if the first item comes before the second, and a positive value if the second item comes before the first. If you are simply searching for an existing element of the sequence, consider using g_sequence_lookup(). This function will fail if the data contained in the sequence is unsorted.

an #GSequenceIter pointing to the position where @data would have been inserted according to @cmp_func and @cmp_data

a #GSequence

data for the new item the function used to compare items in the sequence user data passed to @cmp_func

Like g_sequence_search(), but uses a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as the compare function. @iter_cmp is called with two iterators pointing into @seq. It should return 0 if the iterators are equal, a negative value if the first iterator comes before the second, and a positive value if the second iterator comes before the first. If you are simply searching for an existing element of the sequence, consider using g_sequence_lookup_iter(). This function will fail if the data contained in the sequence is unsorted.

a #GSequenceIter pointing to the position in @seq where @data would have been inserted according to @iter_cmp and @cmp_data

a #GSequence

data for the new item the function used to compare iterators in the sequence user data passed to @iter_cmp

Sorts @seq using @cmp_func. @cmp_func is passed two items of @seq and should return 0 if they are equal, a negative value if the first comes before the second, and a positive value if the second comes before the first.

a #GSequence

the function used to sort the sequence user data passed to @cmp_func

Like g_sequence_sort(), but uses a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as the compare function @cmp_func is called with two iterators pointing into @seq. It should return 0 if the iterators are equal, a negative value if the first iterator comes before the second, and a positive value if the second iterator comes before the first.

a #GSequence

the function used to compare iterators in the sequence user data passed to @cmp_func

Calls @func for each item in the range (@begin, @end) passing @user_data to the function. @func must not modify the sequence itself.

a #GSequenceIter a #GSequenceIter a #GFunc user data passed to @func

Returns the data that @iter points to.

the data that @iter points to

a #GSequenceIter

Inserts a new item just before the item pointed to by @iter.

an iterator pointing to the new item

a #GSequenceIter the data for the new item

Moves the item pointed to by @src to the position indicated by @dest. After calling this function @dest will point to the position immediately after @src. It is allowed for @src and @dest to point into different sequences.

a #GSequenceIter pointing to the item to move a #GSequenceIter pointing to the position to which the item is moved

Inserts the (@begin, @end) range at the destination pointed to by @dest. The @begin and @end iters must point into the same sequence. It is allowed for @dest to point to a different sequence than the one pointed into by @begin and @end. If @dest is %NULL, the range indicated by @begin and @end is removed from the sequence. If @dest points to a place within the (@begin, @end) range, the range does not move.

a #GSequenceIter a #GSequenceIter a #GSequenceIter

Creates a new GSequence. The @data_destroy function, if non-%NULL will be called on all items when the sequence is destroyed and on items that are removed from the sequence.

a new #GSequence

a #GDestroyNotify function, or %NULL

Finds an iterator somewhere in the range (@begin, @end). This iterator will be close to the middle of the range, but is not guaranteed to be exactly in the middle. The @begin and @end iterators must both point to the same sequence and @begin must come before or be equal to @end in the sequence.

a #GSequenceIter pointing somewhere in the (@begin, @end) range

a #GSequenceIter a #GSequenceIter

Removes the item pointed to by @iter. It is an error to pass the end iterator to this function. If the sequence has a data destroy function associated with it, this function is called on the data for the removed item.

a #GSequenceIter

Removes all items in the (@begin, @end) range. If the sequence has a data destroy function associated with it, this function is called on the data for the removed items.

a #GSequenceIter a #GSequenceIter

Changes the data for the item pointed to by @iter to be @data. If the sequence has a data destroy function associated with it, that function is called on the existing data that @iter pointed to.

a #GSequenceIter new data for the item

Moves the data pointed to by @iter to a new position as indicated by @cmp_func. This function should be called for items in a sequence already sorted according to @cmp_func whenever some aspect of an item changes so that @cmp_func may return different values for that item. @cmp_func is called with two items of the @seq, and @cmp_data. It should return 0 if the items are equal, a negative value if the first item comes before the second, and a positive value if the second item comes before the first.

A #GSequenceIter the function used to compare items in the sequence user data passed to @cmp_func.

Like g_sequence_sort_changed(), but uses a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as the compare function. @iter_cmp is called with two iterators pointing into the #GSequence that @iter points into. It should return 0 if the iterators are equal, a negative value if the first iterator comes before the second, and a positive value if the second iterator comes before the first.

a #GSequenceIter the function used to compare iterators in the sequence user data passed to @cmp_func

Swaps the items pointed to by @a and @b. It is allowed for @a and @b to point into difference sequences.

a #GSequenceIter a #GSequenceIter

The #GSequenceIter struct is an opaque data type representing an iterator pointing into a #GSequence.

Returns a negative number if @a comes before @b, 0 if they are equal, and a positive number if @a comes after @b. The @a and @b iterators must point into the same sequence.

a negative number if @a comes before @b, 0 if they are equal, and a positive number if @a comes after @b

a #GSequenceIter

Returns the position of @iter

the position of @iter

a #GSequenceIter

Returns the #GSequence that @iter points into.

the #GSequence that @iter points into

a #GSequenceIter

Returns whether @iter is the begin iterator

whether @iter is the begin iterator

a #GSequenceIter

Returns whether @iter is the end iterator

Whether @iter is the end iterator

a #GSequenceIter

Returns the #GSequenceIter which is @delta positions away from @iter. If @iter is closer than -@delta positions to the beginning of the sequence, the begin iterator is returned. If @iter is closer than @delta positions to the end of the sequence, the end iterator is returned.

a #GSequenceIter which is @delta positions away from @iter

a #GSequenceIter

A positive or negative number indicating how many positions away from @iter the returned #GSequenceIter will be

Returns an iterator pointing to the next position after @iter. If @iter is the end iterator, the end iterator is returned.

a #GSequenceIter pointing to the next position after @iter

a #GSequenceIter

Returns an iterator pointing to the previous position before @iter. If @iter is the begin iterator, the begin iterator is returned.

a #GSequenceIter pointing to the previous position before @iter

a #GSequenceIter

A #GSequenceIterCompareFunc is a function used to compare iterators. It must return zero if the iterators compare equal, a negative value if @a comes before @b, and a positive value if @b comes before @a.

zero if the iterators are equal, a negative value if @a comes before @b, and a positive value if @b comes before @a.

a #GSequenceIter a #GSequenceIter user data

Error codes returned by shell functions.

Mismatched or otherwise mangled quoting. String to be parsed was empty. Some other error.

The `GSource` struct is an opaque data type representing an event source.

Creates a new #GSource structure. The size is specified to allow creating structures derived from #GSource that contain additional data. The size passed in must be at least `sizeof (GSource)`. The source will not initially be associated with any #GMainContext and must be added to one with g_source_attach() before it will be executed.

the newly-created #GSource.

structure containing functions that implement the sources behavior. size of the #GSource structure to create.

Adds @child_source to @source as a "polled" source; when @source is added to a #GMainContext, @child_source will be automatically added with the same priority, when @child_source is triggered, it will cause @source to dispatch (in addition to calling its own callback), and when @source is destroyed, it will destroy @child_source as well. (@source will also still be dispatched if its own prepare/check functions indicate that it is ready.) If you don't need @child_source to do anything on its own when it triggers, you can call g_source_set_dummy_callback() on it to set a callback that does nothing (except return %TRUE if appropriate). @source will hold a reference on @child_source while @child_source is attached to it. This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create.

a #GSource

a second #GSource that @source should "poll"

Adds a file descriptor to the set of file descriptors polled for this source. This is usually combined with g_source_new() to add an event source. The event source's check function will typically test the @revents field in the #GPollFD struct and return %TRUE if events need to be processed. This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create. Using this API forces the linear scanning of event sources on each main loop iteration. Newly-written event sources should try to use g_source_add_unix_fd() instead of this API.

a #GSource

a #GPollFD structure holding information about a file descriptor to watch.

Monitors @fd for the IO events in @events. The tag returned by this function can be used to remove or modify the monitoring of the fd using g_source_remove_unix_fd() or g_source_modify_unix_fd(). It is not necessary to remove the fd before destroying the source; it will be cleaned up automatically. This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create. As the name suggests, this function is not available on Windows.

an opaque tag

a #GSource

the fd to monitor an event mask

Adds a #GSource to a @context so that it will be executed within that context. Remove it by calling g_source_destroy(). This function is safe to call from any thread, regardless of which thread the @context is running in.

the ID (greater than 0) for the source within the #GMainContext.

a #GSource

a #GMainContext (if %NULL, the default context will be used)

Removes a source from its #GMainContext, if any, and mark it as destroyed. The source cannot be subsequently added to another context. It is safe to call this on sources which have already been removed from their context. This does not unref the #GSource: if you still hold a reference, use g_source_unref() to drop it. This function is safe to call from any thread, regardless of which thread the #GMainContext is running in. If the source is currently attached to a #GMainContext, destroying it will effectively unset the callback similar to calling g_source_set_callback(). This can mean, that the data's #GDestroyNotify gets called right away.

a #GSource

Checks whether a source is allowed to be called recursively. see g_source_set_can_recurse().

whether recursion is allowed.

a #GSource

Gets the #GMainContext with which the source is associated. You can call this on a source that has been destroyed, provided that the #GMainContext it was attached to still exists (in which case it will return that #GMainContext). In particular, you can always call this function on the source returned from g_main_current_source(). But calling this function on a source whose #GMainContext has been destroyed is an error.

the #GMainContext with which the source is associated, or %NULL if the context has not yet been added to a source.

a #GSource

This function ignores @source and is otherwise the same as g_get_current_time().

use g_source_get_time() instead

a #GSource

#GTimeVal structure in which to store current time.

Returns the numeric ID for a particular source. The ID of a source is a positive integer which is unique within a particular main loop context. The reverse mapping from ID to source is done by g_main_context_find_source_by_id(). You can only call this function while the source is associated to a #GMainContext instance; calling this function before g_source_attach() or after g_source_destroy() yields undefined behavior. The ID returned is unique within the #GMainContext instance passed to g_source_attach().

the ID (greater than 0) for the source

a #GSource

Gets a name for the source, used in debugging and profiling. The name may be #NULL if it has never been set with g_source_set_name().

the name of the source

a #GSource

Gets the priority of a source.

the priority of the source

a #GSource

Gets the "ready time" of @source, as set by g_source_set_ready_time(). Any time before the current monotonic time (including 0) is an indication that the source will fire immediately.

the monotonic ready time, -1 for "never"

a #GSource

Gets the time to be used when checking this source. The advantage of calling this function over calling g_get_monotonic_time() directly is that when checking multiple sources, GLib can cache a single value instead of having to repeatedly get the system monotonic time. The time here is the system monotonic time, if available, or some other reasonable alternative otherwise. See g_get_monotonic_time().

the monotonic time in microseconds

a #GSource

Returns whether @source has been destroyed. This is important when you operate upon your objects from within idle handlers, but may have freed the object before the dispatch of your idle handler. |[ static gboolean idle_callback (gpointer data) { SomeWidget *self = data; g_mutex_lock (&self->idle_id_mutex); // do stuff with self self->idle_id = 0; g_mutex_unlock (&self->idle_id_mutex); return G_SOURCE_REMOVE; } static void some_widget_do_stuff_later (SomeWidget *self) { g_mutex_lock (&self->idle_id_mutex); self->idle_id = g_idle_add (idle_callback, self); g_mutex_unlock (&self->idle_id_mutex); } static void some_widget_init (SomeWidget *self) { g_mutex_init (&self->idle_id_mutex); // ... } static void some_widget_finalize (GObject *object) { SomeWidget *self = SOME_WIDGET (object); if (self->idle_id) g_source_remove (self->idle_id); g_mutex_clear (&self->idle_id_mutex); G_OBJECT_CLASS (parent_class)->finalize (object); } ]| This will fail in a multi-threaded application if the widget is destroyed before the idle handler fires due to the use after free in the callback. A solution, to this particular problem, is to check to if the source has already been destroy within the callback. |[ static gboolean idle_callback (gpointer data) { SomeWidget *self = data; g_mutex_lock (&self->idle_id_mutex); if (!g_source_is_destroyed (g_main_current_source ())) { // do stuff with self } g_mutex_unlock (&self->idle_id_mutex); return FALSE; } ]| Calls to this function from a thread other than the one acquired by the #GMainContext the #GSource is attached to are typically redundant, as the source could be destroyed immediately after this function returns. However, once a source is destroyed it cannot be un-destroyed, so this function can be used for opportunistic checks from any thread.

%TRUE if the source has been destroyed

a #GSource

Updates the event mask to watch for the fd identified by @tag. @tag is the tag returned from g_source_add_unix_fd(). If you want to remove a fd, don't set its event mask to zero. Instead, call g_source_remove_unix_fd(). This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create. As the name suggests, this function is not available on Windows.

a #GSource

the tag from g_source_add_unix_fd() the new event mask to watch

Queries the events reported for the fd corresponding to @tag on @source during the last poll. The return value of this function is only defined when the function is called from the check or dispatch functions for @source. This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create. As the name suggests, this function is not available on Windows.

the conditions reported on the fd

a #GSource

the tag from g_source_add_unix_fd()

Increases the reference count on a source by one.

@source

a #GSource

Detaches @child_source from @source and destroys it. This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create.

a #GSource

a #GSource previously passed to g_source_add_child_source().

Removes a file descriptor from the set of file descriptors polled for this source. This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create.

a #GSource

a #GPollFD structure previously passed to g_source_add_poll().

Reverses the effect of a previous call to g_source_add_unix_fd(). You only need to call this if you want to remove an fd from being watched while keeping the same source around. In the normal case you will just want to destroy the source. This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create. As the name suggests, this function is not available on Windows.

a #GSource

the tag from g_source_add_unix_fd()

Sets the callback function for a source. The callback for a source is called from the source's dispatch function. The exact type of @func depends on the type of source; ie. you should not count on @func being called with @data as its first parameter. Cast @func with G_SOURCE_FUNC() to avoid warnings about incompatible function types. See [memory management of sources][mainloop-memory-management] for details on how to handle memory management of @data. Typically, you won't use this function. Instead use functions specific to the type of source you are using, such as g_idle_add() or g_timeout_add(). It is safe to call this function multiple times on a source which has already been attached to a context. The changes will take effect for the next time the source is dispatched after this call returns. Note that g_source_destroy() for a currently attached source has the effect of also unsetting the callback.

the source

a callback function the data to pass to callback function a function to call when @data is no longer in use, or %NULL.

Sets the callback function storing the data as a refcounted callback "object". This is used internally. Note that calling g_source_set_callback_indirect() assumes an initial reference count on @callback_data, and thus @callback_funcs->unref will eventually be called once more than @callback_funcs->ref. It is safe to call this function multiple times on a source which has already been attached to a context. The changes will take effect for the next time the source is dispatched after this call returns.

the source

pointer to callback data "object" functions for reference counting @callback_data and getting the callback and data

Sets whether a source can be called recursively. If @can_recurse is %TRUE, then while the source is being dispatched then this source will be processed normally. Otherwise, all processing of this source is blocked until the dispatch function returns.

a #GSource

whether recursion is allowed for this source

Set @dispose as dispose function on @source. @dispose will be called once the reference count of @source reaches 0 but before any of the state of the source is freed, especially before the finalize function is called. This means that at this point @source is still a valid #GSource and it is allow for the reference count to increase again until @dispose returns. The dispose function can be used to clear any "weak" references to the @source in other data structures in a thread-safe way where it is possible for another thread to increase the reference count of @source again while it is being freed. The finalize function can not be used for this purpose as at that point @source is already partially freed and not valid anymore. This should only ever be called from #GSource implementations.

A #GSource to set the dispose function on

#GSourceDisposeFunc to set on the source

Sets the source functions (can be used to override default implementations) of an unattached source.

a #GSource

the new #GSourceFuncs

Sets a name for the source, used in debugging and profiling. The name defaults to #NULL. The source name should describe in a human-readable way what the source does. For example, "X11 event queue" or "GTK+ repaint idle handler" or whatever it is. It is permitted to call this function multiple times, but is not recommended due to the potential performance impact. For example, one could change the name in the "check" function of a #GSourceFuncs to include details like the event type in the source name. Use caution if changing the name while another thread may be accessing it with g_source_get_name(); that function does not copy the value, and changing the value will free it while the other thread may be attempting to use it. Also see g_source_set_static_name().

a #GSource

debug name for the source

Sets the priority of a source. While the main loop is being run, a source will be dispatched if it is ready to be dispatched and no sources at a higher (numerically smaller) priority are ready to be dispatched. A child source always has the same priority as its parent. It is not permitted to change the priority of a source once it has been added as a child of another source.

a #GSource

the new priority.

Sets a #GSource to be dispatched when the given monotonic time is reached (or passed). If the monotonic time is in the past (as it always will be if @ready_time is 0) then the source will be dispatched immediately. If @ready_time is -1 then the source is never woken up on the basis of the passage of time. Dispatching the source does not reset the ready time. You should do so yourself, from the source dispatch function. Note that if you have a pair of sources where the ready time of one suggests that it will be delivered first but the priority for the other suggests that it would be delivered first, and the ready time for both sources is reached during the same main context iteration, then the order of dispatch is undefined. It is a no-op to call this function on a #GSource which has already been destroyed with g_source_destroy(). This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create.

a #GSource

the monotonic time at which the source will be ready, 0 for "immediately", -1 for "never"

A variant of g_source_set_name() that does not duplicate the @name, and can only be used with string literals.

a #GSource

debug name for the source

Decreases the reference count of a source by one. If the resulting reference count is zero the source and associated memory will be destroyed.

a #GSource

Removes the source with the given ID from the default main context. You must use g_source_destroy() for sources added to a non-default main context. The ID of a #GSource is given by g_source_get_id(), or will be returned by the functions g_source_attach(), g_idle_add(), g_idle_add_full(), g_timeout_add(), g_timeout_add_full(), g_child_watch_add(), g_child_watch_add_full(), g_io_add_watch(), and g_io_add_watch_full(). It is a programmer error to attempt to remove a non-existent source. More specifically: source IDs can be reissued after a source has been destroyed and therefore it is never valid to use this function with a source ID which may have already been removed. An example is when scheduling an idle to run in another thread with g_idle_add(): the idle may already have run and been removed by the time this function is called on its (now invalid) source ID. This source ID may have been reissued, leading to the operation being performed against the wrong source.

%TRUE if the source was found and removed.

the ID of the source to remove.

Removes a source from the default main loop context given the source functions and user data. If multiple sources exist with the same source functions and user data, only one will be destroyed.

%TRUE if a source was found and removed.

The @source_funcs passed to g_source_new() the user data for the callback

Removes a source from the default main loop context given the user data for the callback. If multiple sources exist with the same user data, only one will be destroyed.

%TRUE if a source was found and removed.

the user_data for the callback.

Sets the name of a source using its ID. This is a convenience utility to set source names from the return value of g_idle_add(), g_timeout_add(), etc. It is a programmer error to attempt to set the name of a non-existent source. More specifically: source IDs can be reissued after a source has been destroyed and therefore it is never valid to use this function with a source ID which may have already been removed. An example is when scheduling an idle to run in another thread with g_idle_add(): the idle may already have run and been removed by the time this function is called on its (now invalid) source ID. This source ID may have been reissued, leading to the operation being performed against the wrong source.

a #GSource ID debug name for the source

The `GSourceCallbackFuncs` struct contains functions for managing callback objects.

Dispose function for @source. See g_source_set_dispose_function() for details.

#GSource that is currently being disposed

This is just a placeholder for #GClosureMarshal, which cannot be used here for dependency reasons.

Specifies the type of function passed to g_timeout_add(), g_timeout_add_full(), g_idle_add(), and g_idle_add_full(). When calling g_source_set_callback(), you may need to cast a function of a different type to this type. Use G_SOURCE_FUNC() to avoid warnings about incompatible function types.

%FALSE if the source should be removed. %G_SOURCE_CONTINUE and %G_SOURCE_REMOVE are more memorable names for the return value.

data passed to the function, set when the source was created with one of the above functions

The `GSourceFuncs` struct contains a table of functions used to handle event sources in a generic manner. For idle sources, the prepare and check functions always return %TRUE to indicate that the source is always ready to be processed. The prepare function also returns a timeout value of 0 to ensure that the poll() call doesn't block (since that would be time wasted which could have been spent running the idle function). For timeout sources, the prepare and check functions both return %TRUE if the timeout interval has expired. The prepare function also returns a timeout value to ensure that the poll() call doesn't block too long and miss the next timeout. For file descriptor sources, the prepare function typically returns %FALSE, since it must wait until poll() has been called before it knows whether any events need to be processed. It sets the returned timeout to -1 to indicate that it doesn't mind how long the poll() call blocks. In the check function, it tests the results of the poll() call to see if the required condition has been met, and returns %TRUE if so.

A source function that is only called once before being removed from the main context automatically. See: g_idle_add_once(), g_timeout_add_once()

data passed to the function, set when the source was created

Specifies the type of the setup function passed to g_spawn_async(), g_spawn_sync() and g_spawn_async_with_pipes(), which can, in very limited ways, be used to affect the child's execution. On POSIX platforms, the function is called in the child after GLib has performed all the setup it plans to perform, but before calling exec(). Actions taken in this function will only affect the child, not the parent. On Windows, the function is called in the parent. Its usefulness on Windows is thus questionable. In many cases executing the child setup function in the parent can have ill effects, and you should be very careful when porting software to Windows that uses child setup functions. However, even on POSIX, you are extremely limited in what you can safely do from a #GSpawnChildSetupFunc, because any mutexes that were held by other threads in the parent process at the time of the fork() will still be locked in the child process, and they will never be unlocked (since the threads that held them don't exist in the child). POSIX allows only async-signal-safe functions (see signal(7)) to be called in the child between fork() and exec(), which drastically limits the usefulness of child setup functions. In particular, it is not safe to call any function which may call malloc(), which includes POSIX functions such as setenv(). If you need to set up the child environment differently from the parent, you should use g_get_environ(), g_environ_setenv(), and g_environ_unsetenv(), and then pass the complete environment list to the `g_spawn...` function.

user data to pass to the function.

Error codes returned by spawning processes.

Fork failed due to lack of memory. Read or select on pipes failed. Changing to working directory failed. execv() returned `EACCES` execv() returned `EPERM` execv() returned `E2BIG` deprecated alias for %G_SPAWN_ERROR_TOO_BIG (deprecated since GLib 2.32) execv() returned `ENOEXEC` execv() returned `ENAMETOOLONG` execv() returned `ENOENT` execv() returned `ENOMEM` execv() returned `ENOTDIR` execv() returned `ELOOP` execv() returned `ETXTBUSY` execv() returned `EIO` execv() returned `ENFILE` execv() returned `EMFILE` execv() returned `EINVAL` execv() returned `EISDIR` execv() returned `ELIBBAD` Some other fatal failure, `error->message` should explain.

Flags passed to g_spawn_sync(), g_spawn_async() and g_spawn_async_with_pipes().

no flags, default behaviour the parent's open file descriptors will be inherited by the child; otherwise all descriptors except stdin, stdout and stderr will be closed before calling exec() in the child. the child will not be automatically reaped; you must use g_child_watch_add() yourself (or call waitpid() or handle `SIGCHLD` yourself), or the child will become a zombie. `argv[0]` need not be an absolute path, it will be looked for in the user's `PATH`. the child's standard output will be discarded, instead of going to the same location as the parent's standard output. the child's standard error will be discarded. the child will inherit the parent's standard input (by default, the child's standard input is attached to `/dev/null`). the first element of `argv` is the file to execute, while the remaining elements are the actual argument vector to pass to the file. Normally g_spawn_async_with_pipes() uses `argv[0]` as the file to execute, and passes all of `argv` to the child. if `argv[0]` is not an absolute path, it will be looked for in the `PATH` from the passed child environment. Since: 2.34 create all pipes with the `O_CLOEXEC` flag set. Since: 2.40 The child will inherit the parent's standard output. The child will inherit the parent's standard error. The child's standard input is attached to `/dev/null`.

A type corresponding to the appropriate struct type for the stat() system call, depending on the platform and/or compiler being used. See g_stat() for more information.

The GString struct contains the public fields of a GString.

points to the character data. It may move as text is added. The @str field is null-terminated and so can be used as an ordinary C string. contains the length of the string, not including the terminating nul byte. the number of bytes that can be stored in the string before it needs to be reallocated. May be larger than @len. Creates a new #GString, initialized with the given string.

the new #GString

the initial text to copy into the string, or %NULL to start with an empty string

Creates a new #GString with @len bytes of the @init buffer. Because a length is provided, @init need not be nul-terminated, and can contain embedded nul bytes. Since this function does not stop at nul bytes, it is the caller's responsibility to ensure that @init has at least @len addressable bytes.

a new #GString

initial contents of the string length of @init to use

Creates a new #GString, with enough space for @dfl_size bytes. This is useful if you are going to add a lot of text to the string and don't want it to be reallocated too often.

the new #GString

the default size of the space allocated to hold the string

Adds a string onto the end of a #GString, expanding it if necessary.

@string

a #GString

the string to append onto the end of @string

Adds a byte onto the end of a #GString, expanding it if necessary.

@string

a #GString

the byte to append onto the end of @string

Appends @len bytes of @val to @string. If @len is positive, @val may contain embedded nuls and need not be nul-terminated. It is the caller's responsibility to ensure that @val has at least @len addressable bytes. If @len is negative, @val must be nul-terminated and @len is considered to request the entire string length. This makes g_string_append_len() equivalent to g_string_append().

@string

a #GString

bytes to append number of bytes of @val to use, or -1 for all of @val

Appends a formatted string onto the end of a #GString. This function is similar to g_string_printf() except that the text is appended to the #GString.

a #GString

the string format. See the printf() documentation the parameters to insert into the format string

Converts a Unicode character into UTF-8, and appends it to the string.

@string

a #GString

a Unicode character

Appends @unescaped to @string, escaping any characters that are reserved in URIs using URI-style escape sequences.

@string

a #GString

a string a string of reserved characters allowed to be used, or %NULL set %TRUE if the escaped string may include UTF8 characters

Appends a formatted string onto the end of a #GString. This function is similar to g_string_append_printf() except that the arguments to the format string are passed as a va_list.

a #GString

the string format. See the printf() documentation the list of arguments to insert in the output

Converts all uppercase ASCII letters to lowercase ASCII letters.

passed-in @string pointer, with all the uppercase characters converted to lowercase in place, with semantics that exactly match g_ascii_tolower().

a GString

Converts all lowercase ASCII letters to uppercase ASCII letters.

passed-in @string pointer, with all the lowercase characters converted to uppercase in place, with semantics that exactly match g_ascii_toupper().

a GString

Copies the bytes from a string into a #GString, destroying any previous contents. It is rather like the standard strcpy() function, except that you do not have to worry about having enough space to copy the string.

@string

the destination #GString. Its current contents are destroyed.

the string to copy into @string

Converts a #GString to lowercase.

This function uses the locale-specific tolower() function, which is almost never the right thing. Use g_string_ascii_down() or g_utf8_strdown() instead.

the #GString

a #GString

Compares two strings for equality, returning %TRUE if they are equal. For use with #GHashTable.

%TRUE if the strings are the same length and contain the same bytes

a #GString

another #GString

Removes @len bytes from a #GString, starting at position @pos. The rest of the #GString is shifted down to fill the gap.

@string

a #GString

the position of the content to remove the number of bytes to remove, or -1 to remove all following bytes

Frees the memory allocated for the #GString. If @free_segment is %TRUE it also frees the character data. If it's %FALSE, the caller gains ownership of the buffer and must free it after use with g_free().

the character data of @string (i.e. %NULL if @free_segment is %TRUE)

a #GString

if %TRUE, the actual character data is freed as well

Transfers ownership of the contents of @string to a newly allocated #GBytes. The #GString structure itself is deallocated, and it is therefore invalid to use @string after invoking this function. Note that while #GString ensures that its buffer always has a trailing nul character (not reflected in its "len"), the returned #GBytes does not include this extra nul; i.e. it has length exactly equal to the "len" member.

A newly allocated #GBytes containing contents of @string; @string itself is freed

a #GString

Creates a hash code for @str; for use with #GHashTable.

hash code for @str

a string to hash

Inserts a copy of a string into a #GString, expanding it if necessary.

@string

a #GString

the position to insert the copy of the string the string to insert

Inserts a byte into a #GString, expanding it if necessary.

@string

a #GString

the position to insert the byte the byte to insert

Inserts @len bytes of @val into @string at @pos. If @len is positive, @val may contain embedded nuls and need not be nul-terminated. It is the caller's responsibility to ensure that @val has at least @len addressable bytes. If @len is negative, @val must be nul-terminated and @len is considered to request the entire string length. If @pos is -1, bytes are inserted at the end of the string.

@string

a #GString

position in @string where insertion should happen, or -1 for at the end bytes to insert number of bytes of @val to insert, or -1 for all of @val

Converts a Unicode character into UTF-8, and insert it into the string at the given position.

@string

a #GString

the position at which to insert character, or -1 to append at the end of the string a Unicode character

Overwrites part of a string, lengthening it if necessary.

@string

a #GString

the position at which to start overwriting the string that will overwrite the @string starting at @pos

Overwrites part of a string, lengthening it if necessary. This function will work with embedded nuls.

@string

a #GString

the position at which to start overwriting the string that will overwrite the @string starting at @pos the number of bytes to write from @val

Adds a string on to the start of a #GString, expanding it if necessary.

@string

a #GString

the string to prepend on the start of @string

Adds a byte onto the start of a #GString, expanding it if necessary.

@string

a #GString

the byte to prepend on the start of the #GString

Prepends @len bytes of @val to @string. If @len is positive, @val may contain embedded nuls and need not be nul-terminated. It is the caller's responsibility to ensure that @val has at least @len addressable bytes. If @len is negative, @val must be nul-terminated and @len is considered to request the entire string length. This makes g_string_prepend_len() equivalent to g_string_prepend().

@string

a #GString

bytes to prepend number of bytes in @val to prepend, or -1 for all of @val

Converts a Unicode character into UTF-8, and prepends it to the string.

@string

a #GString

a Unicode character

Writes a formatted string into a #GString. This is similar to the standard sprintf() function, except that the #GString buffer automatically expands to contain the results. The previous contents of the #GString are destroyed.

a #GString

the string format. See the printf() documentation the parameters to insert into the format string

Replaces the string @find with the string @replace in a #GString up to @limit times. If the number of instances of @find in the #GString is less than @limit, all instances are replaced. If @limit is `0`, all instances of @find are replaced. If @find is the empty string, since versions 2.69.1 and 2.68.4 the replacement will be inserted no more than once per possible position (beginning of string, end of string and between characters). This did not work correctly in earlier versions.

the number of find and replace operations performed.

a #GString

the string to find in @string the string to insert in place of @find the maximum instances of @find to replace with @replace, or `0` for no limit

Sets the length of a #GString. If the length is less than the current length, the string will be truncated. If the length is greater than the current length, the contents of the newly added area are undefined. (However, as always, string->str[string->len] will be a nul byte.)

@string

a #GString

the new length

Cuts off the end of the GString, leaving the first @len bytes.

@string

a #GString

the new size of @string

Converts a #GString to uppercase.

This function uses the locale-specific toupper() function, which is almost never the right thing. Use g_string_ascii_up() or g_utf8_strup() instead.

@string

a #GString

Writes a formatted string into a #GString. This function is similar to g_string_printf() except that the arguments to the format string are passed as a va_list.

a #GString

the string format. See the printf() documentation the parameters to insert into the format string

An opaque data structure representing String Chunks. It should only be accessed by using the following functions.

Frees all strings contained within the #GStringChunk. After calling g_string_chunk_clear() it is not safe to access any of the strings which were contained within it.

a #GStringChunk

Frees all memory allocated by the #GStringChunk. After calling g_string_chunk_free() it is not safe to access any of the strings which were contained within it.

a #GStringChunk

Adds a copy of @string to the #GStringChunk. It returns a pointer to the new copy of the string in the #GStringChunk. The characters in the string can be changed, if necessary, though you should not change anything after the end of the string. Unlike g_string_chunk_insert_const(), this function does not check for duplicates. Also strings added with g_string_chunk_insert() will not be searched by g_string_chunk_insert_const() when looking for duplicates.

a pointer to the copy of @string within the #GStringChunk

a #GStringChunk

the string to add

Adds a copy of @string to the #GStringChunk, unless the same string has already been added to the #GStringChunk with g_string_chunk_insert_const(). This function is useful if you need to copy a large number of strings but do not want to waste space storing duplicates. But you must remember that there may be several pointers to the same string, and so any changes made to the strings should be done very carefully. Note that g_string_chunk_insert_const() will not return a pointer to a string added with g_string_chunk_insert(), even if they do match.

a pointer to the new or existing copy of @string within the #GStringChunk

a #GStringChunk

the string to add

Adds a copy of the first @len bytes of @string to the #GStringChunk. The copy is nul-terminated. Since this function does not stop at nul bytes, it is the caller's responsibility to ensure that @string has at least @len addressable bytes. The characters in the returned string can be changed, if necessary, though you should not change anything after the end of the string.

a pointer to the copy of @string within the #GStringChunk

a #GStringChunk

bytes to insert number of bytes of @string to insert, or -1 to insert a nul-terminated string

Creates a new #GStringChunk.

a new #GStringChunk

the default size of the blocks of memory which are allocated to store the strings. If a particular string is larger than this default size, a larger block of memory will be allocated for it.

#GStrvBuilder is a method of easily building dynamically sized NULL-terminated string arrays. The following example shows how to build a two element array: |[ g_autoptr(GStrvBuilder) builder = g_strv_builder_new (); g_strv_builder_add (builder, "hello"); g_strv_builder_add (builder, "world"); g_auto(GStrv) array = g_strv_builder_end (builder); ]|

Add a string to the end of the array. Since 2.68

a #GStrvBuilder

a string.

Appends all the given strings to the builder. Since 2.70

a #GStrvBuilder

one or more strings followed by %NULL

Appends all the strings in the given vector to the builder. Since 2.70

a #GStrvBuilder

the vector of strings to add

Ends the builder process and returns the constructed NULL-terminated string array. The returned value should be freed with g_strfreev() when no longer needed.

the constructed string array. Since 2.68

a #GStrvBuilder

Atomically increments the reference count of @builder by one. This function is thread-safe and may be called from any thread.

The passed in #GStrvBuilder

a #GStrvBuilder

Decreases the reference count on @builder. In the event that there are no more references, releases all memory associated with the #GStrvBuilder.

a #GStrvBuilder allocated by g_strv_builder_new()

Creates a new #GStrvBuilder with a reference count of 1. Use g_strv_builder_unref() on the returned value when no longer needed.

the new #GStrvBuilder

Creates a unique temporary directory for each unit test and uses g_set_user_dirs() to set XDG directories to point into subdirectories of it for the duration of the unit test. The directory tree is cleaned up after the test finishes successfully. Note that this doesn’t take effect until g_test_run() is called, so calls to (for example) g_get_user_home_dir() will return the system-wide value when made in a test program’s main() function. The following functions will return subdirectories of the temporary directory when this option is used. The specific subdirectory paths in use are not guaranteed to be stable API — always use a getter function to retrieve them. - g_get_home_dir() - g_get_user_cache_dir() - g_get_system_config_dirs() - g_get_user_config_dir() - g_get_system_data_dirs() - g_get_user_data_dir() - g_get_user_state_dir() - g_get_user_runtime_dir() The subdirectories may not be created by the test harness; as with normal calls to functions like g_get_user_cache_dir(), the caller must be prepared to create the directory if it doesn’t exist.

Evaluates to a time span of one day.

Evaluates to a time span of one hour.

Evaluates to a time span of one millisecond.

Evaluates to a time span of one minute.

Evaluates to a time span of one second.

Works like g_mutex_trylock(), but for a lock defined with %G_LOCK_DEFINE.

the name of the lock

An opaque structure representing a test case.

Free the @test_case.

a #GTestCase

The type used for test case functions that take an extra pointer argument.

the data provided when registering the test

The type of file to return the filename for, when used with g_test_build_filename(). These two options correspond rather directly to the 'dist' and 'built' terminology that automake uses and are explicitly used to distinguish between the 'srcdir' and 'builddir' being separate. All files in your project should either be dist (in the `EXTRA_DIST` or `dist_schema_DATA` sense, in which case they will always be in the srcdir) or built (in the `BUILT_SOURCES` sense, in which case they will always be in the builddir). Note: as a general rule of automake, files that are generated only as part of the build-from-git process (but then are distributed with the tarball) always go in srcdir (even if doing a srcdir != builddir build from git) and are considered as distributed files.

a file that was included in the distribution tarball a file that was built on the compiling machine

The type used for functions that operate on test fixtures. This is used for the fixture setup and teardown functions as well as for the testcases themselves. @user_data is a pointer to the data that was given when registering the test case. @fixture will be a pointer to the area of memory allocated by the test framework, of the size requested. If the requested size was zero then @fixture will be equal to @user_data.

the test fixture the data provided when registering the test

The type used for test case functions.

Internal function for gtester to free test log messages, no ABI guarantees provided.

Internal function for gtester to retrieve test log messages, no ABI guarantees provided.

Internal function for gtester to decode test log messages, no ABI guarantees provided.

Specifies the prototype of fatal log handler functions.

%TRUE if the program should abort, %FALSE otherwise

the log domain of the message the log level of the message (including the fatal and recursion flags) the message to process user data, set in g_test_log_set_fatal_handler()

Internal function for gtester to free test log messages, no ABI guarantees provided.

Flags to pass to g_test_trap_subprocess() to control input and output. Note that in contrast with g_test_trap_fork(), the default is to not show stdout and stderr.

Default behaviour. Since: 2.74 If this flag is given, the child process will inherit the parent's stdin. Otherwise, the child's stdin is redirected to `/dev/null`. If this flag is given, the child process will inherit the parent's stdout. Otherwise, the child's stdout will not be visible, but it will be captured to allow later tests with g_test_trap_assert_stdout(). If this flag is given, the child process will inherit the parent's stderr. Otherwise, the child's stderr will not be visible, but it will be captured to allow later tests with g_test_trap_assert_stderr().

An opaque structure representing a test suite.

Adds @test_case to @suite.

a #GTestSuite

a #GTestCase

Adds @nestedsuite to @suite.

a #GTestSuite

another #GTestSuite

Free the @suite and all nested #GTestSuites.

a #GTestSuite

Test traps are guards around forked tests. These flags determine what traps to set.

#GTestTrapFlags is used only with g_test_trap_fork(), which is deprecated. g_test_trap_subprocess() uses #GTestSubprocessFlags.

Default behaviour. Since: 2.74 Redirect stdout of the test child to `/dev/null` so it cannot be observed on the console during test runs. The actual output is still captured though to allow later tests with g_test_trap_assert_stdout(). Redirect stderr of the test child to `/dev/null` so it cannot be observed on the console during test runs. The actual output is still captured though to allow later tests with g_test_trap_assert_stderr(). If this flag is given, stdin of the child process is shared with stdin of its parent process. It is redirected to `/dev/null` otherwise.

The #GThread struct represents a running thread. This struct is returned by g_thread_new() or g_thread_try_new(). You can obtain the #GThread struct representing the current thread by calling g_thread_self(). GThread is refcounted, see g_thread_ref() and g_thread_unref(). The thread represented by it holds a reference while it is running, and g_thread_join() consumes the reference that it is given, so it is normally not necessary to manage GThread references explicitly. The structure is opaque -- none of its fields may be directly accessed.

This function creates a new thread. The new thread starts by invoking @func with the argument data. The thread will run until @func returns or until g_thread_exit() is called from the new thread. The return value of @func becomes the return value of the thread, which can be obtained with g_thread_join(). The @name can be useful for discriminating threads in a debugger. It is not used for other purposes and does not have to be unique. Some systems restrict the length of @name to 16 bytes. If the thread can not be created the program aborts. See g_thread_try_new() if you want to attempt to deal with failures. If you are using threads to offload (potentially many) short-lived tasks, #GThreadPool may be more appropriate than manually spawning and tracking multiple #GThreads. To free the struct returned by this function, use g_thread_unref(). Note that g_thread_join() implicitly unrefs the #GThread as well. New threads by default inherit their scheduler policy (POSIX) or thread priority (Windows) of the thread creating the new thread. This behaviour changed in GLib 2.64: before threads on Windows were not inheriting the thread priority but were spawned with the default priority. Starting with GLib 2.64 the behaviour is now consistent between Windows and POSIX and all threads inherit their parent thread's priority.

the new #GThread

an (optional) name for the new thread a function to execute in the new thread an argument to supply to the new thread

This function is the same as g_thread_new() except that it allows for the possibility of failure. If a thread can not be created (due to resource limits), @error is set and %NULL is returned.

the new #GThread, or %NULL if an error occurred

an (optional) name for the new thread a function to execute in the new thread an argument to supply to the new thread

Waits until @thread finishes, i.e. the function @func, as given to g_thread_new(), returns or g_thread_exit() is called. If @thread has already terminated, then g_thread_join() returns immediately. Any thread can wait for any other thread by calling g_thread_join(), not just its 'creator'. Calling g_thread_join() from multiple threads for the same @thread leads to undefined behaviour. The value returned by @func or given to g_thread_exit() is returned by this function. g_thread_join() consumes the reference to the passed-in @thread. This will usually cause the #GThread struct and associated resources to be freed. Use g_thread_ref() to obtain an extra reference if you want to keep the GThread alive beyond the g_thread_join() call.

the return value of the thread

a #GThread

Increase the reference count on @thread.

a new reference to @thread

a #GThread

Decrease the reference count on @thread, possibly freeing all resources associated with it. Note that each thread holds a reference to its #GThread while it is running, so it is safe to drop your own reference to it if you don't need it anymore.

a #GThread

Terminates the current thread. If another thread is waiting for us using g_thread_join() then the waiting thread will be woken up and get @retval as the return value of g_thread_join(). Calling g_thread_exit() with a parameter @retval is equivalent to returning @retval from the function @func, as given to g_thread_new(). You must only call g_thread_exit() from a thread that you created yourself with g_thread_new() or related APIs. You must not call this function from a thread created with another threading library or or from within a #GThreadPool.

the return value of this thread

This function returns the #GThread corresponding to the current thread. Note that this function does not increase the reference count of the returned struct. This function will return a #GThread even for threads that were not created by GLib (i.e. those created by other threading APIs). This may be useful for thread identification purposes (i.e. comparisons) but you must not use GLib functions (such as g_thread_join()) on these threads.

the #GThread representing the current thread

Causes the calling thread to voluntarily relinquish the CPU, so that other threads can run. This function is often used as a method to make busy wait less evil.

Possible errors of thread related functions.

a thread couldn't be created due to resource shortage. Try again later.

Specifies the type of the @func functions passed to g_thread_new() or g_thread_try_new().

the return value of the thread

data passed to the thread

The #GThreadPool struct represents a thread pool. It has three public read-only members, but the underlying struct is bigger, so you must not copy this struct.

the function to execute in the threads of this pool the user data for the threads of this pool are all threads exclusive to this pool Frees all resources allocated for @pool. If @immediate is %TRUE, no new task is processed for @pool. Otherwise @pool is not freed before the last task is processed. Note however, that no thread of this pool is interrupted while processing a task. Instead at least all still running threads can finish their tasks before the @pool is freed. If @wait_ is %TRUE, this function does not return before all tasks to be processed (dependent on @immediate, whether all or only the currently running) are ready. Otherwise this function returns immediately. After calling this function @pool must not be used anymore.

a #GThreadPool

should @pool shut down immediately? should the function wait for all tasks to be finished?

Returns the maximal number of threads for @pool.

the maximal number of threads

a #GThreadPool

Returns the number of threads currently running in @pool.

the number of threads currently running

a #GThreadPool

Moves the item to the front of the queue of unprocessed items, so that it will be processed next.

%TRUE if the item was found and moved

a #GThreadPool

an unprocessed item in the pool

Inserts @data into the list of tasks to be executed by @pool. When the number of currently running threads is lower than the maximal allowed number of threads, a new thread is started (or reused) with the properties given to g_thread_pool_new(). Otherwise, @data stays in the queue until a thread in this pool finishes its previous task and processes @data. @error can be %NULL to ignore errors, or non-%NULL to report errors. An error can only occur when a new thread couldn't be created. In that case @data is simply appended to the queue of work to do. Before version 2.32, this function did not return a success status.

%TRUE on success, %FALSE if an error occurred

a #GThreadPool

a new task for @pool

Sets the maximal allowed number of threads for @pool. A value of -1 means that the maximal number of threads is unlimited. If @pool is an exclusive thread pool, setting the maximal number of threads to -1 is not allowed. Setting @max_threads to 0 means stopping all work for @pool. It is effectively frozen until @max_threads is set to a non-zero value again. A thread is never terminated while calling @func, as supplied by g_thread_pool_new(). Instead the maximal number of threads only has effect for the allocation of new threads in g_thread_pool_push(). A new thread is allocated, whenever the number of currently running threads in @pool is smaller than the maximal number. @error can be %NULL to ignore errors, or non-%NULL to report errors. An error can only occur when a new thread couldn't be created. Before version 2.32, this function did not return a success status.

%TRUE on success, %FALSE if an error occurred

a #GThreadPool

a new maximal number of threads for @pool, or -1 for unlimited

Sets the function used to sort the list of tasks. This allows the tasks to be processed by a priority determined by @func, and not just in the order in which they were added to the pool. Note, if the maximum number of threads is more than 1, the order that threads are executed cannot be guaranteed 100%. Threads are scheduled by the operating system and are executed at random. It cannot be assumed that threads are executed in the order they are created.

a #GThreadPool

the #GCompareDataFunc used to sort the list of tasks. This function is passed two tasks. It should return 0 if the order in which they are handled does not matter, a negative value if the first task should be processed before the second or a positive value if the second task should be processed first. user data passed to @func

Returns the number of tasks still unprocessed in @pool.

the number of unprocessed tasks

a #GThreadPool

This function will return the maximum @interval that a thread will wait in the thread pool for new tasks before being stopped. If this function returns 0, threads waiting in the thread pool for new work are not stopped.

the maximum @interval (milliseconds) to wait for new tasks in the thread pool before stopping the thread

Returns the maximal allowed number of unused threads.

the maximal number of unused threads

Returns the number of currently unused threads.

the number of currently unused threads

This function creates a new thread pool. Whenever you call g_thread_pool_push(), either a new thread is created or an unused one is reused. At most @max_threads threads are running concurrently for this thread pool. @max_threads = -1 allows unlimited threads to be created for this thread pool. The newly created or reused thread now executes the function @func with the two arguments. The first one is the parameter to g_thread_pool_push() and the second one is @user_data. Pass g_get_num_processors() to @max_threads to create as many threads as there are logical processors on the system. This will not pin each thread to a specific processor. The parameter @exclusive determines whether the thread pool owns all threads exclusive or shares them with other thread pools. If @exclusive is %TRUE, @max_threads threads are started immediately and they will run exclusively for this thread pool until it is destroyed by g_thread_pool_free(). If @exclusive is %FALSE, threads are created when needed and shared between all non-exclusive thread pools. This implies that @max_threads may not be -1 for exclusive thread pools. Besides, exclusive thread pools are not affected by g_thread_pool_set_max_idle_time() since their threads are never considered idle and returned to the global pool. @error can be %NULL to ignore errors, or non-%NULL to report errors. An error can only occur when @exclusive is set to %TRUE and not all @max_threads threads could be created. See #GThreadError for possible errors that may occur. Note, even in case of error a valid #GThreadPool is returned.

the new #GThreadPool

a function to execute in the threads of the new thread pool user data that is handed over to @func every time it is called the maximal number of threads to execute concurrently in the new thread pool, -1 means no limit should this thread pool be exclusive?

This function creates a new thread pool similar to g_thread_pool_new() but allowing @item_free_func to be specified to free the data passed to g_thread_pool_push() in the case that the #GThreadPool is stopped and freed before all tasks have been executed.

the new #GThreadPool

a function to execute in the threads of the new thread pool user data that is handed over to @func every time it is called used to pass as a free function to g_async_queue_new_full() the maximal number of threads to execute concurrently in the new thread pool, `-1` means no limit should this thread pool be exclusive?

This function will set the maximum @interval that a thread waiting in the pool for new tasks can be idle for before being stopped. This function is similar to calling g_thread_pool_stop_unused_threads() on a regular timeout, except this is done on a per thread basis. By setting @interval to 0, idle threads will not be stopped. The default value is 15000 (15 seconds).

the maximum @interval (in milliseconds) a thread can be idle

Sets the maximal number of unused threads to @max_threads. If @max_threads is -1, no limit is imposed on the number of unused threads. The default value is 2.

maximal number of unused threads

Stops all currently unused threads. This does not change the maximal number of unused threads. This function can be used to regularly stop all unused threads e.g. from g_timeout_add().

Disambiguates a given time in two ways. First, specifies if the given time is in universal or local time. Second, if the time is in local time, specifies if it is local standard time or local daylight time. This is important for the case where the same local time occurs twice (during daylight savings time transitions, for example).

the time is in local standard time the time is in local daylight time the time is in UTC

Represents a precise time, with seconds and microseconds. Similar to the struct timeval returned by the `gettimeofday()` UNIX system call. GLib is attempting to unify around the use of 64-bit integers to represent microsecond-precision time. As such, this type will be removed from a future version of GLib. A consequence of using `glong` for `tv_sec` is that on 32-bit systems `GTimeVal` is subject to the year 2038 problem.

Use #GDateTime or #guint64 instead.

seconds microseconds Adds the given number of microseconds to @time_. @microseconds can also be negative to decrease the value of @time_.

#GTimeVal is not year-2038-safe. Use `guint64` for representing microseconds since the epoch, or use #GDateTime.

a #GTimeVal

number of microseconds to add to @time

Converts @time_ into an RFC 3339 encoded string, relative to the Coordinated Universal Time (UTC). This is one of the many formats allowed by ISO 8601. ISO 8601 allows a large number of date/time formats, with or without punctuation and optional elements. The format returned by this function is a complete date and time, with optional punctuation included, the UTC time zone represented as "Z", and the @tv_usec part included if and only if it is nonzero, i.e. either "YYYY-MM-DDTHH:MM:SSZ" or "YYYY-MM-DDTHH:MM:SS.fffffZ". This corresponds to the Internet date/time format defined by [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt), and to either of the two most-precise formats defined by the W3C Note [Date and Time Formats](http://www.w3.org/TR/NOTE-datetime-19980827). Both of these documents are profiles of ISO 8601. Use g_date_time_format() or g_strdup_printf() if a different variation of ISO 8601 format is required. If @time_ represents a date which is too large to fit into a `struct tm`, %NULL will be returned. This is platform dependent. Note also that since `GTimeVal` stores the number of seconds as a `glong`, on 32-bit systems it is subject to the year 2038 problem. Accordingly, since GLib 2.62, this function has been deprecated. Equivalent functionality is available using: |[ GDateTime *dt = g_date_time_new_from_unix_utc (time_val); iso8601_string = g_date_time_format_iso8601 (dt); g_date_time_unref (dt); ]| The return value of g_time_val_to_iso8601() has been nullable since GLib 2.54; before then, GLib would crash under the same conditions.

#GTimeVal is not year-2038-safe. Use g_date_time_format_iso8601(dt) instead.

a newly allocated string containing an ISO 8601 date, or %NULL if @time_ was too large

a #GTimeVal

Converts a string containing an ISO 8601 encoded date and time to a #GTimeVal and puts it into @time_. @iso_date must include year, month, day, hours, minutes, and seconds. It can optionally include fractions of a second and a time zone indicator. (In the absence of any time zone indication, the timestamp is assumed to be in local time.) Any leading or trailing space in @iso_date is ignored. This function was deprecated, along with #GTimeVal itself, in GLib 2.62. Equivalent functionality is available using code like: |[ GDateTime *dt = g_date_time_new_from_iso8601 (iso8601_string, NULL); gint64 time_val = g_date_time_to_unix (dt); g_date_time_unref (dt); ]|

#GTimeVal is not year-2038-safe. Use g_date_time_new_from_iso8601() instead.

%TRUE if the conversion was successful.

an ISO 8601 encoded date string a #GTimeVal

#GTimeZone is an opaque structure whose members cannot be accessed directly.

A version of g_time_zone_new_identifier() which returns the UTC time zone if @identifier could not be parsed or loaded. If you need to check whether @identifier was loaded successfully, use g_time_zone_new_identifier().

Use g_time_zone_new_identifier() instead, as it provides error reporting. Change your code to handle a potentially %NULL return value.

the requested timezone

a timezone identifier

Creates a #GTimeZone corresponding to @identifier. If @identifier cannot be parsed or loaded, %NULL is returned. @identifier can either be an RFC3339/ISO 8601 time offset or something that would pass as a valid value for the `TZ` environment variable (including %NULL). In Windows, @identifier can also be the unlocalized name of a time zone for standard time, for example "Pacific Standard Time". Valid RFC3339 time offsets are `"Z"` (for UTC) or `"±hh:mm"`. ISO 8601 additionally specifies `"±hhmm"` and `"±hh"`. Offsets are time values to be added to Coordinated Universal Time (UTC) to get the local time. In UNIX, the `TZ` environment variable typically corresponds to the name of a file in the zoneinfo database, an absolute path to a file somewhere else, or a string in "std offset [dst [offset],start[/time],end[/time]]" (POSIX) format. There are no spaces in the specification. The name of standard and daylight savings time zone must be three or more alphabetic characters. Offsets are time values to be added to local time to get Coordinated Universal Time (UTC) and should be `"[±]hh[[:]mm[:ss]]"`. Dates are either `"Jn"` (Julian day with n between 1 and 365, leap years not counted), `"n"` (zero-based Julian day with n between 0 and 365) or `"Mm.w.d"` (day d (0 <= d <= 6) of week w (1 <= w <= 5) of month m (1 <= m <= 12), day 0 is a Sunday). Times are in local wall clock time, the default is 02:00:00. In Windows, the "tzn[+|–]hh[:mm[:ss]][dzn]" format is used, but also accepts POSIX format. The Windows format uses US rules for all time zones; daylight savings time is 60 minutes behind the standard time with date and time of change taken from Pacific Standard Time. Offsets are time values to be added to the local time to get Coordinated Universal Time (UTC). g_time_zone_new_local() calls this function with the value of the `TZ` environment variable. This function itself is independent of the value of `TZ`, but if @identifier is %NULL then `/etc/localtime` will be consulted to discover the correct time zone on UNIX and the registry will be consulted or GetTimeZoneInformation() will be used to get the local time zone on Windows. If intervals are not available, only time zone rules from `TZ` environment variable or other means, then they will be computed from year 1900 to 2037. If the maximum year for the rules is available and it is greater than 2037, then it will followed instead. See [RFC3339 §5.6](http://tools.ietf.org/html/rfc3339#section-5.6) for a precise definition of valid RFC3339 time offsets (the `time-offset` expansion) and ISO 8601 for the full list of valid time offsets. See [The GNU C Library manual](http://www.gnu.org/s/libc/manual/html_node/TZ-Variable.html) for an explanation of the possible values of the `TZ` environment variable. See [Microsoft Time Zone Index Values](http://msdn.microsoft.com/en-us/library/ms912391%28v=winembedded.11%29.aspx) for the list of time zones on Windows. You should release the return value by calling g_time_zone_unref() when you are done with it.

the requested timezone, or %NULL on failure

a timezone identifier

Creates a #GTimeZone corresponding to local time. The local time zone may change between invocations to this function; for example, if the system administrator changes it. This is equivalent to calling g_time_zone_new() with the value of the `TZ` environment variable (including the possibility of %NULL). You should release the return value by calling g_time_zone_unref() when you are done with it.

the local timezone

Creates a #GTimeZone corresponding to the given constant offset from UTC, in seconds. This is equivalent to calling g_time_zone_new() with a string in the form `[+|-]hh[:mm[:ss]]`. It is possible for this function to fail if @seconds is too big (greater than 24 hours), in which case this function will return the UTC timezone for backwards compatibility. To detect failures like this, use g_time_zone_new_identifier() directly.

a timezone at the given offset from UTC, or UTC on failure

offset to UTC, in seconds

Creates a #GTimeZone corresponding to UTC. This is equivalent to calling g_time_zone_new() with a value like "Z", "UTC", "+00", etc. You should release the return value by calling g_time_zone_unref() when you are done with it.

the universal timezone

Finds an interval within @tz that corresponds to the given @time_, possibly adjusting @time_ if required to fit into an interval. The meaning of @time_ depends on @type. This function is similar to g_time_zone_find_interval(), with the difference that it always succeeds (by making the adjustments described below). In any of the cases where g_time_zone_find_interval() succeeds then this function returns the same value, without modifying @time_. This function may, however, modify @time_ in order to deal with non-existent times. If the non-existent local @time_ of 02:30 were requested on March 14th 2010 in Toronto then this function would adjust @time_ to be 03:00 and return the interval containing the adjusted time.

the interval containing @time_, never -1

a #GTimeZone

the #GTimeType of @time_ a pointer to a number of seconds since January 1, 1970

Finds an interval within @tz that corresponds to the given @time_. The meaning of @time_ depends on @type. If @type is %G_TIME_TYPE_UNIVERSAL then this function will always succeed (since universal time is monotonic and continuous). Otherwise @time_ is treated as local time. The distinction between %G_TIME_TYPE_STANDARD and %G_TIME_TYPE_DAYLIGHT is ignored except in the case that the given @time_ is ambiguous. In Toronto, for example, 01:30 on November 7th 2010 occurred twice (once inside of daylight savings time and the next, an hour later, outside of daylight savings time). In this case, the different value of @type would result in a different interval being returned. It is still possible for this function to fail. In Toronto, for example, 02:00 on March 14th 2010 does not exist (due to the leap forward to begin daylight savings time). -1 is returned in that case.

the interval containing @time_, or -1 in case of failure

a #GTimeZone

the #GTimeType of @time_ a number of seconds since January 1, 1970

Determines the time zone abbreviation to be used during a particular @interval of time in the time zone @tz. For example, in Toronto this is currently "EST" during the winter months and "EDT" during the summer months when daylight savings time is in effect.

the time zone abbreviation, which belongs to @tz

a #GTimeZone

an interval within the timezone

Get the identifier of this #GTimeZone, as passed to g_time_zone_new(). If the identifier passed at construction time was not recognised, `UTC` will be returned. If it was %NULL, the identifier of the local timezone at construction time will be returned. The identifier will be returned in the same format as provided at construction time: if provided as a time offset, that will be returned by this function.

identifier for this timezone

a #GTimeZone

Determines the offset to UTC in effect during a particular @interval of time in the time zone @tz. The offset is the number of seconds that you add to UTC time to arrive at local time for @tz (ie: negative numbers for time zones west of GMT, positive numbers for east).

the number of seconds that should be added to UTC to get the local time in @tz

a #GTimeZone

an interval within the timezone

Determines if daylight savings time is in effect during a particular @interval of time in the time zone @tz.

%TRUE if daylight savings time is in effect

a #GTimeZone

an interval within the timezone

Increases the reference count on @tz.

a new reference to @tz.

a #GTimeZone

Decreases the reference count on @tz.

a #GTimeZone

Opaque datatype that records a start time.

Resumes a timer that has previously been stopped with g_timer_stop(). g_timer_stop() must be called before using this function.

a #GTimer.

Destroys a timer, freeing associated resources.

a #GTimer to destroy.

If @timer has been started but not stopped, obtains the time since the timer was started. If @timer has been stopped, obtains the elapsed time between the time it was started and the time it was stopped. The return value is the number of seconds elapsed, including any fractional part. The @microseconds out parameter is essentially useless.

seconds elapsed as a floating point value, including any fractional part.

a #GTimer.

return location for the fractional part of seconds elapsed, in microseconds (that is, the total number of microseconds elapsed, modulo 1000000), or %NULL

Exposes whether the timer is currently active.

%TRUE if the timer is running, %FALSE otherwise

a #GTimer.

This function is useless; it's fine to call g_timer_start() on an already-started timer to reset the start time, so g_timer_reset() serves no purpose.

a #GTimer.

Marks a start time, so that future calls to g_timer_elapsed() will report the time since g_timer_start() was called. g_timer_new() automatically marks the start time, so no need to call g_timer_start() immediately after creating the timer.

a #GTimer.

Marks an end time, so calls to g_timer_elapsed() will return the difference between this end time and the start time.

a #GTimer.

Creates a new timer, and starts timing (i.e. g_timer_start() is implicitly called for you).

a new #GTimer.

The possible types of token returned from each g_scanner_get_next_token() call.

the end of the file a '(' character a ')' character a '{' character a '}' character a '[' character a ']' character a '=' character a ',' character not a token an error occurred a character a binary integer an octal integer an integer a hex integer a floating point number a string a symbol an identifier a null identifier one line comment multi line comment

A union holding the value of the token.

token symbol value token identifier value token binary integer value octal integer value integer value 64-bit integer value floating point value hex integer value string value comment value character value error value

The type of functions which are used to translate user-visible strings, for <option>--help</option> output.

a translation of the string for the current locale. The returned string is owned by GLib and must not be freed.

the untranslated string user data specified when installing the function, e.g. in g_option_group_set_translate_func()

Each piece of memory that is pushed onto the stack is cast to a GTrashStack*.

#GTrashStack is deprecated without replacement

pointer to the previous element of the stack, gets stored in the first `sizeof (gpointer)` bytes of the element Returns the height of a #GTrashStack. Note that execution of this function is of O(N) complexity where N denotes the number of items on the stack.

#GTrashStack is deprecated without replacement

the height of the stack

a #GTrashStack

Returns the element at the top of a #GTrashStack which may be %NULL.

#GTrashStack is deprecated without replacement

the element at the top of the stack

a #GTrashStack

Pops a piece of memory off a #GTrashStack.

#GTrashStack is deprecated without replacement

the element at the top of the stack

a #GTrashStack

Pushes a piece of memory onto a #GTrashStack.

#GTrashStack is deprecated without replacement

a #GTrashStack the piece of memory to push on the stack

Specifies which nodes are visited during several of the tree functions, including g_node_traverse() and g_node_find().

only leaf nodes should be visited. This name has been introduced in 2.6, for older version use %G_TRAVERSE_LEAFS. only non-leaf nodes should be visited. This name has been introduced in 2.6, for older version use %G_TRAVERSE_NON_LEAFS. all nodes should be visited. a mask of all traverse flags. identical to %G_TRAVERSE_LEAVES. identical to %G_TRAVERSE_NON_LEAVES.

Specifies the type of function passed to g_tree_traverse(). It is passed the key and value of each node, together with the @user_data parameter passed to g_tree_traverse(). If the function returns %TRUE, the traversal is stopped.

%TRUE to stop the traversal

a key of a #GTree node the value corresponding to the key user data passed to g_tree_traverse()

Specifies the type of function passed to g_tree_foreach_node(). It is passed each node, together with the @user_data parameter passed to g_tree_foreach_node(). If the function returns %TRUE, the traversal is stopped.

%TRUE to stop the traversal

a #GTreeNode user data passed to g_tree_foreach_node()

Specifies the type of traversal performed by g_tree_traverse(), g_node_traverse() and g_node_find(). The different orders are illustrated here: - In order: A, B, C, D, E, F, G, H, I ![](Sorted_binary_tree_inorder.svg) - Pre order: F, B, A, D, C, E, G, I, H ![](Sorted_binary_tree_preorder.svg) - Post order: A, C, E, D, B, H, I, G, F ![](Sorted_binary_tree_postorder.svg) - Level order: F, B, G, A, D, I, C, E, H ![](Sorted_binary_tree_breadth-first_traversal.svg)

vists a node's left child first, then the node itself, then its right child. This is the one to use if you want the output sorted according to the compare function. visits a node, then its children. visits the node's children, then the node itself. is not implemented for [balanced binary trees][glib-Balanced-Binary-Trees]. For [n-ary trees][glib-N-ary-Trees], it vists the root node first, then its children, then its grandchildren, and so on. Note that this is less efficient than the other orders.

The GTree struct is an opaque data structure representing a [balanced binary tree][glib-Balanced-Binary-Trees]. It should be accessed only by using the following functions.

Creates a new #GTree.

a newly allocated #GTree

the function used to order the nodes in the #GTree. It should return values similar to the standard strcmp() function - 0 if the two arguments are equal, a negative value if the first argument comes before the second, or a positive value if the first argument comes after the second.

Creates a new #GTree like g_tree_new() and allows to specify functions to free the memory allocated for the key and value that get called when removing the entry from the #GTree.

a newly allocated #GTree

qsort()-style comparison function data to pass to comparison function a function to free the memory allocated for the key used when removing the entry from the #GTree or %NULL if you don't want to supply such a function a function to free the memory allocated for the value used when removing the entry from the #GTree or %NULL if you don't want to supply such a function

Creates a new #GTree with a comparison function that accepts user data. See g_tree_new() for more details.

a newly allocated #GTree

qsort()-style comparison function data to pass to comparison function

Removes all keys and values from the #GTree and decreases its reference count by one. If keys and/or values are dynamically allocated, you should either free them first or create the #GTree using g_tree_new_full(). In the latter case the destroy functions you supplied will be called on all keys and values before destroying the #GTree.

a #GTree

Calls the given function for each of the key/value pairs in the #GTree. The function is passed the key and value of each pair, and the given @data parameter. The tree is traversed in sorted order. The tree may not be modified while iterating over it (you can't add/remove items). To remove all items matching a predicate, you need to add each item to a list in your #GTraverseFunc as you walk over the tree, then walk the list and remove each item.

a #GTree

the function to call for each node visited. If this function returns %TRUE, the traversal is stopped. user data to pass to the function

Calls the given function for each of the nodes in the #GTree. The function is passed the pointer to the particular node, and the given @data parameter. The tree traversal happens in-order. The tree may not be modified while iterating over it (you can't add/remove items). To remove all items matching a predicate, you need to add each item to a list in your #GTraverseFunc as you walk over the tree, then walk the list and remove each item.

a #GTree

the function to call for each node visited. If this function returns %TRUE, the traversal is stopped. user data to pass to the function

Gets the height of a #GTree. If the #GTree contains no nodes, the height is 0. If the #GTree contains only one root node the height is 1. If the root node has children the height is 2, etc.

the height of @tree

a #GTree

Inserts a key/value pair into a #GTree. Inserts a new key and value into a #GTree as g_tree_insert_node() does, only this function does not return the inserted or set node.

a #GTree

the key to insert the value corresponding to the key

Inserts a key/value pair into a #GTree. If the given key already exists in the #GTree its corresponding value is set to the new value. If you supplied a @value_destroy_func when creating the #GTree, the old value is freed using that function. If you supplied a @key_destroy_func when creating the #GTree, the passed key is freed using that function. The tree is automatically 'balanced' as new key/value pairs are added, so that the distance from the root to every leaf is as small as possible. The cost of maintaining a balanced tree while inserting new key/value result in a O(n log(n)) operation where most of the other operations are O(log(n)).

the inserted (or set) node.

a #GTree

the key to insert the value corresponding to the key

Gets the value corresponding to the given key. Since a #GTree is automatically balanced as key/value pairs are added, key lookup is O(log n) (where n is the number of key/value pairs in the tree).

the value corresponding to the key, or %NULL if the key was not found

a #GTree

the key to look up

Looks up a key in the #GTree, returning the original key and the associated value. This is useful if you need to free the memory allocated for the original key, for example before calling g_tree_remove().

%TRUE if the key was found in the #GTree

a #GTree

the key to look up returns the original key returns the value associated with the key

Gets the tree node corresponding to the given key. Since a #GTree is automatically balanced as key/value pairs are added, key lookup is O(log n) (where n is the number of key/value pairs in the tree).

the tree node corresponding to the key, or %NULL if the key was not found

a #GTree

the key to look up

Gets the lower bound node corresponding to the given key, or %NULL if the tree is empty or all the nodes in the tree have keys that are strictly lower than the searched key. The lower bound is the first node that has its key greater than or equal to the searched key.

the tree node corresponding to the lower bound, or %NULL if the tree is empty or has only keys strictly lower than the searched key.

a #GTree

the key to calculate the lower bound for

Gets the number of nodes in a #GTree.

the number of nodes in @tree

a #GTree

Returns the first in-order node of the tree, or %NULL for an empty tree.

the first node in the tree

a #GTree

Returns the last in-order node of the tree, or %NULL for an empty tree.

the last node in the tree

a #GTree

Increments the reference count of @tree by one. It is safe to call this function from any thread.

the passed in #GTree

a #GTree

Removes a key/value pair from a #GTree. If the #GTree was created using g_tree_new_full(), the key and value are freed using the supplied destroy functions, otherwise you have to make sure that any dynamically allocated values are freed yourself. If the key does not exist in the #GTree, the function does nothing. The cost of maintaining a balanced tree while removing a key/value result in a O(n log(n)) operation where most of the other operations are O(log(n)).

%TRUE if the key was found (prior to 2.8, this function returned nothing)

a #GTree

the key to remove

Removes all nodes from a #GTree and destroys their keys and values, then resets the #GTree’s root to %NULL.

a #GTree

Inserts a new key and value into a #GTree as g_tree_replace_node() does, only this function does not return the inserted or set node.

a #GTree

the key to insert the value corresponding to the key

Inserts a new key and value into a #GTree similar to g_tree_insert_node(). The difference is that if the key already exists in the #GTree, it gets replaced by the new key. If you supplied a @value_destroy_func when creating the #GTree, the old value is freed using that function. If you supplied a @key_destroy_func when creating the #GTree, the old key is freed using that function. The tree is automatically 'balanced' as new key/value pairs are added, so that the distance from the root to every leaf is as small as possible.

the inserted (or set) node.

a #GTree

the key to insert the value corresponding to the key

Searches a #GTree using @search_func. The @search_func is called with a pointer to the key of a key/value pair in the tree, and the passed in @user_data. If @search_func returns 0 for a key/value pair, then the corresponding value is returned as the result of g_tree_search(). If @search_func returns -1, searching will proceed among the key/value pairs that have a smaller key; if @search_func returns 1, searching will proceed among the key/value pairs that have a larger key.

the value corresponding to the found key, or %NULL if the key was not found

a #GTree

a function used to search the #GTree the data passed as the second argument to @search_func

Searches a #GTree using @search_func. The @search_func is called with a pointer to the key of a key/value pair in the tree, and the passed in @user_data. If @search_func returns 0 for a key/value pair, then the corresponding node is returned as the result of g_tree_search(). If @search_func returns -1, searching will proceed among the key/value pairs that have a smaller key; if @search_func returns 1, searching will proceed among the key/value pairs that have a larger key.

the node corresponding to the found key, or %NULL if the key was not found

a #GTree

a function used to search the #GTree the data passed as the second argument to @search_func

Removes a key and its associated value from a #GTree without calling the key and value destroy functions. If the key does not exist in the #GTree, the function does nothing.

%TRUE if the key was found (prior to 2.8, this function returned nothing)

a #GTree

the key to remove

Calls the given function for each node in the #GTree.

The order of a balanced tree is somewhat arbitrary. If you just want to visit all nodes in sorted order, use g_tree_foreach() instead. If you really need to visit nodes in a different order, consider using an [n-ary tree][glib-N-ary-Trees].

a #GTree

the function to call for each node visited. If this function returns %TRUE, the traversal is stopped. the order in which nodes are visited, one of %G_IN_ORDER, %G_PRE_ORDER and %G_POST_ORDER user data to pass to the function

Decrements the reference count of @tree by one. If the reference count drops to 0, all keys and values will be destroyed (if destroy functions were specified) and all memory allocated by @tree will be released. It is safe to call this function from any thread.

a #GTree

Gets the upper bound node corresponding to the given key, or %NULL if the tree is empty or all the nodes in the tree have keys that are lower than or equal to the searched key. The upper bound is the first node that has its key strictly greater than the searched key.

the tree node corresponding to the upper bound, or %NULL if the tree is empty or has only keys lower than or equal to the searched key.

a #GTree

the key to calculate the upper bound for

An opaque type which identifies a specific node in a #GTree.

Gets the key stored at a particular tree node.

the key at the node.

a #GTree node

Returns the next in-order node of the tree, or %NULL if the passed node was already the last one.

the next node in the tree

a #GTree node

Returns the previous in-order node of the tree, or %NULL if the passed node was already the first one.

the previous node in the tree

a #GTree node

Gets the value stored at a particular tree node.

the value at the node.

a #GTree node

The maximum length (in codepoints) of a compatibility or canonical decomposition of a single Unicode character. This is as defined by Unicode 6.1.

Hints the compiler that the expression is unlikely to evaluate to a true value. The compiler may use this information for optimizations. |[ if (G_UNLIKELY (random () == 1)) g_print ("a random one"); ]|

the expression

Works like g_mutex_unlock(), but for a lock defined with %G_LOCK_DEFINE.

the name of the lock

Generic delimiters characters as defined in [RFC 3986](https://tools.ietf.org/html/rfc3986). Includes `:/?#[]@`.

Subcomponent delimiter characters as defined in [RFC 3986](https://tools.ietf.org/html/rfc3986). Includes `!$&'()*+,;=`.

Number of microseconds in one second (1 million). This macro is provided for code readability.

These are the possible line break classifications. Since new unicode versions may add new types here, applications should be ready to handle unknown values. They may be regarded as %G_UNICODE_BREAK_UNKNOWN. See [Unicode Line Breaking Algorithm](http://www.unicode.org/unicode/reports/tr14/). Mandatory Break (BK) Carriage Return (CR) Line Feed (LF) Attached Characters and Combining Marks (CM) Surrogates (SG) Zero Width Space (ZW) Inseparable (IN) Non-breaking ("Glue") (GL) Contingent Break Opportunity (CB) Space (SP) Break Opportunity After (BA) Break Opportunity Before (BB) Break Opportunity Before and After (B2) Hyphen (HY) Nonstarter (NS) Opening Punctuation (OP) Closing Punctuation (CL) Ambiguous Quotation (QU) Exclamation/Interrogation (EX) Ideographic (ID) Numeric (NU) Infix Separator (Numeric) (IS) Symbols Allowing Break After (SY) Ordinary Alphabetic and Symbol Characters (AL) Prefix (Numeric) (PR) Postfix (Numeric) (PO) Complex Content Dependent (South East Asian) (SA) Ambiguous (Alphabetic or Ideographic) (AI) Unknown (XX) Next Line (NL) Word Joiner (WJ) Hangul L Jamo (JL) Hangul V Jamo (JV) Hangul T Jamo (JT) Hangul LV Syllable (H2) Hangul LVT Syllable (H3) Closing Parenthesis (CP). Since 2.28. Deprecated: 2.70: Use %G_UNICODE_BREAK_CLOSE_PARENTHESIS instead. Closing Parenthesis (CP). Since 2.70 Conditional Japanese Starter (CJ). Since: 2.32 Hebrew Letter (HL). Since: 2.32 Regional Indicator (RI). Since: 2.36 Emoji Base (EB). Since: 2.50 Emoji Modifier (EM). Since: 2.50 Zero Width Joiner (ZWJ). Since: 2.50 The #GUnicodeScript enumeration identifies different writing systems. The values correspond to the names as defined in the Unicode standard. The enumeration has been added in GLib 2.14, and is interchangeable with #PangoScript. Note that new types may be added in the future. Applications should be ready to handle unknown values. See [Unicode Standard Annex #24: Script names](http://www.unicode.org/reports/tr24/). a value never returned from g_unichar_get_script() a character used by multiple different scripts a mark glyph that takes its script from the base glyph to which it is attached Arabic Armenian Bengali Bopomofo Cherokee Coptic Cyrillic Deseret Devanagari Ethiopic Georgian Gothic Greek Gujarati Gurmukhi Han Hangul Hebrew Hiragana Kannada Katakana Khmer Lao Latin Malayalam Mongolian Myanmar Ogham Old Italic Oriya Runic Sinhala Syriac Tamil Telugu Thaana Thai Tibetan Canadian Aboriginal Yi Tagalog Hanunoo Buhid Tagbanwa Braille Cypriot Limbu Osmanya Shavian Linear B Tai Le Ugaritic New Tai Lue Buginese Glagolitic Tifinagh Syloti Nagri Old Persian Kharoshthi an unassigned code point Balinese Cuneiform Phoenician Phags-pa N'Ko Kayah Li. Since 2.16.3 Lepcha. Since 2.16.3 Rejang. Since 2.16.3 Sundanese. Since 2.16.3 Saurashtra. Since 2.16.3 Cham. Since 2.16.3 Ol Chiki. Since 2.16.3 Vai. Since 2.16.3 Carian. Since 2.16.3 Lycian. Since 2.16.3 Lydian. Since 2.16.3 Avestan. Since 2.26 Bamum. Since 2.26 Egyptian Hieroglpyhs. Since 2.26 Imperial Aramaic. Since 2.26 Inscriptional Pahlavi. Since 2.26 Inscriptional Parthian. Since 2.26 Javanese. Since 2.26 Kaithi. Since 2.26 Lisu. Since 2.26 Meetei Mayek. Since 2.26 Old South Arabian. Since 2.26 Old Turkic. Since 2.28 Samaritan. Since 2.26 Tai Tham. Since 2.26 Tai Viet. Since 2.26 Batak. Since 2.28 Brahmi. Since 2.28 Mandaic. Since 2.28 Chakma. Since: 2.32 Meroitic Cursive. Since: 2.32 Meroitic Hieroglyphs. Since: 2.32 Miao. Since: 2.32 Sharada. Since: 2.32 Sora Sompeng. Since: 2.32 Takri. Since: 2.32 Bassa. Since: 2.42 Caucasian Albanian. Since: 2.42 Duployan. Since: 2.42 Elbasan. Since: 2.42 Grantha. Since: 2.42 Kjohki. Since: 2.42 Khudawadi, Sindhi. Since: 2.42 Linear A. Since: 2.42 Mahajani. Since: 2.42 Manichaean. Since: 2.42 Mende Kikakui. Since: 2.42 Modi. Since: 2.42 Mro. Since: 2.42 Nabataean. Since: 2.42 Old North Arabian. Since: 2.42 Old Permic. Since: 2.42 Pahawh Hmong. Since: 2.42 Palmyrene. Since: 2.42 Pau Cin Hau. Since: 2.42 Psalter Pahlavi. Since: 2.42 Siddham. Since: 2.42 Tirhuta. Since: 2.42 Warang Citi. Since: 2.42 Ahom. Since: 2.48 Anatolian Hieroglyphs. Since: 2.48 Hatran. Since: 2.48 Multani. Since: 2.48 Old Hungarian. Since: 2.48 Signwriting. Since: 2.48 Adlam. Since: 2.50 Bhaiksuki. Since: 2.50 Marchen. Since: 2.50 Newa. Since: 2.50 Osage. Since: 2.50 Tangut. Since: 2.50 Masaram Gondi. Since: 2.54 Nushu. Since: 2.54 Soyombo. Since: 2.54 Zanabazar Square. Since: 2.54 Dogra. Since: 2.58 Gunjala Gondi. Since: 2.58 Hanifi Rohingya. Since: 2.58 Makasar. Since: 2.58 Medefaidrin. Since: 2.58 Old Sogdian. Since: 2.58 Sogdian. Since: 2.58 Elym. Since: 2.62 Nand. Since: 2.62 Rohg. Since: 2.62 Wcho. Since: 2.62 Chorasmian. Since: 2.66 Dives Akuru. Since: 2.66 Khitan small script. Since: 2.66 Yezidi. Since: 2.66 Cypro-Minoan. Since: 2.72 Old Uyghur. Since: 2.72 Tangsa. Since: 2.72 Toto. Since: 2.72 Vithkuqi. Since: 2.72 Mathematical notation. Since: 2.72 Kawi. Since 2.74 Nag Mundari. Since 2.74 Looks up the Unicode script for @iso15924. ISO 15924 assigns four-letter codes to scripts. For example, the code for Arabic is 'Arab'. This function accepts four letter codes encoded as a @guint32 in a big-endian fashion. That is, the code expected for Arabic is 0x41726162 (0x41 is ASCII code for 'A', 0x72 is ASCII code for 'r', etc). See [Codes for the representation of names of scripts](http://unicode.org/iso15924/codelists.html) for details.

the Unicode script for @iso15924, or of %G_UNICODE_SCRIPT_INVALID_CODE if @iso15924 is zero and %G_UNICODE_SCRIPT_UNKNOWN if @iso15924 is unknown.

a Unicode script

Looks up the ISO 15924 code for @script. ISO 15924 assigns four-letter codes to scripts. For example, the code for Arabic is 'Arab'. The four letter codes are encoded as a @guint32 by this function in a big-endian fashion. That is, the code returned for Arabic is 0x41726162 (0x41 is ASCII code for 'A', 0x72 is ASCII code for 'r', etc). See [Codes for the representation of names of scripts](http://unicode.org/iso15924/codelists.html) for details.

the ISO 15924 code for @script, encoded as an integer, of zero if @script is %G_UNICODE_SCRIPT_INVALID_CODE or ISO 15924 code 'Zzzz' (script code for UNKNOWN) if @script is not understood.

a Unicode script

These are the possible character classifications from the Unicode specification. See [Unicode Character Database](http://www.unicode.org/reports/tr44/#General_Category_Values). General category "Other, Control" (Cc) General category "Other, Format" (Cf) General category "Other, Not Assigned" (Cn) General category "Other, Private Use" (Co) General category "Other, Surrogate" (Cs) General category "Letter, Lowercase" (Ll) General category "Letter, Modifier" (Lm) General category "Letter, Other" (Lo) General category "Letter, Titlecase" (Lt) General category "Letter, Uppercase" (Lu) General category "Mark, Spacing" (Mc) General category "Mark, Enclosing" (Me) General category "Mark, Nonspacing" (Mn) General category "Number, Decimal Digit" (Nd) General category "Number, Letter" (Nl) General category "Number, Other" (No) General category "Punctuation, Connector" (Pc) General category "Punctuation, Dash" (Pd) General category "Punctuation, Close" (Pe) General category "Punctuation, Final quote" (Pf) General category "Punctuation, Initial quote" (Pi) General category "Punctuation, Other" (Po) General category "Punctuation, Open" (Ps) General category "Symbol, Currency" (Sc) General category "Symbol, Modifier" (Sk) General category "Symbol, Math" (Sm) General category "Symbol, Other" (So) General category "Separator, Line" (Zl) General category "Separator, Paragraph" (Zp) General category "Separator, Space" (Zs) The type of functions to be called when a UNIX fd watch source triggers.

%FALSE if the source should be removed

the fd that triggered the event the IO conditions reported on @fd user data passed to g_unix_fd_add()

The #GUri type and related functions can be used to parse URIs into their components, and build valid URIs from individual components. Note that #GUri scope is to help manipulate URIs in various applications, following [RFC 3986](https://tools.ietf.org/html/rfc3986). In particular, it doesn't intend to cover web browser needs, and doesn't implement the [WHATWG URL](https://url.spec.whatwg.org/) standard. No APIs are provided to help prevent [homograph attacks](https://en.wikipedia.org/wiki/IDN_homograph_attack), so #GUri is not suitable for formatting URIs for display to the user for making security-sensitive decisions. ## Relative and absolute URIs # {#relative-absolute-uris} As defined in [RFC 3986](https://tools.ietf.org/html/rfc3986#section-4), the hierarchical nature of URIs means that they can either be ‘relative references’ (sometimes referred to as ‘relative URIs’) or ‘URIs’ (for clarity, ‘URIs’ are referred to in this documentation as ‘absolute URIs’ — although [in constrast to RFC 3986](https://tools.ietf.org/html/rfc3986#section-4.3), fragment identifiers are always allowed). Relative references have one or more components of the URI missing. In particular, they have no scheme. Any other component, such as hostname, query, etc. may be missing, apart from a path, which has to be specified (but may be empty). The path may be relative, starting with `./` rather than `/`. For example, a valid relative reference is `./path?query`, `/?query#fragment` or `//example.com`. Absolute URIs have a scheme specified. Any other components of the URI which are missing are specified as explicitly unset in the URI, rather than being resolved relative to a base URI using g_uri_parse_relative(). For example, a valid absolute URI is `file:///home/bob` or `https://search.com?query=string`. A #GUri instance is always an absolute URI. A string may be an absolute URI or a relative reference; see the documentation for individual functions as to what forms they accept. ## Parsing URIs The most minimalist APIs for parsing URIs are g_uri_split() and g_uri_split_with_user(). These split a URI into its component parts, and return the parts; the difference between the two is that g_uri_split() treats the ‘userinfo’ component of the URI as a single element, while g_uri_split_with_user() can (depending on the #GUriFlags you pass) treat it as containing a username, password, and authentication parameters. Alternatively, g_uri_split_network() can be used when you are only interested in the components that are needed to initiate a network connection to the service (scheme, host, and port). g_uri_parse() is similar to g_uri_split(), but instead of returning individual strings, it returns a #GUri structure (and it requires that the URI be an absolute URI). g_uri_resolve_relative() and g_uri_parse_relative() allow you to resolve a relative URI relative to a base URI. g_uri_resolve_relative() takes two strings and returns a string, and g_uri_parse_relative() takes a #GUri and a string and returns a #GUri. All of the parsing functions take a #GUriFlags argument describing exactly how to parse the URI; see the documentation for that type for more details on the specific flags that you can pass. If you need to choose different flags based on the type of URI, you can use g_uri_peek_scheme() on the URI string to check the scheme first, and use that to decide what flags to parse it with. For example, you might want to use %G_URI_PARAMS_WWW_FORM when parsing the params for a web URI, so compare the result of g_uri_peek_scheme() against `http` and `https`. ## Building URIs g_uri_join() and g_uri_join_with_user() can be used to construct valid URI strings from a set of component strings. They are the inverse of g_uri_split() and g_uri_split_with_user(). Similarly, g_uri_build() and g_uri_build_with_user() can be used to construct a #GUri from a set of component strings. As with the parsing functions, the building functions take a #GUriFlags argument. In particular, it is important to keep in mind whether the URI components you are using are already `%`-encoded. If so, you must pass the %G_URI_FLAGS_ENCODED flag. ## `file://` URIs Note that Windows and Unix both define special rules for parsing `file://` URIs (involving non-UTF-8 character sets on Unix, and the interpretation of path separators on Windows). #GUri does not implement these rules. Use g_filename_from_uri() and g_filename_to_uri() if you want to properly convert between `file://` URIs and local filenames. ## URI Equality Note that there is no `g_uri_equal ()` function, because comparing URIs usefully requires scheme-specific knowledge that #GUri does not have. #GUri can help with normalization if you use the various encoded #GUriFlags as well as %G_URI_FLAGS_SCHEME_NORMALIZE however it is not comprehensive. For example, `data:,foo` and `data:;base64,Zm9v` resolve to the same thing according to the `data:` URI specification which GLib does not handle.

Gets @uri's authentication parameters, which may contain `%`-encoding, depending on the flags with which @uri was created. (If @uri was not created with %G_URI_FLAGS_HAS_AUTH_PARAMS then this will be %NULL.) Depending on the URI scheme, g_uri_parse_params() may be useful for further parsing this information.

@uri's authentication parameters.

a #GUri

Gets @uri's flags set upon construction.

@uri's flags.

a #GUri

Gets @uri's fragment, which may contain `%`-encoding, depending on the flags with which @uri was created.

@uri's fragment.

a #GUri

Gets @uri's host. This will never have `%`-encoded characters, unless it is non-UTF-8 (which can only be the case if @uri was created with %G_URI_FLAGS_NON_DNS). If @uri contained an IPv6 address literal, this value will be just that address, without the brackets around it that are necessary in the string form of the URI. Note that in this case there may also be a scope ID attached to the address. Eg, `fe80::1234%``em1` (or `fe80::1234%``25em1` if the string is still encoded).

@uri's host.

a #GUri

Gets @uri's password, which may contain `%`-encoding, depending on the flags with which @uri was created. (If @uri was not created with %G_URI_FLAGS_HAS_PASSWORD then this will be %NULL.)

@uri's password.

a #GUri

Gets @uri's path, which may contain `%`-encoding, depending on the flags with which @uri was created.

@uri's path.

a #GUri

Gets @uri's port.

@uri's port, or `-1` if no port was specified.

a #GUri

Gets @uri's query, which may contain `%`-encoding, depending on the flags with which @uri was created. For queries consisting of a series of `name=value` parameters, #GUriParamsIter or g_uri_parse_params() may be useful.

@uri's query.

a #GUri

Gets @uri's scheme. Note that this will always be all-lowercase, regardless of the string or strings that @uri was created from.

@uri's scheme.

a #GUri

Gets the ‘username’ component of @uri's userinfo, which may contain `%`-encoding, depending on the flags with which @uri was created. If @uri was not created with %G_URI_FLAGS_HAS_PASSWORD or %G_URI_FLAGS_HAS_AUTH_PARAMS, this is the same as g_uri_get_userinfo().

@uri's user.

a #GUri

Gets @uri's userinfo, which may contain `%`-encoding, depending on the flags with which @uri was created.

@uri's userinfo.

a #GUri

Parses @uri_ref according to @flags and, if it is a [relative URI][relative-absolute-uris], resolves it relative to @base_uri. If the result is not a valid absolute URI, it will be discarded, and an error returned.

a new #GUri, or NULL on error.

a base absolute URI

a string representing a relative or absolute URI flags describing how to parse @uri_ref

Increments the reference count of @uri by one.

@uri

a #GUri

Returns a string representing @uri. This is not guaranteed to return a string which is identical to the string that @uri was parsed from. However, if the source URI was syntactically correct (according to RFC 3986), and it was parsed with %G_URI_FLAGS_ENCODED, then g_uri_to_string() is guaranteed to return a string which is at least semantically equivalent to the source URI (according to RFC 3986). If @uri might contain sensitive details, such as authentication parameters, or private data in its query string, and the returned string is going to be logged, then consider using g_uri_to_string_partial() to redact parts.

a string representing @uri, which the caller must free.

a #GUri

Returns a string representing @uri, subject to the options in @flags. See g_uri_to_string() and #GUriHideFlags for more details.

a string representing @uri, which the caller must free.

a #GUri

flags describing what parts of @uri to hide

Atomically decrements the reference count of @uri by one. When the reference count reaches zero, the resources allocated by @uri are freed

a #GUri

Creates a new #GUri from the given components according to @flags. See also g_uri_build_with_user(), which allows specifying the components of the "userinfo" separately.

a new #GUri

flags describing how to build the #GUri the URI scheme the userinfo component, or %NULL the host component, or %NULL the port, or `-1` the path component the query component, or %NULL the fragment, or %NULL

Creates a new #GUri from the given components according to @flags (%G_URI_FLAGS_HAS_PASSWORD is added unconditionally). The @flags must be coherent with the passed values, in particular use `%`-encoded values with %G_URI_FLAGS_ENCODED. In contrast to g_uri_build(), this allows specifying the components of the ‘userinfo’ field separately. Note that @user must be non-%NULL if either @password or @auth_params is non-%NULL.

a new #GUri

flags describing how to build the #GUri the URI scheme the user component of the userinfo, or %NULL the password component of the userinfo, or %NULL the auth params of the userinfo, or %NULL the host component, or %NULL the port, or `-1` the path component the query component, or %NULL the fragment, or %NULL

Escapes arbitrary data for use in a URI. Normally all characters that are not ‘unreserved’ (i.e. ASCII alphanumerical characters plus dash, dot, underscore and tilde) are escaped. But if you specify characters in @reserved_chars_allowed they are not escaped. This is useful for the ‘reserved’ characters in the URI specification, since those are allowed unescaped in some portions of a URI. Though technically incorrect, this will also allow escaping nul bytes as `%``00`.

an escaped version of @unescaped. The returned string should be freed when no longer needed.

the unescaped input data. the length of @unescaped a string of reserved characters that are allowed to be used, or %NULL.

Escapes a string for use in a URI. Normally all characters that are not "unreserved" (i.e. ASCII alphanumerical characters plus dash, dot, underscore and tilde) are escaped. But if you specify characters in @reserved_chars_allowed they are not escaped. This is useful for the "reserved" characters in the URI specification, since those are allowed unescaped in some portions of a URI.

an escaped version of @unescaped. The returned string should be freed when no longer needed.

the unescaped input string. a string of reserved characters that are allowed to be used, or %NULL. %TRUE if the result can include UTF-8 characters.

Parses @uri_string according to @flags, to determine whether it is a valid [absolute URI][relative-absolute-uris], i.e. it does not need to be resolved relative to another URI using g_uri_parse_relative(). If it’s not a valid URI, an error is returned explaining how it’s invalid. See g_uri_split(), and the definition of #GUriFlags, for more information on the effect of @flags.

%TRUE if @uri_string is a valid absolute URI, %FALSE on error.

a string containing an absolute URI flags for parsing @uri_string

Joins the given components together according to @flags to create an absolute URI string. @path may not be %NULL (though it may be the empty string). When @host is present, @path must either be empty or begin with a slash (`/`) character. When @host is not present, @path cannot begin with two slash characters (`//`). See [RFC 3986, section 3](https://tools.ietf.org/html/rfc3986#section-3). See also g_uri_join_with_user(), which allows specifying the components of the ‘userinfo’ separately. %G_URI_FLAGS_HAS_PASSWORD and %G_URI_FLAGS_HAS_AUTH_PARAMS are ignored if set in @flags.

an absolute URI string

flags describing how to build the URI string the URI scheme, or %NULL the userinfo component, or %NULL the host component, or %NULL the port, or `-1` the path component the query component, or %NULL the fragment, or %NULL

Joins the given components together according to @flags to create an absolute URI string. @path may not be %NULL (though it may be the empty string). In contrast to g_uri_join(), this allows specifying the components of the ‘userinfo’ separately. It otherwise behaves the same. %G_URI_FLAGS_HAS_PASSWORD and %G_URI_FLAGS_HAS_AUTH_PARAMS are ignored if set in @flags.

an absolute URI string

flags describing how to build the URI string the URI scheme, or %NULL the user component of the userinfo, or %NULL the password component of the userinfo, or %NULL the auth params of the userinfo, or %NULL the host component, or %NULL the port, or `-1` the path component the query component, or %NULL the fragment, or %NULL

Splits an URI list conforming to the text/uri-list mime type defined in RFC 2483 into individual URIs, discarding any comments. The URIs are not validated.

a newly allocated %NULL-terminated list of strings holding the individual URIs. The array should be freed with g_strfreev().

an URI list

Parses @uri_string according to @flags. If the result is not a valid [absolute URI][relative-absolute-uris], it will be discarded, and an error returned.

a new #GUri, or NULL on error.

a string representing an absolute URI flags describing how to parse @uri_string

Many URI schemes include one or more attribute/value pairs as part of the URI value. This method can be used to parse them into a hash table. When an attribute has multiple occurrences, the last value is the final returned value. If you need to handle repeated attributes differently, use #GUriParamsIter. The @params string is assumed to still be `%`-encoded, but the returned values will be fully decoded. (Thus it is possible that the returned values may contain `=` or @separators, if the value was encoded in the input.) Invalid `%`-encoding is treated as with the %G_URI_FLAGS_PARSE_RELAXED rules for g_uri_parse(). (However, if @params is the path or query string from a #GUri that was parsed without %G_URI_FLAGS_PARSE_RELAXED and %G_URI_FLAGS_ENCODED, then you already know that it does not contain any invalid encoding.) %G_URI_PARAMS_WWW_FORM is handled as documented for g_uri_params_iter_init(). If %G_URI_PARAMS_CASE_INSENSITIVE is passed to @flags, attributes will be compared case-insensitively, so a params string `attr=123&Attr=456` will only return a single attribute–value pair, `Attr=456`. Case will be preserved in the returned attributes. If @params cannot be parsed (for example, it contains two @separators characters in a row), then @error is set and %NULL is returned.

A hash table of attribute/value pairs, with both names and values fully-decoded; or %NULL on error.

a `%`-encoded string containing `attribute=value` parameters the length of @params, or `-1` if it is nul-terminated the separator byte character set between parameters. (usually `&`, but sometimes `;` or both `&;`). Note that this function works on bytes not characters, so it can't be used to delimit UTF-8 strings for anything but ASCII characters. You may pass an empty set, in which case no splitting will occur. flags to modify the way the parameters are handled.

The ‘scheme’ component of the URI, or %NULL on error. The returned string should be freed when no longer needed.

a valid URI.

Gets the scheme portion of a URI string. [RFC 3986](https://tools.ietf.org/html/rfc3986#section-3) decodes the scheme as: |[ URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ] ]| Common schemes include `file`, `https`, `svn+ssh`, etc. Unlike g_uri_parse_scheme(), the returned scheme is normalized to all-lowercase and does not need to be freed.

The ‘scheme’ component of the URI, or %NULL on error. The returned string is normalized to all-lowercase, and interned via g_intern_string(), so it does not need to be freed.

a valid URI.

Parses @uri_ref according to @flags and, if it is a [relative URI][relative-absolute-uris], resolves it relative to @base_uri_string. If the result is not a valid absolute URI, it will be discarded, and an error returned. (If @base_uri_string is %NULL, this just returns @uri_ref, or %NULL if @uri_ref is invalid or not absolute.)

the resolved URI string, or NULL on error.

a string representing a base URI a string representing a relative or absolute URI flags describing how to parse @uri_ref

Parses @uri_ref (which can be an [absolute or relative URI][relative-absolute-uris]) according to @flags, and returns the pieces. Any component that doesn't appear in @uri_ref will be returned as %NULL (but note that all URIs always have a path component, though it may be the empty string). If @flags contains %G_URI_FLAGS_ENCODED, then `%`-encoded characters in @uri_ref will remain encoded in the output strings. (If not, then all such characters will be decoded.) Note that decoding will only work if the URI components are ASCII or UTF-8, so you will need to use %G_URI_FLAGS_ENCODED if they are not. Note that the %G_URI_FLAGS_HAS_PASSWORD and %G_URI_FLAGS_HAS_AUTH_PARAMS @flags are ignored by g_uri_split(), since it always returns only the full userinfo; use g_uri_split_with_user() if you want it split up.

%TRUE if @uri_ref parsed successfully, %FALSE on error.

a string containing a relative or absolute URI flags for parsing @uri_ref on return, contains the scheme (converted to lowercase), or %NULL on return, contains the userinfo, or %NULL on return, contains the host, or %NULL on return, contains the port, or `-1` on return, contains the path on return, contains the query, or %NULL on return, contains the fragment, or %NULL

Parses @uri_string (which must be an [absolute URI][relative-absolute-uris]) according to @flags, and returns the pieces relevant to connecting to a host. See the documentation for g_uri_split() for more details; this is mostly a wrapper around that function with simpler arguments. However, it will return an error if @uri_string is a relative URI, or does not contain a hostname component.

%TRUE if @uri_string parsed successfully, %FALSE on error.

a string containing an absolute URI flags for parsing @uri_string on return, contains the scheme (converted to lowercase), or %NULL on return, contains the host, or %NULL on return, contains the port, or `-1`

%TRUE if @uri_ref parsed successfully, %FALSE on error.

a string containing a relative or absolute URI flags for parsing @uri_ref on return, contains the scheme (converted to lowercase), or %NULL on return, contains the user, or %NULL on return, contains the password, or %NULL on return, contains the auth_params, or %NULL on return, contains the host, or %NULL on return, contains the port, or `-1` on return, contains the path on return, contains the query, or %NULL on return, contains the fragment, or %NULL

Unescapes a segment of an escaped string as binary data. Note that in contrast to g_uri_unescape_string(), this does allow nul bytes to appear in the output. If any of the characters in @illegal_characters appears as an escaped character in @escaped_string, then that is an error and %NULL will be returned. This is useful if you want to avoid for instance having a slash being expanded in an escaped path element, which might confuse pathname handling.

an unescaped version of @escaped_string or %NULL on error (if decoding failed, using %G_URI_ERROR_FAILED error code). The returned #GBytes should be unreffed when no longer needed.

A URI-escaped string the length (in bytes) of @escaped_string to escape, or `-1` if it is nul-terminated. a string of illegal characters not to be allowed, or %NULL.

Unescapes a segment of an escaped string. If any of the characters in @illegal_characters or the NUL character appears as an escaped character in @escaped_string, then that is an error and %NULL will be returned. This is useful if you want to avoid for instance having a slash being expanded in an escaped path element, which might confuse pathname handling. Note: `NUL` byte is not accepted in the output, in contrast to g_uri_unescape_bytes().

an unescaped version of @escaped_string, or %NULL on error. The returned string should be freed when no longer needed. As a special case if %NULL is given for @escaped_string, this function will return %NULL.

A string, may be %NULL Pointer to end of @escaped_string, may be %NULL An optional string of illegal characters not to be allowed, may be %NULL

Unescapes a whole escaped string. If any of the characters in @illegal_characters or the NUL character appears as an escaped character in @escaped_string, then that is an error and %NULL will be returned. This is useful if you want to avoid for instance having a slash being expanded in an escaped path element, which might confuse pathname handling.

an unescaped version of @escaped_string. The returned string should be freed when no longer needed.

an escaped string to be unescaped. a string of illegal characters not to be allowed, or %NULL.

Error codes returned by #GUri methods.

Generic error if no more specific error is available. See the error message for details. The scheme of a URI could not be parsed. The user/userinfo of a URI could not be parsed. The password of a URI could not be parsed. The authentication parameters of a URI could not be parsed. The host of a URI could not be parsed. The port of a URI could not be parsed. The path of a URI could not be parsed. The query of a URI could not be parsed. The fragment of a URI could not be parsed.

Flags that describe a URI. When parsing a URI, if you need to choose different flags based on the type of URI, you can use g_uri_peek_scheme() on the URI string to check the scheme first, and use that to decide what flags to parse it with.

No flags set. Parse the URI more relaxedly than the [RFC 3986](https://tools.ietf.org/html/rfc3986) grammar specifies, fixing up or ignoring common mistakes in URIs coming from external sources. This is also needed for some obscure URI schemes where `;` separates the host from the path. Don’t use this flag unless you need to. The userinfo field may contain a password, which will be separated from the username by `:`. The userinfo may contain additional authentication-related parameters, which will be separated from the username and/or password by `;`. When parsing a URI, this indicates that `%`-encoded characters in the userinfo, path, query, and fragment fields should not be decoded. (And likewise the host field if %G_URI_FLAGS_NON_DNS is also set.) When building a URI, it indicates that you have already `%`-encoded the components, and so #GUri should not do any encoding itself. The host component should not be assumed to be a DNS hostname or IP address (for example, for `smb` URIs with NetBIOS hostnames). Same as %G_URI_FLAGS_ENCODED, for the query field only. Same as %G_URI_FLAGS_ENCODED, for the path only. Same as %G_URI_FLAGS_ENCODED, for the fragment only. A scheme-based normalization will be applied. For example, when parsing an HTTP URI changing omitted path to `/` and omitted port to `80`; and when building a URI, changing empty path to `/` and default port `80`). This only supports a subset of known schemes. (Since: 2.68)

Flags describing what parts of the URI to hide in g_uri_to_string_partial(). Note that %G_URI_HIDE_PASSWORD and %G_URI_HIDE_AUTH_PARAMS will only work if the #GUri was parsed with the corresponding flags.

No flags set. Hide the userinfo. Hide the password. Hide the auth_params. Hide the query. Hide the fragment.

Flags modifying the way parameters are handled by g_uri_parse_params() and #GUriParamsIter.

No flags set. Parameter names are case insensitive. Replace `+` with space character. Only useful for URLs on the web, using the `https` or `http` schemas. See %G_URI_FLAGS_PARSE_RELAXED.

Many URI schemes include one or more attribute/value pairs as part of the URI value. For example `scheme://server/path?query=string&is=there` has two attributes – `query=string` and `is=there` – in its query part. A #GUriParamsIter structure represents an iterator that can be used to iterate over the attribute/value pairs of a URI query string. #GUriParamsIter structures are typically allocated on the stack and then initialized with g_uri_params_iter_init(). See the documentation for g_uri_params_iter_init() for a usage example.

Initializes an attribute/value pair iterator. The iterator keeps pointers to the @params and @separators arguments, those variables must thus outlive the iterator and not be modified during the iteration. If %G_URI_PARAMS_WWW_FORM is passed in @flags, `+` characters in the param string will be replaced with spaces in the output. For example, `foo=bar+baz` will give attribute `foo` with value `bar baz`. This is commonly used on the web (the `https` and `http` schemes only), but is deprecated in favour of the equivalent of encoding spaces as `%20`. Unlike with g_uri_parse_params(), %G_URI_PARAMS_CASE_INSENSITIVE has no effect if passed to @flags for g_uri_params_iter_init(). The caller is responsible for doing their own case-insensitive comparisons. |[ GUriParamsIter iter; GError *error = NULL; gchar *unowned_attr, *unowned_value; g_uri_params_iter_init (&iter, "foo=bar&baz=bar&Foo=frob&baz=bar2", -1, "&", G_URI_PARAMS_NONE); while (g_uri_params_iter_next (&iter, &unowned_attr, &unowned_value, &error)) { g_autofree gchar *attr = g_steal_pointer (&unowned_attr); g_autofree gchar *value = g_steal_pointer (&unowned_value); // do something with attr and value; this code will be called 4 times // for the params string in this example: once with attr=foo and value=bar, // then with baz/bar, then Foo/frob, then baz/bar2. } if (error) // handle parsing error ]|

an uninitialized #GUriParamsIter

Advances @iter and retrieves the next attribute/value. %FALSE is returned if an error has occurred (in which case @error is set), or if the end of the iteration is reached (in which case @attribute and @value are set to %NULL and the iterator becomes invalid). If %TRUE is returned, g_uri_params_iter_next() may be called again to receive another attribute/value pair. Note that the same @attribute may be returned multiple times, since URIs allow repeated attributes.

%FALSE if the end of the parameters has been reached or an error was encountered. %TRUE otherwise.

an initialized #GUriParamsIter

on return, contains the attribute, or %NULL. on return, contains the value, or %NULL.

These are logical ids for special directories which are defined depending on the platform used. You should use g_get_user_special_dir() to retrieve the full path associated to the logical id. The #GUserDirectory enumeration can be extended at later date. Not every platform has a directory for every logical id in this enumeration.

the user's Desktop directory the user's Documents directory the user's Downloads directory the user's Music directory the user's Pictures directory the user's shared directory the user's Templates directory the user's Movies directory the number of enum values

A stack-allocated #GVariantBuilder must be initialized if it is used together with g_auto() to avoid warnings or crashes if function returns before g_variant_builder_init() is called on the builder. This macro can be used as initializer instead of an explicit zeroing a variable when declaring it and a following g_variant_builder_init(), but it cannot be assigned to a variable. The passed @variant_type should be a static GVariantType to avoid lifetime issues, as copying the @variant_type does not happen in the G_VARIANT_BUILDER_INIT() call, but rather in functions that make sure that #GVariantBuilder is valid. |[ g_auto(GVariantBuilder) builder = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE_BYTESTRING); ]|

a const GVariantType*

A stack-allocated #GVariantDict must be initialized if it is used together with g_auto() to avoid warnings or crashes if function returns before g_variant_dict_init() is called on the builder. This macro can be used as initializer instead of an explicit zeroing a variable when declaring it and a following g_variant_dict_init(), but it cannot be assigned to a variable. The passed @asv has to live long enough for #GVariantDict to gather the entries from, as the gathering does not happen in the G_VARIANT_DICT_INIT() call, but rather in functions that make sure that #GVariantDict is valid. In context where the initialization value has to be a constant expression, the only possible value of @asv is %NULL. It is still possible to call g_variant_dict_init() safely with a different @asv right after the variable was initialized with G_VARIANT_DICT_INIT(). |[ g_autoptr(GVariant) variant = get_asv_variant (); g_auto(GVariantDict) dict = G_VARIANT_DICT_INIT (variant); ]|

a GVariant*

Converts a string to a const #GVariantType. Depending on the current debugging level, this function may perform a runtime check to ensure that @string is a valid GVariant type string. It is always a programmer error to use this macro with an invalid type string. If in doubt, use g_variant_type_string_is_valid() to check if the string is valid. Since 2.24

a well-formed #GVariantType type string

A macro that should be defined by the user prior to including the glib.h header. The definition should be one of the predefined GLib version macros: %GLIB_VERSION_2_26, %GLIB_VERSION_2_28,... This macro defines the earliest version of GLib that the package is required to be able to compile against. If the compiler is configured to warn about the use of deprecated functions, then using functions that were deprecated in version %GLIB_VERSION_MIN_REQUIRED or earlier will cause warnings (but using functions deprecated in later releases will not).

#GVariant is a variant datatype; it can contain one or more values along with information about the type of the values. A #GVariant may contain simple types, like an integer, or a boolean value; or complex types, like an array of two strings, or a dictionary of key value pairs. A #GVariant is also immutable: once it's been created neither its type nor its content can be modified further. GVariant is useful whenever data needs to be serialized, for example when sending method parameters in D-Bus, or when saving settings using GSettings. When creating a new #GVariant, you pass the data you want to store in it along with a string representing the type of data you wish to pass to it. For instance, if you want to create a #GVariant holding an integer value you can use: |[ GVariant *v = g_variant_new ("u", 40); ]| The string "u" in the first argument tells #GVariant that the data passed to the constructor (40) is going to be an unsigned integer. More advanced examples of #GVariant in use can be found in documentation for [GVariant format strings][gvariant-format-strings-pointers]. The range of possible values is determined by the type. The type system used by #GVariant is #GVariantType. #GVariant instances always have a type and a value (which are given at construction time). The type and value of a #GVariant instance can never change other than by the #GVariant itself being destroyed. A #GVariant cannot contain a pointer. #GVariant is reference counted using g_variant_ref() and g_variant_unref(). #GVariant also has floating reference counts -- see g_variant_ref_sink(). #GVariant is completely threadsafe. A #GVariant instance can be concurrently accessed in any way from any number of threads without problems. #GVariant is heavily optimised for dealing with data in serialized form. It works particularly well with data located in memory-mapped files. It can perform nearly all deserialization operations in a small constant time, usually touching only a single memory page. Serialized #GVariant data can also be sent over the network. #GVariant is largely compatible with D-Bus. Almost all types of #GVariant instances can be sent over D-Bus. See #GVariantType for exceptions. (However, #GVariant's serialization format is not the same as the serialization format of a D-Bus message body: use #GDBusMessage, in the gio library, for those.) For space-efficiency, the #GVariant serialization format does not automatically include the variant's length, type or endianness, which must either be implied from context (such as knowledge that a particular file format always contains a little-endian %G_VARIANT_TYPE_VARIANT which occupies the whole length of the file) or supplied out-of-band (for instance, a length, type and/or endianness indicator could be placed at the beginning of a file, network message or network stream). A #GVariant's size is limited mainly by any lower level operating system constraints, such as the number of bits in #gsize. For example, it is reasonable to have a 2GB file mapped into memory with #GMappedFile, and call g_variant_new_from_data() on it. For convenience to C programmers, #GVariant features powerful varargs-based value construction and destruction. This feature is designed to be embedded in other libraries. There is a Python-inspired text language for describing #GVariant values. #GVariant includes a printer for this language and a parser with type inferencing. ## Memory Use #GVariant tries to be quite efficient with respect to memory use. This section gives a rough idea of how much memory is used by the current implementation. The information here is subject to change in the future. The memory allocated by #GVariant can be grouped into 4 broad purposes: memory for serialized data, memory for the type information cache, buffer management memory and memory for the #GVariant structure itself. ## Serialized Data Memory This is the memory that is used for storing GVariant data in serialized form. This is what would be sent over the network or what would end up on disk, not counting any indicator of the endianness, or of the length or type of the top-level variant. The amount of memory required to store a boolean is 1 byte. 16, 32 and 64 bit integers and double precision floating point numbers use their "natural" size. Strings (including object path and signature strings) are stored with a nul terminator, and as such use the length of the string plus 1 byte. Maybe types use no space at all to represent the null value and use the same amount of space (sometimes plus one byte) as the equivalent non-maybe-typed value to represent the non-null case. Arrays use the amount of space required to store each of their members, concatenated. Additionally, if the items stored in an array are not of a fixed-size (ie: strings, other arrays, etc) then an additional framing offset is stored for each item. The size of this offset is either 1, 2 or 4 bytes depending on the overall size of the container. Additionally, extra padding bytes are added as required for alignment of child values. Tuples (including dictionary entries) use the amount of space required to store each of their members, concatenated, plus one framing offset (as per arrays) for each non-fixed-sized item in the tuple, except for the last one. Additionally, extra padding bytes are added as required for alignment of child values. Variants use the same amount of space as the item inside of the variant, plus 1 byte, plus the length of the type string for the item inside the variant. As an example, consider a dictionary mapping strings to variants. In the case that the dictionary is empty, 0 bytes are required for the serialization. If we add an item "width" that maps to the int32 value of 500 then we will use 4 byte to store the int32 (so 6 for the variant containing it) and 6 bytes for the string. The variant must be aligned to 8 after the 6 bytes of the string, so that's 2 extra bytes. 6 (string) + 2 (padding) + 6 (variant) is 14 bytes used for the dictionary entry. An additional 1 byte is added to the array as a framing offset making a total of 15 bytes. If we add another entry, "title" that maps to a nullable string that happens to have a value of null, then we use 0 bytes for the null value (and 3 bytes for the variant to contain it along with its type string) plus 6 bytes for the string. Again, we need 2 padding bytes. That makes a total of 6 + 2 + 3 = 11 bytes. We now require extra padding between the two items in the array. After the 14 bytes of the first item, that's 2 bytes required. We now require 2 framing offsets for an extra two bytes. 14 + 2 + 11 + 2 = 29 bytes to encode the entire two-item dictionary. ## Type Information Cache For each GVariant type that currently exists in the program a type information structure is kept in the type information cache. The type information structure is required for rapid deserialization. Continuing with the above example, if a #GVariant exists with the type "a{sv}" then a type information struct will exist for "a{sv}", "{sv}", "s", and "v". Multiple uses of the same type will share the same type information. Additionally, all single-digit types are stored in read-only static memory and do not contribute to the writable memory footprint of a program using #GVariant. Aside from the type information structures stored in read-only memory, there are two forms of type information. One is used for container types where there is a single element type: arrays and maybe types. The other is used for container types where there are multiple element types: tuples and dictionary entries. Array type info structures are 6 * sizeof (void *), plus the memory required to store the type string itself. This means that on 32-bit systems, the cache entry for "a{sv}" would require 30 bytes of memory (plus malloc overhead). Tuple type info structures are 6 * sizeof (void *), plus 4 * sizeof (void *) for each item in the tuple, plus the memory required to store the type string itself. A 2-item tuple, for example, would have a type information structure that consumed writable memory in the size of 14 * sizeof (void *) (plus type string) This means that on 32-bit systems, the cache entry for "{sv}" would require 61 bytes of memory (plus malloc overhead). This means that in total, for our "a{sv}" example, 91 bytes of type information would be allocated. The type information cache, additionally, uses a #GHashTable to store and look up the cached items and stores a pointer to this hash table in static storage. The hash table is freed when there are zero items in the type cache. Although these sizes may seem large it is important to remember that a program will probably only have a very small number of different types of values in it and that only one type information structure is required for many different values of the same type. ## Buffer Management Memory #GVariant uses an internal buffer management structure to deal with the various different possible sources of serialized data that it uses. The buffer is responsible for ensuring that the correct call is made when the data is no longer in use by #GVariant. This may involve a g_free() or a g_slice_free() or even g_mapped_file_unref(). One buffer management structure is used for each chunk of serialized data. The size of the buffer management structure is 4 * (void *). On 32-bit systems, that's 16 bytes. ## GVariant structure The size of a #GVariant structure is 6 * (void *). On 32-bit systems, that's 24 bytes. #GVariant structures only exist if they are explicitly created with API calls. For example, if a #GVariant is constructed out of serialized data for the example given above (with the dictionary) then although there are 9 individual values that comprise the entire dictionary (two keys, two values, two variants containing the values, two dictionary entries, plus the dictionary itself), only 1 #GVariant instance exists -- the one referring to the dictionary. If calls are made to start accessing the other values then #GVariant instances will exist for those values only for as long as they are in use (ie: until you call g_variant_unref()). The type information is shared. The serialized data and the buffer management structure for that serialized data is shared by the child. ## Summary To put the entire example together, for our dictionary mapping strings to variants (with two entries, as given above), we are using 91 bytes of memory for type information, 29 bytes of memory for the serialized data, 16 bytes for buffer management and 24 bytes for the #GVariant instance, or a total of 160 bytes, plus malloc overhead. If we were to use g_variant_get_child_value() to access the two dictionary entries, we would use an additional 48 bytes. If we were to have other dictionaries of the same type, we would use more memory for the serialized data and buffer management for those dictionaries, but the type information would be shared.

Creates a new #GVariant instance. Think of this function as an analogue to g_strdup_printf(). The type of the created instance and the arguments that are expected by this function are determined by @format_string. See the section on [GVariant format strings][gvariant-format-strings]. Please note that the syntax of the format string is very likely to be extended in the future. The first character of the format string must not be '*' '?' '@' or 'r'; in essence, a new #GVariant must always be constructed by this function (and not merely passed through it unmodified). Note that the arguments must be of the correct width for their types specified in @format_string. This can be achieved by casting them. See the [GVariant varargs documentation][gvariant-varargs]. |[ MyFlags some_flags = FLAG_ONE | FLAG_TWO; const gchar *some_strings[] = { "a", "b", "c", NULL }; GVariant *new_variant; new_variant = g_variant_new ("(t^as)", // This cast is required. (guint64) some_flags, some_strings); ]|

a new floating #GVariant instance

a #GVariant format string arguments, as per @format_string

Creates a new #GVariant array from @children. @child_type must be non-%NULL if @n_children is zero. Otherwise, the child type is determined by inspecting the first element of the @children array. If @child_type is non-%NULL then it must be a definite type. The items of the array are taken from the @children array. No entry in the @children array may be %NULL. All items in the array must have the same type, which must be the same as @child_type, if given. If the @children are floating references (see g_variant_ref_sink()), the new instance takes ownership of them as if via g_variant_ref_sink().

a floating reference to a new #GVariant array

the element type of the new array an array of #GVariant pointers, the children the length of @children

Creates a new boolean #GVariant instance -- either %TRUE or %FALSE.

a floating reference to a new boolean #GVariant instance

a #gboolean value

Creates a new byte #GVariant instance.

a floating reference to a new byte #GVariant instance

a #guint8 value

Creates an array-of-bytes #GVariant with the contents of @string. This function is just like g_variant_new_string() except that the string need not be valid UTF-8. The nul terminator character at the end of the string is stored in the array.

a floating reference to a new bytestring #GVariant instance

a normal nul-terminated string in no particular encoding

Constructs an array of bytestring #GVariant from the given array of strings. If @length is -1 then @strv is %NULL-terminated.

a new floating #GVariant instance

an array of strings the length of @strv, or -1

Creates a new dictionary entry #GVariant. @key and @value must be non-%NULL. @key must be a value of a basic type (ie: not a container). If the @key or @value are floating references (see g_variant_ref_sink()), the new instance takes ownership of them as if via g_variant_ref_sink().

a floating reference to a new dictionary entry #GVariant

a basic #GVariant, the key a #GVariant, the value

Creates a new double #GVariant instance.

a floating reference to a new double #GVariant instance

a #gdouble floating point value

Constructs a new array #GVariant instance, where the elements are of @element_type type. @elements must be an array with fixed-sized elements. Numeric types are fixed-size as are tuples containing only other fixed-sized types. @element_size must be the size of a single element in the array. For example, if calling this function for an array of 32-bit integers, you might say sizeof(gint32). This value isn't used except for the purpose of a double-check that the form of the serialized data matches the caller's expectation. @n_elements must be the length of the @elements array.

a floating reference to a new array #GVariant instance

the #GVariantType of each element a pointer to the fixed array of contiguous elements the number of elements the size of each element

Constructs a new serialized-mode #GVariant instance. This is the inner interface for creation of new serialized values that gets called from various functions in gvariant.c. A reference is taken on @bytes. The data in @bytes must be aligned appropriately for the @type being loaded. Otherwise this function will internally create a copy of the memory (since GLib 2.60) or (in older versions) fail and exit the process.

a new #GVariant with a floating reference

a #GVariantType a #GBytes if the contents of @bytes are trusted

Creates a new #GVariant instance from serialized data. @type is the type of #GVariant instance that will be constructed. The interpretation of @data depends on knowing the type. @data is not modified by this function and must remain valid with an unchanging value until such a time as @notify is called with @user_data. If the contents of @data change before that time then the result is undefined. If @data is trusted to be serialized data in normal form then @trusted should be %TRUE. This applies to serialized data created within this process or read from a trusted location on the disk (such as a file installed in /usr/lib alongside your application). You should set trusted to %FALSE if @data is read from the network, a file in the user's home directory, etc. If @data was not stored in this machine's native endianness, any multi-byte numeric values in the returned variant will also be in non-native endianness. g_variant_byteswap() can be used to recover the original values. @notify will be called with @user_data when @data is no longer needed. The exact time of this call is unspecified and might even be before this function returns. Note: @data must be backed by memory that is aligned appropriately for the @type being loaded. Otherwise this function will internally create a copy of the memory (since GLib 2.60) or (in older versions) fail and exit the process.

a new floating #GVariant of type @type

a definite #GVariantType the serialized data the size of @data %TRUE if @data is definitely in normal form function to call when @data is no longer needed data for @notify

Creates a new handle #GVariant instance. By convention, handles are indexes into an array of file descriptors that are sent alongside a D-Bus message. If you're not interacting with D-Bus, you probably don't need them.

a floating reference to a new handle #GVariant instance

a #gint32 value

Creates a new int16 #GVariant instance.

a floating reference to a new int16 #GVariant instance

a #gint16 value

Creates a new int32 #GVariant instance.

a floating reference to a new int32 #GVariant instance

a #gint32 value

Creates a new int64 #GVariant instance.

a floating reference to a new int64 #GVariant instance

a #gint64 value

Depending on if @child is %NULL, either wraps @child inside of a maybe container or creates a Nothing instance for the given @type. At least one of @child_type and @child must be non-%NULL. If @child_type is non-%NULL then it must be a definite type. If they are both non-%NULL then @child_type must be the type of @child. If @child is a floating reference (see g_variant_ref_sink()), the new instance takes ownership of @child.

a floating reference to a new #GVariant maybe instance

the #GVariantType of the child, or %NULL the child value, or %NULL

Creates a D-Bus object path #GVariant with the contents of @string. @string must be a valid D-Bus object path. Use g_variant_is_object_path() if you're not sure.

a floating reference to a new object path #GVariant instance

a normal C nul-terminated string

Constructs an array of object paths #GVariant from the given array of strings. Each string must be a valid #GVariant object path; see g_variant_is_object_path(). If @length is -1 then @strv is %NULL-terminated.

a new floating #GVariant instance

an array of strings the length of @strv, or -1

Parses @format and returns the result. @format must be a text format #GVariant with one extension: at any point that a value may appear in the text, a '%' character followed by a GVariant format string (as per g_variant_new()) may appear. In that case, the same arguments are collected from the argument list as g_variant_new() would have collected. Note that the arguments must be of the correct width for their types specified in @format. This can be achieved by casting them. See the [GVariant varargs documentation][gvariant-varargs]. Consider this simple example: |[ g_variant_new_parsed ("[('one', 1), ('two', %i), (%s, 3)]", 2, "three"); ]| In the example, the variable argument parameters are collected and filled in as if they were part of the original string to produce the result of |[ [('one', 1), ('two', 2), ('three', 3)] ]| This function is intended only to be used with @format as a string literal. Any parse error is fatal to the calling process. If you want to parse data from untrusted sources, use g_variant_parse(). You may not use this function to return, unmodified, a single #GVariant pointer from the argument list. ie: @format may not solely be anything along the lines of "%*", "%?", "\%r", or anything starting with "%@".

a new floating #GVariant instance

a text format #GVariant arguments as per @format

Parses @format and returns the result. This is the version of g_variant_new_parsed() intended to be used from libraries. The return value will be floating if it was a newly created GVariant instance. In the case that @format simply specified the collection of a #GVariant pointer (eg: @format was "%*") then the collected #GVariant pointer will be returned unmodified, without adding any additional references. Note that the arguments in @app must be of the correct width for their types specified in @format when collected into the #va_list. See the [GVariant varargs documentation][gvariant-varargs]. In order to behave correctly in all cases it is necessary for the calling function to g_variant_ref_sink() the return result before returning control to the user that originally provided the pointer. At this point, the caller will have their own full reference to the result. This can also be done by adding the result to a container, or by passing it to another g_variant_new() call.

a new, usually floating, #GVariant

a text format #GVariant a pointer to a #va_list

Creates a string-type GVariant using printf formatting. This is similar to calling g_strdup_printf() and then g_variant_new_string() but it saves a temporary variable and an unnecessary copy.

a floating reference to a new string #GVariant instance

a printf-style format string arguments for @format_string

Creates a D-Bus type signature #GVariant with the contents of @string. @string must be a valid D-Bus type signature. Use g_variant_is_signature() if you're not sure.

a floating reference to a new signature #GVariant instance

a normal C nul-terminated string

Creates a string #GVariant with the contents of @string. @string must be valid UTF-8, and must not be %NULL. To encode potentially-%NULL strings, use g_variant_new() with `ms` as the [format string][gvariant-format-strings-maybe-types].

a floating reference to a new string #GVariant instance

a normal UTF-8 nul-terminated string

Constructs an array of strings #GVariant from the given array of strings. If @length is -1 then @strv is %NULL-terminated.

a new floating #GVariant instance

an array of strings the length of @strv, or -1

Creates a string #GVariant with the contents of @string. @string must be valid UTF-8, and must not be %NULL. To encode potentially-%NULL strings, use this with g_variant_new_maybe(). This function consumes @string. g_free() will be called on @string when it is no longer required. You must not modify or access @string in any other way after passing it to this function. It is even possible that @string is immediately freed.

a floating reference to a new string #GVariant instance

a normal UTF-8 nul-terminated string

Creates a new tuple #GVariant out of the items in @children. The type is determined from the types of @children. No entry in the @children array may be %NULL. If @n_children is 0 then the unit tuple is constructed. If the @children are floating references (see g_variant_ref_sink()), the new instance takes ownership of them as if via g_variant_ref_sink().

a floating reference to a new #GVariant tuple

the items to make the tuple out of the length of @children

Creates a new uint16 #GVariant instance.

a floating reference to a new uint16 #GVariant instance

a #guint16 value

Creates a new uint32 #GVariant instance.

a floating reference to a new uint32 #GVariant instance

a #guint32 value

Creates a new uint64 #GVariant instance.

a floating reference to a new uint64 #GVariant instance

a #guint64 value

This function is intended to be used by libraries based on #GVariant that want to provide g_variant_new()-like functionality to their users. The API is more general than g_variant_new() to allow a wider range of possible uses. @format_string must still point to a valid format string, but it only needs to be nul-terminated if @endptr is %NULL. If @endptr is non-%NULL then it is updated to point to the first character past the end of the format string. @app is a pointer to a #va_list. The arguments, according to @format_string, are collected from this #va_list and the list is left pointing to the argument following the last. Note that the arguments in @app must be of the correct width for their types specified in @format_string when collected into the #va_list. See the [GVariant varargs documentation][gvariant-varargs]. These two generalisations allow mixing of multiple calls to g_variant_new_va() and g_variant_get_va() within a single actual varargs call by the user. The return value will be floating if it was a newly created GVariant instance (for example, if the format string was "(ii)"). In the case that the format_string was '*', '?', 'r', or a format starting with '@' then the collected #GVariant pointer will be returned unmodified, without adding any additional references. In order to behave correctly in all cases it is necessary for the calling function to g_variant_ref_sink() the return result before returning control to the user that originally provided the pointer. At this point, the caller will have their own full reference to the result. This can also be done by adding the result to a container, or by passing it to another g_variant_new() call.

a new, usually floating, #GVariant

a string that is prefixed with a format string location to store the end pointer, or %NULL a pointer to a #va_list

Boxes @value. The result is a #GVariant instance representing a variant containing the original value. If @child is a floating reference (see g_variant_ref_sink()), the new instance takes ownership of @child.

a floating reference to a new variant #GVariant instance

a #GVariant instance

Performs a byteswapping operation on the contents of @value. The result is that all multi-byte numeric data contained in @value is byteswapped. That includes 16, 32, and 64bit signed and unsigned integers as well as file handles and double precision floating point values. This function is an identity mapping on any value that does not contain multi-byte numeric data. That include strings, booleans, bytes and containers containing only these things (recursively). The returned value is always in normal form and is marked as trusted. A full, not floating, reference is returned.

the byteswapped form of @value

a #GVariant

Checks if calling g_variant_get() with @format_string on @value would be valid from a type-compatibility standpoint. @format_string is assumed to be a valid format string (from a syntactic standpoint). If @copy_only is %TRUE then this function additionally checks that it would be safe to call g_variant_unref() on @value immediately after the call to g_variant_get() without invalidating the result. This is only possible if deep copies are made (ie: there are no pointers to the data inside of the soon-to-be-freed #GVariant instance). If this check fails then a g_critical() is printed and %FALSE is returned. This function is meant to be used by functions that wish to provide varargs accessors to #GVariant values of uncertain values (eg: g_variant_lookup() or g_menu_model_get_item_attribute()).

%TRUE if @format_string is safe to use

a #GVariant

a valid #GVariant format string %TRUE to ensure the format string makes deep copies

Classifies @value according to its top-level type.

the #GVariantClass of @value

a #GVariant

Compares @one and @two. The types of @one and @two are #gconstpointer only to allow use of this function with #GTree, #GPtrArray, etc. They must each be a #GVariant. Comparison is only defined for basic types (ie: booleans, numbers, strings). For booleans, %FALSE is less than %TRUE. Numbers are ordered in the usual way. Strings are in ASCII lexographical order. It is a programmer error to attempt to compare container values or two values that have types that are not exactly equal. For example, you cannot compare a 32-bit signed integer with a 32-bit unsigned integer. Also note that this function is not particularly well-behaved when it comes to comparison of doubles; in particular, the handling of incomparable values (ie: NaN) is undefined. If you only require an equality comparison, g_variant_equal() is more general.

negative value if a < b; zero if a = b; positive value if a > b.

a basic-typed #GVariant instance

a #GVariant instance of the same type

Similar to g_variant_get_bytestring() except that instead of returning a constant string, the string is duplicated. The return value must be freed using g_free().

a newly allocated string

an array-of-bytes #GVariant instance

a pointer to a #gsize, to store the length (not including the nul terminator)

Gets the contents of an array of array of bytes #GVariant. This call makes a deep copy; the return result should be released with g_strfreev(). If @length is non-%NULL then the number of elements in the result is stored there. In any case, the resulting array will be %NULL-terminated. For an empty array, @length will be set to 0 and a pointer to a %NULL pointer will be returned.

an array of strings

an array of array of bytes #GVariant ('aay')

the length of the result, or %NULL

Gets the contents of an array of object paths #GVariant. This call makes a deep copy; the return result should be released with g_strfreev(). If @length is non-%NULL then the number of elements in the result is stored there. In any case, the resulting array will be %NULL-terminated. For an empty array, @length will be set to 0 and a pointer to a %NULL pointer will be returned.

an array of strings

an array of object paths #GVariant

the length of the result, or %NULL

Similar to g_variant_get_string() except that instead of returning a constant string, the string is duplicated. The string will always be UTF-8 encoded. The return value must be freed using g_free().

a newly allocated string, UTF-8 encoded

a string #GVariant instance

a pointer to a #gsize, to store the length

Gets the contents of an array of strings #GVariant. This call makes a deep copy; the return result should be released with g_strfreev(). If @length is non-%NULL then the number of elements in the result is stored there. In any case, the resulting array will be %NULL-terminated. For an empty array, @length will be set to 0 and a pointer to a %NULL pointer will be returned.

an array of strings

an array of strings #GVariant

the length of the result, or %NULL

Checks if @one and @two have the same type and value. The types of @one and @two are #gconstpointer only to allow use of this function with #GHashTable. They must each be a #GVariant.

%TRUE if @one and @two are equal

a #GVariant instance

Deconstructs a #GVariant instance. Think of this function as an analogue to scanf(). The arguments that are expected by this function are entirely determined by @format_string. @format_string also restricts the permissible types of @value. It is an error to give a value with an incompatible type. See the section on [GVariant format strings][gvariant-format-strings]. Please note that the syntax of the format string is very likely to be extended in the future. @format_string determines the C types that are used for unpacking the values and also determines if the values are copied or borrowed, see the section on [GVariant format strings][gvariant-format-strings-pointers].

a #GVariant instance

a #GVariant format string arguments, as per @format_string

Returns the boolean value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_BOOLEAN.

%TRUE or %FALSE

a boolean #GVariant instance

Returns the byte value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_BYTE.

a #guint8

a byte #GVariant instance

Returns the string value of a #GVariant instance with an array-of-bytes type. The string has no particular encoding. If the array does not end with a nul terminator character, the empty string is returned. For this reason, you can always trust that a non-%NULL nul-terminated string will be returned by this function. If the array contains a nul terminator character somewhere other than the last byte then the returned string is the string, up to the first such nul character. g_variant_get_fixed_array() should be used instead if the array contains arbitrary data that could not be nul-terminated or could contain nul bytes. It is an error to call this function with a @value that is not an array of bytes. The return value remains valid as long as @value exists.

the constant string

an array-of-bytes #GVariant instance

Gets the contents of an array of array of bytes #GVariant. This call makes a shallow copy; the return result should be released with g_free(), but the individual strings must not be modified. If @length is non-%NULL then the number of elements in the result is stored there. In any case, the resulting array will be %NULL-terminated. For an empty array, @length will be set to 0 and a pointer to a %NULL pointer will be returned.

an array of constant strings

an array of array of bytes #GVariant ('aay')

the length of the result, or %NULL

Reads a child item out of a container #GVariant instance and deconstructs it according to @format_string. This call is essentially a combination of g_variant_get_child_value() and g_variant_get(). @format_string determines the C types that are used for unpacking the values and also determines if the values are copied or borrowed, see the section on [GVariant format strings][gvariant-format-strings-pointers].

a container #GVariant

the index of the child to deconstruct a #GVariant format string arguments, as per @format_string

Reads a child item out of a container #GVariant instance. This includes variants, maybes, arrays, tuples and dictionary entries. It is an error to call this function on any other type of #GVariant. It is an error if @index_ is greater than the number of child items in the container. See g_variant_n_children(). The returned value is never floating. You should free it with g_variant_unref() when you're done with it. Note that values borrowed from the returned child are not guaranteed to still be valid after the child is freed even if you still hold a reference to @value, if @value has not been serialized at the time this function is called. To avoid this, you can serialize @value by calling g_variant_get_data() and optionally ignoring the return value. There may be implementation specific restrictions on deeply nested values, which would result in the unit tuple being returned as the child value, instead of further nested children. #GVariant is guaranteed to handle nesting up to at least 64 levels. This function is O(1).

the child at the specified index

a container #GVariant

the index of the child to fetch

Returns a pointer to the serialized form of a #GVariant instance. The returned data may not be in fully-normalised form if read from an untrusted source. The returned data must not be freed; it remains valid for as long as @value exists. If @value is a fixed-sized value that was deserialized from a corrupted serialized container then %NULL may be returned. In this case, the proper thing to do is typically to use the appropriate number of nul bytes in place of @value. If @value is not fixed-sized then %NULL is never returned. In the case that @value is already in serialized form, this function is O(1). If the value is not already in serialized form, serialization occurs implicitly and is approximately O(n) in the size of the result. To deserialize the data returned by this function, in addition to the serialized data, you must know the type of the #GVariant, and (if the machine might be different) the endianness of the machine that stored it. As a result, file formats or network messages that incorporate serialized #GVariants must include this information either implicitly (for instance "the file always contains a %G_VARIANT_TYPE_VARIANT and it is always in little-endian order") or explicitly (by storing the type and/or endianness in addition to the serialized data).

the serialized form of @value, or %NULL

a #GVariant instance

Returns a pointer to the serialized form of a #GVariant instance. The semantics of this function are exactly the same as g_variant_get_data(), except that the returned #GBytes holds a reference to the variant data.

A new #GBytes representing the variant data

a #GVariant

Returns the double precision floating point value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_DOUBLE.

a #gdouble

a double #GVariant instance

Provides access to the serialized data for an array of fixed-sized items. @value must be an array with fixed-sized elements. Numeric types are fixed-size, as are tuples containing only other fixed-sized types. @element_size must be the size of a single element in the array, as given by the section on [serialized data memory][gvariant-serialized-data-memory]. In particular, arrays of these fixed-sized types can be interpreted as an array of the given C type, with @element_size set to the size the appropriate type: - %G_VARIANT_TYPE_INT16 (etc.): #gint16 (etc.) - %G_VARIANT_TYPE_BOOLEAN: #guchar (not #gboolean!) - %G_VARIANT_TYPE_BYTE: #guint8 - %G_VARIANT_TYPE_HANDLE: #guint32 - %G_VARIANT_TYPE_DOUBLE: #gdouble For example, if calling this function for an array of 32-bit integers, you might say `sizeof(gint32)`. This value isn't used except for the purpose of a double-check that the form of the serialized data matches the caller's expectation. @n_elements, which must be non-%NULL, is set equal to the number of items in the array.

a pointer to the fixed array

a #GVariant array with fixed-sized elements

a pointer to the location to store the number of items the size of each element

Returns the 32-bit signed integer value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_HANDLE. By convention, handles are indexes into an array of file descriptors that are sent alongside a D-Bus message. If you're not interacting with D-Bus, you probably don't need them.

a #gint32

a handle #GVariant instance

Returns the 16-bit signed integer value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_INT16.

a #gint16

an int16 #GVariant instance

Returns the 32-bit signed integer value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_INT32.

a #gint32

an int32 #GVariant instance

Returns the 64-bit signed integer value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_INT64.

a #gint64

an int64 #GVariant instance

Given a maybe-typed #GVariant instance, extract its value. If the value is Nothing, then this function returns %NULL.

the contents of @value, or %NULL

a maybe-typed value

Gets a #GVariant instance that has the same value as @value and is trusted to be in normal form. If @value is already trusted to be in normal form then a new reference to @value is returned. If @value is not already trusted, then it is scanned to check if it is in normal form. If it is found to be in normal form then it is marked as trusted and a new reference to it is returned. If @value is found not to be in normal form then a new trusted #GVariant is created with the same value as @value. It makes sense to call this function if you've received #GVariant data from untrusted sources and you want to ensure your serialized output is definitely in normal form. If @value is already in normal form, a new reference will be returned (which will be floating if @value is floating). If it is not in normal form, the newly created #GVariant will be returned with a single non-floating reference. Typically, g_variant_take_ref() should be called on the return value from this function to guarantee ownership of a single non-floating reference to it.

a trusted #GVariant

a #GVariant

Gets the contents of an array of object paths #GVariant. This call makes a shallow copy; the return result should be released with g_free(), but the individual strings must not be modified. If @length is non-%NULL then the number of elements in the result is stored there. In any case, the resulting array will be %NULL-terminated. For an empty array, @length will be set to 0 and a pointer to a %NULL pointer will be returned.

an array of constant strings

an array of object paths #GVariant

the length of the result, or %NULL

Determines the number of bytes that would be required to store @value with g_variant_store(). If @value has a fixed-sized type then this function always returned that fixed size. In the case that @value is already in serialized form or the size has already been calculated (ie: this function has been called before) then this function is O(1). Otherwise, the size is calculated, an operation which is approximately O(n) in the number of values involved.

the serialized size of @value

a #GVariant instance

Returns the string value of a #GVariant instance with a string type. This includes the types %G_VARIANT_TYPE_STRING, %G_VARIANT_TYPE_OBJECT_PATH and %G_VARIANT_TYPE_SIGNATURE. The string will always be UTF-8 encoded, will never be %NULL, and will never contain nul bytes. If @length is non-%NULL then the length of the string (in bytes) is returned there. For trusted values, this information is already known. Untrusted values will be validated and, if valid, a strlen() will be performed. If invalid, a default value will be returned — for %G_VARIANT_TYPE_OBJECT_PATH, this is `"/"`, and for other types it is the empty string. It is an error to call this function with a @value of any type other than those three. The return value remains valid as long as @value exists.

the constant string, UTF-8 encoded

a string #GVariant instance

a pointer to a #gsize, to store the length

Gets the contents of an array of strings #GVariant. This call makes a shallow copy; the return result should be released with g_free(), but the individual strings must not be modified. If @length is non-%NULL then the number of elements in the result is stored there. In any case, the resulting array will be %NULL-terminated. For an empty array, @length will be set to 0 and a pointer to a %NULL pointer will be returned.

an array of constant strings

an array of strings #GVariant

the length of the result, or %NULL

Determines the type of @value. The return value is valid for the lifetime of @value and must not be freed.

a #GVariantType

a #GVariant

Returns the type string of @value. Unlike the result of calling g_variant_type_peek_string(), this string is nul-terminated. This string belongs to #GVariant and must not be freed.

the type string for the type of @value

a #GVariant

Returns the 16-bit unsigned integer value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_UINT16.

a #guint16

a uint16 #GVariant instance

Returns the 32-bit unsigned integer value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_UINT32.

a #guint32

a uint32 #GVariant instance

Returns the 64-bit unsigned integer value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_UINT64.

a #guint64

a uint64 #GVariant instance

This function is intended to be used by libraries based on #GVariant that want to provide g_variant_get()-like functionality to their users. The API is more general than g_variant_get() to allow a wider range of possible uses. @format_string must still point to a valid format string, but it only need to be nul-terminated if @endptr is %NULL. If @endptr is non-%NULL then it is updated to point to the first character past the end of the format string. @app is a pointer to a #va_list. The arguments, according to @format_string, are collected from this #va_list and the list is left pointing to the argument following the last. These two generalisations allow mixing of multiple calls to g_variant_new_va() and g_variant_get_va() within a single actual varargs call by the user. @format_string determines the C types that are used for unpacking the values and also determines if the values are copied or borrowed, see the section on [GVariant format strings][gvariant-format-strings-pointers].

a #GVariant

a string that is prefixed with a format string location to store the end pointer, or %NULL a pointer to a #va_list

Unboxes @value. The result is the #GVariant instance that was contained in @value.

the item contained in the variant

a variant #GVariant instance

Generates a hash value for a #GVariant instance. The output of this function is guaranteed to be the same for a given value only per-process. It may change between different processor architectures or even different versions of GLib. Do not use this function as a basis for building protocols or file formats. The type of @value is #gconstpointer only to allow use of this function with #GHashTable. @value must be a #GVariant.

a hash value corresponding to @value

a basic #GVariant value as a #gconstpointer

Checks if @value is a container.

%TRUE if @value is a container

a #GVariant instance

Checks whether @value has a floating reference count. This function should only ever be used to assert that a given variant is or is not floating, or for debug purposes. To acquire a reference to a variant that might be floating, always use g_variant_ref_sink() or g_variant_take_ref(). See g_variant_ref_sink() for more information about floating reference counts.

whether @value is floating

a #GVariant

Checks if @value is in normal form. The main reason to do this is to detect if a given chunk of serialized data is in normal form: load the data into a #GVariant using g_variant_new_from_data() and then use this function to check. If @value is found to be in normal form then it will be marked as being trusted. If the value was already marked as being trusted then this function will immediately return %TRUE. There may be implementation specific restrictions on deeply nested values. GVariant is guaranteed to handle nesting up to at least 64 levels.

%TRUE if @value is in normal form

a #GVariant instance

Checks if a value has a type matching the provided type.

%TRUE if the type of @value matches @type

a #GVariant instance

a #GVariantType

Creates a heap-allocated #GVariantIter for iterating over the items in @value. Use g_variant_iter_free() to free the return value when you no longer need it. A reference is taken to @value and will be released only when g_variant_iter_free() is called.

a new heap-allocated #GVariantIter

a container #GVariant

Looks up a value in a dictionary #GVariant. This function is a wrapper around g_variant_lookup_value() and g_variant_get(). In the case that %NULL would have been returned, this function returns %FALSE. Otherwise, it unpacks the returned value and returns %TRUE. @format_string determines the C types that are used for unpacking the values and also determines if the values are copied or borrowed, see the section on [GVariant format strings][gvariant-format-strings-pointers]. This function is currently implemented with a linear scan. If you plan to do many lookups then #GVariantDict may be more efficient.

%TRUE if a value was unpacked

a dictionary #GVariant

the key to look up in the dictionary a GVariant format string the arguments to unpack the value into

Looks up a value in a dictionary #GVariant. This function works with dictionaries of the type a{s*} (and equally well with type a{o*}, but we only further discuss the string case for sake of clarity). In the event that @dictionary has the type a{sv}, the @expected_type string specifies what type of value is expected to be inside of the variant. If the value inside the variant has a different type then %NULL is returned. In the event that @dictionary has a value type other than v then @expected_type must directly match the value type and it is used to unpack the value directly or an error occurs. In either case, if @key is not found in @dictionary, %NULL is returned. If the key is found and the value has the correct type, it is returned. If @expected_type was specified then any non-%NULL return value will have this type. This function is currently implemented with a linear scan. If you plan to do many lookups then #GVariantDict may be more efficient.

the value of the dictionary key, or %NULL

a dictionary #GVariant

the key to look up in the dictionary a #GVariantType, or %NULL

Determines the number of children in a container #GVariant instance. This includes variants, maybes, arrays, tuples and dictionary entries. It is an error to call this function on any other type of #GVariant. For variants, the return value is always 1. For values with maybe types, it is always zero or one. For arrays, it is the length of the array. For tuples it is the number of tuple items (which depends only on the type). For dictionary entries, it is always 2 This function is O(1).

the number of children in the container

a container #GVariant

Pretty-prints @value in the format understood by g_variant_parse(). The format is described [here][gvariant-text]. If @type_annotate is %TRUE, then type information is included in the output.

a newly-allocated string holding the result.

a #GVariant

%TRUE if type information should be included in the output

Behaves as g_variant_print(), but operates on a #GString. If @string is non-%NULL then it is appended to and returned. Else, a new empty #GString is allocated and it is returned.

a #GString containing the string

a #GVariant

a #GString, or %NULL %TRUE if type information should be included in the output

Increases the reference count of @value.

the same @value

a #GVariant

#GVariant uses a floating reference count system. All functions with names starting with `g_variant_new_` return floating references. Calling g_variant_ref_sink() on a #GVariant with a floating reference will convert the floating reference into a full reference. Calling g_variant_ref_sink() on a non-floating #GVariant results in an additional normal reference being added. In other words, if the @value is floating, then this call "assumes ownership" of the floating reference, converting it to a normal reference. If the @value is not floating, then this call adds a new normal reference increasing the reference count by one. All calls that result in a #GVariant instance being inserted into a container will call g_variant_ref_sink() on the instance. This means that if the value was just created (and has only its floating reference) then the container will assume sole ownership of the value at that point and the caller will not need to unreference it. This makes certain common styles of programming much easier while still maintaining normal refcounting semantics in situations where values are not floating.

the same @value

a #GVariant

Stores the serialized form of @value at @data. @data should be large enough. See g_variant_get_size(). The stored data is in machine native byte order but may not be in fully-normalised form if read from an untrusted source. See g_variant_get_normal_form() for a solution. As with g_variant_get_data(), to be able to deserialize the serialized variant successfully, its type and (if the destination machine might be different) its endianness must also be available. This function is approximately O(n) in the size of @data.

the #GVariant to store

the location to store the serialized data at

If @value is floating, sink it. Otherwise, do nothing. Typically you want to use g_variant_ref_sink() in order to automatically do the correct thing with respect to floating or non-floating references, but there is one specific scenario where this function is helpful. The situation where this function is helpful is when creating an API that allows the user to provide a callback function that returns a #GVariant. We certainly want to allow the user the flexibility to return a non-floating reference from this callback (for the case where the value that is being returned already exists). At the same time, the style of the #GVariant API makes it likely that for newly-created #GVariant instances, the user can be saved some typing if they are allowed to return a #GVariant with a floating reference. Using this function on the return value of the user's callback allows the user to do whichever is more convenient for them. The caller will always receives exactly one full reference to the value: either the one that was returned in the first place, or a floating reference that has been converted to a full reference. This function has an odd interaction when combined with g_variant_ref_sink() running at the same time in another thread on the same #GVariant instance. If g_variant_ref_sink() runs first then the result will be that the floating reference is converted to a hard reference. If g_variant_take_ref() runs first then the result will be that the floating reference is converted to a hard reference and an additional reference on top of that one is added. It is best to avoid this situation.

the same @value

a #GVariant

Decreases the reference count of @value. When its reference count drops to 0, the memory used by the variant is freed.

a #GVariant

Determines if a given string is a valid D-Bus object path. You should ensure that a string is a valid D-Bus object path before passing it to g_variant_new_object_path(). A valid object path starts with `/` followed by zero or more sequences of characters separated by `/` characters. Each sequence must contain only the characters `[A-Z][a-z][0-9]_`. No sequence (including the one following the final `/` character) may be empty.

%TRUE if @string is a D-Bus object path

a normal C nul-terminated string

Determines if a given string is a valid D-Bus type signature. You should ensure that a string is a valid D-Bus type signature before passing it to g_variant_new_signature(). D-Bus type signatures consist of zero or more definite #GVariantType strings in sequence.

%TRUE if @string is a D-Bus type signature

a normal C nul-terminated string

Parses a #GVariant from a text representation. A single #GVariant is parsed from the content of @text. The format is described [here][gvariant-text]. The memory at @limit will never be accessed and the parser behaves as if the character at @limit is the nul terminator. This has the effect of bounding @text. If @endptr is non-%NULL then @text is permitted to contain data following the value that this function parses and @endptr will be updated to point to the first character past the end of the text parsed by this function. If @endptr is %NULL and there is extra data then an error is returned. If @type is non-%NULL then the value will be parsed to have that type. This may result in additional parse errors (in the case that the parsed value doesn't fit the type) but may also result in fewer errors (in the case that the type would have been ambiguous, such as with empty arrays). In the event that the parsing is successful, the resulting #GVariant is returned. It is never floating, and must be freed with g_variant_unref(). In case of any error, %NULL will be returned. If @error is non-%NULL then it will be set to reflect the error that occurred. Officially, the language understood by the parser is "any string produced by g_variant_print()". There may be implementation specific restrictions on deeply nested values, which would result in a %G_VARIANT_PARSE_ERROR_RECURSION error. #GVariant is guaranteed to handle nesting up to at least 64 levels.

a non-floating reference to a #GVariant, or %NULL

a #GVariantType, or %NULL a string containing a GVariant in text form a pointer to the end of @text, or %NULL a location to store the end pointer, or %NULL

Pretty-prints a message showing the context of a #GVariant parse error within the string for which parsing was attempted. The resulting string is suitable for output to the console or other monospace media where newlines are treated in the usual way. The message will typically look something like one of the following: |[ unterminated string constant: (1, 2, 3, 'abc ^^^^ ]| or |[ unable to find a common type: [1, 2, 3, 'str'] ^ ^^^^^ ]| The format of the message may change in a future version. @error must have come from a failed attempt to g_variant_parse() and @source_str must be exactly the same string that caused the error. If @source_str was not nul-terminated when you passed it to g_variant_parse() then you must add nul termination before using this function.

the printed message

a #GError from the #GVariantParseError domain the string that was given to the parser

Same as g_variant_error_quark().

Use g_variant_parse_error_quark() instead.

A utility type for constructing container-type #GVariant instances. This is an opaque structure and may only be accessed using the following functions. #GVariantBuilder is not threadsafe in any way. Do not attempt to access it from more than one thread.

Allocates and initialises a new #GVariantBuilder. You should call g_variant_builder_unref() on the return value when it is no longer needed. The memory will not be automatically freed by any other call. In most cases it is easier to place a #GVariantBuilder directly on the stack of the calling function and initialise it with g_variant_builder_init().

a #GVariantBuilder

a container type

Adds to a #GVariantBuilder. This call is a convenience wrapper that is exactly equivalent to calling g_variant_new() followed by g_variant_builder_add_value(). Note that the arguments must be of the correct width for their types specified in @format_string. This can be achieved by casting them. See the [GVariant varargs documentation][gvariant-varargs]. This function might be used as follows: |[ GVariant * make_pointless_dictionary (void) { GVariantBuilder builder; int i; g_variant_builder_init (&builder, G_VARIANT_TYPE_ARRAY); for (i = 0; i < 16; i++) { gchar buf[3]; sprintf (buf, "%d", i); g_variant_builder_add (&builder, "{is}", i, buf); } return g_variant_builder_end (&builder); } ]|

a #GVariantBuilder

a #GVariant varargs format string arguments, as per @format_string

Adds to a #GVariantBuilder. This call is a convenience wrapper that is exactly equivalent to calling g_variant_new_parsed() followed by g_variant_builder_add_value(). Note that the arguments must be of the correct width for their types specified in @format_string. This can be achieved by casting them. See the [GVariant varargs documentation][gvariant-varargs]. This function might be used as follows: |[ GVariant * make_pointless_dictionary (void) { GVariantBuilder builder; int i; g_variant_builder_init (&builder, G_VARIANT_TYPE_ARRAY); g_variant_builder_add_parsed (&builder, "{'width', <%i>}", 600); g_variant_builder_add_parsed (&builder, "{'title', <%s>}", "foo"); g_variant_builder_add_parsed (&builder, "{'transparency', <0.5>}"); return g_variant_builder_end (&builder); } ]|

a #GVariantBuilder

a text format #GVariant arguments as per @format

Adds @value to @builder. It is an error to call this function in any way that would create an inconsistent value to be constructed. Some examples of this are putting different types of items into an array, putting the wrong types or number of items in a tuple, putting more than one value into a variant, etc. If @value is a floating reference (see g_variant_ref_sink()), the @builder instance takes ownership of @value.

a #GVariantBuilder

a #GVariant

Releases all memory associated with a #GVariantBuilder without freeing the #GVariantBuilder structure itself. It typically only makes sense to do this on a stack-allocated #GVariantBuilder if you want to abort building the value part-way through. This function need not be called if you call g_variant_builder_end() and it also doesn't need to be called on builders allocated with g_variant_builder_new() (see g_variant_builder_unref() for that). This function leaves the #GVariantBuilder structure set to all-zeros. It is valid to call this function on either an initialised #GVariantBuilder or one that is set to all-zeros but it is not valid to call this function on uninitialised memory.

a #GVariantBuilder

Closes the subcontainer inside the given @builder that was opened by the most recent call to g_variant_builder_open(). It is an error to call this function in any way that would create an inconsistent value to be constructed (ie: too few values added to the subcontainer).

a #GVariantBuilder

Ends the builder process and returns the constructed value. It is not permissible to use @builder in any way after this call except for reference counting operations (in the case of a heap-allocated #GVariantBuilder) or by reinitialising it with g_variant_builder_init() (in the case of stack-allocated). This means that for the stack-allocated builders there is no need to call g_variant_builder_clear() after the call to g_variant_builder_end(). It is an error to call this function in any way that would create an inconsistent value to be constructed (ie: insufficient number of items added to a container with a specific number of children required). It is also an error to call this function if the builder was created with an indefinite array or maybe type and no children have been added; in this case it is impossible to infer the type of the empty array.

a new, floating, #GVariant

a #GVariantBuilder

Initialises a #GVariantBuilder structure. @type must be non-%NULL. It specifies the type of container to construct. It can be an indefinite type such as %G_VARIANT_TYPE_ARRAY or a definite type such as "as" or "(ii)". Maybe, array, tuple, dictionary entry and variant-typed values may be constructed. After the builder is initialised, values are added using g_variant_builder_add_value() or g_variant_builder_add(). After all the child values are added, g_variant_builder_end() frees the memory associated with the builder and returns the #GVariant that was created. This function completely ignores the previous contents of @builder. On one hand this means that it is valid to pass in completely uninitialised memory. On the other hand, this means that if you are initialising over top of an existing #GVariantBuilder you need to first call g_variant_builder_clear() in order to avoid leaking memory. You must not call g_variant_builder_ref() or g_variant_builder_unref() on a #GVariantBuilder that was initialised with this function. If you ever pass a reference to a #GVariantBuilder outside of the control of your own code then you should assume that the person receiving that reference may try to use reference counting; you should use g_variant_builder_new() instead of this function.

a #GVariantBuilder

a container type

Opens a subcontainer inside the given @builder. When done adding items to the subcontainer, g_variant_builder_close() must be called. @type is the type of the container: so to build a tuple of several values, @type must include the tuple itself. It is an error to call this function in any way that would cause an inconsistent value to be constructed (ie: adding too many values or a value of an incorrect type). Example of building a nested variant: |[ GVariantBuilder builder; guint32 some_number = get_number (); g_autoptr (GHashTable) some_dict = get_dict (); GHashTableIter iter; const gchar *key; const GVariant *value; g_autoptr (GVariant) output = NULL; g_variant_builder_init (&builder, G_VARIANT_TYPE ("(ua{sv})")); g_variant_builder_add (&builder, "u", some_number); g_variant_builder_open (&builder, G_VARIANT_TYPE ("a{sv}")); g_hash_table_iter_init (&iter, some_dict); while (g_hash_table_iter_next (&iter, (gpointer *) &key, (gpointer *) &value)) { g_variant_builder_open (&builder, G_VARIANT_TYPE ("{sv}")); g_variant_builder_add (&builder, "s", key); g_variant_builder_add (&builder, "v", value); g_variant_builder_close (&builder); } g_variant_builder_close (&builder); output = g_variant_builder_end (&builder); ]|

a #GVariantBuilder

the #GVariantType of the container

Increases the reference count on @builder. Don't call this on stack-allocated #GVariantBuilder instances or bad things will happen.

a new reference to @builder

a #GVariantBuilder allocated by g_variant_builder_new()

Decreases the reference count on @builder. In the event that there are no more references, releases all memory associated with the #GVariantBuilder. Don't call this on stack-allocated #GVariantBuilder instances or bad things will happen.

a #GVariantBuilder allocated by g_variant_builder_new()

The range of possible top-level types of #GVariant instances.

The #GVariant is a boolean. The #GVariant is a byte. The #GVariant is a signed 16 bit integer. The #GVariant is an unsigned 16 bit integer. The #GVariant is a signed 32 bit integer. The #GVariant is an unsigned 32 bit integer. The #GVariant is a signed 64 bit integer. The #GVariant is an unsigned 64 bit integer. The #GVariant is a file handle index. The #GVariant is a double precision floating point value. The #GVariant is a normal string. The #GVariant is a D-Bus object path string. The #GVariant is a D-Bus signature string. The #GVariant is a variant. The #GVariant is a maybe-typed value. The #GVariant is an array. The #GVariant is a tuple. The #GVariant is a dictionary entry.

#GVariantDict is a mutable interface to #GVariant dictionaries. It can be used for doing a sequence of dictionary lookups in an efficient way on an existing #GVariant dictionary or it can be used to construct new dictionaries with a hashtable-like interface. It can also be used for taking existing dictionaries and modifying them in order to create new ones. #GVariantDict can only be used with %G_VARIANT_TYPE_VARDICT dictionaries. It is possible to use #GVariantDict allocated on the stack or on the heap. When using a stack-allocated #GVariantDict, you begin with a call to g_variant_dict_init() and free the resources with a call to g_variant_dict_clear(). Heap-allocated #GVariantDict follows normal refcounting rules: you allocate it with g_variant_dict_new() and use g_variant_dict_ref() and g_variant_dict_unref(). g_variant_dict_end() is used to convert the #GVariantDict back into a dictionary-type #GVariant. When used with stack-allocated instances, this also implicitly frees all associated memory, but for heap-allocated instances, you must still call g_variant_dict_unref() afterwards. You will typically want to use a heap-allocated #GVariantDict when you expose it as part of an API. For most other uses, the stack-allocated form will be more convenient. Consider the following two examples that do the same thing in each style: take an existing dictionary and look up the "count" uint32 key, adding 1 to it if it is found, or returning an error if the key is not found. Each returns the new dictionary as a floating #GVariant. ## Using a stack-allocated GVariantDict |[ GVariant * add_to_count (GVariant *orig, GError **error) { GVariantDict dict; guint32 count; g_variant_dict_init (&dict, orig); if (!g_variant_dict_lookup (&dict, "count", "u", &count)) { g_set_error (...); g_variant_dict_clear (&dict); return NULL; } g_variant_dict_insert (&dict, "count", "u", count + 1); return g_variant_dict_end (&dict); } ]| ## Using heap-allocated GVariantDict |[ GVariant * add_to_count (GVariant *orig, GError **error) { GVariantDict *dict; GVariant *result; guint32 count; dict = g_variant_dict_new (orig); if (g_variant_dict_lookup (dict, "count", "u", &count)) { g_variant_dict_insert (dict, "count", "u", count + 1); result = g_variant_dict_end (dict); } else { g_set_error (...); result = NULL; } g_variant_dict_unref (dict); return result; } ]|

Allocates and initialises a new #GVariantDict. You should call g_variant_dict_unref() on the return value when it is no longer needed. The memory will not be automatically freed by any other call. In some cases it may be easier to place a #GVariantDict directly on the stack of the calling function and initialise it with g_variant_dict_init(). This is particularly useful when you are using #GVariantDict to construct a #GVariant.

a #GVariantDict

the #GVariant with which to initialise the dictionary

Releases all memory associated with a #GVariantDict without freeing the #GVariantDict structure itself. It typically only makes sense to do this on a stack-allocated #GVariantDict if you want to abort building the value part-way through. This function need not be called if you call g_variant_dict_end() and it also doesn't need to be called on dicts allocated with g_variant_dict_new (see g_variant_dict_unref() for that). It is valid to call this function on either an initialised #GVariantDict or one that was previously cleared by an earlier call to g_variant_dict_clear() but it is not valid to call this function on uninitialised memory.

a #GVariantDict

Checks if @key exists in @dict.

%TRUE if @key is in @dict

a #GVariantDict

the key to look up in the dictionary

Returns the current value of @dict as a #GVariant of type %G_VARIANT_TYPE_VARDICT, clearing it in the process. It is not permissible to use @dict in any way after this call except for reference counting operations (in the case of a heap-allocated #GVariantDict) or by reinitialising it with g_variant_dict_init() (in the case of stack-allocated).

a new, floating, #GVariant

a #GVariantDict

Initialises a #GVariantDict structure. If @from_asv is given, it is used to initialise the dictionary. This function completely ignores the previous contents of @dict. On one hand this means that it is valid to pass in completely uninitialised memory. On the other hand, this means that if you are initialising over top of an existing #GVariantDict you need to first call g_variant_dict_clear() in order to avoid leaking memory. You must not call g_variant_dict_ref() or g_variant_dict_unref() on a #GVariantDict that was initialised with this function. If you ever pass a reference to a #GVariantDict outside of the control of your own code then you should assume that the person receiving that reference may try to use reference counting; you should use g_variant_dict_new() instead of this function.

a #GVariantDict

the initial value for @dict

Inserts a value into a #GVariantDict. This call is a convenience wrapper that is exactly equivalent to calling g_variant_new() followed by g_variant_dict_insert_value().

a #GVariantDict

the key to insert a value for a #GVariant varargs format string arguments, as per @format_string

Inserts (or replaces) a key in a #GVariantDict. @value is consumed if it is floating.

a #GVariantDict

the key to insert a value for the value to insert

Looks up a value in a #GVariantDict. This function is a wrapper around g_variant_dict_lookup_value() and g_variant_get(). In the case that %NULL would have been returned, this function returns %FALSE. Otherwise, it unpacks the returned value and returns %TRUE. @format_string determines the C types that are used for unpacking the values and also determines if the values are copied or borrowed, see the section on [GVariant format strings][gvariant-format-strings-pointers].

%TRUE if a value was unpacked

a #GVariantDict

the key to look up in the dictionary a GVariant format string the arguments to unpack the value into

Looks up a value in a #GVariantDict. If @key is not found in @dictionary, %NULL is returned. The @expected_type string specifies what type of value is expected. If the value associated with @key has a different type then %NULL is returned. If the key is found and the value has the correct type, it is returned. If @expected_type was specified then any non-%NULL return value will have this type.

the value of the dictionary key, or %NULL

a #GVariantDict

the key to look up in the dictionary a #GVariantType, or %NULL

Increases the reference count on @dict. Don't call this on stack-allocated #GVariantDict instances or bad things will happen.

a new reference to @dict

a heap-allocated #GVariantDict

Removes a key and its associated value from a #GVariantDict.

%TRUE if the key was found and removed

a #GVariantDict

the key to remove

Decreases the reference count on @dict. In the event that there are no more references, releases all memory associated with the #GVariantDict. Don't call this on stack-allocated #GVariantDict instances or bad things will happen.

a heap-allocated #GVariantDict

#GVariantIter is an opaque data structure and can only be accessed using the following functions.

Creates a new heap-allocated #GVariantIter to iterate over the container that was being iterated over by @iter. Iteration begins on the new iterator from the current position of the old iterator but the two copies are independent past that point. Use g_variant_iter_free() to free the return value when you no longer need it. A reference is taken to the container that @iter is iterating over and will be related only when g_variant_iter_free() is called.

a new heap-allocated #GVariantIter

a #GVariantIter

Frees a heap-allocated #GVariantIter. Only call this function on iterators that were returned by g_variant_iter_new() or g_variant_iter_copy().

a heap-allocated #GVariantIter

Initialises (without allocating) a #GVariantIter. @iter may be completely uninitialised prior to this call; its old value is ignored. The iterator remains valid for as long as @value exists, and need not be freed in any way.

the number of items in @value

a pointer to a #GVariantIter

a container #GVariant

Gets the next item in the container and unpacks it into the variable argument list according to @format_string, returning %TRUE. If no more items remain then %FALSE is returned. On the first call to this function, the pointers appearing on the variable argument list are assumed to point at uninitialised memory. On the second and later calls, it is assumed that the same pointers will be given and that they will point to the memory as set by the previous call to this function. This allows the previous values to be freed, as appropriate. This function is intended to be used with a while loop as demonstrated in the following example. This function can only be used when iterating over an array. It is only valid to call this function with a string constant for the format string and the same string constant must be used each time. Mixing calls to this function and g_variant_iter_next() or g_variant_iter_next_value() on the same iterator causes undefined behavior. If you break out of a such a while loop using g_variant_iter_loop() then you must free or unreference all the unpacked values as you would with g_variant_get(). Failure to do so will cause a memory leak. Here is an example for memory management with g_variant_iter_loop(): |[ // Iterates a dictionary of type 'a{sv}' void iterate_dictionary (GVariant *dictionary) { GVariantIter iter; GVariant *value; gchar *key; g_variant_iter_init (&iter, dictionary); while (g_variant_iter_loop (&iter, "{sv}", &key, &value)) { g_print ("Item '%s' has type '%s'\n", key, g_variant_get_type_string (value)); // no need to free 'key' and 'value' here // unless breaking out of this loop } } ]| For most cases you should use g_variant_iter_next(). This function is really only useful when unpacking into #GVariant or #GVariantIter in order to allow you to skip the call to g_variant_unref() or g_variant_iter_free(). For example, if you are only looping over simple integer and string types, g_variant_iter_next() is definitely preferred. For string types, use the '&' prefix to avoid allocating any memory at all (and thereby avoiding the need to free anything as well). @format_string determines the C types that are used for unpacking the values and also determines if the values are copied or borrowed. See the section on [GVariant format strings][gvariant-format-strings-pointers].

%TRUE if a value was unpacked, or %FALSE if there was no value

a #GVariantIter

a GVariant format string the arguments to unpack the value into

Queries the number of child items in the container that we are iterating over. This is the total number of items -- not the number of items remaining. This function might be useful for preallocation of arrays.

the number of children in the container

a #GVariantIter

Gets the next item in the container and unpacks it into the variable argument list according to @format_string, returning %TRUE. If no more items remain then %FALSE is returned. All of the pointers given on the variable arguments list of this function are assumed to point at uninitialised memory. It is the responsibility of the caller to free all of the values returned by the unpacking process. Here is an example for memory management with g_variant_iter_next(): |[ // Iterates a dictionary of type 'a{sv}' void iterate_dictionary (GVariant *dictionary) { GVariantIter iter; GVariant *value; gchar *key; g_variant_iter_init (&iter, dictionary); while (g_variant_iter_next (&iter, "{sv}", &key, &value)) { g_print ("Item '%s' has type '%s'\n", key, g_variant_get_type_string (value)); // must free data for ourselves g_variant_unref (value); g_free (key); } } ]| For a solution that is likely to be more convenient to C programmers when dealing with loops, see g_variant_iter_loop(). @format_string determines the C types that are used for unpacking the values and also determines if the values are copied or borrowed. See the section on [GVariant format strings][gvariant-format-strings-pointers].

%TRUE if a value was unpacked, or %FALSE if there as no value

a #GVariantIter

a GVariant format string the arguments to unpack the value into

Gets the next item in the container. If no more items remain then %NULL is returned. Use g_variant_unref() to drop your reference on the return value when you no longer need it. Here is an example for iterating with g_variant_iter_next_value(): |[ // recursively iterate a container void iterate_container_recursive (GVariant *container) { GVariantIter iter; GVariant *child; g_variant_iter_init (&iter, container); while ((child = g_variant_iter_next_value (&iter))) { g_print ("type '%s'\n", g_variant_get_type_string (child)); if (g_variant_is_container (child)) iterate_container_recursive (child); g_variant_unref (child); } } ]|

a #GVariant, or %NULL

a #GVariantIter

Error codes returned by parsing text-format GVariants.

generic error (unused) a non-basic #GVariantType was given where a basic type was expected cannot infer the #GVariantType an indefinite #GVariantType was given where a definite type was expected extra data after parsing finished invalid character in number or unicode escape not a valid #GVariant format string not a valid object path not a valid type signature not a valid #GVariant type string could not find a common type for array entries the numerical value is out of range of the given type the numerical value is out of range for any type cannot parse as variant of the specified type an unexpected token was encountered an unknown keyword was encountered unterminated string constant no value given variant was too deeply nested; #GVariant is only guaranteed to handle nesting up to 64 levels (Since: 2.64)

This section introduces the GVariant type system. It is based, in large part, on the D-Bus type system, with two major changes and some minor lifting of restrictions. The [D-Bus specification](http://dbus.freedesktop.org/doc/dbus-specification.html), therefore, provides a significant amount of information that is useful when working with GVariant. The first major change with respect to the D-Bus type system is the introduction of maybe (or "nullable") types. Any type in GVariant can be converted to a maybe type, in which case, "nothing" (or "null") becomes a valid value. Maybe types have been added by introducing the character "m" to type strings. The second major change is that the GVariant type system supports the concept of "indefinite types" -- types that are less specific than the normal types found in D-Bus. For example, it is possible to speak of "an array of any type" in GVariant, where the D-Bus type system would require you to speak of "an array of integers" or "an array of strings". Indefinite types have been added by introducing the characters "*", "?" and "r" to type strings. Finally, all arbitrary restrictions relating to the complexity of types are lifted along with the restriction that dictionary entries may only appear nested inside of arrays. Just as in D-Bus, GVariant types are described with strings ("type strings"). Subject to the differences mentioned above, these strings are of the same form as those found in D-Bus. Note, however: D-Bus always works in terms of messages and therefore individual type strings appear nowhere in its interface. Instead, "signatures" are a concatenation of the strings of the type of each argument in a message. GVariant deals with single values directly so GVariant type strings always describe the type of exactly one value. This means that a D-Bus signature string is generally not a valid GVariant type string -- except in the case that it is the signature of a message containing exactly one argument. An indefinite type is similar in spirit to what may be called an abstract type in other type systems. No value can exist that has an indefinite type as its type, but values can exist that have types that are subtypes of indefinite types. That is to say, g_variant_get_type() will never return an indefinite type, but calling g_variant_is_of_type() with an indefinite type may return %TRUE. For example, you cannot have a value that represents "an array of no particular type", but you can have an "array of integers" which certainly matches the type of "an array of no particular type", since "array of integers" is a subtype of "array of no particular type". This is similar to how instances of abstract classes may not directly exist in other type systems, but instances of their non-abstract subtypes may. For example, in GTK, no object that has the type of #GtkBin can exist (since #GtkBin is an abstract class), but a #GtkWindow can certainly be instantiated, and you would say that the #GtkWindow is a #GtkBin (since #GtkWindow is a subclass of #GtkBin). ## GVariant Type Strings A GVariant type string can be any of the following: - any basic type string (listed below) - "v", "r" or "*" - one of the characters 'a' or 'm', followed by another type string - the character '(', followed by a concatenation of zero or more other type strings, followed by the character ')' - the character '{', followed by a basic type string (see below), followed by another type string, followed by the character '}' A basic type string describes a basic type (as per g_variant_type_is_basic()) and is always a single character in length. The valid basic type strings are "b", "y", "n", "q", "i", "u", "x", "t", "h", "d", "s", "o", "g" and "?". The above definition is recursive to arbitrary depth. "aaaaai" and "(ui(nq((y)))s)" are both valid type strings, as is "a(aa(ui)(qna{ya(yd)}))". In order to not hit memory limits, #GVariant imposes a limit on recursion depth of 65 nested containers. This is the limit in the D-Bus specification (64) plus one to allow a #GDBusMessage to be nested in a top-level tuple. The meaning of each of the characters is as follows: - `b`: the type string of %G_VARIANT_TYPE_BOOLEAN; a boolean value. - `y`: the type string of %G_VARIANT_TYPE_BYTE; a byte. - `n`: the type string of %G_VARIANT_TYPE_INT16; a signed 16 bit integer. - `q`: the type string of %G_VARIANT_TYPE_UINT16; an unsigned 16 bit integer. - `i`: the type string of %G_VARIANT_TYPE_INT32; a signed 32 bit integer. - `u`: the type string of %G_VARIANT_TYPE_UINT32; an unsigned 32 bit integer. - `x`: the type string of %G_VARIANT_TYPE_INT64; a signed 64 bit integer. - `t`: the type string of %G_VARIANT_TYPE_UINT64; an unsigned 64 bit integer. - `h`: the type string of %G_VARIANT_TYPE_HANDLE; a signed 32 bit value that, by convention, is used as an index into an array of file descriptors that are sent alongside a D-Bus message. - `d`: the type string of %G_VARIANT_TYPE_DOUBLE; a double precision floating point value. - `s`: the type string of %G_VARIANT_TYPE_STRING; a string. - `o`: the type string of %G_VARIANT_TYPE_OBJECT_PATH; a string in the form of a D-Bus object path. - `g`: the type string of %G_VARIANT_TYPE_SIGNATURE; a string in the form of a D-Bus type signature. - `?`: the type string of %G_VARIANT_TYPE_BASIC; an indefinite type that is a supertype of any of the basic types. - `v`: the type string of %G_VARIANT_TYPE_VARIANT; a container type that contain any other type of value. - `a`: used as a prefix on another type string to mean an array of that type; the type string "ai", for example, is the type of an array of signed 32-bit integers. - `m`: used as a prefix on another type string to mean a "maybe", or "nullable", version of that type; the type string "ms", for example, is the type of a value that maybe contains a string, or maybe contains nothing. - `()`: used to enclose zero or more other concatenated type strings to create a tuple type; the type string "(is)", for example, is the type of a pair of an integer and a string. - `r`: the type string of %G_VARIANT_TYPE_TUPLE; an indefinite type that is a supertype of any tuple type, regardless of the number of items. - `{}`: used to enclose a basic type string concatenated with another type string to create a dictionary entry type, which usually appears inside of an array to form a dictionary; the type string "a{sd}", for example, is the type of a dictionary that maps strings to double precision floating point values. The first type (the basic type) is the key type and the second type is the value type. The reason that the first type is restricted to being a basic type is so that it can easily be hashed. - `*`: the type string of %G_VARIANT_TYPE_ANY; the indefinite type that is a supertype of all types. Note that, as with all type strings, this character represents exactly one type. It cannot be used inside of tuples to mean "any number of items". Any type string of a container that contains an indefinite type is, itself, an indefinite type. For example, the type string "a*" (corresponding to %G_VARIANT_TYPE_ARRAY) is an indefinite type that is a supertype of every array type. "(*s)" is a supertype of all tuples that contain exactly two items where the second item is a string. "a{?*}" is an indefinite type that is a supertype of all arrays containing dictionary entries where the key is any basic type and the value is any type at all. This is, by definition, a dictionary, so this type string corresponds to %G_VARIANT_TYPE_DICTIONARY. Note that, due to the restriction that the key of a dictionary entry must be a basic type, "{**}" is not a valid type string.

Creates a new #GVariantType corresponding to the type string given by @type_string. It is appropriate to call g_variant_type_free() on the return value. It is a programmer error to call this function with an invalid type string. Use g_variant_type_string_is_valid() if you are unsure.

a new #GVariantType

a valid GVariant type string

Constructs the type corresponding to an array of elements of the type @type. It is appropriate to call g_variant_type_free() on the return value.

a new array #GVariantType Since 2.24

a #GVariantType

Constructs the type corresponding to a dictionary entry with a key of type @key and a value of type @value. It is appropriate to call g_variant_type_free() on the return value.

a new dictionary entry #GVariantType Since 2.24

a basic #GVariantType a #GVariantType

Constructs the type corresponding to a maybe instance containing type @type or Nothing. It is appropriate to call g_variant_type_free() on the return value.

a new maybe #GVariantType Since 2.24

a #GVariantType

Constructs a new tuple type, from @items. @length is the number of items in @items, or -1 to indicate that @items is %NULL-terminated. It is appropriate to call g_variant_type_free() on the return value.

a new tuple #GVariantType Since 2.24

an array of #GVariantTypes, one for each item the length of @items, or -1

Makes a copy of a #GVariantType. It is appropriate to call g_variant_type_free() on the return value. @type may not be %NULL.

a new #GVariantType Since 2.24

a #GVariantType

Returns a newly-allocated copy of the type string corresponding to @type. The returned string is nul-terminated. It is appropriate to call g_free() on the return value.

the corresponding type string Since 2.24

a #GVariantType

Determines the element type of an array or maybe type. This function may only be used with array or maybe types.

the element type of @type Since 2.24

an array or maybe #GVariantType

Compares @type1 and @type2 for equality. Only returns %TRUE if the types are exactly equal. Even if one type is an indefinite type and the other is a subtype of it, %FALSE will be returned if they are not exactly equal. If you want to check for subtypes, use g_variant_type_is_subtype_of(). The argument types of @type1 and @type2 are only #gconstpointer to allow use with #GHashTable without function pointer casting. For both arguments, a valid #GVariantType must be provided.

%TRUE if @type1 and @type2 are exactly equal Since 2.24

a #GVariantType

Determines the first item type of a tuple or dictionary entry type. This function may only be used with tuple or dictionary entry types, but must not be used with the generic tuple type %G_VARIANT_TYPE_TUPLE. In the case of a dictionary entry type, this returns the type of the key. %NULL is returned in case of @type being %G_VARIANT_TYPE_UNIT. This call, together with g_variant_type_next() provides an iterator interface over tuple and dictionary entry types.

the first item type of @type, or %NULL Since 2.24

a tuple or dictionary entry #GVariantType

Frees a #GVariantType that was allocated with g_variant_type_copy(), g_variant_type_new() or one of the container type constructor functions. In the case that @type is %NULL, this function does nothing. Since 2.24

a #GVariantType, or %NULL

Returns the length of the type string corresponding to the given @type. This function must be used to determine the valid extent of the memory region returned by g_variant_type_peek_string().

the length of the corresponding type string Since 2.24

a #GVariantType

Hashes @type. The argument type of @type is only #gconstpointer to allow use with #GHashTable without function pointer casting. A valid #GVariantType must be provided.

the hash value Since 2.24

a #GVariantType

Determines if the given @type is an array type. This is true if the type string for @type starts with an 'a'. This function returns %TRUE for any indefinite type for which every definite subtype is an array type -- %G_VARIANT_TYPE_ARRAY, for example.

%TRUE if @type is an array type Since 2.24

a #GVariantType

Determines if the given @type is a basic type. Basic types are booleans, bytes, integers, doubles, strings, object paths and signatures. Only a basic type may be used as the key of a dictionary entry. This function returns %FALSE for all indefinite types except %G_VARIANT_TYPE_BASIC.

%TRUE if @type is a basic type Since 2.24

a #GVariantType

Determines if the given @type is a container type. Container types are any array, maybe, tuple, or dictionary entry types plus the variant type. This function returns %TRUE for any indefinite type for which every definite subtype is a container -- %G_VARIANT_TYPE_ARRAY, for example.

%TRUE if @type is a container type Since 2.24

a #GVariantType

Determines if the given @type is definite (ie: not indefinite). A type is definite if its type string does not contain any indefinite type characters ('*', '?', or 'r'). A #GVariant instance may not have an indefinite type, so calling this function on the result of g_variant_get_type() will always result in %TRUE being returned. Calling this function on an indefinite type like %G_VARIANT_TYPE_ARRAY, however, will result in %FALSE being returned.

%TRUE if @type is definite Since 2.24

a #GVariantType

Determines if the given @type is a dictionary entry type. This is true if the type string for @type starts with a '{'. This function returns %TRUE for any indefinite type for which every definite subtype is a dictionary entry type -- %G_VARIANT_TYPE_DICT_ENTRY, for example.

%TRUE if @type is a dictionary entry type Since 2.24

a #GVariantType

Determines if the given @type is a maybe type. This is true if the type string for @type starts with an 'm'. This function returns %TRUE for any indefinite type for which every definite subtype is a maybe type -- %G_VARIANT_TYPE_MAYBE, for example.

%TRUE if @type is a maybe type Since 2.24

a #GVariantType

Checks if @type is a subtype of @supertype. This function returns %TRUE if @type is a subtype of @supertype. All types are considered to be subtypes of themselves. Aside from that, only indefinite types can have subtypes.

%TRUE if @type is a subtype of @supertype Since 2.24

a #GVariantType

Determines if the given @type is a tuple type. This is true if the type string for @type starts with a '(' or if @type is %G_VARIANT_TYPE_TUPLE. This function returns %TRUE for any indefinite type for which every definite subtype is a tuple type -- %G_VARIANT_TYPE_TUPLE, for example.

%TRUE if @type is a tuple type Since 2.24

a #GVariantType

Determines if the given @type is the variant type.

%TRUE if @type is the variant type Since 2.24

a #GVariantType

Determines the key type of a dictionary entry type. This function may only be used with a dictionary entry type. Other than the additional restriction, this call is equivalent to g_variant_type_first().

the key type of the dictionary entry Since 2.24

a dictionary entry #GVariantType

Determines the number of items contained in a tuple or dictionary entry type. This function may only be used with tuple or dictionary entry types, but must not be used with the generic tuple type %G_VARIANT_TYPE_TUPLE. In the case of a dictionary entry type, this function will always return 2.

the number of items in @type Since 2.24

a tuple or dictionary entry #GVariantType

Determines the next item type of a tuple or dictionary entry type. @type must be the result of a previous call to g_variant_type_first() or g_variant_type_next(). If called on the key type of a dictionary entry then this call returns the value type. If called on the value type of a dictionary entry then this call returns %NULL. For tuples, %NULL is returned when @type is the last item in a tuple.

the next #GVariantType after @type, or %NULL Since 2.24

a #GVariantType from a previous call

Returns the type string corresponding to the given @type. The result is not nul-terminated; in order to determine its length you must call g_variant_type_get_string_length(). To get a nul-terminated string, see g_variant_type_dup_string().

the corresponding type string (not nul-terminated) Since 2.24

a #GVariantType

Determines the value type of a dictionary entry type. This function may only be used with a dictionary entry type.

the value type of the dictionary entry Since 2.24

a dictionary entry #GVariantType

Checks if @type_string is a valid GVariant type string. This call is equivalent to calling g_variant_type_string_scan() and confirming that the following character is a nul terminator.

%TRUE if @type_string is exactly one valid type string Since 2.24

a pointer to any string

Scan for a single complete and valid GVariant type string in @string. The memory pointed to by @limit (or bytes beyond it) is never accessed. If a valid type string is found, @endptr is updated to point to the first character past the end of the string that was found and %TRUE is returned. If there is no valid type string starting at @string, or if the type string does not end before @limit then %FALSE is returned. For the simple case of checking if a string is a valid type string, see g_variant_type_string_is_valid().

%TRUE if a valid type string was found

a pointer to any string the end of @string, or %NULL location to store the end pointer, or %NULL

Declares a type of function which takes no arguments and has no return value. It is used to specify the type function passed to g_atexit().

On Windows, this macro defines a DllMain() function that stores the actual DLL name that the code being compiled will be included in. On non-Windows platforms, expands to nothing.

empty or "static" the name of the (pointer to the) char array where the DLL name will be stored. If this is used, you must also include `windows.h`. If you need a more complex DLL entry point function, you cannot use this

On Windows, this macro defines an expression which evaluates to %TRUE if the code is running on a version of Windows where the wide character versions of the Win32 API functions, and the wide character versions of the C library functions work. (They are always present in the DLLs, but don't work on Windows 9x and Me.) On non-Windows platforms, it is not defined.

On Windows, this macro defines an expression which evaluates to %TRUE if the code is running on an NT-based Windows operating system. On non-Windows platforms, it is not defined.

A wrapper for the POSIX abort() function. On Windows it is a function that makes extra effort (including a call to abort()) to ensure that a debugger-catchable exception is thrown before the program terminates. See your C library manual for more details about abort().

A wrapper for the POSIX access() function. This function is used to test a pathname for one or several of read, write or execute permissions, or just existence. On Windows, the file protection mechanism is not at all POSIX-like, and the underlying function in the C library only checks the FAT-style READONLY attribute, and does not look at the ACL of a file at all. This function is this in practise almost useless on Windows. Software that needs to handle file permissions on Windows more exactly should use the Win32 API. See your C library manual for more details about access().

zero if the pathname refers to an existing file system object that has all the tested permissions, or -1 otherwise or on error.

a pathname in the GLib file name encoding (UTF-8 on Windows) as in access()

This function is similar to g_malloc(), allocating (@n_blocks * @n_block_bytes) bytes, but care is taken to align the allocated memory to with the given alignment value. Additionally, it will detect possible overflow during multiplication. If the allocation fails (because the system is out of memory), the program is terminated. Aligned memory allocations returned by this function can only be freed using g_aligned_free().

the allocated memory

the number of blocks to allocate the size of each block in bytes the alignment to be enforced, which must be a positive power of 2 and a multiple of `sizeof(void*)`

This function is similar to g_aligned_alloc(), but it will also clear the allocated memory before returning it.

the allocated, cleared memory

the number of blocks to allocate the size of each block in bytes the alignment to be enforced, which must be a positive power of 2 and a multiple of `sizeof(void*)`

Frees the memory allocated by g_aligned_alloc().

the memory to deallocate

Allocates @size bytes on the stack; these bytes will be freed when the current stack frame is cleaned up. This macro essentially just wraps the alloca() function present on most UNIX variants. Thus it provides the same advantages and pitfalls as alloca(): - alloca() is very fast, as on most systems it's implemented by just adjusting the stack pointer register. - It doesn't cause any memory fragmentation, within its scope, separate alloca() blocks just build up and are released together at function end. - Allocation sizes have to fit into the current stack frame. For instance in a threaded environment on Linux, the per-thread stack size is limited to 2 Megabytes, so be sparse with alloca() uses. - Allocation failure due to insufficient stack space is not indicated with a %NULL return like e.g. with malloc(). Instead, most systems probably handle it the same way as out of stack space situations from infinite function recursion, i.e. with a segmentation fault. - Allowing @size to be specified by an untrusted party would allow for them to trigger a segmentation fault by specifying a large size, leading to a denial of service vulnerability. @size must always be entirely under the control of the program. - Special care has to be taken when mixing alloca() with GNU C variable sized arrays. Stack space allocated with alloca() in the same scope as a variable sized array will be freed together with the variable sized array upon exit of that scope, and not upon exit of the enclosing function scope.

number of bytes to allocate.

Wraps g_alloca() and initializes allocated memory to zeroes. If @size is `0` it returns %NULL. Note that the @size argument will be evaluated multiple times.

number of bytes to allocate.

An "atomically reference counted box", or "ArcBox", is an opaque wrapper data type that is guaranteed to be as big as the size of a given data type, and which augments the given data type with thread safe reference counting semantics for its memory management. ArcBox is useful if you have a plain old data type, like a structure typically placed on the stack, and you wish to provide additional API to use it on the heap; or if you want to implement a new type to be passed around by reference without necessarily implementing copy/free semantics or your own reference counting. The typical use is: |[ typedef struct { char *name; char *address; char *city; char *state; int age; } Person; Person * person_new (void) { return g_atomic_rc_box_new0 (Person); } ]| Every time you wish to acquire a reference on the memory, you should call g_atomic_rc_box_acquire(); similarly, when you wish to release a reference you should call g_atomic_rc_box_release(): |[ // Add a Person to the Database; the Database acquires ownership // of the Person instance void add_person_to_database (Database *db, Person *p) { db->persons = g_list_prepend (db->persons, g_atomic_rc_box_acquire (p)); } // Removes a Person from the Database; the reference acquired by // add_person_to_database() is released here void remove_person_from_database (Database *db, Person *p) { db->persons = g_list_remove (db->persons, p); g_atomic_rc_box_release (p); } ]| If you have additional memory allocated inside the structure, you can use g_atomic_rc_box_release_full(), which takes a function pointer, which will be called if the reference released was the last: |[ void person_clear (Person *p) { g_free (p->name); g_free (p->address); g_free (p->city); g_free (p->state); } void remove_person_from_database (Database *db, Person *p) { db->persons = g_list_remove (db->persons, p); g_atomic_rc_box_release_full (p, (GDestroyNotify) person_clear); } ]| If you wish to transfer the ownership of a reference counted data type without increasing the reference count, you can use g_steal_pointer(): |[ Person *p = g_atomic_rc_box_new (Person); fill_person_details (p); add_person_to_database (db, g_steal_pointer (&p)); ]| ## Thread safety The reference counting operations on data allocated using g_atomic_rc_box_alloc(), g_atomic_rc_box_new(), and g_atomic_rc_box_dup() are guaranteed to be atomic, and thus can be safely be performed by different threads. It is important to note that only the reference acquisition and release are atomic; changes to the content of the data are your responsibility. ## Automatic pointer clean up If you want to add g_autoptr() support to your plain old data type through reference counting, you can use the G_DEFINE_AUTOPTR_CLEANUP_FUNC() and g_atomic_rc_box_release(): |[ G_DEFINE_AUTOPTR_CLEANUP_FUNC (MyDataStruct, g_atomic_rc_box_release) ]| If you need to clear the contents of the data, you will need to use an ancillary function that calls g_rc_box_release_full(): |[ static void my_data_struct_release (MyDataStruct *data) { // my_data_struct_clear() is defined elsewhere g_atomic_rc_box_release_full (data, (GDestroyNotify) my_data_struct_clear); } G_DEFINE_AUTOPTR_CLEANUP_FUNC (MyDataStruct, my_data_struct_release) ]|

Adds the value on to the end of the array. The array will grow in size automatically if necessary. g_array_append_val() is a macro which uses a reference to the value parameter @v. This means that you cannot use it with literal values such as "27". You must use variables.

a #GArray the value to append to the #GArray

Returns the element of a #GArray at the given index. The return value is cast to the given type. This is the main way to read or write an element in a #GArray. Writing an element is typically done by reference, as in the following example. This example gets a pointer to an element in a #GArray, and then writes to a field in it: |[ EDayViewEvent *event; // This gets a pointer to the 4th element in the array of // EDayViewEvent structs. event = &g_array_index (events, EDayViewEvent, 3); event->start_time = g_get_current_time (); ]| This example reads from and writes to an array of integers: |[ g_autoptr(GArray) int_array = g_array_new (FALSE, FALSE, sizeof (guint)); for (guint i = 0; i < 10; i++) g_array_append_val (int_array, i); guint *my_int = &g_array_index (int_array, guint, 1); g_print ("Int at index 1 is %u; decrementing it\n", *my_int); *my_int = *my_int - 1; ]|

a #GArray the type of the elements the index of the element to return

Inserts an element into an array at the given index. g_array_insert_val() is a macro which uses a reference to the value parameter @v. This means that you cannot use it with literal values such as "27". You must use variables.

a #GArray the index to place the element at the value to insert into the array

Adds the value on to the start of the array. The array will grow in size automatically if necessary. This operation is slower than g_array_append_val() since the existing elements in the array have to be moved to make space for the new element. g_array_prepend_val() is a macro which uses a reference to the value parameter @v. This means that you cannot use it with literal values such as "27". You must use variables.

a #GArray the value to prepend to the #GArray

Arrays are similar to standard C arrays, except that they grow automatically as elements are added. Array elements can be of any size (though all elements of one array are the same size), and the array can be automatically cleared to '0's and zero-terminated. To create a new array use g_array_new(). To add elements to an array with a cost of O(n) at worst, use g_array_append_val(), g_array_append_vals(), g_array_prepend_val(), g_array_prepend_vals(), g_array_insert_val() and g_array_insert_vals(). To access an element of an array in O(1) (to read it or to write it), use g_array_index(). To set the size of an array, use g_array_set_size(). To free an array, use g_array_unref() or g_array_free(). All the sort functions are internally calling a quick-sort (or similar) function with an average cost of O(n log(n)) and a worst case cost of O(n^2). Here is an example that stores integers in a #GArray: |[ GArray *garray; gint i; // We create a new array to store gint values. // We don't want it zero-terminated or cleared to 0's. garray = g_array_new (FALSE, FALSE, sizeof (gint)); for (i = 0; i < 10000; i++) g_array_append_val (garray, i); for (i = 0; i < 10000; i++) if (g_array_index (garray, gint, i) != i) g_print ("ERROR: got %d instead of %d\n", g_array_index (garray, gint, i), i); g_array_free (garray, TRUE); ]| #GByteArray is a mutable array of bytes based on #GArray, to provide arrays of bytes which grow automatically as elements are added. To create a new #GByteArray use g_byte_array_new(). To add elements to a #GByteArray, use g_byte_array_append(), and g_byte_array_prepend(). To set the size of a #GByteArray, use g_byte_array_set_size(). To free a #GByteArray, use g_byte_array_free(). An example for using a #GByteArray: |[ GByteArray *gbarray; gint i; gbarray = g_byte_array_new (); for (i = 0; i < 10000; i++) g_byte_array_append (gbarray, (guint8*) "abcd", 4); for (i = 0; i < 10000; i++) { g_assert (gbarray->data[4*i] == 'a'); g_assert (gbarray->data[4*i+1] == 'b'); g_assert (gbarray->data[4*i+2] == 'c'); g_assert (gbarray->data[4*i+3] == 'd'); } g_byte_array_free (gbarray, TRUE); ]| See #GBytes if you are interested in an immutable object representing a sequence of bytes. Pointer Arrays are similar to Arrays but are used only for storing pointers. If you remove elements from the array, elements at the end of the array are moved into the space previously occupied by the removed element. This means that you should not rely on the index of particular elements remaining the same. You should also be careful when deleting elements while iterating over the array. To create a pointer array, use g_ptr_array_new(). To add elements to a pointer array, use g_ptr_array_add(). To remove elements from a pointer array, use g_ptr_array_remove(), g_ptr_array_remove_index() or g_ptr_array_remove_index_fast(). To access an element of a pointer array, use g_ptr_array_index(). To set the size of a pointer array, use g_ptr_array_set_size(). To free a pointer array, use g_ptr_array_free(). An example using a #GPtrArray: |[ GPtrArray *array; gchar *string1 = "one"; gchar *string2 = "two"; gchar *string3 = "three"; array = g_ptr_array_new (); g_ptr_array_add (array, (gpointer) string1); g_ptr_array_add (array, (gpointer) string2); g_ptr_array_add (array, (gpointer) string3); if (g_ptr_array_index (array, 0) != (gpointer) string1) g_print ("ERROR: got %p instead of %p\n", g_ptr_array_index (array, 0), string1); g_ptr_array_free (array, TRUE); ]| Determines the numeric value of a character as a decimal digit. Differs from g_unichar_digit_value() because it takes a char, so there's no worry about sign extension if characters are signed.

If @c is a decimal digit (according to g_ascii_isdigit()), its numeric value. Otherwise, -1.

an ASCII character

Converts a #gdouble to a string, using the '.' as decimal point. This function generates enough precision that converting the string back using g_ascii_strtod() gives the same machine-number (on machines with IEEE compatible 64bit doubles). It is guaranteed that the size of the resulting string will never be larger than %G_ASCII_DTOSTR_BUF_SIZE bytes, including the terminating nul character, which is always added.

The pointer to the buffer with the converted string.

A buffer to place the resulting string in The length of the buffer. The #gdouble to convert

Converts a #gdouble to a string, using the '.' as decimal point. To format the number you pass in a printf()-style format string. Allowed conversion specifiers are 'e', 'E', 'f', 'F', 'g' and 'G'. The @format must just be a single format specifier starting with `%`, expecting a #gdouble argument. The returned buffer is guaranteed to be nul-terminated. If you just want to want to serialize the value into a string, use g_ascii_dtostr().

The pointer to the buffer with the converted string.

A buffer to place the resulting string in The length of the buffer. The printf()-style format to use for the code to use for converting The #gdouble to convert

Determines whether a character is alphanumeric. Unlike the standard C library isalnum() function, this only recognizes standard ASCII letters and ignores the locale, returning %FALSE for all non-ASCII characters. Also, unlike the standard library function, this takes a char, not an int, so don't call it on %EOF, but no need to cast to #guchar before passing a possibly non-ASCII character in.

any character

Determines whether a character is alphabetic (i.e. a letter). Unlike the standard C library isalpha() function, this only recognizes standard ASCII letters and ignores the locale, returning %FALSE for all non-ASCII characters. Also, unlike the standard library function, this takes a char, not an int, so don't call it on %EOF, but no need to cast to #guchar before passing a possibly non-ASCII character in.

any character

Determines whether a character is a control character. Unlike the standard C library iscntrl() function, this only recognizes standard ASCII control characters and ignores the locale, returning %FALSE for all non-ASCII characters. Also, unlike the standard library function, this takes a char, not an int, so don't call it on %EOF, but no need to cast to #guchar before passing a possibly non-ASCII character in.

any character

Determines whether a character is digit (0-9). Unlike the standard C library isdigit() function, this takes a char, not an int, so don't call it on %EOF, but no need to cast to #guchar before passing a possibly non-ASCII character in.

any character

Determines whether a character is a printing character and not a space. Unlike the standard C library isgraph() function, this only recognizes standard ASCII characters and ignores the locale, returning %FALSE for all non-ASCII characters. Also, unlike the standard library function, this takes a char, not an int, so don't call it on %EOF, but no need to cast to #guchar before passing a possibly non-ASCII character in.

any character

Determines whether a character is an ASCII lower case letter. Unlike the standard C library islower() function, this only recognizes standard ASCII letters and ignores the locale, returning %FALSE for all non-ASCII characters. Also, unlike the standard library function, this takes a char, not an int, so don't call it on %EOF, but no need to worry about casting to #guchar before passing a possibly non-ASCII character in.

any character

Determines whether a character is a printing character. Unlike the standard C library isprint() function, this only recognizes standard ASCII characters and ignores the locale, returning %FALSE for all non-ASCII characters. Also, unlike the standard library function, this takes a char, not an int, so don't call it on %EOF, but no need to cast to #guchar before passing a possibly non-ASCII character in.

any character

Determines whether a character is a punctuation character. Unlike the standard C library ispunct() function, this only recognizes standard ASCII letters and ignores the locale, returning %FALSE for all non-ASCII characters. Also, unlike the standard library function, this takes a char, not an int, so don't call it on %EOF, but no need to cast to #guchar before passing a possibly non-ASCII character in.

any character

Determines whether a character is a white-space character. Unlike the standard C library isspace() function, this only recognizes standard ASCII white-space and ignores the locale, returning %FALSE for all non-ASCII characters. Also, unlike the standard library function, this takes a char, not an int, so don't call it on %EOF, but no need to cast to #guchar before passing a possibly non-ASCII character in.

any character

Determines whether a character is an ASCII upper case letter. Unlike the standard C library isupper() function, this only recognizes standard ASCII letters and ignores the locale, returning %FALSE for all non-ASCII characters. Also, unlike the standard library function, this takes a char, not an int, so don't call it on %EOF, but no need to worry about casting to #guchar before passing a possibly non-ASCII character in.

any character

Determines whether a character is a hexadecimal-digit character. Unlike the standard C library isxdigit() function, this takes a char, not an int, so don't call it on %EOF, but no need to cast to #guchar before passing a possibly non-ASCII character in.

any character

Compare two strings, ignoring the case of ASCII characters. Unlike the BSD strcasecmp() function, this only recognizes standard ASCII letters and ignores the locale, treating all non-ASCII bytes as if they are not letters. This function should be used only on strings that are known to be in encodings where the bytes corresponding to ASCII letters always represent themselves. This includes UTF-8 and the ISO-8859-* charsets, but not for instance double-byte encodings like the Windows Codepage 932, where the trailing bytes of double-byte characters include all ASCII letters. If you compare two CP932 strings using this function, you will get false matches. Both @s1 and @s2 must be non-%NULL.

0 if the strings match, a negative value if @s1 < @s2, or a positive value if @s1 > @s2.

string to compare with @s2 string to compare with @s1

Converts all upper case ASCII letters to lower case ASCII letters.

a newly-allocated string, with all the upper case characters in @str converted to lower case, with semantics that exactly match g_ascii_tolower(). (Note that this is unlike the old g_strdown(), which modified the string in place.)

a string length of @str in bytes, or -1 if @str is nul-terminated

A convenience function for converting a string to a signed number. This function assumes that @str contains only a number of the given @base that is within inclusive bounds limited by @min and @max. If this is true, then the converted number is stored in @out_num. An empty string is not a valid input. A string with leading or trailing whitespace is also an invalid input. @base can be between 2 and 36 inclusive. Hexadecimal numbers must not be prefixed with "0x" or "0X". Such a problem does not exist for octal numbers, since they were usually prefixed with a zero which does not change the value of the parsed number. Parsing failures result in an error with the %G_NUMBER_PARSER_ERROR domain. If the input is invalid, the error code will be %G_NUMBER_PARSER_ERROR_INVALID. If the parsed number is out of bounds - %G_NUMBER_PARSER_ERROR_OUT_OF_BOUNDS. See g_ascii_strtoll() if you have more complex needs such as parsing a string which starts with a number, but then has other characters.

%TRUE if @str was a number, otherwise %FALSE.

a string base of a parsed number a lower bound (inclusive) an upper bound (inclusive) a return location for a number

A convenience function for converting a string to an unsigned number. This function assumes that @str contains only a number of the given @base that is within inclusive bounds limited by @min and @max. If this is true, then the converted number is stored in @out_num. An empty string is not a valid input. A string with leading or trailing whitespace is also an invalid input. A string with a leading sign (`-` or `+`) is not a valid input for the unsigned parser. @base can be between 2 and 36 inclusive. Hexadecimal numbers must not be prefixed with "0x" or "0X". Such a problem does not exist for octal numbers, since they were usually prefixed with a zero which does not change the value of the parsed number. Parsing failures result in an error with the %G_NUMBER_PARSER_ERROR domain. If the input is invalid, the error code will be %G_NUMBER_PARSER_ERROR_INVALID. If the parsed number is out of bounds - %G_NUMBER_PARSER_ERROR_OUT_OF_BOUNDS. See g_ascii_strtoull() if you have more complex needs such as parsing a string which starts with a number, but then has other characters.

%TRUE if @str was a number, otherwise %FALSE.

a string base of a parsed number a lower bound (inclusive) an upper bound (inclusive) a return location for a number

Compare @s1 and @s2, ignoring the case of ASCII characters and any characters after the first @n in each string. If either string is less than @n bytes long, comparison will stop at the first nul byte encountered. Unlike the BSD strcasecmp() function, this only recognizes standard ASCII letters and ignores the locale, treating all non-ASCII characters as if they are not letters. The same warning as in g_ascii_strcasecmp() applies: Use this function only on strings known to be in encodings where bytes corresponding to ASCII letters always represent themselves.

0 if the strings match, a negative value if @s1 < @s2, or a positive value if @s1 > @s2.

string to compare with @s2 string to compare with @s1 number of characters to compare

Converts a string to a #gdouble value. This function behaves like the standard strtod() function does in the C locale. It does this without actually changing the current locale, since that would not be thread-safe. A limitation of the implementation is that this function will still accept localized versions of infinities and NANs. This function is typically used when reading configuration files or other non-user input that should be locale independent. To handle input from the user you should normally use the locale-sensitive system strtod() function. To convert from a #gdouble to a string in a locale-insensitive way, use g_ascii_dtostr(). If the correct value would cause overflow, plus or minus %HUGE_VAL is returned (according to the sign of the value), and %ERANGE is stored in %errno. If the correct value would cause underflow, zero is returned and %ERANGE is stored in %errno. This function resets %errno before calling strtod() so that you can reliably detect overflow and underflow.

the #gdouble value.

the string to convert to a numeric value. if non-%NULL, it returns the character after the last character used in the conversion.

Converts a string to a #gint64 value. This function behaves like the standard strtoll() function does in the C locale. It does this without actually changing the current locale, since that would not be thread-safe. This function is typically used when reading configuration files or other non-user input that should be locale independent. To handle input from the user you should normally use the locale-sensitive system strtoll() function. If the correct value would cause overflow, %G_MAXINT64 or %G_MININT64 is returned, and `ERANGE` is stored in `errno`. If the base is outside the valid range, zero is returned, and `EINVAL` is stored in `errno`. If the string conversion fails, zero is returned, and @endptr returns @nptr (if @endptr is non-%NULL).

the #gint64 value or zero on error.

the string to convert to a numeric value. if non-%NULL, it returns the character after the last character used in the conversion. to be used for the conversion, 2..36 or 0

Converts a string to a #guint64 value. This function behaves like the standard strtoull() function does in the C locale. It does this without actually changing the current locale, since that would not be thread-safe. Note that input with a leading minus sign (`-`) is accepted, and will return the negation of the parsed number, unless that would overflow a #guint64. Critically, this means you cannot assume that a short fixed length input will never result in a low return value, as the input could have a leading `-`. This function is typically used when reading configuration files or other non-user input that should be locale independent. To handle input from the user you should normally use the locale-sensitive system strtoull() function. If the correct value would cause overflow, %G_MAXUINT64 is returned, and `ERANGE` is stored in `errno`. If the base is outside the valid range, zero is returned, and `EINVAL` is stored in `errno`. If the string conversion fails, zero is returned, and @endptr returns @nptr (if @endptr is non-%NULL).

the #guint64 value or zero on error.

the string to convert to a numeric value. if non-%NULL, it returns the character after the last character used in the conversion. to be used for the conversion, 2..36 or 0

Converts all lower case ASCII letters to upper case ASCII letters.

a newly allocated string, with all the lower case characters in @str converted to upper case, with semantics that exactly match g_ascii_toupper(). (Note that this is unlike the old g_strup(), which modified the string in place.)

a string length of @str in bytes, or -1 if @str is nul-terminated

Convert a character to ASCII lower case. Unlike the standard C library tolower() function, this only recognizes standard ASCII letters and ignores the locale, returning all non-ASCII characters unchanged, even if they are lower case letters in a particular character set. Also unlike the standard library function, this takes and returns a char, not an int, so don't call it on %EOF but no need to worry about casting to #guchar before passing a possibly non-ASCII character in.

the result of converting @c to lower case. If @c is not an ASCII upper case letter, @c is returned unchanged.

any character

Convert a character to ASCII upper case. Unlike the standard C library toupper() function, this only recognizes standard ASCII letters and ignores the locale, returning all non-ASCII characters unchanged, even if they are upper case letters in a particular character set. Also unlike the standard library function, this takes and returns a char, not an int, so don't call it on %EOF but no need to worry about casting to #guchar before passing a possibly non-ASCII character in.

the result of converting @c to upper case. If @c is not an ASCII lower case letter, @c is returned unchanged.

any character

Determines the numeric value of a character as a hexadecimal digit. Differs from g_unichar_xdigit_value() because it takes a char, so there's no worry about sign extension if characters are signed.

If @c is a hex digit (according to g_ascii_isxdigit()), its numeric value. Otherwise, -1.

an ASCII character.

Debugging macro to terminate the application if the assertion fails. If the assertion fails (i.e. the expression is not true), an error message is logged and the application is terminated. The macro can be turned off in final releases of code by defining `G_DISABLE_ASSERT` when compiling the application, so code must not depend on any side effects from @expr. Similarly, it must not be used in unit tests, otherwise the unit tests will be ineffective if compiled with `G_DISABLE_ASSERT`. Use g_assert_true() and related macros in unit tests instead.

the expression to check

Debugging macro to compare two floating point numbers. The effect of `g_assert_cmpfloat (n1, op, n2)` is the same as `g_assert_true (n1 op n2)`. The advantage of this macro is that it can produce a message that includes the actual values of @n1 and @n2.

a floating point number The comparison operator to use. One of `==`, `!=`, `<`, `>`, `<=`, `>=`. another floating point number

Debugging macro to compare two floating point numbers within an epsilon. The effect of `g_assert_cmpfloat_with_epsilon (n1, n2, epsilon)` is the same as `g_assert_true (abs (n1 - n2) < epsilon)`. The advantage of this macro is that it can produce a message that includes the actual values of @n1 and @n2.

a floating point number another floating point number a numeric value that expresses the expected tolerance between @n1 and @n2

Debugging macro to compare to unsigned integers. This is a variant of g_assert_cmpuint() that displays the numbers in hexadecimal notation in the message.

an unsigned integer The comparison operator to use. One of `==`, `!=`, `<`, `>`, `<=`, `>=`. another unsigned integer

Debugging macro to compare two integers. The effect of `g_assert_cmpint (n1, op, n2)` is the same as `g_assert_true (n1 op n2)`. The advantage of this macro is that it can produce a message that includes the actual values of @n1 and @n2.

an integer The comparison operator to use. One of `==`, `!=`, `<`, `>`, `<=`, `>=`. another integer

Debugging macro to compare memory regions. If the comparison fails, an error message is logged and the application is either terminated or the testcase marked as failed. The effect of `g_assert_cmpmem (m1, l1, m2, l2)` is the same as `g_assert_true (l1 == l2 && memcmp (m1, m2, l1) == 0)`. The advantage of this macro is that it can produce a message that includes the actual values of @l1 and @l2. @m1 may be %NULL if (and only if) @l1 is zero; similarly for @m2 and @l2. |[ g_assert_cmpmem (buf->data, buf->len, expected, sizeof (expected)); ]|

pointer to a buffer length of @m1 pointer to another buffer length of @m2

Debugging macro to compare two strings. If the comparison fails, an error message is logged and the application is either terminated or the testcase marked as failed. The strings are compared using g_strcmp0(). The effect of `g_assert_cmpstr (s1, op, s2)` is the same as `g_assert_true (g_strcmp0 (s1, s2) op 0)`. The advantage of this macro is that it can produce a message that includes the actual values of @s1 and @s2. |[ g_assert_cmpstr (mystring, ==, "fubar"); ]|

a string (may be %NULL) The comparison operator to use. One of `==`, `!=`, `<`, `>`, `<=`, `>=`. another string (may be %NULL)

Debugging macro to check if two %NULL-terminated string arrays (i.e. 2 #GStrv) are equal. If they are not equal, an error message is logged and the application is either terminated or the testcase marked as failed. If both arrays are %NULL, the check passes. If one array is %NULL but the other is not, an error message is logged. The effect of `g_assert_cmpstrv (strv1, strv2)` is the same as `g_assert_true (g_strv_equal (strv1, strv2))` (if both arrays are not %NULL). The advantage of this macro is that it can produce a message that includes how @strv1 and @strv2 are different. |[ const char *expected[] = { "one", "two", "three", NULL }; g_assert_cmpstrv (mystrv, expected); ]|

a string array (may be %NULL) another string array (may be %NULL)

Debugging macro to compare two unsigned integers. The effect of `g_assert_cmpuint (n1, op, n2)` is the same as `g_assert_true (n1 op n2)`. The advantage of this macro is that it can produce a message that includes the actual values of @n1 and @n2.

an unsigned integer The comparison operator to use. One of `==`, `!=`, `<`, `>`, `<=`, `>=`. another unsigned integer

Debugging macro to compare two #GVariants. If the comparison fails, an error message is logged and the application is either terminated or the testcase marked as failed. The variants are compared using g_variant_equal(). The effect of `g_assert_cmpvariant (v1, v2)` is the same as `g_assert_true (g_variant_equal (v1, v2))`. The advantage of this macro is that it can produce a message that includes the actual values of @v1 and @v2.

pointer to a #GVariant pointer to another #GVariant

Debugging macro to check that a method has returned the correct #GError. The effect of `g_assert_error (err, dom, c)` is the same as `g_assert_true (err != NULL && err->domain == dom && err->code == c)`. The advantage of this macro is that it can produce a message that includes the incorrect error message and code. This can only be used to test for a specific error. If you want to test that @err is set, but don't care what it's set to, just use `g_assert_nonnull (err)`.

a #GError, possibly %NULL the expected error domain (a #GQuark) the expected error code

Debugging macro to check an expression is false. If the assertion fails (i.e. the expression is not false), an error message is logged and the application is either terminated or the testcase marked as failed. Note that unlike g_assert(), this macro is unaffected by whether `G_DISABLE_ASSERT` is defined. Hence it should only be used in tests and, conversely, g_assert() should not be used in tests. See g_test_set_nonfatal_assertions().

the expression to check

Debugging macro to check that an expression has a non-negative return value, as used by traditional POSIX functions (such as `rmdir()`) to indicate success. If the assertion fails (i.e. the @expr returns a negative value), an error message is logged and the testcase is marked as failed. The error message will contain the value of `errno` and its human-readable message from g_strerror(). This macro will clear the value of `errno` before executing @expr.

the expression to check

Debugging macro to check that a #GError is not set. The effect of `g_assert_no_error (err)` is the same as `g_assert_true (err == NULL)`. The advantage of this macro is that it can produce a message that includes the error message and code.

a #GError, possibly %NULL

Debugging macro to check an expression is not %NULL. If the assertion fails (i.e. the expression is %NULL), an error message is logged and the application is either terminated or the testcase marked as failed. Note that unlike g_assert(), this macro is unaffected by whether `G_DISABLE_ASSERT` is defined. Hence it should only be used in tests and, conversely, g_assert() should not be used in tests. See g_test_set_nonfatal_assertions().

the expression to check

Debugging macro to terminate the application if it is ever reached. If it is reached, an error message is logged and the application is terminated. The macro can be turned off in final releases of code by defining `G_DISABLE_ASSERT` when compiling the application. Hence, it should not be used in unit tests, where assertions should always be effective.

Debugging macro to check an expression is %NULL. If the assertion fails (i.e. the expression is not %NULL), an error message is logged and the application is either terminated or the testcase marked as failed. Note that unlike g_assert(), this macro is unaffected by whether `G_DISABLE_ASSERT` is defined. Hence it should only be used in tests and, conversely, g_assert() should not be used in tests. See g_test_set_nonfatal_assertions().

the expression to check

Debugging macro to check that an expression is true. If the assertion fails (i.e. the expression is not true), an error message is logged and the application is either terminated or the testcase marked as failed. Note that unlike g_assert(), this macro is unaffected by whether `G_DISABLE_ASSERT` is defined. Hence it should only be used in tests and, conversely, g_assert() should not be used in tests. See g_test_set_nonfatal_assertions().

the expression to check

Internal function used to print messages from the public g_assert() and g_assert_not_reached() macros.

log domain file containing the assertion line number of the assertion function containing the assertion expression which failed

Often you need to communicate between different threads. In general it's safer not to do this by shared memory, but by explicit message passing. These messages only make sense asynchronously for multi-threaded applications though, as a synchronous operation could as well be done in the same thread. Asynchronous queues are an exception from most other GLib data structures, as they can be used simultaneously from multiple threads without explicit locking and they bring their own builtin reference counting. This is because the nature of an asynchronous queue is that it will always be used by at least 2 concurrent threads. For using an asynchronous queue you first have to create one with g_async_queue_new(). #GAsyncQueue structs are reference counted, use g_async_queue_ref() and g_async_queue_unref() to manage your references. A thread which wants to send a message to that queue simply calls g_async_queue_push() to push the message to the queue. A thread which is expecting messages from an asynchronous queue simply calls g_async_queue_pop() for that queue. If no message is available in the queue at that point, the thread is now put to sleep until a message arrives. The message will be removed from the queue and returned. The functions g_async_queue_try_pop() and g_async_queue_timeout_pop() can be used to only check for the presence of messages or to only wait a certain time for messages respectively. For almost every function there exist two variants, one that locks the queue and one that doesn't. That way you can hold the queue lock (acquire it with g_async_queue_lock() and release it with g_async_queue_unlock()) over multiple queue accessing instructions. This can be necessary to ensure the integrity of the queue, but should only be used when really necessary, as it can make your life harder if used unwisely. Normally you should only use the locking function variants (those without the _unlocked suffix). In many cases, it may be more convenient to use #GThreadPool when you need to distribute work to a set of worker threads instead of using #GAsyncQueue manually. #GThreadPool uses a GAsyncQueue internally. Specifies a function to be called at normal program termination. Since GLib 2.8.2, on Windows g_atexit() actually is a preprocessor macro that maps to a call to the atexit() function in the C library. This means that in case the code that calls g_atexit(), i.e. atexit(), is in a DLL, the function will be called when the DLL is detached from the program. This typically makes more sense than that the function is called when the GLib DLL is detached, which happened earlier when g_atexit() was a function in the GLib DLL. The behaviour of atexit() in the context of dynamically loaded modules is not formally specified and varies wildly. On POSIX systems, calling g_atexit() (or atexit()) in a dynamically loaded module which is unloaded before the program terminates might well cause a crash at program exit. Some POSIX systems implement atexit() like Windows, and have each dynamically loaded module maintain an own atexit chain that is called when the module is unloaded. On other POSIX systems, before a dynamically loaded module is unloaded, the registered atexit functions (if any) residing in that module are called, regardless where the code that registered them resided. This is presumably the most robust approach. As can be seen from the above, for portability it's best to avoid calling g_atexit() (or atexit()) except in the main executable of a program.

It is best to avoid g_atexit().

the function to call on normal program termination.

Atomically adds @val to the value of @atomic. Think of this operation as an atomic version of `{ tmp = *atomic; *atomic += val; return tmp; }`. This call acts as a full compiler and hardware memory barrier. Before version 2.30, this function did not return a value (but g_atomic_int_exchange_and_add() did, and had the same meaning). While @atomic has a `volatile` qualifier, this is a historical artifact and the pointer passed to it should not be `volatile`.

the value of @atomic before the add, signed

a pointer to a #gint or #guint the value to add

Performs an atomic bitwise 'and' of the value of @atomic and @val, storing the result back in @atomic. This call acts as a full compiler and hardware memory barrier. Think of this operation as an atomic version of `{ tmp = *atomic; *atomic &= val; return tmp; }`. While @atomic has a `volatile` qualifier, this is a historical artifact and the pointer passed to it should not be `volatile`.

the value of @atomic before the operation, unsigned

a pointer to a #gint or #guint the value to 'and'

Compares @atomic to @oldval and, if equal, sets it to @newval. If @atomic was not equal to @oldval then no change occurs. This compare and exchange is done atomically. Think of this operation as an atomic version of `{ if (*atomic == oldval) { *atomic = newval; return TRUE; } else return FALSE; }`. This call acts as a full compiler and hardware memory barrier. While @atomic has a `volatile` qualifier, this is a historical artifact and the pointer passed to it should not be `volatile`.

%TRUE if the exchange took place

a pointer to a #gint or #guint the value to compare with the value to conditionally replace with

Compares @atomic to @oldval and, if equal, sets it to @newval. If @atomic was not equal to @oldval then no change occurs. In any case the value of @atomic before this operation is stored in @preval. This compare and exchange is done atomically. Think of this operation as an atomic version of `{ *preval = *atomic; if (*atomic == oldval) { *atomic = newval; return TRUE; } else return FALSE; }`. This call acts as a full compiler and hardware memory barrier. See also g_atomic_int_compare_and_exchange()

%TRUE if the exchange took place

a pointer to a #gint or #guint the value to compare with the value to conditionally replace with the contents of @atomic before this operation

Decrements the value of @atomic by 1. Think of this operation as an atomic version of `{ *atomic -= 1; return (*atomic == 0); }`. This call acts as a full compiler and hardware memory barrier. While @atomic has a `volatile` qualifier, this is a historical artifact and the pointer passed to it should not be `volatile`.

%TRUE if the resultant value is zero

a pointer to a #gint or #guint

Sets the @atomic to @newval and returns the old value from @atomic. This exchange is done atomically. Think of this operation as an atomic version of `{ tmp = *atomic; *atomic = val; return tmp; }`. This call acts as a full compiler and hardware memory barrier.

the value of @atomic before the exchange, signed

a pointer to a #gint or #guint the value to replace with

This function existed before g_atomic_int_add() returned the prior value of the integer (which it now does). It is retained only for compatibility reasons. Don't use this function in new code.

Use g_atomic_int_add() instead.

the value of @atomic before the add, signed

a pointer to a #gint the value to add

Gets the current value of @atomic. This call acts as a full compiler and hardware memory barrier (before the get). While @atomic has a `volatile` qualifier, this is a historical artifact and the pointer passed to it should not be `volatile`.

the value of the integer

a pointer to a #gint or #guint

Increments the value of @atomic by 1. Think of this operation as an atomic version of `{ *atomic += 1; }`. This call acts as a full compiler and hardware memory barrier. While @atomic has a `volatile` qualifier, this is a historical artifact and the pointer passed to it should not be `volatile`.

a pointer to a #gint or #guint

Performs an atomic bitwise 'or' of the value of @atomic and @val, storing the result back in @atomic. Think of this operation as an atomic version of `{ tmp = *atomic; *atomic |= val; return tmp; }`. This call acts as a full compiler and hardware memory barrier. While @atomic has a `volatile` qualifier, this is a historical artifact and the pointer passed to it should not be `volatile`.

the value of @atomic before the operation, unsigned

a pointer to a #gint or #guint the value to 'or'

Sets the value of @atomic to @newval. This call acts as a full compiler and hardware memory barrier (after the set). While @atomic has a `volatile` qualifier, this is a historical artifact and the pointer passed to it should not be `volatile`.

a pointer to a #gint or #guint a new value to store

Performs an atomic bitwise 'xor' of the value of @atomic and @val, storing the result back in @atomic. Think of this operation as an atomic version of `{ tmp = *atomic; *atomic ^= val; return tmp; }`. This call acts as a full compiler and hardware memory barrier. While @atomic has a `volatile` qualifier, this is a historical artifact and the pointer passed to it should not be `volatile`.

the value of @atomic before the operation, unsigned

a pointer to a #gint or #guint the value to 'xor'

The following is a collection of compiler macros to provide atomic access to integer and pointer-sized values. The macros that have 'int' in the name will operate on pointers to #gint and #guint. The macros with 'pointer' in the name will operate on pointers to any pointer-sized value, including #gsize. There is no support for 64bit operations on platforms with 32bit pointers because it is not generally possible to perform these operations atomically. The get, set and exchange operations for integers and pointers nominally operate on #gint and #gpointer, respectively. Of the arithmetic operations, the 'add' operation operates on (and returns) signed integer values (#gint and #gssize) and the 'and', 'or', and 'xor' operations operate on (and return) unsigned integer values (#guint and #gsize). All of the operations act as a full compiler and (where appropriate) hardware memory barrier. Acquire and release or producer and consumer barrier semantics are not available through this API. It is very important that all accesses to a particular integer or pointer be performed using only this API and that different sizes of operation are not mixed or used on overlapping memory regions. Never read or assign directly from or to a value -- always use this API. For simple reference counting purposes you should use g_atomic_int_inc() and g_atomic_int_dec_and_test(). Other uses that fall outside of simple reference counting patterns are prone to subtle bugs and occasionally undefined behaviour. It is also worth noting that since all of these operations require global synchronisation of the entire machine, they can be quite slow. In the case of performing multiple atomic operations it can often be faster to simply acquire a mutex lock around the critical area, perform the operations normally and then release the lock. Atomically adds @val to the value of @atomic. Think of this operation as an atomic version of `{ tmp = *atomic; *atomic += val; return tmp; }`. This call acts as a full compiler and hardware memory barrier. While @atomic has a `volatile` qualifier, this is a historical artifact and the pointer passed to it should not be `volatile`.

the value of @atomic before the add, signed

a pointer to a #gpointer-sized value the value to add

Performs an atomic bitwise 'and' of the value of @atomic and @val, storing the result back in @atomic. Think of this operation as an atomic version of `{ tmp = *atomic; *atomic &= val; return tmp; }`. This call acts as a full compiler and hardware memory barrier. While @atomic has a `volatile` qualifier, this is a historical artifact and the pointer passed to it should not be `volatile`.

the value of @atomic before the operation, unsigned

a pointer to a #gpointer-sized value the value to 'and'

%TRUE if the exchange took place

a pointer to a #gpointer-sized value the value to compare with the value to conditionally replace with

%TRUE if the exchange took place

a pointer to a #gpointer-sized value the value to compare with the value to conditionally replace with the contents of @atomic before this operation

the value of @atomic before the exchange

a pointer to a #gpointer-sized value the value to replace with

the value of the pointer

a pointer to a #gpointer-sized value

the value of @atomic before the operation, unsigned

a pointer to a #gpointer-sized value the value to 'or'

a pointer to a #gpointer-sized value a new value to store

the value of @atomic before the operation, unsigned

a pointer to a #gpointer-sized value the value to 'xor'

Atomically acquires a reference on the data pointed by @mem_block.

a pointer to the data, with its reference count increased

a pointer to reference counted data

Allocates @block_size bytes of memory, and adds atomic reference counting semantics to it. The data will be freed when its reference count drops to zero. The allocated data is guaranteed to be suitably aligned for any built-in type.

a pointer to the allocated memory

the size of the allocation, must be greater than 0

Allocates @block_size bytes of memory, and adds atomic reference counting semantics to it. The contents of the returned data is set to zero. The data will be freed when its reference count drops to zero. The allocated data is guaranteed to be suitably aligned for any built-in type.

a pointer to the allocated memory

the size of the allocation, must be greater than 0

Allocates a new block of data with atomic reference counting semantics, and copies @block_size bytes of @mem_block into it.

a pointer to the allocated memory

the number of bytes to copy, must be greater than 0 the memory to copy

Retrieves the size of the reference counted data pointed by @mem_block.

the size of the data, in bytes

a pointer to reference counted data

A convenience macro to allocate atomically reference counted data with the size of the given @type. This macro calls g_atomic_rc_box_alloc() with `sizeof (@type)` and casts the returned pointer to a pointer of the given @type, avoiding a type cast in the source code.

the type to allocate, typically a structure name

A convenience macro to allocate atomically reference counted data with the size of the given @type, and set its contents to zero. This macro calls g_atomic_rc_box_alloc0() with `sizeof (@type)` and casts the returned pointer to a pointer of the given @type, avoiding a type cast in the source code.

the type to allocate, typically a structure name

Atomically releases a reference on the data pointed by @mem_block. If the reference was the last one, it will free the resources allocated for @mem_block.

a pointer to reference counted data

Atomically releases a reference on the data pointed by @mem_block. If the reference was the last one, it will call @clear_func to clear the contents of @mem_block, and then will free the resources allocated for @mem_block.

a pointer to reference counted data a function to call when clearing the data

Atomically compares the current value of @arc with @val.

%TRUE if the reference count is the same as the given value

the address of an atomic reference count variable the value to compare

Atomically decreases the reference count. If %TRUE is returned, the reference count reached 0. After this point, @arc is an undefined state and must be reinitialized with g_atomic_ref_count_init() to be used again.

%TRUE if the reference count reached 0, and %FALSE otherwise

the address of an atomic reference count variable

Atomically increases the reference count.

the address of an atomic reference count variable

Initializes a reference count variable to 1.

the address of an atomic reference count variable

Base64 is an encoding that allows a sequence of arbitrary bytes to be encoded as a sequence of printable ASCII characters. For the definition of Base64, see [RFC 1421](http://www.ietf.org/rfc/rfc1421.txt) or [RFC 2045](http://www.ietf.org/rfc/rfc2045.txt). Base64 is most commonly used as a MIME transfer encoding for email. GLib supports incremental encoding using g_base64_encode_step() and g_base64_encode_close(). Incremental decoding can be done with g_base64_decode_step(). To encode or decode data in one go, use g_base64_encode() or g_base64_decode(). To avoid memory allocation when decoding, you can use g_base64_decode_inplace(). Support for Base64 encoding has been added in GLib 2.12. Decode a sequence of Base-64 encoded text into binary data. Note that the returned binary data is not necessarily zero-terminated, so it should not be used as a character string.

newly allocated buffer containing the binary data that @text represents. The returned buffer must be freed with g_free().

zero-terminated string with base64 text to decode The length of the decoded data is written here

Decode a sequence of Base-64 encoded text into binary data by overwriting the input data.

The binary data that @text responds. This pointer is the same as the input @text.

zero-terminated string with base64 text to decode The length of the decoded data is written here

Incrementally decode a sequence of binary data from its Base-64 stringified representation. By calling this function multiple times you can convert data in chunks to avoid having to have the full encoded data in memory. The output buffer must be large enough to fit all the data that will be written to it. Since base64 encodes 3 bytes in 4 chars you need at least: (@len / 4) * 3 + 3 bytes (+ 3 may be needed in case of non-zero state).

The number of bytes of output that was written

binary input data max length of @in data to decode output buffer Saved state between steps, initialize to 0 Saved state between steps, initialize to 0

Encode a sequence of binary data into its Base-64 stringified representation.

a newly allocated, zero-terminated Base-64 encoded string representing @data. The returned string must be freed with g_free().

the binary data to encode the length of @data

Flush the status from a sequence of calls to g_base64_encode_step(). The output buffer must be large enough to fit all the data that will be written to it. It will need up to 4 bytes, or up to 5 bytes if line-breaking is enabled. The @out array will not be automatically nul-terminated.

The number of bytes of output that was written

whether to break long lines pointer to destination buffer Saved state from g_base64_encode_step() Saved state from g_base64_encode_step()

Incrementally encode a sequence of binary data into its Base-64 stringified representation. By calling this function multiple times you can convert data in chunks to avoid having to have the full encoded data in memory. When all of the data has been converted you must call g_base64_encode_close() to flush the saved state. The output buffer must be large enough to fit all the data that will be written to it. Due to the way base64 encodes you will need at least: (@len / 3 + 1) * 4 + 4 bytes (+ 4 may be needed in case of non-zero state). If you enable line-breaking you will need at least: ((@len / 3 + 1) * 4 + 4) / 76 + 1 bytes of extra space. @break_lines is typically used when putting base64-encoded data in emails. It breaks the lines at 76 columns instead of putting all of the text on the same line. This avoids problems with long lines in the email system. Note however that it breaks the lines with `LF` characters, not `CR LF` sequences, so the result cannot be passed directly to SMTP or certain other protocols.

The number of bytes of output that was written

the binary data to encode the length of @in whether to break long lines pointer to destination buffer Saved state between steps, initialize to 0 Saved state between steps, initialize to 0

Gets the name of the file without any leading directory components. It returns a pointer into the given file name string.

Use g_path_get_basename() instead, but notice that g_path_get_basename() allocates new memory for the returned string, unlike this function which returns a pointer into the argument.

the name of the file without any leading directory components

the name of the file

Sets the indicated @lock_bit in @address. If the bit is already set, this call will block until g_bit_unlock() unsets the corresponding bit. Attempting to lock on two different bits within the same integer is not supported and will very probably cause deadlocks. The value of the bit that is set is (1u << @bit). If @bit is not between 0 and 31 then the result is undefined. This function accesses @address atomically. All other accesses to @address must be atomic in order for this function to work reliably. While @address has a `volatile` qualifier, this is a historical artifact and the argument passed to it should not be `volatile`.

a pointer to an integer a bit value between 0 and 31

Find the position of the first bit set in @mask, searching from (but not including) @nth_bit upwards. Bits are numbered from 0 (least significant) to sizeof(#gulong) * 8 - 1 (31 or 63, usually). To start searching from the 0th bit, set @nth_bit to -1.

the index of the first bit set which is higher than @nth_bit, or -1 if no higher bits are set

a #gulong containing flags the index of the bit to start the search from

Find the position of the first bit set in @mask, searching from (but not including) @nth_bit downwards. Bits are numbered from 0 (least significant) to sizeof(#gulong) * 8 - 1 (31 or 63, usually). To start searching from the last bit, set @nth_bit to -1 or GLIB_SIZEOF_LONG * 8.

the index of the first bit set which is lower than @nth_bit, or -1 if no lower bits are set

a #gulong containing flags the index of the bit to start the search from

Gets the number of bits used to hold @number, e.g. if @number is 4, 3 bits are needed.

the number of bits used to hold @number

a #guint

Sets the indicated @lock_bit in @address, returning %TRUE if successful. If the bit is already set, returns %FALSE immediately. Attempting to lock on two different bits within the same integer is not supported. The value of the bit that is set is (1u << @bit). If @bit is not between 0 and 31 then the result is undefined. This function accesses @address atomically. All other accesses to @address must be atomic in order for this function to work reliably. While @address has a `volatile` qualifier, this is a historical artifact and the argument passed to it should not be `volatile`.

%TRUE if the lock was acquired

a pointer to an integer a bit value between 0 and 31

Clears the indicated @lock_bit in @address. If another thread is currently blocked in g_bit_lock() on this same bit then it will be woken up. This function accesses @address atomically. All other accesses to @address must be atomic in order for this function to work reliably. While @address has a `volatile` qualifier, this is a historical artifact and the argument passed to it should not be `volatile`.

a pointer to an integer a bit value between 0 and 31

GBookmarkFile lets you parse, edit or create files containing bookmarks to URI, along with some meta-data about the resource pointed by the URI like its MIME type, the application that is registering the bookmark and the icon that should be used to represent the bookmark. The data is stored using the [Desktop Bookmark Specification](http://www.gnome.org/~ebassi/bookmark-spec). The syntax of the bookmark files is described in detail inside the Desktop Bookmark Specification, here is a quick summary: bookmark files use a sub-class of the XML Bookmark Exchange Language specification, consisting of valid UTF-8 encoded XML, under the <xbel> root element; each bookmark is stored inside a <bookmark> element, using its URI: no relative paths can be used inside a bookmark file. The bookmark may have a user defined title and description, to be used instead of the URI. Under the <metadata> element, with its owner attribute set to `http://freedesktop.org`, is stored the meta-data about a resource pointed by its URI. The meta-data consists of the resource's MIME type; the applications that have registered a bookmark; the groups to which a bookmark belongs to; a visibility flag, used to set the bookmark as "private" to the applications and groups that has it registered; the URI and MIME type of an icon, to be used when displaying the bookmark inside a GUI. Here is an example of a bookmark file: [bookmarks.xbel](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/glib/tests/bookmarks.xbel) A bookmark file might contain more than one bookmark; each bookmark is accessed through its URI. The important caveat of bookmark files is that when you add a new bookmark you must also add the application that is registering it, using g_bookmark_file_add_application() or g_bookmark_file_set_application_info(). If a bookmark has no applications then it won't be dumped when creating the on disk representation, using g_bookmark_file_to_data() or g_bookmark_file_to_file(). The #GBookmarkFile parser was added in GLib 2.12. Creates a filename from a series of elements using the correct separator for filenames. On Unix, this function behaves identically to `g_build_path (G_DIR_SEPARATOR_S, first_element, ....)`. On Windows, it takes into account that either the backslash (`\` or slash (`/`) can be used as separator in filenames, but otherwise behaves as on UNIX. When file pathname separators need to be inserted, the one that last previously occurred in the parameters (reading from left to right) is used. No attempt is made to force the resulting filename to be an absolute path. If the first element is a relative path, the result will be a relative path.

a newly-allocated string that must be freed with g_free().

the first element in the path remaining elements in path, terminated by %NULL

Behaves exactly like g_build_filename(), but takes the path elements as a va_list. This function is mainly meant for language bindings.

a newly-allocated string that must be freed with g_free().

the first element in the path va_list of remaining elements in path

Behaves exactly like g_build_filename(), but takes the path elements as a string array, instead of varargs. This function is mainly meant for language bindings.

a newly-allocated string that must be freed with g_free().

%NULL-terminated array of strings containing the path elements.

Creates a path from a series of elements using @separator as the separator between elements. At the boundary between two elements, any trailing occurrences of separator in the first element, or leading occurrences of separator in the second element are removed and exactly one copy of the separator is inserted. Empty elements are ignored. The number of leading copies of the separator on the result is the same as the number of leading copies of the separator on the first non-empty element. The number of trailing copies of the separator on the result is the same as the number of trailing copies of the separator on the last non-empty element. (Determination of the number of trailing copies is done without stripping leading copies, so if the separator is `ABA`, then `ABABA` has 1 trailing copy.) However, if there is only a single non-empty element, and there are no characters in that element not part of the leading or trailing separators, then the result is exactly the original value of that element. Other than for determination of the number of leading and trailing copies of the separator, elements consisting only of copies of the separator are ignored.

a newly-allocated string that must be freed with g_free().

a string used to separator the elements of the path. the first element in the path remaining elements in path, terminated by %NULL

Behaves exactly like g_build_path(), but takes the path elements as a string array, instead of varargs. This function is mainly meant for language bindings.

a newly-allocated string that must be freed with g_free().

a string used to separator the elements of the path. %NULL-terminated array of strings containing the path elements.

the element data if @free_segment is %FALSE, otherwise %NULL. The element data should be freed using g_free().

a #GByteArray if %TRUE the actual byte data is freed as well

a new immutable #GBytes representing same byte data that was in the array

a #GByteArray

Creates a new #GByteArray with a reference count of 1.

the new #GByteArray

a new #GByteArray

byte data for the array length of @data

Frees the data in the array and resets the size to zero, while the underlying array is preserved for use elsewhere and returned to the caller.

the element data, which should be freed using g_free().

a #GByteArray. pointer to retrieve the number of elements of the original array

A #GByteArray

These macros provide a portable way to determine the host byte order and to convert values between different byte orders. The byte order is the order in which bytes are stored to create larger data types such as the #gint and #glong values. The host byte order is the byte order used on the current machine. Some processors store the most significant bytes (i.e. the bytes that hold the largest part of the value) first. These are known as big-endian processors. Other processors (notably the x86 family) store the most significant byte last. These are known as little-endian processors. Finally, to complicate matters, some other processors store the bytes in a rather curious order known as PDP-endian. For a 4-byte word, the 3rd most significant byte is stored first, then the 4th, then the 1st and finally the 2nd. Obviously there is a problem when these different processors communicate with each other, for example over networks or by using binary file formats. This is where these macros come in. They are typically used to convert values into a byte order which has been agreed on for use when communicating between different processors. The Internet uses what is known as 'network byte order' as the standard byte order (which is in fact the big-endian byte order). Note that the byte order conversion macros may evaluate their arguments multiple times, thus you should not use them with arguments which have side-effects. Gets the canonical file name from @filename. All triple slashes are turned into single slashes, and all `..` and `.`s resolved against @relative_to. Symlinks are not followed, and the returned path is guaranteed to be absolute. If @filename is an absolute path, @relative_to is ignored. Otherwise, @relative_to will be prepended to @filename to make it absolute. @relative_to must be an absolute path, or %NULL. If @relative_to is %NULL, it'll fallback to g_get_current_dir(). This function never fails, and will canonicalize file paths even if they don't exist. No file system I/O is done.

a newly allocated string with the canonical file path

the name of the file the relative directory, or %NULL to use the current working directory

A wrapper for the POSIX chdir() function. The function changes the current directory of the process to @path. See your C library manual for more details about chdir().

0 on success, -1 if an error occurred.

a pathname in the GLib file name encoding (UTF-8 on Windows)

Checks that the GLib library in use is compatible with the given version. Generally you would pass in the constants %GLIB_MAJOR_VERSION, %GLIB_MINOR_VERSION, %GLIB_MICRO_VERSION as the three arguments to this function; that produces a check that the library in use is compatible with the version of GLib the application or module was compiled against. Compatibility is defined by two things: first the version of the running library is newer than the version `@required_major.required_minor.@required_micro`. Second the running library must be binary compatible with the version `@required_major.@required_minor.@required_micro` (same major version.)

%NULL if the GLib library is compatible with the given version, or a string describing the version mismatch. The returned string is owned by GLib and must not be modified or freed.

the required major version the required minor version the required micro version

GLib offers a set of macros for doing additions and multiplications of unsigned integers, with checks for overflows. The helpers all have three arguments. A pointer to the destination is always the first argument and the operands to the operation are the other two. Following standard GLib convention, the helpers return %TRUE in case of success (ie: no overflow). The helpers may be macros, normal functions or inlines. They may be implemented with inline assembly or compiler intrinsics where available. GLib provides a generic API for computing checksums (or "digests") for a sequence of arbitrary bytes, using various hashing algorithms like MD5, SHA-1 and SHA-256. Checksums are commonly used in various environments and specifications. GLib supports incremental checksums using the GChecksum data structure, by calling g_checksum_update() as long as there's data available and then using g_checksum_get_string() or g_checksum_get_digest() to compute the checksum and return it either as a string in hexadecimal form, or as a raw sequence of bytes. To compute the checksum for binary blobs and NUL-terminated strings in one go, use the convenience functions g_compute_checksum_for_data() and g_compute_checksum_for_string(), respectively. Support for checksums has been added in GLib 2.16 Gets the length in bytes of digests of type @checksum_type

the checksum length, or -1 if @checksum_type is not supported.

a #GChecksumType

Sets a function to be called when the child indicated by @pid exits, at a default priority, %G_PRIORITY_DEFAULT. If you obtain @pid from g_spawn_async() or g_spawn_async_with_pipes() you will need to pass %G_SPAWN_DO_NOT_REAP_CHILD as flag to the spawn function for the child watching to work. Note that on platforms where #GPid must be explicitly closed (see g_spawn_close_pid()) @pid must not be closed while the source is still active. Typically, you will want to call g_spawn_close_pid() in the callback function for the source. GLib supports only a single callback per process id. On POSIX platforms, the same restrictions mentioned for g_child_watch_source_new() apply to this function. This internally creates a main loop source using g_child_watch_source_new() and attaches it to the main loop context using g_source_attach(). You can do these steps manually if you need greater control.

the ID (greater than 0) of the event source.

process id to watch. On POSIX the positive pid of a child process. On Windows a handle for a process (which doesn't have to be a child). function to call data to pass to @function

Sets a function to be called when the child indicated by @pid exits, at the priority @priority. If you obtain @pid from g_spawn_async() or g_spawn_async_with_pipes() you will need to pass %G_SPAWN_DO_NOT_REAP_CHILD as flag to the spawn function for the child watching to work. In many programs, you will want to call g_spawn_check_wait_status() in the callback to determine whether or not the child exited successfully. Also, note that on platforms where #GPid must be explicitly closed (see g_spawn_close_pid()) @pid must not be closed while the source is still active. Typically, you should invoke g_spawn_close_pid() in the callback function for the source. GLib supports only a single callback per process id. On POSIX platforms, the same restrictions mentioned for g_child_watch_source_new() apply to this function. This internally creates a main loop source using g_child_watch_source_new() and attaches it to the main loop context using g_source_attach(). You can do these steps manually if you need greater control.

the ID (greater than 0) of the event source.

the priority of the idle source. Typically this will be in the range between %G_PRIORITY_DEFAULT_IDLE and %G_PRIORITY_HIGH_IDLE. process to watch. On POSIX the positive pid of a child process. On Windows a handle for a process (which doesn't have to be a child). function to call data to pass to @function function to call when the idle is removed, or %NULL

Creates a new child_watch source. The source will not initially be associated with any #GMainContext and must be added to one with g_source_attach() before it will be executed. Note that child watch sources can only be used in conjunction with `g_spawn...` when the %G_SPAWN_DO_NOT_REAP_CHILD flag is used. Note that on platforms where #GPid must be explicitly closed (see g_spawn_close_pid()) @pid must not be closed while the source is still active. Typically, you will want to call g_spawn_close_pid() in the callback function for the source. On POSIX platforms, the following restrictions apply to this API due to limitations in POSIX process interfaces: * @pid must be a child of this process * @pid must be positive * the application must not call `waitpid` with a non-positive first argument, for instance in another thread * the application must not wait for @pid to exit by any other mechanism, including `waitpid(pid, ...)` or a second child-watch source for the same @pid * the application must not ignore `SIGCHLD` If any of those conditions are not met, this and related APIs will not work correctly. This can often be diagnosed via a GLib warning stating that `ECHILD` was received by `waitpid`. Calling `waitpid` for specific processes other than @pid remains a valid thing to do.

the newly-created child watch source

process to watch. On POSIX the positive pid of a child process. On Windows a handle for a process (which doesn't have to be a child).

If @err or *@err is %NULL, does nothing. Otherwise, calls g_error_free() on *@err and sets *@err to %NULL.

Clears a numeric handler, such as a #GSource ID. @tag_ptr must be a valid pointer to the variable holding the handler. If the ID is zero then this function does nothing. Otherwise, clear_func() is called with the ID as a parameter, and the tag is set to zero. A macro is also included that allows this function to be used without pointer casts.

a pointer to the handler ID the function to call to clear the handler

Clears a pointer to a #GList, freeing it and, optionally, freeing its elements using @destroy. @list_ptr must be a valid pointer. If @list_ptr points to a null #GList, this does nothing.

a #GList return location the function to pass to g_list_free_full() or %NULL to not free elements

Clears a reference to a variable. @pp must not be %NULL. If the reference is %NULL then this function does nothing. Otherwise, the variable is destroyed using @destroy and the pointer is set to %NULL. A macro is also included that allows this function to be used without pointer casts. This will mask any warnings about incompatible function types or calling conventions, so you must ensure that your @destroy function is compatible with being called as `GDestroyNotify` using the standard calling convention for the platform that GLib was compiled for; otherwise the program will experience undefined behaviour.

a pointer to a variable, struct member etc. holding a pointer a function to which a gpointer can be passed, to destroy *@pp

Clears a pointer to a #GSList, freeing it and, optionally, freeing its elements using @destroy. @slist_ptr must be a valid pointer. If @slist_ptr points to a null #GSList, this does nothing.

a #GSList return location the function to pass to g_slist_free_full() or %NULL to not free elements

This wraps the close() call. In case of error, %errno will be preserved, but the error will also be stored as a #GError in @error. In case of success, %errno is undefined. Besides using #GError, there is another major reason to prefer this function over the call provided by the system; on Unix, it will attempt to correctly handle %EINTR, which has platform-specific semantics. It is a bug to call this function with an invalid file descriptor. Since 2.76, this function is guaranteed to be async-signal-safe if (and only if) @error is %NULL and @fd is a valid open file descriptor.

%TRUE on success, %FALSE if there was an error.

A file descriptor

Computes the checksum for a binary @data. This is a convenience wrapper for g_checksum_new(), g_checksum_get_string() and g_checksum_free(). The hexadecimal string returned will be in lower case.

the digest of the binary data as a string in hexadecimal, or %NULL if g_checksum_new() fails for @checksum_type. The returned string should be freed with g_free() when done using it.

a #GChecksumType binary blob to compute the digest of

Computes the checksum for a binary @data of @length. This is a convenience wrapper for g_checksum_new(), g_checksum_get_string() and g_checksum_free(). The hexadecimal string returned will be in lower case.

the digest of the binary data as a string in hexadecimal, or %NULL if g_checksum_new() fails for @checksum_type. The returned string should be freed with g_free() when done using it.

a #GChecksumType binary blob to compute the digest of length of @data

Computes the checksum of a string. The hexadecimal string returned will be in lower case.

the checksum as a hexadecimal string, or %NULL if g_checksum_new() fails for @checksum_type. The returned string should be freed with g_free() when done using it.

a #GChecksumType the string to compute the checksum of the length of the string, or -1 if the string is null-terminated.

Computes the HMAC for a binary @data. This is a convenience wrapper for g_hmac_new(), g_hmac_get_string() and g_hmac_unref(). The hexadecimal string returned will be in lower case.

the HMAC of the binary data as a string in hexadecimal. The returned string should be freed with g_free() when done using it.

a #GChecksumType to use for the HMAC the key to use in the HMAC binary blob to compute the HMAC of

Computes the HMAC for a binary @data of @length. This is a convenience wrapper for g_hmac_new(), g_hmac_get_string() and g_hmac_unref(). The hexadecimal string returned will be in lower case.

the HMAC of the binary data as a string in hexadecimal. The returned string should be freed with g_free() when done using it.

a #GChecksumType to use for the HMAC the key to use in the HMAC the length of the key binary blob to compute the HMAC of length of @data

Computes the HMAC for a string. The hexadecimal string returned will be in lower case.

the HMAC as a hexadecimal string. The returned string should be freed with g_free() when done using it.

a #GChecksumType to use for the HMAC the key to use in the HMAC the length of the key the string to compute the HMAC for the length of the string, or -1 if the string is nul-terminated

The g_convert() family of function wraps the functionality of iconv(). In addition to pure character set conversions, GLib has functions to deal with the extra complications of encodings for file names. ## File Name Encodings Historically, UNIX has not had a defined encoding for file names: a file name is valid as long as it does not have path separators in it ("/"). However, displaying file names may require conversion: from the character set in which they were created, to the character set in which the application operates. Consider the Spanish file name "Presentación.sxi". If the application which created it uses ISO-8859-1 for its encoding, |[ Character: P r e s e n t a c i ó n . s x i Hex code: 50 72 65 73 65 6e 74 61 63 69 f3 6e 2e 73 78 69 ]| However, if the application use UTF-8, the actual file name on disk would look like this: |[ Character: P r e s e n t a c i ó n . s x i Hex code: 50 72 65 73 65 6e 74 61 63 69 c3 b3 6e 2e 73 78 69 ]| Glib uses UTF-8 for its strings, and GUI toolkits like GTK+ that use GLib do the same thing. If you get a file name from the file system, for example, from readdir() or from g_dir_read_name(), and you wish to display the file name to the user, you will need to convert it into UTF-8. The opposite case is when the user types the name of a file they wish to save: the toolkit will give you that string in UTF-8 encoding, and you will need to convert it to the character set used for file names before you can create the file with open() or fopen(). By default, GLib assumes that file names on disk are in UTF-8 encoding. This is a valid assumption for file systems which were created relatively recently: most applications use UTF-8 encoding for their strings, and that is also what they use for the file names they create. However, older file systems may still contain file names created in "older" encodings, such as ISO-8859-1. In this case, for compatibility reasons, you may want to instruct GLib to use that particular encoding for file names rather than UTF-8. You can do this by specifying the encoding for file names in the [`G_FILENAME_ENCODING`][G_FILENAME_ENCODING] environment variable. For example, if your installation uses ISO-8859-1 for file names, you can put this in your `~/.profile`: |[ export G_FILENAME_ENCODING=ISO-8859-1 ]| GLib provides the functions g_filename_to_utf8() and g_filename_from_utf8() to perform the necessary conversions. These functions convert file names from the encoding specified in `G_FILENAME_ENCODING` to UTF-8 and vice-versa. This [diagram][file-name-encodings-diagram] illustrates how these functions are used to convert between UTF-8 and the encoding for file names in the file system. ## Conversion between file name encodings # {#file-name-encodings-diagram) ![](file-name-encodings.png) ## Checklist for Application Writers This section is a practical summary of the detailed things to do to make sure your applications process file name encodings correctly. 1. If you get a file name from the file system from a function such as readdir() or gtk_file_chooser_get_filename(), you do not need to do any conversion to pass that file name to functions like open(), rename(), or fopen() -- those are "raw" file names which the file system understands. 2. If you need to display a file name, convert it to UTF-8 first by using g_filename_to_utf8(). If conversion fails, display a string like "Unknown file name". Do not convert this string back into the encoding used for file names if you wish to pass it to the file system; use the original file name instead. For example, the document window of a word processor could display "Unknown file name" in its title bar but still let the user save the file, as it would keep the raw file name internally. This can happen if the user has not set the `G_FILENAME_ENCODING` environment variable even though they have files whose names are not encoded in UTF-8. 3. If your user interface lets the user type a file name for saving or renaming, convert it to the encoding used for file names in the file system by using g_filename_from_utf8(). Pass the converted file name to functions like fopen(). If conversion fails, ask the user to enter a different file name. This can happen if the user types Japanese characters when `G_FILENAME_ENCODING` is set to `ISO-8859-1`, for example. Converts a string from one character set to another. Note that you should use g_iconv() for streaming conversions. Despite the fact that @bytes_read can return information about partial characters, the g_convert_... functions are not generally suitable for streaming. If the underlying converter maintains internal state, then this won't be preserved across successive calls to g_convert(), g_convert_with_iconv() or g_convert_with_fallback(). (An example of this is the GNU C converter for CP1255 which does not emit a base character until it knows that the next character is not a mark that could combine with the base character.) Using extensions such as "//TRANSLIT" may not work (or may not work well) on many platforms. Consider using g_str_to_ascii() instead.

If the conversion was successful, a newly allocated buffer containing the converted string, which must be freed with g_free(). Otherwise %NULL and @error will be set.

the string to convert. the length of the string in bytes, or -1 if the string is nul-terminated (Note that some encodings may allow nul bytes to occur inside strings. In that case, using -1 for the @len parameter is unsafe) name of character set into which to convert @str character set of @str. location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will be the byte offset after the last valid input sequence. the number of bytes stored in the output buffer (not including the terminating nul).

Converts a string from one character set to another, possibly including fallback sequences for characters not representable in the output. Note that it is not guaranteed that the specification for the fallback sequences in @fallback will be honored. Some systems may do an approximate conversion from @from_codeset to @to_codeset in their iconv() functions, in which case GLib will simply return that approximate conversion. Note that you should use g_iconv() for streaming conversions. Despite the fact that @bytes_read can return information about partial characters, the g_convert_... functions are not generally suitable for streaming. If the underlying converter maintains internal state, then this won't be preserved across successive calls to g_convert(), g_convert_with_iconv() or g_convert_with_fallback(). (An example of this is the GNU C converter for CP1255 which does not emit a base character until it knows that the next character is not a mark that could combine with the base character.)

If the conversion was successful, a newly allocated buffer containing the converted string, which must be freed with g_free(). Otherwise %NULL and @error will be set.

the string to convert. the length of the string in bytes, or -1 if the string is nul-terminated (Note that some encodings may allow nul bytes to occur inside strings. In that case, using -1 for the @len parameter is unsafe) name of character set into which to convert @str character set of @str. UTF-8 string to use in place of characters not present in the target encoding. (The string must be representable in the target encoding). If %NULL, characters not in the target encoding will be represented as Unicode escapes \uxxxx or \Uxxxxyyyy. location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. the number of bytes stored in the output buffer (not including the terminating nul).

Converts a string from one character set to another. Note that you should use g_iconv() for streaming conversions. Despite the fact that @bytes_read can return information about partial characters, the g_convert_... functions are not generally suitable for streaming. If the underlying converter maintains internal state, then this won't be preserved across successive calls to g_convert(), g_convert_with_iconv() or g_convert_with_fallback(). (An example of this is the GNU C converter for CP1255 which does not emit a base character until it knows that the next character is not a mark that could combine with the base character.) Characters which are valid in the input character set, but which have no representation in the output character set will result in a %G_CONVERT_ERROR_ILLEGAL_SEQUENCE error. This is in contrast to the iconv() specification, which leaves this behaviour implementation defined. Note that this is the same error code as is returned for an invalid byte sequence in the input character set. To get defined behaviour for conversion of unrepresentable characters, use g_convert_with_fallback().

If the conversion was successful, a newly allocated buffer containing the converted string, which must be freed with g_free(). Otherwise %NULL and @error will be set.

the string to convert. the length of the string in bytes, or -1 if the string is nul-terminated (Note that some encodings may allow nul bytes to occur inside strings. In that case, using -1 for the @len parameter is unsafe) conversion descriptor from g_iconv_open() location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will be the byte offset after the last valid input sequence. the number of bytes stored in the output buffer (not including the terminating nul).

Logs a "critical warning" (%G_LOG_LEVEL_CRITICAL). Critical warnings are intended to be used in the event of an error that originated in the current process (a programmer error). Logging of a critical error is by definition an indication of a bug somewhere in the current program (or its libraries). g_return_if_fail(), g_return_val_if_fail(), g_return_if_reached() and g_return_val_if_reached() log at %G_LOG_LEVEL_CRITICAL. You can make critical warnings fatal at runtime by setting the `G_DEBUG` environment variable (see [Running GLib Applications](glib-running.html)): |[ G_DEBUG=fatal-warnings gdb ./my-program ]| You can also use g_log_set_always_fatal(). Any unrelated failures can be skipped over in [gdb](https://www.gnu.org/software/gdb/) using the `continue` command. The message should typically *not* be translated to the user's language. If g_log_default_handler() is used as the log handler function, a new-line character will automatically be appended to @..., and need not be entered manually. If structured logging is enabled, this will use g_log_structured(); otherwise it will use g_log(). See [Using Structured Logging][using-structured-logging].

format string, followed by parameters to insert into the format string (as with printf())

Keyed data lists provide lists of arbitrary data elements which can be accessed either with a string or with a #GQuark corresponding to the string. The #GQuark methods are quicker, since the strings have to be converted to #GQuarks anyway. Data lists are used for associating arbitrary data with #GObjects, using g_object_set_data() and related functions. To create a datalist, use g_datalist_init(). To add data elements to a datalist use g_datalist_id_set_data(), g_datalist_id_set_data_full(), g_datalist_set_data() and g_datalist_set_data_full(). To get data elements from a datalist use g_datalist_id_get_data() and g_datalist_get_data(). To iterate over all data elements in a datalist use g_datalist_foreach() (not thread-safe). To remove data elements from a datalist use g_datalist_id_remove_data() and g_datalist_remove_data(). To remove all data elements from a datalist, use g_datalist_clear(). Frees all the data elements of the datalist. The data elements' destroy functions are called if they have been set.

a datalist.

Calls the given function for each data element of the datalist. The function is called with each data element's #GQuark id and data, together with the given @user_data parameter. Note that this function is NOT thread-safe. So unless @datalist can be protected from any modifications during invocation of this function, it should not be called. @func can make changes to @datalist, but the iteration will not reflect changes made during the g_datalist_foreach() call, other than skipping over elements that are removed.

a datalist. the function to call for each data element. user data to pass to the function.

Gets a data element, using its string identifier. This is slower than g_datalist_id_get_data() because it compares strings.

the data element, or %NULL if it is not found.

a datalist. the string identifying a data element.

Gets flags values packed in together with the datalist. See g_datalist_set_flags().

the flags of the datalist

pointer to the location that holds a list

This is a variant of g_datalist_id_get_data() which returns a 'duplicate' of the value. @dup_func defines the meaning of 'duplicate' in this context, it could e.g. take a reference on a ref-counted object. If the @key_id is not set in the datalist then @dup_func will be called with a %NULL argument. Note that @dup_func is called while the datalist is locked, so it is not allowed to read or modify the datalist. This function can be useful to avoid races when multiple threads are using the same datalist and the same key.

the result of calling @dup_func on the value associated with @key_id in @datalist, or %NULL if not set. If @dup_func is %NULL, the value is returned unmodified.

location of a datalist the #GQuark identifying a data element function to duplicate the old value passed as user_data to @dup_func

Retrieves the data element corresponding to @key_id.

the data element, or %NULL if it is not found.

a datalist. the #GQuark identifying a data element.

Removes an element, using its #GQuark identifier.

a datalist. the #GQuark identifying the data element.

Removes multiple keys from a datalist. This is more efficient than calling g_datalist_id_remove_data() multiple times in a row.

a datalist keys to remove length of @keys, must be <= 16

Removes an element, without calling its destroy notification function.

the data previously stored at @key_id, or %NULL if none.

a datalist. the #GQuark identifying a data element.

Compares the member that is associated with @key_id in @datalist to @oldval, and if they are the same, replace @oldval with @newval. This is like a typical atomic compare-and-exchange operation, for a member of @datalist. If the previous value was replaced then ownership of the old value (@oldval) is passed to the caller, including the registered destroy notify for it (passed out in @old_destroy). Its up to the caller to free this as they wish, which may or may not include using @old_destroy as sometimes replacement should not destroy the object in the normal way.

%TRUE if the existing value for @key_id was replaced by @newval, %FALSE otherwise.

location of a datalist the #GQuark identifying a data element the old value to compare against the new value to replace it with destroy notify for the new value destroy notify for the existing value

Sets the data corresponding to the given #GQuark id. Any previous data with the same key is removed, and its destroy function is called.

a datalist. the #GQuark to identify the data element. the data element, or %NULL to remove any previous element corresponding to @q.

Sets the data corresponding to the given #GQuark id, and the function to be called when the element is removed from the datalist. Any previous data with the same key is removed, and its destroy function is called.

a datalist. the #GQuark to identify the data element. the data element or %NULL to remove any previous element corresponding to @key_id. the function to call when the data element is removed. This function will be called with the data element and can be used to free any memory allocated for it. If @data is %NULL, then @destroy_func must also be %NULL.

Resets the datalist to %NULL. It does not free any memory or call any destroy functions.

a pointer to a pointer to a datalist.

Removes an element using its string identifier. The data element's destroy function is called if it has been set.

a datalist. the string identifying the data element.

Removes an element, without calling its destroy notifier.

a datalist. the string identifying the data element.

Sets the data element corresponding to the given string identifier.

a datalist. the string to identify the data element. the data element, or %NULL to remove any previous element corresponding to @k.

Sets the data element corresponding to the given string identifier, and the function to be called when the data element is removed.

a datalist. the string to identify the data element. the data element, or %NULL to remove any previous element corresponding to @k. the function to call when the data element is removed. This function will be called with the data element and can be used to free any memory allocated for it. If @d is %NULL, then @f must also be %NULL.

Turns on flag values for a data list. This function is used to keep a small number of boolean flags in an object with a data list without using any additional space. It is not generally useful except in circumstances where space is very tight. (It is used in the base #GObject type, for example.)

pointer to the location that holds a list the flags to turn on. The values of the flags are restricted by %G_DATALIST_FLAGS_MASK (currently 3; giving two possible boolean flags). A value for @flags that doesn't fit within the mask is an error.

Turns off flag values for a data list. See g_datalist_unset_flags()

pointer to the location that holds a list the flags to turn off. The values of the flags are restricted by %G_DATALIST_FLAGS_MASK (currently 3: giving two possible boolean flags). A value for @flags that doesn't fit within the mask is an error.

Destroys the dataset, freeing all memory allocated, and calling any destroy functions set for data elements.

the location identifying the dataset.

Calls the given function for each data element which is associated with the given location. Note that this function is NOT thread-safe. So unless @dataset_location can be protected from any modifications during invocation of this function, it should not be called. @func can make changes to the dataset, but the iteration will not reflect changes made during the g_dataset_foreach() call, other than skipping over elements that are removed.

the location identifying the dataset. the function to call for each data element. user data to pass to the function.

Gets the data element corresponding to a string.

the location identifying the dataset. the string identifying the data element.

Gets the data element corresponding to a #GQuark.

the data element corresponding to the #GQuark, or %NULL if it is not found.

the location identifying the dataset. the #GQuark id to identify the data element.

Removes a data element from a dataset. The data element's destroy function is called if it has been set.

the location identifying the dataset. the #GQuark id identifying the data element.

Removes an element, without calling its destroy notification function.

the data previously stored at @key_id, or %NULL if none.

the location identifying the dataset. the #GQuark ID identifying the data element.

Sets the data element associated with the given #GQuark id. Any previous data with the same key is removed, and its destroy function is called.

the location identifying the dataset. the #GQuark id to identify the data element. the data element.

Sets the data element associated with the given #GQuark id, and also the function to call when the data element is destroyed. Any previous data with the same key is removed, and its destroy function is called.

the location identifying the dataset. the #GQuark id to identify the data element. the data element. the function to call when the data element is removed. This function will be called with the data element and can be used to free any memory allocated for it.

Removes a data element corresponding to a string. Its destroy function is called if it has been set.

the location identifying the dataset. the string identifying the data element.

Removes an element, without calling its destroy notifier.

the location identifying the dataset. the string identifying the data element.

Sets the data corresponding to the given string identifier.

the location identifying the dataset. the string to identify the data element. the data element.

Sets the data corresponding to the given string identifier, and the function to call when the data element is destroyed.

the location identifying the dataset. the string to identify the data element. the data element. the function to call when the data element is removed. This function will be called with the data element and can be used to free any memory allocated for it.

Datasets associate groups of data elements with particular memory locations. These are useful if you need to associate data with a structure returned from an external library. Since you cannot modify the structure, you use its location in memory as the key into a dataset, where you can associate any number of data elements with it. There are two forms of most of the dataset functions. The first form uses strings to identify the data elements associated with a location. The second form uses #GQuark identifiers, which are created with a call to g_quark_from_string() or g_quark_from_static_string(). The second form is quicker, since it does not require looking up the string in the hash table of #GQuark identifiers. There is no function to create a dataset. It is automatically created as soon as you add elements to it. To add data elements to a dataset use g_dataset_id_set_data(), g_dataset_id_set_data_full(), g_dataset_set_data() and g_dataset_set_data_full(). To get data elements from a dataset use g_dataset_id_get_data() and g_dataset_get_data(). To iterate over all data elements in a dataset use g_dataset_foreach() (not thread-safe). To remove data elements from a dataset use g_dataset_id_remove_data() and g_dataset_remove_data(). To destroy a dataset, use g_dataset_destroy(). The #GDate data structure represents a day between January 1, Year 1, and sometime a few thousand years in the future (right now it will go to the year 65535 or so, but g_date_set_parse() only parses up to the year 8000 or so - just count on "a few thousand"). #GDate is meant to represent everyday dates, not astronomical dates or historical dates or ISO timestamps or the like. It extrapolates the current Gregorian calendar forward and backward in time; there is no attempt to change the calendar to match time periods or locations. #GDate does not store time information; it represents a day. The #GDate implementation has several nice features; it is only a 64-bit struct, so storing large numbers of dates is very efficient. It can keep both a Julian and day-month-year representation of the date, since some calculations are much easier with one representation or the other. A Julian representation is simply a count of days since some fixed day in the past; for #GDate the fixed day is January 1, 1 AD. ("Julian" dates in the #GDate API aren't really Julian dates in the technical sense; technically, Julian dates count from the start of the Julian period, Jan 1, 4713 BC). #GDate is simple to use. First you need a "blank" date; you can get a dynamically allocated date from g_date_new(), or you can declare an automatic variable or array and initialize it by calling g_date_clear(). A cleared date is safe; it's safe to call g_date_set_dmy() and the other mutator functions to initialize the value of a cleared date. However, a cleared date is initially invalid, meaning that it doesn't represent a day that exists. It is undefined to call any of the date calculation routines on an invalid date. If you obtain a date from a user or other unpredictable source, you should check its validity with the g_date_valid() predicate. g_date_valid() is also used to check for errors with g_date_set_parse() and other functions that can fail. Dates can be invalidated by calling g_date_clear() again. It is very important to use the API to access the #GDate struct. Often only the day-month-year or only the Julian representation is valid. Sometimes neither is valid. Use the API. GLib also features #GDateTime which represents a precise time. #GDateTime is a structure that combines a Gregorian date and time into a single structure. It provides many conversion and methods to manipulate dates and times. Time precision is provided down to microseconds and the time can range (proleptically) from 0001-01-01 00:00:00 to 9999-12-31 23:59:59.999999. #GDateTime follows POSIX time in the sense that it is oblivious to leap seconds. #GDateTime is an immutable object; once it has been created it cannot be modified further. All modifiers will create a new #GDateTime. Nearly all such functions can fail due to the date or time going out of range, in which case %NULL will be returned. #GDateTime is reference counted: the reference count is increased by calling g_date_time_ref() and decreased by calling g_date_time_unref(). When the reference count drops to 0, the resources allocated by the #GDateTime structure are released. Many parts of the API may produce non-obvious results. As an example, adding two months to January 31st will yield March 31st whereas adding one month and then one month again will yield either March 28th or March 29th. Also note that adding 24 hours is not always the same as adding one day (since days containing daylight savings time transitions are either 23 or 25 hours in length). #GDateTime is available since GLib 2.26. Returns the number of days in a month, taking leap years into account.

number of days in @month during the @year

month year

number of Mondays in the year

a year

the number of weeks in @year

year to count weeks in

%TRUE if the year is a leap year

year to check

number of characters written to the buffer, or 0 the buffer was too small

destination buffer buffer size format string valid #GDate

Returns %TRUE if the day of the month is valid (a day is valid if it's between 1 and 31 inclusive).

%TRUE if the day is valid

day to check

Returns %TRUE if the day-month-year triplet forms a valid, existing day in the range of days #GDate understands (Year 1 or later, no more than a few thousand years in the future).

%TRUE if the date is a valid one

day month year

Returns %TRUE if the Julian day is valid. Anything greater than zero is basically a valid Julian, though there is a 32-bit limit.

%TRUE if the Julian day is valid

Julian day to check

Returns %TRUE if the month value is valid. The 12 #GDateMonth enumeration values are the only valid months.

%TRUE if the month is valid

month

Returns %TRUE if the weekday is valid. The seven #GDateWeekday enumeration values are the only valid weekdays.

%TRUE if the weekday is valid

weekday

Returns %TRUE if the year is valid. Any year greater than 0 is valid, though there is a 16-bit limit to what #GDate will understand.

%TRUE if the year is valid

year

This is a variant of g_dgettext() that allows specifying a locale category instead of always using `LC_MESSAGES`. See g_dgettext() for more information about how this functions differs from calling dcgettext() directly.

the translated string for the given locale category

the translation domain to use, or %NULL to use the domain set with textdomain() message to translate a locale category

A convenience function/macro to log a debug message. The message should typically *not* be translated to the user's language. If g_log_default_handler() is used as the log handler function, a new-line character will automatically be appended to @..., and need not be entered manually. Such messages are suppressed by the g_log_default_handler() and g_log_writer_default() unless the `G_MESSAGES_DEBUG` environment variable is set appropriately. If structured logging is enabled, this will use g_log_structured(); otherwise it will use g_log(). See [Using Structured Logging][using-structured-logging].

format string, followed by parameters to insert into the format string (as with printf())

This function is a wrapper of dgettext() which does not translate the message if the default domain as set with textdomain() has no translations for the current locale. The advantage of using this function over dgettext() proper is that libraries using this function (like GTK+) will not use translations if the application using the library does not have translations for the current locale. This results in a consistent English-only interface instead of one having partial translations. For this feature to work, the call to textdomain() and setlocale() should precede any g_dgettext() invocations. For GTK+, it means calling textdomain() before gtk_init or its variants. This function disables translations if and only if upon its first call all the following conditions hold: - @domain is not %NULL - textdomain() has been called to set a default text domain - there is no translations available for the default text domain and the current locale - current locale is not "C" or any English locales (those starting with "en_") Note that this behavior may not be desired for example if an application has its untranslated messages in a language other than English. In those cases the application should call textdomain() after initializing GTK+. Applications should normally not use this function directly, but use the _() macro for translations.

The translated string

the translation domain to use, or %NULL to use the domain set with textdomain() message to translate

The actual name used. This string should be freed with g_free() when not needed any longer and is is in the GLib file name encoding. In case of errors, %NULL is returned and @error will be set.

Template for directory name, as in g_mkdtemp(), basename only, or %NULL for a default template

Compares two #gpointer arguments and returns %TRUE if they are equal. It can be passed to g_hash_table_new() as the @key_equal_func parameter, when using opaque pointers compared by pointer value as keys in a #GHashTable. This equality function is also appropriate for keys that are integers stored in pointers, such as `GINT_TO_POINTER (n)`.

%TRUE if the two keys match.

a key a key to compare with @v1

Converts a gpointer to a hash value. It can be passed to g_hash_table_new() as the @hash_func parameter, when using opaque pointers compared by pointer value as keys in a #GHashTable. This hash function is also appropriate for keys that are integers stored in pointers, such as `GINT_TO_POINTER (n)`.

a hash value corresponding to the key.

a #gpointer key

This function is a wrapper of dngettext() which does not translate the message if the default domain as set with textdomain() has no translations for the current locale. See g_dgettext() for details of how this differs from dngettext() proper.

The translated string

the translation domain to use, or %NULL to use the domain set with textdomain() message to translate plural form of the message the quantity for which translation is needed

Compares the two #gdouble values being pointed to and returns %TRUE if they are equal. It can be passed to g_hash_table_new() as the @key_equal_func parameter, when using non-%NULL pointers to doubles as keys in a #GHashTable.

%TRUE if the two keys match.

a pointer to a #gdouble key a pointer to a #gdouble key to compare with @v1

Converts a pointer to a #gdouble to a hash value. It can be passed to g_hash_table_new() as the @hash_func parameter, It can be passed to g_hash_table_new() as the @hash_func parameter, when using non-%NULL pointers to doubles as keys in a #GHashTable.

a hash value corresponding to the key.

a pointer to a #gdouble key

This function is a variant of g_dgettext() which supports a disambiguating message context. GNU gettext uses the '\004' character to separate the message context and message id in @msgctxtid. If 0 is passed as @msgidoffset, this function will fall back to trying to use the deprecated convention of using "|" as a separation character. This uses g_dgettext() internally. See that functions for differences with dgettext() proper. Applications should normally not use this function directly, but use the C_() macro for translations with context.

The translated string

the translation domain to use, or %NULL to use the domain set with textdomain() a combined message context and message id, separated by a \004 character the offset of the message id in @msgctxid

This function is a variant of g_dgettext() which supports a disambiguating message context. GNU gettext uses the '\004' character to separate the message context and message id in @msgctxtid. This uses g_dgettext() internally. See that functions for differences with dgettext() proper. This function differs from C_() in that it is not a macro and thus you may use non-string-literals as context and msgid arguments.

The translated string

the translation domain to use, or %NULL to use the domain set with textdomain() the message context the message

Returns the value of the environment variable @variable in the provided list @envp.

the value of the environment variable, or %NULL if the environment variable is not set in @envp. The returned string is owned by @envp, and will be freed if @variable is set or unset again.

an environment list (eg, as returned from g_get_environ()), or %NULL for an empty environment list the environment variable to get

Sets the environment variable @variable in the provided list @envp to @value.

the updated environment list. Free it using g_strfreev().

an environment list that can be freed using g_strfreev() (e.g., as returned from g_get_environ()), or %NULL for an empty environment list the environment variable to set, must not contain '=' the value for to set the variable to whether to change the variable if it already exists

Removes the environment variable @variable from the provided environment @envp.

the updated environment list. Free it using g_strfreev().

an environment list that can be freed using g_strfreev() (e.g., as returned from g_get_environ()), or %NULL for an empty environment list the environment variable to remove, must not contain '='

A convenience function/macro to log an error message. The message should typically *not* be translated to the user's language. This is not intended for end user error reporting. Use of #GError is preferred for that instead, as it allows calling functions to perform actions conditional on the type of error. Error messages are always fatal, resulting in a call to G_BREAKPOINT() to terminate the application. This function will result in a core dump; don't use it for errors you expect. Using this function indicates a bug in your program, i.e. an assertion failure. If g_log_default_handler() is used as the log handler function, a new-line character will automatically be appended to @..., and need not be entered manually. If structured logging is enabled, this will use g_log_structured(); otherwise it will use g_log(). See [Using Structured Logging][using-structured-logging].

format string, followed by parameters to insert into the format string (as with printf())

GLib provides a standard method of reporting errors from a called function to the calling code. (This is the same problem solved by exceptions in other languages.) It's important to understand that this method is both a data type (the #GError struct) and a [set of rules][gerror-rules]. If you use #GError incorrectly, then your code will not properly interoperate with other code that uses #GError, and users of your API will probably get confused. In most cases, [using #GError is preferred over numeric error codes][gerror-comparison], but there are situations where numeric error codes are useful for performance. First and foremost: #GError should only be used to report recoverable runtime errors, never to report programming errors. If the programmer has screwed up, then you should use g_warning(), g_return_if_fail(), g_assert(), g_error(), or some similar facility. (Incidentally, remember that the g_error() function should only be used for programming errors, it should not be used to print any error reportable via #GError.) Examples of recoverable runtime errors are "file not found" or "failed to parse input." Examples of programming errors are "NULL passed to strcmp()" or "attempted to free the same pointer twice." These two kinds of errors are fundamentally different: runtime errors should be handled or reported to the user, programming errors should be eliminated by fixing the bug in the program. This is why most functions in GLib and GTK+ do not use the #GError facility. Functions that can fail take a return location for a #GError as their last argument. On error, a new #GError instance will be allocated and returned to the caller via this argument. For example: |[ gboolean g_file_get_contents (const gchar *filename, gchar **contents, gsize *length, GError **error); ]| If you pass a non-%NULL value for the `error` argument, it should point to a location where an error can be placed. For example: |[ gchar *contents; GError *err = NULL; g_file_get_contents ("foo.txt", &contents, NULL, &err); g_assert ((contents == NULL && err != NULL) || (contents != NULL && err == NULL)); if (err != NULL) { // Report error to user, and free error g_assert (contents == NULL); fprintf (stderr, "Unable to read file: %s\n", err->message); g_error_free (err); } else { // Use file contents g_assert (contents != NULL); } ]| Note that `err != NULL` in this example is a reliable indicator of whether g_file_get_contents() failed. Additionally, g_file_get_contents() returns a boolean which indicates whether it was successful. Because g_file_get_contents() returns %FALSE on failure, if you are only interested in whether it failed and don't need to display an error message, you can pass %NULL for the @error argument: |[ if (g_file_get_contents ("foo.txt", &contents, NULL, NULL)) // ignore errors // no error occurred ; else // error ; ]| The #GError object contains three fields: @domain indicates the module the error-reporting function is located in, @code indicates the specific error that occurred, and @message is a user-readable error message with as many details as possible. Several functions are provided to deal with an error received from a called function: g_error_matches() returns %TRUE if the error matches a given domain and code, g_propagate_error() copies an error into an error location (so the calling function will receive it), and g_clear_error() clears an error location by freeing the error and resetting the location to %NULL. To display an error to the user, simply display the @message, perhaps along with additional context known only to the calling function (the file being opened, or whatever - though in the g_file_get_contents() case, the @message already contains a filename). Since error messages may be displayed to the user, they need to be valid UTF-8 (all GTK widgets expect text to be UTF-8). Keep this in mind in particular when formatting error messages with filenames, which are in the 'filename encoding', and need to be turned into UTF-8 using g_filename_to_utf8(), g_filename_display_name() or g_utf8_make_valid(). Note, however, that many error messages are too technical to display to the user in an application, so prefer to use g_error_matches() to categorize errors from called functions, and build an appropriate error message for the context within your application. Error messages from a #GError are more appropriate to be printed in system logs or on the command line. They are typically translated. When implementing a function that can report errors, the basic tool is g_set_error(). Typically, if a fatal error occurs you want to g_set_error(), then return immediately. g_set_error() does nothing if the error location passed to it is %NULL. Here's an example: |[ gint foo_open_file (GError **error) { gint fd; int saved_errno; g_return_val_if_fail (error == NULL || *error == NULL, -1); fd = open ("file.txt", O_RDONLY); saved_errno = errno; if (fd < 0) { g_set_error (error, FOO_ERROR, // error domain FOO_ERROR_BLAH, // error code "Failed to open file: %s", // error message format string g_strerror (saved_errno)); return -1; } else return fd; } ]| Things are somewhat more complicated if you yourself call another function that can report a #GError. If the sub-function indicates fatal errors in some way other than reporting a #GError, such as by returning %TRUE on success, you can simply do the following: |[ gboolean my_function_that_can_fail (GError **err) { g_return_val_if_fail (err == NULL || *err == NULL, FALSE); if (!sub_function_that_can_fail (err)) { // assert that error was set by the sub-function g_assert (err == NULL || *err != NULL); return FALSE; } // otherwise continue, no error occurred g_assert (err == NULL || *err == NULL); } ]| If the sub-function does not indicate errors other than by reporting a #GError (or if its return value does not reliably indicate errors) you need to create a temporary #GError since the passed-in one may be %NULL. g_propagate_error() is intended for use in this case. |[ gboolean my_function_that_can_fail (GError **err) { GError *tmp_error; g_return_val_if_fail (err == NULL || *err == NULL, FALSE); tmp_error = NULL; sub_function_that_can_fail (&tmp_error); if (tmp_error != NULL) { // store tmp_error in err, if err != NULL, // otherwise call g_error_free() on tmp_error g_propagate_error (err, tmp_error); return FALSE; } // otherwise continue, no error occurred } ]| Error pileups are always a bug. For example, this code is incorrect: |[ gboolean my_function_that_can_fail (GError **err) { GError *tmp_error; g_return_val_if_fail (err == NULL || *err == NULL, FALSE); tmp_error = NULL; sub_function_that_can_fail (&tmp_error); other_function_that_can_fail (&tmp_error); if (tmp_error != NULL) { g_propagate_error (err, tmp_error); return FALSE; } } ]| @tmp_error should be checked immediately after sub_function_that_can_fail(), and either cleared or propagated upward. The rule is: after each error, you must either handle the error, or return it to the calling function. Note that passing %NULL for the error location is the equivalent of handling an error by always doing nothing about it. So the following code is fine, assuming errors in sub_function_that_can_fail() are not fatal to my_function_that_can_fail(): |[ gboolean my_function_that_can_fail (GError **err) { GError *tmp_error; g_return_val_if_fail (err == NULL || *err == NULL, FALSE); sub_function_that_can_fail (NULL); // ignore errors tmp_error = NULL; other_function_that_can_fail (&tmp_error); if (tmp_error != NULL) { g_propagate_error (err, tmp_error); return FALSE; } } ]| Note that passing %NULL for the error location ignores errors; it's equivalent to `try { sub_function_that_can_fail (); } catch (...) {}` in C++. It does not mean to leave errors unhandled; it means to handle them by doing nothing. Error domains and codes are conventionally named as follows: - The error domain is called <NAMESPACE>_<MODULE>_ERROR, for example %G_SPAWN_ERROR or %G_THREAD_ERROR: |[ #define G_SPAWN_ERROR g_spawn_error_quark () G_DEFINE_QUARK (g-spawn-error-quark, g_spawn_error) ]| - The quark function for the error domain is called <namespace>_<module>_error_quark, for example g_spawn_error_quark() or g_thread_error_quark(). - The error codes are in an enumeration called <Namespace><Module>Error; for example, #GThreadError or #GSpawnError. - Members of the error code enumeration are called <NAMESPACE>_<MODULE>_ERROR_<CODE>, for example %G_SPAWN_ERROR_FORK or %G_THREAD_ERROR_AGAIN. - If there's a "generic" or "unknown" error code for unrecoverable errors it doesn't make sense to distinguish with specific codes, it should be called <NAMESPACE>_<MODULE>_ERROR_FAILED, for example %G_SPAWN_ERROR_FAILED. In the case of error code enumerations that may be extended in future releases, you should generally not handle this error code explicitly, but should instead treat any unrecognized error code as equivalent to FAILED. ## Comparison of #GError and traditional error handling # {#gerror-comparison} #GError has several advantages over traditional numeric error codes: importantly, tools like [gobject-introspection](https://developer.gnome.org/gi/stable/) understand #GErrors and convert them to exceptions in bindings; the message includes more information than just a code; and use of a domain helps prevent misinterpretation of error codes. #GError has disadvantages though: it requires a memory allocation, and formatting the error message string has a performance overhead. This makes it unsuitable for use in retry loops where errors are a common case, rather than being unusual. For example, using %G_IO_ERROR_WOULD_BLOCK means hitting these overheads in the normal control flow. String formatting overhead can be eliminated by using g_set_error_literal() in some cases. These performance issues can be compounded if a function wraps the #GErrors returned by the functions it calls: this multiplies the number of allocations and string formatting operations. This can be partially mitigated by using g_prefix_error(). ## Rules for use of #GError # {#gerror-rules} Summary of rules for use of #GError: - Do not report programming errors via #GError. - The last argument of a function that returns an error should be a location where a #GError can be placed (i.e. `GError **error`). If #GError is used with varargs, the `GError**` should be the last argument before the `...`. - The caller may pass %NULL for the `GError**` if they are not interested in details of the exact error that occurred. - If %NULL is passed for the `GError**` argument, then errors should not be returned to the caller, but your function should still abort and return if an error occurs. That is, control flow should not be affected by whether the caller wants to get a #GError. - If a #GError is reported, then your function by definition had a fatal failure and did not complete whatever it was supposed to do. If the failure was not fatal, then you handled it and you should not report it. If it was fatal, then you must report it and discontinue whatever you were doing immediately. - If a #GError is reported, out parameters are not guaranteed to be set to any defined value. - A `GError*` must be initialized to %NULL before passing its address to a function that can report errors. - #GError structs must not be stack-allocated. - "Piling up" errors is always a bug. That is, if you assign a new #GError to a `GError*` that is non-%NULL, thus overwriting the previous error, it indicates that you should have aborted the operation instead of continuing. If you were able to continue, you should have cleared the previous error with g_clear_error(). g_set_error() will complain if you pile up errors. - By convention, if you return a boolean value indicating success then %TRUE means success and %FALSE means failure. Avoid creating functions which have a boolean return value and a #GError parameter, but where the boolean does something other than signal whether the #GError is set. Among other problems, it requires C callers to allocate a temporary error. Instead, provide a `gboolean *` out parameter. There are functions in GLib itself such as g_key_file_has_key() that are hard to use because of this. If %FALSE is returned, the error must be set to a non-%NULL value. One exception to this is that in situations that are already considered to be undefined behaviour (such as when a g_return_val_if_fail() check fails), the error need not be set. Instead of checking separately whether the error is set, callers should ensure that they do not provoke undefined behaviour, then assume that the error will be set on failure. - A %NULL return value is also frequently used to mean that an error occurred. You should make clear in your documentation whether %NULL is a valid return value in non-error cases; if %NULL is a valid value, then users must check whether an error was returned to see if the function succeeded. - When implementing a function that can report errors, you may want to add a check at the top of your function that the error return location is either %NULL or contains a %NULL error (e.g. `g_return_if_fail (error == NULL || *error == NULL);`). ## Extended #GError Domains # {#gerror-extended-domains} Since GLib 2.68 it is possible to extend the #GError type. This is done with the G_DEFINE_EXTENDED_ERROR() macro. To create an extended #GError type do something like this in the header file: |[ typedef enum { MY_ERROR_BAD_REQUEST, } MyError; #define MY_ERROR (my_error_quark ()) GQuark my_error_quark (void); int my_error_get_parse_error_id (GError *error); const char * my_error_get_bad_request_details (GError *error); ]| and in implementation: |[ typedef struct { int parse_error_id; char *bad_request_details; } MyErrorPrivate; static void my_error_private_init (MyErrorPrivate *priv) { priv->parse_error_id = -1; // No need to set priv->bad_request_details to NULL, // the struct is initialized with zeros. } static void my_error_private_copy (const MyErrorPrivate *src_priv, MyErrorPrivate *dest_priv) { dest_priv->parse_error_id = src_priv->parse_error_id; dest_priv->bad_request_details = g_strdup (src_priv->bad_request_details); } static void my_error_private_clear (MyErrorPrivate *priv) { g_free (priv->bad_request_details); } // This defines the my_error_get_private and my_error_quark functions. G_DEFINE_EXTENDED_ERROR (MyError, my_error) int my_error_get_parse_error_id (GError *error) { MyErrorPrivate *priv = my_error_get_private (error); g_return_val_if_fail (priv != NULL, -1); return priv->parse_error_id; } const char * my_error_get_bad_request_details (GError *error) { MyErrorPrivate *priv = my_error_get_private (error); g_return_val_if_fail (priv != NULL, NULL); g_return_val_if_fail (error->code != MY_ERROR_BAD_REQUEST, NULL); return priv->bad_request_details; } static void my_error_set_bad_request (GError **error, const char *reason, int error_id, const char *details) { MyErrorPrivate *priv; g_set_error (error, MY_ERROR, MY_ERROR_BAD_REQUEST, "Invalid request: %s", reason); if (error != NULL && *error != NULL) { priv = my_error_get_private (error); g_return_val_if_fail (priv != NULL, NULL); priv->parse_error_id = error_id; priv->bad_request_details = g_strdup (details); } } ]| An example of use of the error could be: |[ gboolean send_request (GBytes *request, GError **error) { ParseFailedStatus *failure = validate_request (request); if (failure != NULL) { my_error_set_bad_request (error, failure->reason, failure->error_id, failure->details); parse_failed_status_free (failure); return FALSE; } return send_one (request, error); } ]| Please note that if you are a library author and your library exposes an existing error domain, then you can't make this error domain an extended one without breaking ABI. This is because earlier it was possible to create an error with this error domain on the stack and then copy it with g_error_copy(). If the new version of your library makes the error domain an extended one, then g_error_copy() called by code that allocated the error on the stack will try to copy more data than it used to, which will lead to undefined behavior. You must not stack-allocate errors with an extended error domain, and it is bad practice to stack-allocate any other #GErrors. Extended error domains in unloadable plugins/modules are not supported. Gets a #GFileError constant based on the passed-in @err_no. For example, if you pass in `EEXIST` this function returns %G_FILE_ERROR_EXIST. Unlike `errno` values, you can portably assume that all #GFileError values will exist. Normally a #GFileError value goes into a #GError returned from a function that manipulates files. So you would use g_file_error_from_errno() when constructing a #GError.

#GFileError corresponding to the given @err_no

an "errno" value

Reads an entire file into allocated memory, with good error checking. If the call was successful, it returns %TRUE and sets @contents to the file contents and @length to the length of the file contents in bytes. The string stored in @contents will be nul-terminated, so for text files you can pass %NULL for the @length argument. If the call was not successful, it returns %FALSE and sets @error. The error domain is %G_FILE_ERROR. Possible error codes are those in the #GFileError enumeration. In the error case, @contents is set to %NULL and @length is set to zero.

%TRUE on success, %FALSE if an error occurred

name of a file to read contents from, in the GLib file name encoding location to store an allocated string, use g_free() to free the returned string location to store length in bytes of the contents, or %NULL

Opens a file for writing in the preferred directory for temporary files (as returned by g_get_tmp_dir()). @tmpl should be a string in the GLib file name encoding containing a sequence of six 'X' characters, as the parameter to g_mkstemp(). However, unlike these functions, the template should only be a basename, no directory components are allowed. If template is %NULL, a default template is used. Note that in contrast to g_mkstemp() (and mkstemp()) @tmpl is not modified, and might thus be a read-only literal string. Upon success, and if @name_used is non-%NULL, the actual name used is returned in @name_used. This string should be freed with g_free() when not needed any longer. The returned name is in the GLib file name encoding.

A file handle (as from open()) to the file opened for reading and writing. The file is opened in binary mode on platforms where there is a difference. The file handle should be closed with close(). In case of errors, -1 is returned and @error will be set.

Template for file name, as in g_mkstemp(), basename only, or %NULL for a default template location to store actual name used, or %NULL

Reads the contents of the symbolic link @filename like the POSIX readlink() function. The returned string is in the encoding used for filenames. Use g_filename_to_utf8() to convert it to UTF-8. The returned string may also be a relative path. Use g_build_filename() to convert it to an absolute path: |[ g_autoptr(GError) local_error = NULL; g_autofree gchar *link_target = g_file_read_link ("/etc/localtime", &local_error); if (local_error != NULL) g_error ("Error reading link: %s", local_error->message); if (!g_path_is_absolute (link_target)) { g_autofree gchar *absolute_link_target = g_build_filename ("/etc", link_target, NULL); g_free (link_target); link_target = g_steal_pointer (&absolute_link_target); } ]|

A newly-allocated string with the contents of the symbolic link, or %NULL if an error occurred.

the symbolic link

Writes all of @contents to a file named @filename. This is a convenience wrapper around calling g_file_set_contents_full() with `flags` set to `G_FILE_SET_CONTENTS_CONSISTENT | G_FILE_SET_CONTENTS_ONLY_EXISTING` and `mode` set to `0666`.

%TRUE on success, %FALSE if an error occurred

name of a file to write @contents to, in the GLib file name encoding string to write to the file length of @contents, or -1 if @contents is a nul-terminated string

Writes all of @contents to a file named @filename, with good error checking. If a file called @filename already exists it will be overwritten. @flags control the properties of the write operation: whether it’s atomic, and what the tradeoff is between returning quickly or being resilient to system crashes. As this function performs file I/O, it is recommended to not call it anywhere where blocking would cause problems, such as in the main loop of a graphical application. In particular, if @flags has any value other than %G_FILE_SET_CONTENTS_NONE then this function may call `fsync()`. If %G_FILE_SET_CONTENTS_CONSISTENT is set in @flags, the operation is atomic in the sense that it is first written to a temporary file which is then renamed to the final name. Notes: - On UNIX, if @filename already exists hard links to @filename will break. Also since the file is recreated, existing permissions, access control lists, metadata etc. may be lost. If @filename is a symbolic link, the link itself will be replaced, not the linked file. - On UNIX, if @filename already exists and is non-empty, and if the system supports it (via a journalling filesystem or equivalent), and if %G_FILE_SET_CONTENTS_CONSISTENT is set in @flags, the `fsync()` call (or equivalent) will be used to ensure atomic replacement: @filename will contain either its old contents or @contents, even in the face of system power loss, the disk being unsafely removed, etc. - On UNIX, if @filename does not already exist or is empty, there is a possibility that system power loss etc. after calling this function will leave @filename empty or full of NUL bytes, depending on the underlying filesystem, unless %G_FILE_SET_CONTENTS_DURABLE and %G_FILE_SET_CONTENTS_CONSISTENT are set in @flags. - On Windows renaming a file will not remove an existing file with the new name, so on Windows there is a race condition between the existing file being removed and the temporary file being renamed. - On Windows there is no way to remove a file that is open to some process, or mapped into memory. Thus, this function will fail if @filename already exists and is open. If the call was successful, it returns %TRUE. If the call was not successful, it returns %FALSE and sets @error. The error domain is %G_FILE_ERROR. Possible error codes are those in the #GFileError enumeration. Note that the name for the temporary file is constructed by appending up to 7 characters to @filename. If the file didn’t exist before and is created, it will be given the permissions from @mode. Otherwise, the permissions of the existing file may be changed to @mode depending on @flags, or they may remain unchanged.

%TRUE on success, %FALSE if an error occurred

name of a file to write @contents to, in the GLib file name encoding string to write to the file length of @contents, or -1 if @contents is a nul-terminated string flags controlling the safety vs speed of the operation file mode, as passed to `open()`; typically this will be `0666`

Returns %TRUE if any of the tests in the bitfield @test are %TRUE. For example, `(G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)` will return %TRUE if the file exists; the check whether it's a directory doesn't matter since the existence test is %TRUE. With the current set of available tests, there's no point passing in more than one test at a time. Apart from %G_FILE_TEST_IS_SYMLINK all tests follow symbolic links, so for a symbolic link to a regular file g_file_test() will return %TRUE for both %G_FILE_TEST_IS_SYMLINK and %G_FILE_TEST_IS_REGULAR. Note, that for a dangling symbolic link g_file_test() will return %TRUE for %G_FILE_TEST_IS_SYMLINK and %FALSE for all other flags. You should never use g_file_test() to test whether it is safe to perform an operation, because there is always the possibility of the condition changing before you actually perform the operation. For example, you might think you could use %G_FILE_TEST_IS_SYMLINK to know whether it is safe to write to a file without being tricked into writing into a different location. It doesn't work! |[ // DON'T DO THIS if (!g_file_test (filename, G_FILE_TEST_IS_SYMLINK)) { fd = g_open (filename, O_WRONLY); // write to fd } ]| Another thing to note is that %G_FILE_TEST_EXISTS and %G_FILE_TEST_IS_EXECUTABLE are implemented using the access() system call. This usually doesn't matter, but if your program is setuid or setgid it means that these tests will give you the answer for the real user ID and group ID, rather than the effective user ID and group ID. On Windows, there are no symlinks, so testing for %G_FILE_TEST_IS_SYMLINK will always return %FALSE. Testing for %G_FILE_TEST_IS_EXECUTABLE will just check that the file exists and its name indicates that it is executable, checking for well-known extensions and those listed in the `PATHEXT` environment variable.

whether a test was %TRUE

a filename to test in the GLib file name encoding bitfield of #GFileTest flags

Returns the display basename for the particular filename, guaranteed to be valid UTF-8. The display name might not be identical to the filename, for instance there might be problems converting it to UTF-8, and some files can be translated in the display. If GLib cannot make sense of the encoding of @filename, as a last resort it replaces unknown characters with U+FFFD, the Unicode replacement character. You can search the result for the UTF-8 encoding of this character (which is "\357\277\275" in octal notation) to find out if @filename was in an invalid encoding. You must pass the whole absolute pathname to this functions so that translation of well known locations can be done. This function is preferred over g_filename_display_name() if you know the whole path, as it allows translation.

a newly allocated string containing a rendition of the basename of the filename in valid UTF-8

an absolute pathname in the GLib file name encoding

Converts a filename into a valid UTF-8 string. The conversion is not necessarily reversible, so you should keep the original around and use the return value of this function only for display purposes. Unlike g_filename_to_utf8(), the result is guaranteed to be non-%NULL even if the filename actually isn't in the GLib file name encoding. If GLib cannot make sense of the encoding of @filename, as a last resort it replaces unknown characters with U+FFFD, the Unicode replacement character. You can search the result for the UTF-8 encoding of this character (which is "\357\277\275" in octal notation) to find out if @filename was in an invalid encoding. If you know the whole pathname of the file you should use g_filename_display_basename(), since that allows location-based translation of filenames.

a newly allocated string containing a rendition of the filename in valid UTF-8

a pathname hopefully in the GLib file name encoding

Converts an escaped ASCII-encoded URI to a local filename in the encoding used for filenames.

a newly-allocated string holding the resulting filename, or %NULL on an error.

a uri describing a filename (escaped, encoded in ASCII). Location to store hostname for the URI. If there is no hostname in the URI, %NULL will be stored in this location.

Converts a string from UTF-8 to the encoding GLib uses for filenames. Note that on Windows GLib uses UTF-8 for filenames; on other platforms, this function indirectly depends on the [current locale][setlocale]. The input string shall not contain nul characters even if the @len argument is positive. A nul character found inside the string will result in error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE. If the filename encoding is not UTF-8 and the conversion output contains a nul character, the error %G_CONVERT_ERROR_EMBEDDED_NUL is set and the function returns %NULL.

The converted string, or %NULL on an error.

a UTF-8 encoded string. the length of the string, or -1 if the string is nul-terminated. location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will be the byte offset after the last valid input sequence. the number of bytes stored in the output buffer (not including the terminating nul).

Converts an absolute filename to an escaped ASCII-encoded URI, with the path component following Section 3.3. of RFC 2396.

a newly-allocated string holding the resulting URI, or %NULL on an error.

an absolute filename specified in the GLib file name encoding, which is the on-disk file name bytes on Unix, and UTF-8 on Windows A UTF-8 encoded hostname, or %NULL for none.

Converts a string which is in the encoding used by GLib for filenames into a UTF-8 string. Note that on Windows GLib uses UTF-8 for filenames; on other platforms, this function indirectly depends on the [current locale][setlocale]. The input string shall not contain nul characters even if the @len argument is positive. A nul character found inside the string will result in error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE. If the source encoding is not UTF-8 and the conversion output contains a nul character, the error %G_CONVERT_ERROR_EMBEDDED_NUL is set and the function returns %NULL. Use g_convert() to produce output that may contain embedded nul characters.

The converted string, or %NULL on an error.

a string in the encoding for filenames the length of the string, or -1 if the string is nul-terminated (Note that some encodings may allow nul bytes to occur inside strings. In that case, using -1 for the @len parameter is unsafe) location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will be the byte offset after the last valid input sequence. the number of bytes stored in the output buffer (not including the terminating nul).

Do not use these APIs unless you are porting a POSIX application to Windows. A more high-level file access API is provided as GIO — see the documentation for #GFile. There is a group of functions which wrap the common POSIX functions dealing with filenames (g_open(), g_rename(), g_mkdir(), g_stat(), g_unlink(), g_remove(), g_fopen(), g_freopen()). The point of these wrappers is to make it possible to handle file names with any Unicode characters in them on Windows without having to use ifdefs and the wide character API in the application code. On some Unix systems, these APIs may be defined as identical to their POSIX counterparts. For this reason, you must check for and include the necessary header files (such as `fcntl.h`) before using functions like g_creat(). You must also define the relevant feature test macros. The pathname argument should be in the GLib file name encoding. On POSIX this is the actual on-disk encoding which might correspond to the locale settings of the process (or the `G_FILENAME_ENCODING` environment variable), or not. On Windows the GLib file name encoding is UTF-8. Note that the Microsoft C library does not use UTF-8, but has separate APIs for current system code page and wide characters (UTF-16). The GLib wrappers call the wide character API if present (on modern Windows systems), otherwise convert to/from the system code page. Another group of functions allows to open and read directories in the GLib file name encoding. These are g_dir_open(), g_dir_read_name(), g_dir_rewind(), g_dir_close(). Locates the first executable named @program in the user's path, in the same way that execvp() would locate it. Returns an allocated string with the absolute path name, or %NULL if the program is not found in the path. If @program is already an absolute path, returns a copy of @program if @program exists and is executable, and %NULL otherwise. On Windows, if @program does not have a file type suffix, tries with the suffixes .exe, .cmd, .bat and .com, and the suffixes in the `PATHEXT` environment variable. On Windows, it looks for the file in the same way as CreateProcess() would. This means first in the directory where the executing program was loaded from, then in the current directory, then in the Windows 32-bit system directory, then in the Windows directory, and finally in the directories in the `PATH` environment variable. If the program is found, the return value contains the full name including the type suffix.

a newly-allocated string with the absolute path, or %NULL

a program name in the GLib file name encoding

Formats a size (for example the size of a file) into a human readable string. Sizes are rounded to the nearest size prefix (kB, MB, GB) and are displayed rounded to the nearest tenth. E.g. the file size 3292528 bytes will be converted into the string "3.2 MB". The returned string is UTF-8, and may use a non-breaking space to separate the number and units, to ensure they aren’t separated when line wrapped. The prefix units base is 1000 (i.e. 1 kB is 1000 bytes). This string should be freed with g_free() when not needed any longer. See g_format_size_full() for more options about how the size might be formatted.

a newly-allocated formatted string containing a human readable file size

a size in bytes

Formats a size (for example the size of a file) into a human readable string. Sizes are rounded to the nearest size prefix (KB, MB, GB) and are displayed rounded to the nearest tenth. E.g. the file size 3292528 bytes will be converted into the string "3.1 MB". The prefix units base is 1024 (i.e. 1 KB is 1024 bytes). This string should be freed with g_free() when not needed any longer.

This function is broken due to its use of SI suffixes to denote IEC units. Use g_format_size() instead.

a newly-allocated formatted string containing a human readable file size

a size in bytes

Formats a size. This function is similar to g_format_size() but allows for flags that modify the output. See #GFormatSizeFlags.

a newly-allocated formatted string containing a human readable file size

a size in bytes #GFormatSizeFlags to modify the output

An implementation of the standard fprintf() function which supports positional parameters, as specified in the Single Unix Specification. `glib/gprintf.h` must be explicitly included in order to use this function.

the number of bytes printed.

the stream to write to. a standard printf() format string, but notice [string precision pitfalls][string-precision] the arguments to insert in the output.

Frees the memory pointed to by @mem. If @mem is %NULL it simply returns, so there is no need to check @mem against %NULL before calling this function.

the memory to free

Gets a human-readable name for the application, as set by g_set_application_name(). This name should be localized if possible, and is intended for display to the user. Contrast with g_get_prgname(), which gets a non-localized name. If g_set_application_name() has not been called, returns the result of g_get_prgname() (which may be %NULL if g_set_prgname() has also not been called).

human-readable application name. May return %NULL

Obtains the character set for the [current locale][setlocale]; you might use this character set as an argument to g_convert(), to convert from the current locale's encoding to some other encoding. (Frequently g_locale_to_utf8() and g_locale_from_utf8() are nice shortcuts, though.) On Windows the character set returned by this function is the so-called system default ANSI code-page. That is the character set used by the "narrow" versions of C library and Win32 functions that handle file names. It might be different from the character set used by the C library's current locale. On Linux, the character set is found by consulting nl_langinfo() if available. If not, the environment variables `LC_ALL`, `LC_CTYPE`, `LANG` and `CHARSET` are queried in order. The return value is %TRUE if the locale's encoding is UTF-8, in that case you can perhaps avoid calling g_convert(). The string returned in @charset is not allocated, and should not be freed.

%TRUE if the returned charset is UTF-8

return location for character set name, or %NULL.

Gets the character set for the current locale.

a newly allocated string containing the name of the character set. This string must be freed with g_free().

Obtains the character set used by the console attached to the process, which is suitable for printing output to the terminal. Usually this matches the result returned by g_get_charset(), but in environments where the locale's character set does not match the encoding of the console this function tries to guess a more suitable value instead. On Windows the character set returned by this function is the output code page used by the console associated with the calling process. If the codepage can't be determined (for example because there is no console attached) UTF-8 is assumed. The return value is %TRUE if the locale's encoding is UTF-8, in that case you can perhaps avoid calling g_convert(). The string returned in @charset is not allocated, and should not be freed.

%TRUE if the returned charset is UTF-8

return location for character set name, or %NULL.

Gets the current directory. The returned string should be freed when no longer needed. The encoding of the returned string is system defined. On Windows, it is always UTF-8. Since GLib 2.40, this function will return the value of the "PWD" environment variable if it is set and it happens to be the same as the current directory. This can make a difference in the case that the current directory is the target of a symbolic link.

the current directory

Equivalent to the UNIX gettimeofday() function, but portable. You may find g_get_real_time() to be more convenient.

#GTimeVal is not year-2038-safe. Use g_get_real_time() instead.

#GTimeVal structure in which to store current time.

Gets the list of environment variables for the current process. The list is %NULL terminated and each item in the list is of the form 'NAME=VALUE'. This is equivalent to direct access to the 'environ' global variable, except portable. The return value is freshly allocated and it should be freed with g_strfreev() when it is no longer needed.

the list of environment variables

Determines the preferred character sets used for filenames. The first character set from the @charsets is the filename encoding, the subsequent character sets are used when trying to generate a displayable representation of a filename, see g_filename_display_name(). On Unix, the character sets are determined by consulting the environment variables `G_FILENAME_ENCODING` and `G_BROKEN_FILENAMES`. On Windows, the character set used in the GLib API is always UTF-8 and said environment variables have no effect. `G_FILENAME_ENCODING` may be set to a comma-separated list of character set names. The special token "\@locale" is taken to mean the character set for the [current locale][setlocale]. If `G_FILENAME_ENCODING` is not set, but `G_BROKEN_FILENAMES` is, the character set of the current locale is taken as the filename encoding. If neither environment variable is set, UTF-8 is taken as the filename encoding, but the character set of the current locale is also put in the list of encodings. The returned @charsets belong to GLib and must not be freed. Note that on Unix, regardless of the locale character set or `G_FILENAME_ENCODING` value, the actual file names present on a system might be in any random encoding or just gibberish.

%TRUE if the filename encoding is UTF-8.

return location for the %NULL-terminated list of encoding names

Gets the current user's home directory. As with most UNIX tools, this function will return the value of the `HOME` environment variable if it is set to an existing absolute path name, falling back to the `passwd` file in the case that it is unset. If the path given in `HOME` is non-absolute, does not exist, or is not a directory, the result is undefined. Before version 2.36 this function would ignore the `HOME` environment variable, taking the value from the `passwd` database instead. This was changed to increase the compatibility of GLib with other programs (and the XDG basedir specification) and to increase testability of programs based on GLib (by making it easier to run them from test frameworks). If your program has a strong requirement for either the new or the old behaviour (and if you don't wish to increase your GLib dependency to ensure that the new behaviour is in effect) then you should either directly check the `HOME` environment variable yourself or unset it before calling any functions in GLib.

the current user's home directory

Return a name for the machine. The returned name is not necessarily a fully-qualified domain name, or even present in DNS or some other name service at all. It need not even be unique on your local network or site, but usually it is. Callers should not rely on the return value having any specific properties like uniqueness for security purposes. Even if the name of the machine is changed while an application is running, the return value from this function does not change. The returned string is owned by GLib and should not be modified or freed. If no name can be determined, a default fixed string "localhost" is returned. The encoding of the returned string is UTF-8.

the host name of the machine.

Computes a list of applicable locale names, which can be used to e.g. construct locale-dependent filenames or search paths. The returned list is sorted from most desirable to least desirable and always contains the default locale "C". For example, if LANGUAGE=de:en_US, then the returned list is "de", "en_US", "en", "C". This function consults the environment variables `LANGUAGE`, `LC_ALL`, `LC_MESSAGES` and `LANG` to find the list of locales specified by the user.

a %NULL-terminated array of strings owned by GLib that must not be modified or freed.

Computes a list of applicable locale names with a locale category name, which can be used to construct the fallback locale-dependent filenames or search paths. The returned list is sorted from most desirable to least desirable and always contains the default locale "C". This function consults the environment variables `LANGUAGE`, `LC_ALL`, @category_name, and `LANG` to find the list of locales specified by the user. g_get_language_names() returns g_get_language_names_with_category("LC_MESSAGES").

a %NULL-terminated array of strings owned by the thread g_get_language_names_with_category was called from. It must not be modified or freed. It must be copied if planned to be used in another thread.

a locale category name

Returns a list of derived variants of @locale, which can be used to e.g. construct locale-dependent filenames or search paths. The returned list is sorted from most desirable to least desirable. This function handles territory, charset and extra locale modifiers. See [`setlocale(3)`](man:setlocale) for information about locales and their format. @locale itself is guaranteed to be returned in the output. For example, if @locale is `fr_BE`, then the returned list is `fr_BE`, `fr`. If @locale is `en_GB.UTF-8@euro`, then the returned list is `en_GB.UTF-8@euro`, `en_GB.UTF-8`, `en_GB@euro`, `en_GB`, `en.UTF-8@euro`, `en.UTF-8`, `en@euro`, `en`. If you need the list of variants for the current locale, use g_get_language_names().

a newly allocated array of newly allocated strings with the locale variants. Free with g_strfreev().

a locale identifier

Queries the system monotonic time. The monotonic clock will always increase and doesn't suffer discontinuities when the user (or NTP) changes the system time. It may or may not continue to tick during times where the machine is suspended. We try to use the clock that corresponds as closely as possible to the passage of time as measured by system calls such as poll() but it may not always be possible to do this.

the monotonic time, in microseconds

Determine the approximate number of threads that the system will schedule simultaneously for this process. This is intended to be used as a parameter to g_thread_pool_new() for CPU bound tasks and similar cases.

Number of schedulable threads, always greater than 0

Get information about the operating system. On Linux this comes from the `/etc/os-release` file. On other systems, it may come from a variety of sources. You can either use the standard key names like %G_OS_INFO_KEY_NAME or pass any UTF-8 string key name. For example, `/etc/os-release` provides a number of other less commonly used values that may be useful. No key is guaranteed to be provided, so the caller should always check if the result is %NULL.

The associated value for the requested key or %NULL if this information is not provided.

a key for the OS info being requested, for example %G_OS_INFO_KEY_NAME.

Gets the name of the program. This name should not be localized, in contrast to g_get_application_name(). If you are using #GApplication the program name is set in g_application_run(). In case of GDK or GTK+ it is set in gdk_init(), which is called by gtk_init() and the #GtkApplication::startup handler. The program name is found by taking the last component of @argv[0].

the name of the program, or %NULL if it has not been set yet. The returned string belongs to GLib and must not be modified or freed.

Gets the real name of the user. This usually comes from the user's entry in the `passwd` file. The encoding of the returned string is system-defined. (On Windows, it is, however, always UTF-8.) If the real user name cannot be determined, the string "Unknown" is returned.

the user's real name.

Queries the system wall-clock time. This call is functionally equivalent to g_get_current_time() except that the return value is often more convenient than dealing with a #GTimeVal. You should only use this call if you are actually interested in the real wall-clock time. g_get_monotonic_time() is probably more useful for measuring intervals.

the number of microseconds since January 1, 1970 UTC.

Returns an ordered list of base directories in which to access system-wide configuration information. On UNIX platforms this is determined using the mechanisms described in the [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec). In this case the list of directories retrieved will be `XDG_CONFIG_DIRS`. On Windows it follows XDG Base Directory Specification if `XDG_CONFIG_DIRS` is defined. If `XDG_CONFIG_DIRS` is undefined, the directory that contains application data for all users is used instead. A typical path is `C:\Documents and Settings\All Users\Application Data`. This folder is used for application data that is not user specific. For example, an application can store a spell-check dictionary, a database of clip art, or a log file in the FOLDERID_ProgramData folder. This information will not roam and is available to anyone using the computer. The return value is cached and modifying it at runtime is not supported, as it’s not thread-safe to modify environment variables at runtime.

a %NULL-terminated array of strings owned by GLib that must not be modified or freed.

Returns an ordered list of base directories in which to access system-wide application data. On UNIX platforms this is determined using the mechanisms described in the [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec) In this case the list of directories retrieved will be `XDG_DATA_DIRS`. On Windows it follows XDG Base Directory Specification if `XDG_DATA_DIRS` is defined. If `XDG_DATA_DIRS` is undefined, the first elements in the list are the Application Data and Documents folders for All Users. (These can be determined only on Windows 2000 or later and are not present in the list on other Windows versions.) See documentation for FOLDERID_ProgramData and FOLDERID_PublicDocuments. Then follows the "share" subfolder in the installation folder for the package containing the DLL that calls this function, if it can be determined. Finally the list contains the "share" subfolder in the installation folder for GLib, and in the installation folder for the package the application's .exe file belongs to. The installation folders above are determined by looking up the folder where the module (DLL or EXE) in question is located. If the folder's name is "bin", its parent is used, otherwise the folder itself. Note that on Windows the returned list can vary depending on where this function is called. The return value is cached and modifying it at runtime is not supported, as it’s not thread-safe to modify environment variables at runtime.

a %NULL-terminated array of strings owned by GLib that must not be modified or freed.

Gets the directory to use for temporary files. On UNIX, this is taken from the `TMPDIR` environment variable. If the variable is not set, `P_tmpdir` is used, as defined by the system C library. Failing that, a hard-coded default of "/tmp" is returned. On Windows, the `TEMP` environment variable is used, with the root directory of the Windows installation (eg: "C:\") used as a default. The encoding of the returned string is system-defined. On Windows, it is always UTF-8. The return value is never %NULL or the empty string.

the directory to use for temporary files.

Returns a base directory in which to store non-essential, cached data specific to particular user. On UNIX platforms this is determined using the mechanisms described in the [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec). In this case the directory retrieved will be `XDG_CACHE_HOME`. On Windows it follows XDG Base Directory Specification if `XDG_CACHE_HOME` is defined. If `XDG_CACHE_HOME` is undefined, the directory that serves as a common repository for temporary Internet files is used instead. A typical path is `C:\Documents and Settings\username\Local Settings\Temporary Internet Files`. See the [documentation for `FOLDERID_InternetCache`](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid). The return value is cached and modifying it at runtime is not supported, as it’s not thread-safe to modify environment variables at runtime.

a string owned by GLib that must not be modified or freed.

Returns a base directory in which to store user-specific application configuration information such as user preferences and settings. On UNIX platforms this is determined using the mechanisms described in the [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec). In this case the directory retrieved will be `XDG_CONFIG_HOME`. On Windows it follows XDG Base Directory Specification if `XDG_CONFIG_HOME` is defined. If `XDG_CONFIG_HOME` is undefined, the folder to use for local (as opposed to roaming) application data is used instead. See the [documentation for `FOLDERID_LocalAppData`](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid). Note that in this case on Windows it will be the same as what g_get_user_data_dir() returns. The return value is cached and modifying it at runtime is not supported, as it’s not thread-safe to modify environment variables at runtime.

a string owned by GLib that must not be modified or freed.

Returns a base directory in which to access application data such as icons that is customized for a particular user. On UNIX platforms this is determined using the mechanisms described in the [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec). In this case the directory retrieved will be `XDG_DATA_HOME`. On Windows it follows XDG Base Directory Specification if `XDG_DATA_HOME` is defined. If `XDG_DATA_HOME` is undefined, the folder to use for local (as opposed to roaming) application data is used instead. See the [documentation for `FOLDERID_LocalAppData`](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid). Note that in this case on Windows it will be the same as what g_get_user_config_dir() returns. The return value is cached and modifying it at runtime is not supported, as it’s not thread-safe to modify environment variables at runtime.

a string owned by GLib that must not be modified or freed.

Gets the user name of the current user. The encoding of the returned string is system-defined. On UNIX, it might be the preferred file name encoding, or something else, and there is no guarantee that it is even consistent on a machine. On Windows, it is always UTF-8.

the user name of the current user.

Returns a directory that is unique to the current user on the local system. This is determined using the mechanisms described in the [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec). This is the directory specified in the `XDG_RUNTIME_DIR` environment variable. In the case that this variable is not set, we return the value of g_get_user_cache_dir(), after verifying that it exists. The return value is cached and modifying it at runtime is not supported, as it’s not thread-safe to modify environment variables at runtime.

a string owned by GLib that must not be modified or freed.

Returns the full path of a special directory using its logical id. On UNIX this is done using the XDG special user directories. For compatibility with existing practise, %G_USER_DIRECTORY_DESKTOP falls back to `$HOME/Desktop` when XDG special user directories have not been set up. Depending on the platform, the user might be able to change the path of the special directory without requiring the session to restart; GLib will not reflect any change once the special directories are loaded.

the path to the specified special directory, or %NULL if the logical id was not found. The returned string is owned by GLib and should not be modified or freed.

the logical id of special directory

Returns a base directory in which to store state files specific to particular user. On UNIX platforms this is determined using the mechanisms described in the [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec). In this case the directory retrieved will be `XDG_STATE_HOME`. On Windows it follows XDG Base Directory Specification if `XDG_STATE_HOME` is defined. If `XDG_STATE_HOME` is undefined, the folder to use for local (as opposed to roaming) application data is used instead. See the [documentation for `FOLDERID_LocalAppData`](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid). Note that in this case on Windows it will be the same as what g_get_user_data_dir() returns. The return value is cached and modifying it at runtime is not supported, as it’s not thread-safe to modify environment variables at runtime.

a string owned by GLib that must not be modified or freed.

Returns the value of an environment variable. On UNIX, the name and value are byte strings which might or might not be in some consistent character set and encoding. On Windows, they are in UTF-8. On Windows, in case the environment variable's value contains references to other environment variables, they are expanded.

the value of the environment variable, or %NULL if the environment variable is not found. The returned string may be overwritten by the next call to g_getenv(), g_setenv() or g_unsetenv().

the environment variable to get

Functions for manipulating internet hostnames; in particular, for converting between Unicode and ASCII-encoded forms of Internationalized Domain Names (IDNs). The [Internationalized Domain Names for Applications (IDNA)](http://www.ietf.org/rfc/rfc3490.txt) standards allow for the use of Unicode domain names in applications, while providing backward-compatibility with the old ASCII-only DNS, by defining an ASCII-Compatible Encoding of any given Unicode name, which can be used with non-IDN-aware applications and protocols. (For example, "Παν語.org" maps to "xn--4wa8awb4637h.org".) Most of GLib is intended to be portable; in contrast, this set of functions is designed for programs which explicitly target UNIX, or are using it to build higher level abstractions which would be conditionally compiled if the platform matches %G_OS_UNIX. To use these functions, you must explicitly include the "glib-unix.h" header. This is a convenience function for using a #GHashTable as a set. It is equivalent to calling g_hash_table_replace() with @key as both the key and the value. In particular, this means that if @key already exists in the hash table, then the old copy of @key in the hash table is freed and @key replaces it in the table. When a hash table only ever contains keys that have themselves as the corresponding value it is able to be stored more efficiently. See the discussion in the section description. Starting from GLib 2.40, this function returns a boolean value to indicate whether the newly added value was already in the hash table or not.

%TRUE if the key did not exist yet

a #GHashTable a key to insert

Checks if @key is in @hash_table.

%TRUE if @key is in @hash_table, %FALSE otherwise.

a #GHashTable a key to check

a #GHashTable

This function is deprecated and will be removed in the next major release of GLib. It does nothing.

a #GHashTable

%TRUE if the key did not exist yet

a #GHashTable a key to insert the value to associate with the key

the associated value, or %NULL if the key is not found

a #GHashTable the key to look up

%TRUE if the key was found in the #GHashTable

a #GHashTable the key to look up return location for the original key return location for the value associated with the key

a new #GHashTable

Another #GHashTable

%TRUE if the key was found and removed from the #GHashTable

a #GHashTable the key to remove

a #GHashTable

%TRUE if the key did not exist yet

a #GHashTable a key to insert the value to associate with the key

Returns the number of elements contained in the #GHashTable.

the number of key/value pairs in the #GHashTable.

a #GHashTable

Removes a key and its associated value from a #GHashTable without calling the key and value destroy functions.

%TRUE if the key was found and removed from the #GHashTable

a #GHashTable the key to remove

Removes all keys and their associated values from a #GHashTable without calling the key and value destroy functions.

a #GHashTable

%TRUE if the key was found in the #GHashTable

a #GHashTable the key to look up return location for the original key return location for the value associated with the key

This function is deprecated and will be removed in the next major release of GLib. It does nothing.

a #GHashTable

a valid #GHashTable

A #GHashTable provides associations between keys and values which is optimized so that given a key, the associated value can be found, inserted or removed in amortized O(1). All operations going through each element take O(n) time (list all keys/values, table resize, etc.). Note that neither keys nor values are copied when inserted into the #GHashTable, so they must exist for the lifetime of the #GHashTable. This means that the use of static strings is OK, but temporary strings (i.e. those created in buffers and those returned by GTK widgets) should be copied with g_strdup() before being inserted. If keys or values are dynamically allocated, you must be careful to ensure that they are freed when they are removed from the #GHashTable, and also when they are overwritten by new insertions into the #GHashTable. It is also not advisable to mix static strings and dynamically-allocated strings in a #GHashTable, because it then becomes difficult to determine whether the string should be freed. To create a #GHashTable, use g_hash_table_new(). To insert a key and value into a #GHashTable, use g_hash_table_insert(). To look up a value corresponding to a given key, use g_hash_table_lookup() and g_hash_table_lookup_extended(). g_hash_table_lookup_extended() can also be used to simply check if a key is present in the hash table. To remove a key and value, use g_hash_table_remove(). To call a function for each key and value pair use g_hash_table_foreach() or use an iterator to iterate over the key/value pairs in the hash table, see #GHashTableIter. The iteration order of a hash table is not defined, and you must not rely on iterating over keys/values in the same order as they were inserted. To destroy a #GHashTable use g_hash_table_destroy(). A common use-case for hash tables is to store information about a set of keys, without associating any particular value with each key. GHashTable optimizes one way of doing so: If you store only key-value pairs where key == value, then GHashTable does not allocate memory to store the values, which can be a considerable space saving, if your set is large. The functions g_hash_table_add() and g_hash_table_contains() are designed to be used when using #GHashTable this way. #GHashTable is not designed to be statically initialised with keys and values known at compile time. To build a static hash table, use a tool such as [gperf](https://www.gnu.org/software/gperf/). HMACs should be used when producing a cookie or hash based on data and a key. Simple mechanisms for using SHA1 and other algorithms to digest a key and data together are vulnerable to various security issues. [HMAC](http://en.wikipedia.org/wiki/HMAC) uses algorithms like SHA1 in a secure way to produce a digest of a key and data. Both the key and data are arbitrary byte arrays of bytes or characters. Support for HMAC Digests has been added in GLib 2.30, and support for SHA-512 in GLib 2.42. Support for SHA-384 was added in GLib 2.52.

Appends a #GHook onto the end of a #GHookList.

a #GHookList the #GHook to add to the end of @hook_list

Destroys a #GHook, given its ID.

%TRUE if the #GHook was found in the #GHookList and destroyed

a #GHookList a hook ID

Removes one #GHook from a #GHookList, marking it inactive and calling g_hook_unref() on it.

a #GHookList the #GHook to remove

Calls the #GHookList @finalize_hook function if it exists, and frees the memory allocated for the #GHook.

a #GHookList the #GHook to free

Inserts a #GHook into a #GHookList, before a given #GHook.

a #GHookList the #GHook to insert the new #GHook before the #GHook to insert

Prepends a #GHook on the start of a #GHookList.

a #GHookList the #GHook to add to the start of @hook_list

Decrements the reference count of a #GHook. If the reference count falls to 0, the #GHook is removed from the #GHookList and g_hook_free() is called to free it.

a #GHookList the #GHook to unref

The #GHookList, #GHook and their related functions provide support for lists of hook functions. Functions can be added and removed from the lists, and the list of hook functions can be invoked. Tests if @hostname contains segments with an ASCII-compatible encoding of an Internationalized Domain Name. If this returns %TRUE, you should decode the hostname with g_hostname_to_unicode() before displaying it to the user. Note that a hostname might contain a mix of encoded and unencoded segments, and so it is possible for g_hostname_is_non_ascii() and g_hostname_is_ascii_encoded() to both return %TRUE for a name.

%TRUE if @hostname contains any ASCII-encoded segments.

a hostname

Tests if @hostname is the string form of an IPv4 or IPv6 address. (Eg, "192.168.0.1".) Since 2.66, IPv6 addresses with a zone-id are accepted (RFC6874).

%TRUE if @hostname is an IP address

a hostname (or IP address in string form)

Tests if @hostname contains Unicode characters. If this returns %TRUE, you need to encode the hostname with g_hostname_to_ascii() before using it in non-IDN-aware contexts. Note that a hostname might contain a mix of encoded and unencoded segments, and so it is possible for g_hostname_is_non_ascii() and g_hostname_is_ascii_encoded() to both return %TRUE for a name.

%TRUE if @hostname contains any non-ASCII characters

a hostname

Converts @hostname to its canonical ASCII form; an ASCII-only string containing no uppercase letters and not ending with a trailing dot.

an ASCII hostname, which must be freed, or %NULL if @hostname is in some way invalid.

a valid UTF-8 or ASCII hostname

Converts @hostname to its canonical presentation form; a UTF-8 string in Unicode normalization form C, containing no uppercase letters, no forbidden characters, and no ASCII-encoded segments, and not ending with a trailing dot. Of course if @hostname is not an internationalized hostname, then the canonical presentation form will be entirely ASCII.

a UTF-8 hostname, which must be freed, or %NULL if @hostname is in some way invalid.

a valid UTF-8 or ASCII hostname

Converts a 32-bit integer value from host to network byte order.

a 32-bit integer value in host byte order

Converts a 16-bit integer value from host to network byte order.

a 16-bit integer value in host byte order

GLib doesn't force any particular localization method upon its users. But since GLib itself is localized using the gettext() mechanism, it seems natural to offer the de-facto standard gettext() support macros in an easy-to-use form. In order to use these macros in an application, you must include `<glib/gi18n.h>`. For use in a library, you must include `<glib/gi18n-lib.h>` after defining the %GETTEXT_PACKAGE macro suitably for your library: |[ #define GETTEXT_PACKAGE "gtk20" #include <glib/gi18n-lib.h> ]| For an application, note that you also have to call bindtextdomain(), bind_textdomain_codeset(), textdomain() and setlocale() early on in your main() to make gettext() work. For example: |[ #include <glib/gi18n.h> #include <locale.h> int main (int argc, char **argv) { setlocale (LC_ALL, ""); bindtextdomain (GETTEXT_PACKAGE, DATADIR "/locale"); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); // Rest of your application. } ]| where `DATADIR` is as typically provided by automake or Meson. For a library, you only have to call bindtextdomain() and bind_textdomain_codeset() in your initialization function. If your library doesn't have an initialization function, you can call the functions before the first translated message. The [gettext manual](http://www.gnu.org/software/gettext/manual/gettext.html#Maintainers) covers details of how to integrate gettext into a project’s build system and workflow. Same as the standard UNIX routine iconv(), but may be implemented via libiconv on UNIX flavors that lack a native implementation. GLib provides g_convert() and g_locale_to_utf8() which are likely more convenient than the raw iconv wrappers. Note that the behaviour of iconv() for characters which are valid in the input character set, but which have no representation in the output character set, is implementation defined. This function may return success (with a positive number of non-reversible conversions as replacement characters were used), or it may return -1 and set an error such as %EILSEQ, in such a situation.

count of non-reversible conversions, or -1 on error

conversion descriptor from g_iconv_open() bytes to convert inout parameter, bytes remaining to convert in @inbuf converted output bytes inout parameter, bytes available to fill in @outbuf

a "conversion descriptor", or (GIConv)-1 if opening the converter failed.

destination codeset source codeset

Adds a function to be called whenever there are no higher priority events pending to the default main loop. The function is given the default idle priority, %G_PRIORITY_DEFAULT_IDLE. If the function returns %FALSE it is automatically removed from the list of event sources and will not be called again. See [memory management of sources][mainloop-memory-management] for details on how to handle the return value and memory management of @data. This internally creates a main loop source using g_idle_source_new() and attaches it to the global #GMainContext using g_source_attach(), so the callback will be invoked in whichever thread is running that main context. You can do these steps manually if you need greater control or to use a custom main context.

the ID (greater than 0) of the event source.

function to call data to pass to @function.

Adds a function to be called whenever there are no higher priority events pending. If the function returns %G_SOURCE_REMOVE or %FALSE it is automatically removed from the list of event sources and will not be called again. See [memory management of sources][mainloop-memory-management] for details on how to handle the return value and memory management of @data. This internally creates a main loop source using g_idle_source_new() and attaches it to the global #GMainContext using g_source_attach(), so the callback will be invoked in whichever thread is running that main context. You can do these steps manually if you need greater control or to use a custom main context.

the ID (greater than 0) of the event source.

the priority of the idle source. Typically this will be in the range between %G_PRIORITY_DEFAULT_IDLE and %G_PRIORITY_HIGH_IDLE. function to call data to pass to @function function to call when the idle is removed, or %NULL

Adds a function to be called whenever there are no higher priority events pending to the default main loop. The function is given the default idle priority, %G_PRIORITY_DEFAULT_IDLE. The function will only be called once and then the source will be automatically removed from the main context. This function otherwise behaves like g_idle_add().

the ID (greater than 0) of the event source

function to call data to pass to @function

Removes the idle function with the given data.

%TRUE if an idle source was found and removed.

the data for the idle source's callback.

Creates a new idle source. The source will not initially be associated with any #GMainContext and must be added to one with g_source_attach() before it will be executed. Note that the default priority for idle sources is %G_PRIORITY_DEFAULT_IDLE, as compared to other sources which have a default priority of %G_PRIORITY_DEFAULT.

the newly-created idle source

A convenience function/macro to log an informational message. Seldom used. If g_log_default_handler() is used as the log handler function, a new-line character will automatically be appended to @..., and need not be entered manually. Such messages are suppressed by the g_log_default_handler() and g_log_writer_default() unless the `G_MESSAGES_DEBUG` environment variable is set appropriately. If structured logging is enabled, this will use g_log_structured(); otherwise it will use g_log(). See [Using Structured Logging][using-structured-logging].

format string, followed by parameters to insert into the format string (as with printf())

Compares the two #gint64 values being pointed to and returns %TRUE if they are equal. It can be passed to g_hash_table_new() as the @key_equal_func parameter, when using non-%NULL pointers to 64-bit integers as keys in a #GHashTable.

%TRUE if the two keys match.

a pointer to a #gint64 key a pointer to a #gint64 key to compare with @v1

Converts a pointer to a #gint64 to a hash value. It can be passed to g_hash_table_new() as the @hash_func parameter, when using non-%NULL pointers to 64-bit integer values as keys in a #GHashTable.

a hash value corresponding to the key.

a pointer to a #gint64 key

Compares the two #gint values being pointed to and returns %TRUE if they are equal. It can be passed to g_hash_table_new() as the @key_equal_func parameter, when using non-%NULL pointers to integers as keys in a #GHashTable. Note that this function acts on pointers to #gint, not on #gint directly: if your hash table's keys are of the form `GINT_TO_POINTER (n)`, use g_direct_equal() instead.

%TRUE if the two keys match.

a pointer to a #gint key a pointer to a #gint key to compare with @v1

Converts a pointer to a #gint to a hash value. It can be passed to g_hash_table_new() as the @hash_func parameter, when using non-%NULL pointers to integer values as keys in a #GHashTable. Note that this function acts on pointers to #gint, not on #gint directly: if your hash table's keys are of the form `GINT_TO_POINTER (n)`, use g_direct_hash() instead.

a hash value corresponding to the key.

a pointer to a #gint key

Returns a canonical representation for @string. Interned strings can be compared for equality by comparing the pointers, instead of using strcmp(). g_intern_static_string() does not copy the string, therefore @string must not be freed or modified. This function must not be used before library constructors have finished running. In particular, this means it cannot be used to initialize global variables in C++.

a canonical representation for the string

a static string

Returns a canonical representation for @string. Interned strings can be compared for equality by comparing the pointers, instead of using strcmp(). This function must not be used before library constructors have finished running. In particular, this means it cannot be used to initialize global variables in C++.

a canonical representation for the string

a string

Adds the #GIOChannel into the default main loop context with the default priority.

the event source id

a #GIOChannel the condition to watch for the function to call when the condition is satisfied user data to pass to @func

Adds the #GIOChannel into the default main loop context with the given priority. This internally creates a main loop source using g_io_create_watch() and attaches it to the main loop context with g_source_attach(). You can do these steps manually if you need greater control.

the event source id

a #GIOChannel the priority of the #GIOChannel source the condition to watch for the function to call when the condition is satisfied user data to pass to @func the function to call when the source is removed

Converts an `errno` error number to a #GIOChannelError.

a #GIOChannelError error number, e.g. %G_IO_CHANNEL_ERROR_INVAL.

an `errno` error number, e.g. `EINVAL`

Creates a #GSource that's dispatched when @condition is met for the given @channel. For example, if condition is %G_IO_IN, the source will be dispatched when there's data available for reading. The callback function invoked by the #GSource should be added with g_source_set_callback(), but it has type #GIOFunc (not #GSourceFunc). g_io_add_watch() is a simpler interface to this same functionality, for the case where you want to add the source to the default main loop context at the default priority. On Windows, polling a #GSource created to watch a channel for a socket puts the socket in non-blocking mode. This is a side-effect of the implementation and unavoidable.

a new #GSource

a #GIOChannel to watch conditions to watch for

The #GIOChannel data type aims to provide a portable method for using file descriptors, pipes, and sockets, and integrating them into the [main event loop][glib-The-Main-Event-Loop]. Currently, full support is available on UNIX platforms, support for Windows is only partially complete. To create a new #GIOChannel on UNIX systems use g_io_channel_unix_new(). This works for plain file descriptors, pipes and sockets. Alternatively, a channel can be created for a file in a system independent manner using g_io_channel_new_file(). Once a #GIOChannel has been created, it can be used in a generic manner with the functions g_io_channel_read_chars(), g_io_channel_write_chars(), g_io_channel_seek_position(), and g_io_channel_shutdown(). To add a #GIOChannel to the [main event loop][glib-The-Main-Event-Loop], use g_io_add_watch() or g_io_add_watch_full(). Here you specify which events you are interested in on the #GIOChannel, and provide a function to be called whenever these events occur. #GIOChannel instances are created with an initial reference count of 1. g_io_channel_ref() and g_io_channel_unref() can be used to increment or decrement the reference count respectively. When the reference count falls to 0, the #GIOChannel is freed. (Though it isn't closed automatically, unless it was created using g_io_channel_new_file().) Using g_io_add_watch() or g_io_add_watch_full() increments a channel's reference count. The new functions g_io_channel_read_chars(), g_io_channel_read_line(), g_io_channel_read_line_string(), g_io_channel_read_to_end(), g_io_channel_write_chars(), g_io_channel_seek_position(), and g_io_channel_flush() should not be mixed with the deprecated functions g_io_channel_read(), g_io_channel_write(), and g_io_channel_seek() on the same channel.

#GKeyFile lets you parse, edit or create files containing groups of key-value pairs, which we call "key files" for lack of a better name. Several freedesktop.org specifications use key files now, e.g the [Desktop Entry Specification](http://freedesktop.org/Standards/desktop-entry-spec) and the [Icon Theme Specification](http://freedesktop.org/Standards/icon-theme-spec). The syntax of key files is described in detail in the [Desktop Entry Specification](http://freedesktop.org/Standards/desktop-entry-spec), here is a quick summary: Key files consists of groups of key-value pairs, interspersed with comments. |[ # this is just an example # there can be comments before the first group [First Group] Name=Key File Example\tthis value shows\nescaping # localized strings are stored in multiple key-value pairs Welcome=Hello Welcome[de]=Hallo Welcome[fr_FR]=Bonjour Welcome[it]=Ciao Welcome[be@latin]=Hello [Another Group] Numbers=2;20;-200;0 Booleans=true;false;true;true ]| Lines beginning with a '#' and blank lines are considered comments. Groups are started by a header line containing the group name enclosed in '[' and ']', and ended implicitly by the start of the next group or the end of the file. Each key-value pair must be contained in a group. Key-value pairs generally have the form `key=value`, with the exception of localized strings, which have the form `key[locale]=value`, with a locale identifier of the form `lang_COUNTRY@MODIFIER` where `COUNTRY` and `MODIFIER` are optional. Space before and after the '=' character are ignored. Newline, tab, carriage return and backslash characters in value are escaped as \n, \t, \r, and \\\\, respectively. To preserve leading spaces in values, these can also be escaped as \s. Key files can store strings (possibly with localized variants), integers, booleans and lists of these. Lists are separated by a separator character, typically ';' or ','. To use the list separator character in a value in a list, it has to be escaped by prefixing it with a backslash. This syntax is obviously inspired by the .ini files commonly met on Windows, but there are some important differences: - .ini files use the ';' character to begin comments, key files use the '#' character. - Key files do not allow for ungrouped keys meaning only comments can precede the first group. - Key files are always encoded in UTF-8. - Key and Group names are case-sensitive. For example, a group called [GROUP] is a different from [group]. - .ini files don't have a strongly typed boolean entry type, they only have GetProfileInt(). In key files, only true and false (in lower case) are allowed. Note that in contrast to the [Desktop Entry Specification](http://freedesktop.org/Standards/desktop-entry-spec), groups in key files may contain the same key multiple times; the last entry wins. Key files may also contain multiple groups with the same name; they are merged together. Another difference is that keys and group names in key files are not restricted to ASCII characters. Here is an example of loading a key file and reading a value: |[ g_autoptr(GError) error = NULL; g_autoptr(GKeyFile) key_file = g_key_file_new (); if (!g_key_file_load_from_file (key_file, "key-file.ini", flags, &error)) { if (!g_error_matches (error, G_FILE_ERROR, G_FILE_ERROR_NOENT)) g_warning ("Error loading key file: %s", error->message); return; } g_autofree gchar *val = g_key_file_get_string (key_file, "Group Name", "SomeKey", &error); if (val == NULL && !g_error_matches (error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND)) { g_warning ("Error finding key in key file: %s", error->message); return; } else if (val == NULL) { // Fall back to a default value. val = g_strdup ("default-value"); } ]| Here is an example of creating and saving a key file: |[ g_autoptr(GKeyFile) key_file = g_key_file_new (); const gchar *val = …; g_autoptr(GError) error = NULL; g_key_file_set_string (key_file, "Group Name", "SomeKey", val); // Save as a file. if (!g_key_file_save_to_file (key_file, "key-file.ini", &error)) { g_warning ("Error saving key file: %s", error->message); return; } // Or store to a GBytes for use elsewhere. gsize data_len; g_autofree guint8 *data = (guint8 *) g_key_file_to_data (key_file, &data_len, &error); if (data == NULL) { g_warning ("Error saving key file: %s", error->message); return; } g_autoptr(GBytes) bytes = g_bytes_new_take (g_steal_pointer (&data), data_len); ]| The #GList structure and its associated functions provide a standard doubly-linked list data structure. The benefit of this data-structure is to provide insertion/deletion operations in O(1) complexity where access/search operations are in O(n). The benefit of #GList over #GSList (singly linked list) is that the worst case on access/search operations is divided by two which comes at a cost in space as we need to retain two pointers in place of one. Each element in the list contains a piece of data, together with pointers which link to the previous and next elements in the list. Using these pointers it is possible to move through the list in both directions (unlike the singly-linked [GSList][glib-Singly-Linked-Lists], which only allows movement through the list in the forward direction). The double linked list does not keep track of the number of items and does not keep track of both the start and end of the list. If you want fast access to both the start and the end of the list, and/or the number of items in the list, use a [GQueue][glib-Double-ended-Queues] instead. The data contained in each element can be either integer values, by using one of the [Type Conversion Macros][glib-Type-Conversion-Macros], or simply pointers to any type of data. List elements are allocated from the [slice allocator][glib-Memory-Slices], which is more efficient than allocating elements individually. Note that most of the #GList functions expect to be passed a pointer to the first element in the list. The functions which insert elements return the new start of the list, which may have changed. There is no function to create a #GList. %NULL is considered to be a valid, empty list so you simply set a #GList* to %NULL to initialize it. To add elements, use g_list_append(), g_list_prepend(), g_list_insert() and g_list_insert_sorted(). To visit all elements in the list, use a loop over the list: |[ GList *l; for (l = list; l != NULL; l = l->next) { // do something with l->data } ]| To call a function for each element in the list, use g_list_foreach(). To loop over the list and modify it (e.g. remove a certain element) a while loop is more appropriate, for example: |[ GList *l = list; while (l != NULL) { GList *next = l->next; if (should_be_removed (l)) { // possibly free l->data list = g_list_delete_link (list, l); } l = next; } ]| To remove elements, use g_list_remove(). To navigate in a list, use g_list_first(), g_list_last(), g_list_next(), g_list_previous(). To find elements in the list use g_list_nth(), g_list_nth_data(), g_list_find() and g_list_find_custom(). To find the index of an element use g_list_position() and g_list_index(). To free the entire list, use g_list_free() or g_list_free_full(). The #GSList structure and its associated functions provide a standard singly-linked list data structure. The benefit of this data-structure is to provide insertion/deletion operations in O(1) complexity where access/search operations are in O(n). The benefit of #GSList over #GList (doubly linked list) is that they are lighter in space as they only need to retain one pointer but it double the cost of the worst case access/search operations. Each element in the list contains a piece of data, together with a pointer which links to the next element in the list. Using this pointer it is possible to move through the list in one direction only (unlike the [double-linked lists][glib-Doubly-Linked-Lists], which allow movement in both directions). The data contained in each element can be either integer values, by using one of the [Type Conversion Macros][glib-Type-Conversion-Macros], or simply pointers to any type of data. List elements are allocated from the [slice allocator][glib-Memory-Slices], which is more efficient than allocating elements individually. Note that most of the #GSList functions expect to be passed a pointer to the first element in the list. The functions which insert elements return the new start of the list, which may have changed. There is no function to create a #GSList. %NULL is considered to be the empty list so you simply set a #GSList* to %NULL. To add elements, use g_slist_append(), g_slist_prepend(), g_slist_insert() and g_slist_insert_sorted(). To remove elements, use g_slist_remove(). To find elements in the list use g_slist_last(), g_slist_next(), g_slist_nth(), g_slist_nth_data(), g_slist_find() and g_slist_find_custom(). To find the index of an element use g_slist_position() and g_slist_index(). To call a function for each element in the list use g_slist_foreach(). To free the entire list, use g_slist_free().

A convenience macro to get the next element in a #GList. Note that it is considered perfectly acceptable to access @list->next directly.

an element in a #GList

A convenience macro to get the previous element in a #GList. Note that it is considered perfectly acceptable to access @list->prev directly.

an element in a #GList

Gets the names of all variables set in the environment. Programs that want to be portable to Windows should typically use this function and g_getenv() instead of using the environ array from the C library directly. On Windows, the strings in the environ array are in system codepage encoding, while in most of the typical use cases for environment variables in GLib-using programs you want the UTF-8 encoding that this function and g_getenv() provide.

a %NULL-terminated list of strings which must be freed with g_strfreev().

Converts a string from UTF-8 to the encoding used for strings by the C runtime (usually the same as that used by the operating system) in the [current locale][setlocale]. On Windows this means the system codepage. The input string shall not contain nul characters even if the @len argument is positive. A nul character found inside the string will result in error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE. Use g_convert() to convert input that may contain embedded nul characters.

A newly-allocated buffer containing the converted string, or %NULL on an error, and error will be set.

a UTF-8 encoded string the length of the string, or -1 if the string is nul-terminated. location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will be the byte offset after the last valid input sequence. the number of bytes stored in the output buffer (not including the terminating nul).

Converts a string which is in the encoding used for strings by the C runtime (usually the same as that used by the operating system) in the [current locale][setlocale] into a UTF-8 string. If the source encoding is not UTF-8 and the conversion output contains a nul character, the error %G_CONVERT_ERROR_EMBEDDED_NUL is set and the function returns %NULL. If the source encoding is UTF-8, an embedded nul character is treated with the %G_CONVERT_ERROR_ILLEGAL_SEQUENCE error for backward compatibility with earlier versions of this library. Use g_convert() to produce output that may contain embedded nul characters.

The converted string, or %NULL on an error.

a string in the encoding of the current locale. On Windows this means the system codepage. the length of the string, or -1 if the string is nul-terminated (Note that some encodings may allow nul bytes to occur inside strings. In that case, using -1 for the @len parameter is unsafe) location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will be the byte offset after the last valid input sequence. the number of bytes stored in the output buffer (not including the terminating nul).

Logs an error or debugging message. If the log level has been set as fatal, G_BREAKPOINT() is called to terminate the program. See the documentation for G_BREAKPOINT() for details of the debugging options this provides. If g_log_default_handler() is used as the log handler function, a new-line character will automatically be appended to @..., and need not be entered manually. If [structured logging is enabled][using-structured-logging] this will output via the structured log writer function (see g_log_set_writer_func()).

the log domain, usually %G_LOG_DOMAIN, or %NULL for the default the log level, either from #GLogLevelFlags or a user-defined level the message format. See the `printf()` documentation the parameters to insert into the format string

The default log handler set up by GLib; g_log_set_default_handler() allows to install an alternate default log handler. This is used if no log handler has been set for the particular log domain and log level combination. It outputs the message to stderr or stdout and if the log level is fatal it calls G_BREAKPOINT(). It automatically prints a new-line character after the message, so one does not need to be manually included in @message. The behavior of this log handler can be influenced by a number of environment variables: - `G_MESSAGES_PREFIXED`: A :-separated list of log levels for which messages should be prefixed by the program name and PID of the application. - `G_MESSAGES_DEBUG`: A space-separated list of log domains for which debug and informational messages are printed. By default these messages are not printed. stderr is used for levels %G_LOG_LEVEL_ERROR, %G_LOG_LEVEL_CRITICAL, %G_LOG_LEVEL_WARNING and %G_LOG_LEVEL_MESSAGE. stdout is used for the rest, unless stderr was requested by g_log_writer_default_set_use_stderr(). This has no effect if structured logging is enabled; see [Using Structured Logging][using-structured-logging].

the log domain of the message, or %NULL for the default "" application domain the level of the message the message data passed from g_log() which is unused

Return whether debug output from the GLib logging system is enabled. Note that this should not be used to conditionalise calls to g_debug() or other logging functions; it should only be used from %GLogWriterFunc implementations. Note also that the value of this does not depend on `G_MESSAGES_DEBUG`; see the docs for g_log_set_debug_enabled().

%TRUE if debug output is enabled, %FALSE otherwise

Removes the log handler. This has no effect if structured logging is enabled; see [Using Structured Logging][using-structured-logging].

the log domain the id of the handler, which was returned in g_log_set_handler()

Sets the message levels which are always fatal, in any log domain. When a message with any of these levels is logged the program terminates. You can only set the levels defined by GLib to be fatal. %G_LOG_LEVEL_ERROR is always fatal. You can also make some message levels fatal at runtime by setting the `G_DEBUG` environment variable (see [Running GLib Applications](glib-running.html)). Libraries should not call this function, as it affects all messages logged by a process, including those from other libraries. Structured log messages (using g_log_structured() and g_log_structured_array()) are fatal only if the default log writer is used; otherwise it is up to the writer function to determine which log messages are fatal. See [Using Structured Logging][using-structured-logging].

the old fatal mask

the mask containing bits set for each level of error which is to be fatal

Enable or disable debug output from the GLib logging system for all domains. This value interacts disjunctively with `G_MESSAGES_DEBUG` — if either of them would allow a debug message to be outputted, it will be. Note that this should not be used from within library code to enable debug output — it is intended for external use.

%TRUE to enable debug output, %FALSE otherwise

Installs a default log handler which is used if no log handler has been set for the particular log domain and log level combination. By default, GLib uses g_log_default_handler() as default log handler. This has no effect if structured logging is enabled; see [Using Structured Logging][using-structured-logging].

the previous default log handler

the log handler function data passed to the log handler

Sets the log levels which are fatal in the given domain. %G_LOG_LEVEL_ERROR is always fatal. This has no effect on structured log messages (using g_log_structured() or g_log_structured_array()). To change the fatal behaviour for specific log messages, programs must install a custom log writer function using g_log_set_writer_func(). See [Using Structured Logging][using-structured-logging]. This function is mostly intended to be used with %G_LOG_LEVEL_CRITICAL. You should typically not set %G_LOG_LEVEL_WARNING, %G_LOG_LEVEL_MESSAGE, %G_LOG_LEVEL_INFO or %G_LOG_LEVEL_DEBUG as fatal except inside of test programs.

the old fatal mask for the log domain

the log domain the new fatal mask

Sets the log handler for a domain and a set of log levels. To handle fatal and recursive messages the @log_levels parameter must be combined with the %G_LOG_FLAG_FATAL and %G_LOG_FLAG_RECURSION bit flags. Note that since the %G_LOG_LEVEL_ERROR log level is always fatal, if you want to set a handler for this log level you must combine it with %G_LOG_FLAG_FATAL. This has no effect if structured logging is enabled; see [Using Structured Logging][using-structured-logging]. Here is an example for adding a log handler for all warning messages in the default domain: |[ g_log_set_handler (NULL, G_LOG_LEVEL_WARNING | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION, my_log_handler, NULL); ]| This example adds a log handler for all critical messages from GTK+: |[ g_log_set_handler ("Gtk", G_LOG_LEVEL_CRITICAL | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION, my_log_handler, NULL); ]| This example adds a log handler for all messages from GLib: |[ g_log_set_handler ("GLib", G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION, my_log_handler, NULL); ]|

the id of the new handler

the log domain, or %NULL for the default "" application domain the log levels to apply the log handler for. To handle fatal and recursive messages as well, combine the log levels with the %G_LOG_FLAG_FATAL and %G_LOG_FLAG_RECURSION bit flags. the log handler function data passed to the log handler

Like g_log_set_handler(), but takes a destroy notify for the @user_data. This has no effect if structured logging is enabled; see [Using Structured Logging][using-structured-logging].

the id of the new handler

Set a writer function which will be called to format and write out each log message. Each program should set a writer function, or the default writer (g_log_writer_default()) will be used. Libraries **must not** call this function — only programs are allowed to install a writer function, as there must be a single, central point where log messages are formatted and outputted. There can only be one writer function. It is an error to set more than one.

log writer function, which must not be %NULL user data to pass to @func function to free @user_data once it’s finished with, if non-%NULL

Log a message with structured data. The message will be passed through to the log writer set by the application using g_log_set_writer_func(). If the message is fatal (i.e. its log level is %G_LOG_LEVEL_ERROR), the program will be aborted by calling G_BREAKPOINT() at the end of this function. If the log writer returns %G_LOG_WRITER_UNHANDLED (failure), no other fallback writers will be tried. See the documentation for #GLogWriterFunc for information on chaining writers. The structured data is provided as key–value pairs, where keys are UTF-8 strings, and values are arbitrary pointers — typically pointing to UTF-8 strings, but that is not a requirement. To pass binary (non-nul-terminated) structured data, use g_log_structured_array(). The keys for structured data should follow the [systemd journal fields](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html) specification. It is suggested that custom keys are namespaced according to the code which sets them. For example, custom keys from GLib all have a `GLIB_` prefix. Note that keys that expect UTF-8 strings (specifically `"MESSAGE"` and `"GLIB_DOMAIN"`) must be passed as NUL-terminated UTF-8 strings until GLib version 2.74.1 because the default log handler did not consider the length of the `GLogField`. Starting with GLib 2.74.1 this is fixed and non-NUL-terminated UTF-8 strings can be passed with their correct length. The @log_domain will be converted into a `GLIB_DOMAIN` field. @log_level will be converted into a [`PRIORITY`](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html#PRIORITY=) field. The format string will have its placeholders substituted for the provided values and be converted into a [`MESSAGE`](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html#MESSAGE=) field. Other fields you may commonly want to pass into this function: * [`MESSAGE_ID`](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html#MESSAGE_ID=) * [`CODE_FILE`](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html#CODE_FILE=) * [`CODE_LINE`](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html#CODE_LINE=) * [`CODE_FUNC`](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html#CODE_FUNC=) * [`ERRNO`](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html#ERRNO=) Note that `CODE_FILE`, `CODE_LINE` and `CODE_FUNC` are automatically set by the logging macros, G_DEBUG_HERE(), g_message(), g_warning(), g_critical(), g_error(), etc, if the symbols `G_LOG_USE_STRUCTURED` is defined before including `glib.h`. For example: |[ g_log_structured (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "MESSAGE_ID", "06d4df59e6c24647bfe69d2c27ef0b4e", "MY_APPLICATION_CUSTOM_FIELD", "some debug string", "MESSAGE", "This is a debug message about pointer %p and integer %u.", some_pointer, some_integer); ]| Note that each `MESSAGE_ID` must be [uniquely and randomly generated](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html#MESSAGE_ID=). If adding a `MESSAGE_ID`, consider shipping a [message catalog](https://www.freedesktop.org/wiki/Software/systemd/catalog/) with your software. To pass a user data pointer to the log writer function which is specific to this logging call, you must use g_log_structured_array() and pass the pointer as a field with #GLogField.length set to zero, otherwise it will be interpreted as a string. For example: |[ const GLogField fields[] = { { "MESSAGE", "This is a debug message.", -1 }, { "MESSAGE_ID", "fcfb2e1e65c3494386b74878f1abf893", -1 }, { "MY_APPLICATION_CUSTOM_FIELD", "some debug string", -1 }, { "MY_APPLICATION_STATE", state_object, 0 }, }; g_log_structured_array (G_LOG_LEVEL_DEBUG, fields, G_N_ELEMENTS (fields)); ]| Note also that, even if no other structured fields are specified, there must always be a `MESSAGE` key before the format string. The `MESSAGE`-format pair has to be the last of the key-value pairs, and `MESSAGE` is the only field for which printf()-style formatting is supported. The default writer function for `stdout` and `stderr` will automatically append a new-line character after the message, so you should not add one manually to the format string.

log domain, usually %G_LOG_DOMAIN log level, either from #GLogLevelFlags, or a user-defined level key-value pairs of structured data to add to the log entry, followed by the key "MESSAGE", followed by a printf()-style message format, followed by parameters to insert in the format string

Log a message with structured data. The message will be passed through to the log writer set by the application using g_log_set_writer_func(). If the message is fatal (i.e. its log level is %G_LOG_LEVEL_ERROR), the program will be aborted at the end of this function. See g_log_structured() for more documentation. This assumes that @log_level is already present in @fields (typically as the `PRIORITY` field).

log level, either from #GLogLevelFlags, or a user-defined level key–value pairs of structured data to add to the log message number of elements in the @fields array

Log a message with structured data, accepting the data within a #GVariant. This version is especially useful for use in other languages, via introspection. The only mandatory item in the @fields dictionary is the "MESSAGE" which must contain the text shown to the user. The values in the @fields dictionary are likely to be of type String (%G_VARIANT_TYPE_STRING). Array of bytes (%G_VARIANT_TYPE_BYTESTRING) is also supported. In this case the message is handled as binary and will be forwarded to the log writer as such. The size of the array should not be higher than %G_MAXSSIZE. Otherwise it will be truncated to this size. For other types g_variant_print() will be used to convert the value into a string. For more details on its usage and about the parameters, see g_log_structured().

log domain, usually %G_LOG_DOMAIN log level, either from #GLogLevelFlags, or a user-defined level a dictionary (#GVariant of the type %G_VARIANT_TYPE_VARDICT) containing the key-value pairs of message data.

Format a structured log message and output it to the default log destination for the platform. On Linux, this is typically the systemd journal, falling back to `stdout` or `stderr` if running from the terminal or if output is being redirected to a file. Support for other platform-specific logging mechanisms may be added in future. Distributors of GLib may modify this function to impose their own (documented) platform-specific log writing policies. This is suitable for use as a #GLogWriterFunc, and is the default writer used if no other is set using g_log_set_writer_func(). As with g_log_default_handler(), this function drops debug and informational messages unless their log domain (or `all`) is listed in the space-separated `G_MESSAGES_DEBUG` environment variable. g_log_writer_default() uses the mask set by g_log_set_always_fatal() to determine which messages are fatal. When using a custom writer func instead it is up to the writer function to determine which log messages are fatal.

%G_LOG_WRITER_HANDLED on success, %G_LOG_WRITER_UNHANDLED otherwise

log level, either from #GLogLevelFlags, or a user-defined level key–value pairs of structured data forming the log message number of elements in the @fields array user data passed to g_log_set_writer_func()

Configure whether the built-in log functions (g_log_default_handler() for the old-style API, and both g_log_writer_default() and g_log_writer_standard_streams() for the structured API) will output all log messages to `stderr`. By default, log messages of levels %G_LOG_LEVEL_INFO and %G_LOG_LEVEL_DEBUG are sent to `stdout`, and other log messages are sent to `stderr`. This is problematic for applications that intend to reserve `stdout` for structured output such as JSON or XML. This function sets global state. It is not thread-aware, and should be called at the very start of a program, before creating any other threads or creating objects that could create worker threads of their own.

If %TRUE, use `stderr` for log messages that would normally have appeared on `stdout`

Check whether g_log_writer_default() and g_log_default_handler() would ignore a message with the given domain and level. As with g_log_default_handler(), this function drops debug and informational messages unless their log domain (or `all`) is listed in the space-separated `G_MESSAGES_DEBUG` environment variable. This can be used when implementing log writers with the same filtering behaviour as the default, but a different destination or output format: |[ if (g_log_writer_default_would_drop (log_level, log_domain)) return G_LOG_WRITER_HANDLED; ]| or to skip an expensive computation if it is only needed for a debugging message, and `G_MESSAGES_DEBUG` is not set: |[ if (!g_log_writer_default_would_drop (G_LOG_LEVEL_DEBUG, G_LOG_DOMAIN)) { gchar *result = expensive_computation (my_object); g_debug ("my_object result: %s", result); g_free (result); } ]|

%TRUE if the log message would be dropped by GLib's default log handlers

log level, either from #GLogLevelFlags, or a user-defined level log domain

Format a structured log message as a string suitable for outputting to the terminal (or elsewhere). This will include the values of all fields it knows how to interpret, which includes `MESSAGE` and `GLIB_DOMAIN` (see the documentation for g_log_structured()). It does not include values from unknown fields. The returned string does **not** have a trailing new-line character. It is encoded in the character set of the current locale, which is not necessarily UTF-8.

string containing the formatted log message, in the character set of the current locale

log level, either from #GLogLevelFlags, or a user-defined level key–value pairs of structured data forming the log message number of elements in the @fields array %TRUE to use ANSI color escape sequences when formatting the message, %FALSE to not

Check whether the given @output_fd file descriptor is a connection to the systemd journal, or something else (like a log file or `stdout` or `stderr`). Invalid file descriptors are accepted and return %FALSE, which allows for the following construct without needing any additional error handling: |[ is_journald = g_log_writer_is_journald (fileno (stderr)); ]|

%TRUE if @output_fd points to the journal, %FALSE otherwise

output file descriptor to check

Format a structured log message and send it to the systemd journal as a set of key–value pairs. All fields are sent to the journal, but if a field has length zero (indicating program-specific data) then only its key will be sent. This is suitable for use as a #GLogWriterFunc. If GLib has been compiled without systemd support, this function is still defined, but will always return %G_LOG_WRITER_UNHANDLED.

%G_LOG_WRITER_HANDLED on success, %G_LOG_WRITER_UNHANDLED otherwise

Format a structured log message and print it to either `stdout` or `stderr`, depending on its log level. %G_LOG_LEVEL_INFO and %G_LOG_LEVEL_DEBUG messages are sent to `stdout`, or to `stderr` if requested by g_log_writer_default_set_use_stderr(); all other log levels are sent to `stderr`. Only fields which are understood by this function are included in the formatted string which is printed. If the output stream supports ANSI color escape sequences, they will be used in the output. A trailing new-line character is added to the log message when it is printed. This is suitable for use as a #GLogWriterFunc.

%G_LOG_WRITER_HANDLED on success, %G_LOG_WRITER_UNHANDLED otherwise

Check whether the given @output_fd file descriptor supports ANSI color escape sequences. If so, they can safely be used when formatting log messages.

%TRUE if ANSI color escapes are supported, %FALSE otherwise

output file descriptor to check

the log domain, or %NULL for the default "" application domain the log level the message format. See the printf() documentation the parameters to insert into the format string

These macros provide a few commonly-used features. These macros provide more specialized features which are not needed so often by application programmers. The main event loop manages all the available sources of events for GLib and GTK+ applications. These events can come from any number of different types of sources such as file descriptors (plain files, pipes or sockets) and timeouts. New types of event sources can also be added using g_source_attach(). To allow multiple independent sets of sources to be handled in different threads, each source is associated with a #GMainContext. A #GMainContext can only be running in a single thread, but sources can be added to it and removed from it from other threads. All functions which operate on a #GMainContext or a built-in #GSource are thread-safe. Each event source is assigned a priority. The default priority, %G_PRIORITY_DEFAULT, is 0. Values less than 0 denote higher priorities. Values greater than 0 denote lower priorities. Events from high priority sources are always processed before events from lower priority sources: if several sources are ready to dispatch, the ones with equal-highest priority will be dispatched on the current #GMainContext iteration, and the rest wait until a subsequent #GMainContext iteration when they have the highest priority of the sources which are ready for dispatch. Idle functions can also be added, and assigned a priority. These will be run whenever no events with a higher priority are ready to be dispatched. The #GMainLoop data type represents a main event loop. A GMainLoop is created with g_main_loop_new(). After adding the initial event sources, g_main_loop_run() is called. This continuously checks for new events from each of the event sources and dispatches them. Finally, the processing of an event from one of the sources leads to a call to g_main_loop_quit() to exit the main loop, and g_main_loop_run() returns. It is possible to create new instances of #GMainLoop recursively. This is often used in GTK+ applications when showing modal dialog boxes. Note that event sources are associated with a particular #GMainContext, and will be checked and dispatched for all main loops associated with that GMainContext. GTK+ contains wrappers of some of these functions, e.g. gtk_main(), gtk_main_quit() and gtk_events_pending(). ## Creating new source types One of the unusual features of the #GMainLoop functionality is that new types of event source can be created and used in addition to the builtin type of event source. A new event source type is used for handling GDK events. A new source type is created by "deriving" from the #GSource structure. The derived type of source is represented by a structure that has the #GSource structure as a first element, and other elements specific to the new source type. To create an instance of the new source type, call g_source_new() passing in the size of the derived structure and a table of functions. These #GSourceFuncs determine the behavior of the new source type. New source types basically interact with the main context in two ways. Their prepare function in #GSourceFuncs can set a timeout to determine the maximum amount of time that the main loop will sleep before checking the source again. In addition, or as well, the source can add file descriptors to the set that the main context checks using g_source_add_poll(). ## Customizing the main loop iteration Single iterations of a #GMainContext can be run with g_main_context_iteration(). In some cases, more detailed control of exactly how the details of the main loop work is desired, for instance, when integrating the #GMainLoop with an external main loop. In such cases, you can call the component functions of g_main_context_iteration() directly. These functions are g_main_context_prepare(), g_main_context_query(), g_main_context_check() and g_main_context_dispatch(). If the event loop thread releases #GMainContext ownership until the results required by g_main_context_check() are ready you must create a context with the flag %G_MAIN_CONTEXT_FLAGS_OWNERLESS_POLLING or else you'll lose g_source_attach() notifications. This happens for instance when you integrate the GLib event loop into implementations that follow the proactor pattern (i.e. in these contexts the `poll()` implementation will reclaim the thread for other tasks until the results are ready). One example of the proactor pattern is the Boost.Asio library. ## State of a Main Context # {#mainloop-states} The operation of these functions can best be seen in terms of a state diagram, as shown in this image. ![](mainloop-states.gif) On UNIX, the GLib mainloop is incompatible with fork(). Any program using the mainloop must either exec() or exit() from the child without returning to the mainloop. ## Memory management of sources # {#mainloop-memory-management} There are two options for memory management of the user data passed to a #GSource to be passed to its callback on invocation. This data is provided in calls to g_timeout_add(), g_timeout_add_full(), g_idle_add(), etc. and more generally, using g_source_set_callback(). This data is typically an object which ‘owns’ the timeout or idle callback, such as a widget or a network protocol implementation. In many cases, it is an error for the callback to be invoked after this owning object has been destroyed, as that results in use of freed memory. The first, and preferred, option is to store the source ID returned by functions such as g_timeout_add() or g_source_attach(), and explicitly remove that source from the main context using g_source_remove() when the owning object is finalized. This ensures that the callback can only be invoked while the object is still alive. The second option is to hold a strong reference to the object in the callback, and to release it in the callback’s #GDestroyNotify. This ensures that the object is kept alive until after the source is finalized, which is guaranteed to be after it is invoked for the final time. The #GDestroyNotify is another callback passed to the ‘full’ variants of #GSource functions (for example, g_timeout_add_full()). It is called when the source is finalized, and is designed for releasing references like this. One important caveat of this second approach is that it will keep the object alive indefinitely if the main loop is stopped before the #GSource is invoked, which may be undesirable. Returns the global default main context. This is the main context used for main loop functions when a main loop is not explicitly specified, and corresponds to the "main" main loop. See also g_main_context_get_thread_default().

the global default main context.

the thread-default #GMainContext, or %NULL if the thread-default context is the global default context.

the thread-default #GMainContext. Unref with g_main_context_unref() when you are done with it.

Returns the currently firing source for this thread.

The currently firing source or %NULL.

Returns the depth of the stack of calls to g_main_context_dispatch() on any #GMainContext in the current thread. That is, when called from the toplevel, it gives 0. When called from within a callback from g_main_context_iteration() (or g_main_loop_run(), etc.) it returns 1. When called from within a callback to a recursive call to g_main_context_iteration(), it returns 2. And so forth. This function is useful in a situation like the following: Imagine an extremely simple "garbage collected" system. |[ static GList *free_list; gpointer allocate_memory (gsize size) { gpointer result = g_malloc (size); free_list = g_list_prepend (free_list, result); return result; } void free_allocated_memory (void) { GList *l; for (l = free_list; l; l = l->next); g_free (l->data); g_list_free (free_list); free_list = NULL; } [...] while (TRUE); { g_main_context_iteration (NULL, TRUE); free_allocated_memory(); } ]| This works from an application, however, if you want to do the same thing from a library, it gets more difficult, since you no longer control the main loop. You might think you can simply use an idle function to make the call to free_allocated_memory(), but that doesn't work, since the idle function could be called from a recursive callback. This can be fixed by using g_main_depth() |[ gpointer allocate_memory (gsize size) { FreeListBlock *block = g_new (FreeListBlock, 1); block->mem = g_malloc (size); block->depth = g_main_depth (); free_list = g_list_prepend (free_list, block); return block->mem; } void free_allocated_memory (void) { GList *l; int depth = g_main_depth (); for (l = free_list; l; ); { GList *next = l->next; FreeListBlock *block = l->data; if (block->depth > depth) { g_free (block->mem); g_free (block); free_list = g_list_delete_link (free_list, l); } l = next; } } ]| There is a temptation to use g_main_depth() to solve problems with reentrancy. For instance, while waiting for data to be received from the network in response to a menu item, the menu item might be selected again. It might seem that one could make the menu item's callback return immediately and do nothing if g_main_depth() returns a value greater than 1. However, this should be avoided since the user then sees selecting the menu item do nothing. Furthermore, you'll find yourself adding these checks all over your code, since there are doubtless many, many things that the user could do. Instead, you can use the following techniques: 1. Use gtk_widget_set_sensitive() or modal dialogs to prevent the user from interacting with elements while the main loop is recursing. 2. Avoid main loop recursion in situations where you can't handle arbitrary callbacks. Instead, structure your code so that you simply return to the main loop and then get called again when there is more work to do.

The main loop recursion level in the current thread

Allocates @n_bytes bytes of memory. If @n_bytes is 0 it returns %NULL. If the allocation fails (because the system is out of memory), the program is terminated.

a pointer to the allocated memory

the number of bytes to allocate

Allocates @n_bytes bytes of memory, initialized to 0's. If @n_bytes is 0 it returns %NULL. If the allocation fails (because the system is out of memory), the program is terminated.

a pointer to the allocated memory

the number of bytes to allocate

This function is similar to g_malloc0(), allocating (@n_blocks * @n_block_bytes) bytes, but care is taken to detect possible overflow during multiplication. If the allocation fails (because the system is out of memory), the program is terminated.

a pointer to the allocated memory

the number of blocks to allocate the size of each block in bytes

This function is similar to g_malloc(), allocating (@n_blocks * @n_block_bytes) bytes, but care is taken to detect possible overflow during multiplication. If the allocation fails (because the system is out of memory), the program is terminated.

a pointer to the allocated memory

the number of blocks to allocate the size of each block in bytes

The "GMarkup" parser is intended to parse a simple markup format that's a subset of XML. This is a small, efficient, easy-to-use parser. It should not be used if you expect to interoperate with other applications generating full-scale XML, and must not be used if you expect to parse untrusted input. However, it's very useful for application data files, config files, etc. where you know your application will be the only one writing the file. Full-scale XML parsers should be able to parse the subset used by GMarkup, so you can easily migrate to full-scale XML at a later time if the need arises. GMarkup is not guaranteed to signal an error on all invalid XML; the parser may accept documents that an XML parser would not. However, XML documents which are not well-formed (which is a weaker condition than being valid. See the [XML specification](http://www.w3.org/TR/REC-xml/) for definitions of these terms.) are not considered valid GMarkup documents. Simplifications to XML include: - Only UTF-8 encoding is allowed - No user-defined entities - Processing instructions, comments and the doctype declaration are "passed through" but are not interpreted in any way - No DTD or validation The markup format does support: - Elements - Attributes - 5 standard entities: & < > " ' - Character references - Sections marked as CDATA Collects the attributes of the element from the data passed to the #GMarkupParser start_element function, dealing with common error conditions and supporting boolean values. This utility function is not required to write a parser but can save a lot of typing. The @element_name, @attribute_names, @attribute_values and @error parameters passed to the start_element callback should be passed unmodified to this function. Following these arguments is a list of "supported" attributes to collect. It is an error to specify multiple attributes with the same name. If any attribute not in the list appears in the @attribute_names array then an unknown attribute error will result. The #GMarkupCollectType field allows specifying the type of collection to perform and if a given attribute must appear or is optional. The attribute name is simply the name of the attribute to collect. The pointer should be of the appropriate type (see the descriptions under #GMarkupCollectType) and may be %NULL in case a particular attribute is to be allowed but ignored. This function deals with issuing errors for missing attributes (of type %G_MARKUP_ERROR_MISSING_ATTRIBUTE), unknown attributes (of type %G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE) and duplicate attributes (of type %G_MARKUP_ERROR_INVALID_CONTENT) as well as parse errors for boolean-valued attributes (again of type %G_MARKUP_ERROR_INVALID_CONTENT). In all of these cases %FALSE will be returned and @error will be set as appropriate.

%TRUE if successful

the current tag name the attribute names the attribute values a pointer to a #GError or %NULL the #GMarkupCollectType of the first attribute the name of the first attribute a pointer to the storage location of the first attribute (or %NULL), followed by more types names and pointers, ending with %G_MARKUP_COLLECT_INVALID

Escapes text so that the markup parser will parse it verbatim. Less than, greater than, ampersand, etc. are replaced with the corresponding entities. This function would typically be used when writing out a file to be parsed with the markup parser. Note that this function doesn't protect whitespace and line endings from being processed according to the XML rules for normalization of line endings and attribute values. Note also that this function will produce character references in the range of  ...  for all control sequences except for tabstop, newline and carriage return. The character references in this range are not valid XML 1.0, but they are valid XML 1.1 and will be accepted by the GMarkup parser.

a newly allocated string with the escaped text

some valid UTF-8 text length of @text in bytes, or -1 if the text is nul-terminated

Formats arguments according to @format, escaping all string and character arguments in the fashion of g_markup_escape_text(). This is useful when you want to insert literal strings into XML-style markup output, without having to worry that the strings might themselves contain markup. |[ const char *store = "Fortnum & Mason"; const char *item = "Tea"; char *output; output = g_markup_printf_escaped ("<purchase>" "<store>%s</store>" "<item>%s</item>" "</purchase>", store, item); ]|

newly allocated result from formatting operation. Free with g_free().

printf() style format string the arguments to insert in the format string

Formats the data in @args according to @format, escaping all string and character arguments in the fashion of g_markup_escape_text(). See g_markup_printf_escaped().

newly allocated result from formatting operation. Free with g_free().

printf() style format string variable argument list, similar to vprintf()

Checks whether the allocator used by g_malloc() is the system's malloc implementation. If it returns %TRUE memory allocated with malloc() can be used interchangeably with memory allocated using g_malloc(). This function is useful for avoiding an extra copy of allocated memory returned by a non-GLib-based API.

GLib always uses the system malloc, so this function always returns %TRUE.

if %TRUE, malloc() and g_malloc() can be mixed.

GLib used to support some tools for memory profiling, but this no longer works. There are many other useful tools for memory profiling these days which can be used instead.

Use other memory profiling tools instead

This function used to let you override the memory allocation function. However, its use was incompatible with the use of global constructors in GLib and GIO, because those use the GLib allocators before main is reached. Therefore this function is now deprecated and is just a stub.

This function now does nothing. Use other memory profiling tools instead

table of memory allocation routines.

Allocates @byte_size bytes of memory, and copies @byte_size bytes into it from @mem. If @mem is %NULL it returns %NULL.

Use g_memdup2() instead, as it accepts a #gsize argument for @byte_size, avoiding the possibility of overflow in a #gsize → #guint conversion

a pointer to the newly-allocated copy of the memory, or %NULL if @mem is %NULL.

the memory to copy. the number of bytes to copy.

Allocates @byte_size bytes of memory, and copies @byte_size bytes into it from @mem. If @mem is %NULL it returns %NULL. This replaces g_memdup(), which was prone to integer overflows when converting the argument from a #gsize to a #guint.

a pointer to the newly-allocated copy of the memory, or %NULL if @mem is %NULL.

the memory to copy. the number of bytes to copy.

Copies a block of memory @len bytes long, from @src to @dest. The source and destination areas may overlap.

Just use memmove().

the destination address to copy the bytes to. the source address to copy the bytes from. the number of bytes to copy.

These functions provide support for allocating and freeing memory. If any call to allocate memory using functions g_new(), g_new0(), g_renew(), g_malloc(), g_malloc0(), g_malloc0_n(), g_realloc(), and g_realloc_n() fails, the application is terminated. This also means that there is no need to check if the call succeeded. On the other hand, the `g_try_...()` family of functions returns %NULL on failure that can be used as a check for unsuccessful memory allocation. The application is not terminated in this case. As all GLib functions and data structures use `g_malloc()` internally, unless otherwise specified, any allocation failure will result in the application being terminated. It's important to match g_malloc() (and wrappers such as g_new()) with g_free(), g_slice_alloc() (and wrappers such as g_slice_new()) with g_slice_free(), plain malloc() with free(), and (if you're using C++) new with delete and new[] with delete[]. Otherwise bad things can happen, since these allocators may use different memory pools (and new/delete call constructors and destructors). Since GLib 2.46 g_malloc() is hardcoded to always use the system malloc implementation. Memory slices provide a space-efficient and multi-processing scalable way to allocate equal-sized pieces of memory, just like the original #GMemChunks (from GLib 2.8), while avoiding their excessive memory-waste, scalability and performance problems. To achieve these goals, the slice allocator uses a sophisticated, layered design that has been inspired by Bonwick's slab allocator ([Bonwick94](http://citeseer.ist.psu.edu/bonwick94slab.html) Jeff Bonwick, The slab allocator: An object-caching kernel memory allocator. USENIX 1994, and [Bonwick01](http://citeseer.ist.psu.edu/bonwick01magazines.html) Bonwick and Jonathan Adams, Magazines and vmem: Extending the slab allocator to many cpu's and arbitrary resources. USENIX 2001) It uses posix_memalign() to optimize allocations of many equally-sized chunks, and has per-thread free lists (the so-called magazine layer) to quickly satisfy allocation requests of already known structure sizes. This is accompanied by extra caching logic to keep freed memory around for some time before returning it to the system. Memory that is unused due to alignment constraints is used for cache colorization (random distribution of chunk addresses) to improve CPU cache utilization. The caching layer of the slice allocator adapts itself to high lock contention to improve scalability. The slice allocator can allocate blocks as small as two pointers, and unlike malloc(), it does not reserve extra space per block. For large block sizes, g_slice_new() and g_slice_alloc() will automatically delegate to the system malloc() implementation. For newly written code it is recommended to use the new `g_slice` API instead of g_malloc() and friends, as long as objects are not resized during their lifetime and the object size used at allocation time is still available when freeing. Here is an example for using the slice allocator: |[ gchar *mem[10000]; gint i; // Allocate 10000 blocks. for (i = 0; i < 10000; i++) { mem[i] = g_slice_alloc (50); // Fill in the memory with some junk. for (j = 0; j < 50; j++) mem[i][j] = i * j; } // Now free all of the blocks. for (i = 0; i < 10000; i++) g_slice_free1 (50, mem[i]); ]| And here is an example for using the using the slice allocator with data structures: |[ GRealArray *array; // Allocate one block, using the g_slice_new() macro. array = g_slice_new (GRealArray); // We can now use array just like a normal pointer to a structure. array->data = NULL; array->len = 0; array->alloc = 0; array->zero_terminated = (zero_terminated ? 1 : 0); array->clear = (clear ? 1 : 0); array->elt_size = elt_size; // We can free the block, so it can be reused. g_slice_free (GRealArray, array); ]|

A convenience function/macro to log a normal message. If g_log_default_handler() is used as the log handler function, a new-line character will automatically be appended to @..., and need not be entered manually. If structured logging is enabled, this will use g_log_structured(); otherwise it will use g_log(). See [Using Structured Logging][using-structured-logging].

format string, followed by parameters to insert into the format string (as with printf())

These functions provide support for outputting messages. The g_return family of macros (g_return_if_fail(), g_return_val_if_fail(), g_return_if_reached(), g_return_val_if_reached()) should only be used for programming errors, a typical use case is checking for invalid parameters at the beginning of a public function. They should not be used if you just mean "if (error) return", they should only be used if you mean "if (bug in program) return". The program behavior is generally considered undefined after one of these checks fails. They are not intended for normal control flow, only to give a perhaps-helpful warning before giving up. Structured logging output is supported using g_log_structured(). This differs from the traditional g_log() API in that log messages are handled as a collection of key–value pairs representing individual pieces of information, rather than as a single string containing all the information in an arbitrary format. The convenience macros g_info(), g_message(), g_debug(), g_warning() and g_error() will use the traditional g_log() API unless you define the symbol %G_LOG_USE_STRUCTURED before including `glib.h`. But note that even messages logged through the traditional g_log() API are ultimatively passed to g_log_structured(), so that all log messages end up in same destination. If %G_LOG_USE_STRUCTURED is defined, g_test_expect_message() will become ineffective for the wrapper macros g_warning() and friends (see [Testing for Messages][testing-for-messages]). The support for structured logging was motivated by the following needs (some of which were supported previously; others weren’t): * Support for multiple logging levels. * Structured log support with the ability to add `MESSAGE_ID`s (see g_log_structured()). * Moving the responsibility for filtering log messages from the program to the log viewer — instead of libraries and programs installing log handlers (with g_log_set_handler()) which filter messages before output, all log messages are outputted, and the log viewer program (such as `journalctl`) must filter them. This is based on the idea that bugs are sometimes hard to reproduce, so it is better to log everything possible and then use tools to analyse the logs than it is to not be able to reproduce a bug to get additional log data. Code which uses logging in performance-critical sections should compile out the g_log_structured() calls in release builds, and compile them in in debugging builds. * A single writer function which handles all log messages in a process, from all libraries and program code; rather than multiple log handlers with poorly defined interactions between them. This allows a program to easily change its logging policy by changing the writer function, for example to log to an additional location or to change what logging output fallbacks are used. The log writer functions provided by GLib are exposed publicly so they can be used from programs’ log writers. This allows log writer policy and implementation to be kept separate. * If a library wants to add standard information to all of its log messages (such as library state) or to redact private data (such as passwords or network credentials), it should use a wrapper function around its g_log_structured() calls or implement that in the single log writer function. * If a program wants to pass context data from a g_log_structured() call to its log writer function so that, for example, it can use the correct server connection to submit logs to, that user data can be passed as a zero-length #GLogField to g_log_structured_array(). * Color output needed to be supported on the terminal, to make reading through logs easier. ## Using Structured Logging ## {#using-structured-logging} To use structured logging (rather than the old-style logging), either use the g_log_structured() and g_log_structured_array() functions; or define `G_LOG_USE_STRUCTURED` before including any GLib header, and use the g_message(), g_debug(), g_error() (etc.) macros. You do not need to define `G_LOG_USE_STRUCTURED` to use g_log_structured(), but it is a good idea to avoid confusion. ## Log Domains ## {#log-domains} Log domains may be used to broadly split up the origins of log messages. Typically, there are one or a few log domains per application or library. %G_LOG_DOMAIN should be used to define the default log domain for the current compilation unit — it is typically defined at the top of a source file, or in the preprocessor flags for a group of source files. Log domains must be unique, and it is recommended that they are the application or library name, optionally followed by a hyphen and a sub-domain name. For example, `bloatpad` or `bloatpad-io`. ## Debug Message Output ## {#debug-message-output} The default log functions (g_log_default_handler() for the old-style API and g_log_writer_default() for the structured API) both drop debug and informational messages by default, unless the log domains of those messages are listed in the `G_MESSAGES_DEBUG` environment variable (or it is set to `all`). It is recommended that custom log writer functions re-use the `G_MESSAGES_DEBUG` environment variable, rather than inventing a custom one, so that developers can re-use the same debugging techniques and tools across projects. Since GLib 2.68, this can be implemented by dropping messages for which g_log_writer_default_would_drop() returns %TRUE. ## Testing for Messages ## {#testing-for-messages} With the old g_log() API, g_test_expect_message() and g_test_assert_expected_messages() could be used in simple cases to check whether some code under test had emitted a given log message. These functions have been deprecated with the structured logging API, for several reasons: * They relied on an internal queue which was too inflexible for many use cases, where messages might be emitted in several orders, some messages might not be emitted deterministically, or messages might be emitted by unrelated log domains. * They do not support structured log fields. * Examining the log output of code is a bad approach to testing it, and while it might be necessary for legacy code which uses g_log(), it should be avoided for new code using g_log_structured(). They will continue to work as before if g_log() is in use (and %G_LOG_USE_STRUCTURED is not defined). They will do nothing if used with the structured logging API. Examining the log output of code is discouraged: libraries should not emit to `stderr` during defined behaviour, and hence this should not be tested. If the log emissions of a library during undefined behaviour need to be tested, they should be limited to asserting that the library aborts and prints a suitable error message before aborting. This should be done with g_test_trap_assert_stderr(). If it is really necessary to test the structured log messages emitted by a particular piece of code – and the code cannot be restructured to be more suitable to more conventional unit testing – you should write a custom log writer function (see g_log_set_writer_func()) which appends all log messages to a queue. When you want to check the log messages, examine and clear the queue, ignoring irrelevant log messages (for example, from log domains other than the one under test). These are portable utility functions. Create a directory if it doesn't already exist. Create intermediate parent directories as needed, too.

0 if the directory already exists, or was successfully created. Returns -1 if an error occurred, with errno set.

a pathname in the GLib file name encoding permissions to use for newly created directories

Creates a temporary directory. See the mkdtemp() documentation on most UNIX-like systems. The parameter is a string that should follow the rules for mkdtemp() templates, i.e. contain the string "XXXXXX". g_mkdtemp() is slightly more flexible than mkdtemp() in that the sequence does not have to occur at the very end of the template. The X string will be modified to form the name of a directory that didn't exist. The string should be in the GLib file name encoding. Most importantly, on Windows it should be in UTF-8. If you are going to be creating a temporary directory inside the directory returned by g_get_tmp_dir(), you might want to use g_dir_make_tmp() instead.

A pointer to @tmpl, which has been modified to hold the directory name. In case of errors, %NULL is returned and %errno will be set.

template directory name

Creates a temporary directory. See the mkdtemp() documentation on most UNIX-like systems. The parameter is a string that should follow the rules for mkdtemp() templates, i.e. contain the string "XXXXXX". g_mkdtemp_full() is slightly more flexible than mkdtemp() in that the sequence does not have to occur at the very end of the template and you can pass a @mode. The X string will be modified to form the name of a directory that didn't exist. The string should be in the GLib file name encoding. Most importantly, on Windows it should be in UTF-8. If you are going to be creating a temporary directory inside the directory returned by g_get_tmp_dir(), you might want to use g_dir_make_tmp() instead.

A pointer to @tmpl, which has been modified to hold the directory name. In case of errors, %NULL is returned, and %errno will be set.

template directory name permissions to create the temporary directory with

Opens a temporary file. See the mkstemp() documentation on most UNIX-like systems. The parameter is a string that should follow the rules for mkstemp() templates, i.e. contain the string "XXXXXX". g_mkstemp() is slightly more flexible than mkstemp() in that the sequence does not have to occur at the very end of the template. The X string will be modified to form the name of a file that didn't exist. The string should be in the GLib file name encoding. Most importantly, on Windows it should be in UTF-8.

template filename

Opens a temporary file. See the mkstemp() documentation on most UNIX-like systems. The parameter is a string that should follow the rules for mkstemp() templates, i.e. contain the string "XXXXXX". g_mkstemp_full() is slightly more flexible than mkstemp() in that the sequence does not have to occur at the very end of the template and you can pass a @mode and additional @flags. The X string will be modified to form the name of a file that didn't exist. The string should be in the GLib file name encoding. Most importantly, on Windows it should be in UTF-8.

A file handle (as from open()) to the file opened for reading and writing. The file handle should be closed with close(). In case of errors, -1 is returned and %errno will be set.

template filename flags to pass to an open() call in addition to O_EXCL and O_CREAT, which are passed automatically permissions to create the temporary file with

Allocates @n_structs elements of type @struct_type. The returned pointer is cast to a pointer to the given type. If @n_structs is 0 it returns %NULL. Care is taken to avoid overflow when calculating the size of the allocated block. Since the returned pointer is already casted to the right type, it is normally unnecessary to cast it explicitly, and doing so might hide memory allocation errors.

the type of the elements to allocate the number of elements to allocate

Allocates @n_structs elements of type @struct_type, initialized to 0's. The returned pointer is cast to a pointer to the given type. If @n_structs is 0 it returns %NULL. Care is taken to avoid overflow when calculating the size of the allocated block. Since the returned pointer is already casted to the right type, it is normally unnecessary to cast it explicitly, and doing so might hide memory allocation errors.

the type of the elements to allocate. the number of elements to allocate.

Wraps g_alloca() in a more typesafe manner. As mentioned in the documentation for g_alloca(), @n_structs must always be entirely under the control of the program, or you may introduce a denial of service vulnerability. In addition, the multiplication of @struct_type by @n_structs is not checked, so an overflow may lead to a remote code execution vulnerability.

Type of memory chunks to be allocated Number of chunks to be allocated

Wraps g_alloca0() in a more typesafe manner.

the type of the elements to allocate. the number of elements to allocate.

Inserts a #GNode as the last child of the given parent.

the #GNode to place the new #GNode under the #GNode to insert

Inserts a new #GNode as the last child of the given parent.

the #GNode to place the new #GNode under the data for the new #GNode

Gets the first child of a #GNode.

a #GNode

Inserts a new #GNode at the given position.

the #GNode to place the new #GNode under the position to place the new #GNode at. If position is -1, the new #GNode is inserted as the last child of @parent the data for the new #GNode

Inserts a new #GNode after the given sibling.

the #GNode to place the new #GNode under the sibling #GNode to place the new #GNode after the data for the new #GNode

Inserts a new #GNode before the given sibling.

the #GNode to place the new #GNode under the sibling #GNode to place the new #GNode before the data for the new #GNode

Gets the next sibling of a #GNode.

a #GNode

Inserts a new #GNode as the first child of the given parent.

the #GNode to place the new #GNode under the data for the new #GNode

Gets the previous sibling of a #GNode.

a #GNode

Converts a 32-bit integer value from network to host byte order.

a 32-bit integer value in network byte order

Converts a 16-bit integer value from network to host byte order.

a 16-bit integer value in network byte order

Set the pointer at the specified location to %NULL.

the memory address of the pointer.

GLib offers mathematical constants such as %G_PI for the value of pi; many platforms have these in the C library, but some don't, the GLib versions always exist. The #GFloatIEEE754 and #GDoubleIEEE754 unions are used to access the sign, mantissa and exponent of IEEE floats and doubles. These unions are defined as appropriate for a given platform. IEEE floats and doubles are supported (used for storage) by at least Intel, PPC and Sparc. See [IEEE 754-2008](http://en.wikipedia.org/wiki/IEEE_float) for more information about IEEE number formats. Prompts the user with `[E]xit, [H]alt, show [S]tack trace or [P]roceed`. This function is intended to be used for debugging use only. The following example shows how it can be used together with the g_log() functions. |[ #include <glib.h> static void log_handler (const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer user_data) { g_log_default_handler (log_domain, log_level, message, user_data); g_on_error_query (MY_PROGRAM_NAME); } int main (int argc, char *argv[]) { g_log_set_handler (MY_LOG_DOMAIN, G_LOG_LEVEL_WARNING | G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL, log_handler, NULL); ... ]| If "[E]xit" is selected, the application terminates with a call to _exit(0). If "[S]tack" trace is selected, g_on_error_stack_trace() is called. This invokes gdb, which attaches to the current process and shows a stack trace. The prompt is then shown again. If "[P]roceed" is selected, the function returns. This function may cause different actions on non-UNIX platforms. On Windows consider using the `G_DEBUGGER` environment variable (see [Running GLib Applications](glib-running.html)) and calling g_on_error_stack_trace() instead.

the program name, needed by gdb for the "[S]tack trace" option. If @prg_name is %NULL, g_get_prgname() is called to get the program name (which will work correctly if gdk_init() or gtk_init() has been called)

Invokes gdb, which attaches to the current process and shows a stack trace. Called by g_on_error_query() when the "[S]tack trace" option is selected. You can get the current process's program name with g_get_prgname(), assuming that you have called gtk_init() or gdk_init(). This function may cause different actions on non-UNIX platforms. When running on Windows, this function is *not* called by g_on_error_query(). If called directly, it will raise an exception, which will crash the program. If the `G_DEBUGGER` environment variable is set, a debugger will be invoked to attach and handle that exception (see [Running GLib Applications](glib-running.html)).

the program name, needed by gdb for the "[S]tack trace" option

The first call to this routine by a process with a given #GOnce struct calls @func with the given argument. Thereafter, subsequent calls to g_once() with the same #GOnce struct do not call @func again, but return the stored result of the first call. On return from g_once(), the status of @once will be %G_ONCE_STATUS_READY. For example, a mutex or a thread-specific data key must be created exactly once. In a threaded environment, calling g_once() ensures that the initialization is serialized across multiple threads. Calling g_once() recursively on the same #GOnce struct in @func will lead to a deadlock. |[ gpointer get_debug_flags (void) { static GOnce my_once = G_ONCE_INIT; g_once (&my_once, parse_debug_flags, NULL); return my_once.retval; } ]|

a #GOnce structure the #GThreadFunc function associated to @once. This function is called only once, regardless of the number of times it and its associated #GOnce struct are passed to g_once(). data to be passed to @func

%TRUE if the initialization section should be entered, %FALSE and blocks otherwise

location of a static initializable variable containing 0

location of a static initializable variable containing 0 new non-0 value for *@value_location

The GOption commandline parser is intended to be a simpler replacement for the popt library. It supports short and long commandline options, as shown in the following example: `testtreemodel -r 1 --max-size 20 --rand --display=:1.0 -vb -- file1 file2` The example demonstrates a number of features of the GOption commandline parser: - Options can be single letters, prefixed by a single dash. - Multiple short options can be grouped behind a single dash. - Long options are prefixed by two consecutive dashes. - Options can have an extra argument, which can be a number, a string or a filename. For long options, the extra argument can be appended with an equals sign after the option name, which is useful if the extra argument starts with a dash, which would otherwise cause it to be interpreted as another option. - Non-option arguments are returned to the application as rest arguments. - An argument consisting solely of two dashes turns off further parsing, any remaining arguments (even those starting with a dash) are returned to the application as rest arguments. Another important feature of GOption is that it can automatically generate nicely formatted help output. Unless it is explicitly turned off with g_option_context_set_help_enabled(), GOption will recognize the `--help`, `-?`, `--help-all` and `--help-groupname` options (where `groupname` is the name of a #GOptionGroup) and write a text similar to the one shown in the following example to stdout. |[ Usage: testtreemodel [OPTION...] - test tree model performance Help Options: -h, --help Show help options --help-all Show all help options --help-gtk Show GTK+ Options Application Options: -r, --repeats=N Average over N repetitions -m, --max-size=M Test up to 2^M items --display=DISPLAY X display to use -v, --verbose Be verbose -b, --beep Beep when done --rand Randomize the data ]| GOption groups options in #GOptionGroups, which makes it easy to incorporate options from multiple sources. The intended use for this is to let applications collect option groups from the libraries it uses, add them to their #GOptionContext, and parse all options by a single call to g_option_context_parse(). See gtk_get_option_group() for an example. If an option is declared to be of type string or filename, GOption takes care of converting it to the right encoding; strings are returned in UTF-8, filenames are returned in the GLib filename encoding. Note that this only works if setlocale() has been called before g_option_context_parse(). Here is a complete example of setting up GOption to parse the example commandline above and produce the example help output. |[ static gint repeats = 2; static gint max_size = 8; static gboolean verbose = FALSE; static gboolean beep = FALSE; static gboolean randomize = FALSE; static GOptionEntry entries[] = { { "repeats", 'r', 0, G_OPTION_ARG_INT, &repeats, "Average over N repetitions", "N" }, { "max-size", 'm', 0, G_OPTION_ARG_INT, &max_size, "Test up to 2^M items", "M" }, { "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose, "Be verbose", NULL }, { "beep", 'b', 0, G_OPTION_ARG_NONE, &beep, "Beep when done", NULL }, { "rand", 0, 0, G_OPTION_ARG_NONE, &randomize, "Randomize the data", NULL }, G_OPTION_ENTRY_NULL }; int main (int argc, char *argv[]) { GError *error = NULL; GOptionContext *context; context = g_option_context_new ("- test tree model performance"); g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE); g_option_context_add_group (context, gtk_get_option_group (TRUE)); if (!g_option_context_parse (context, &argc, &argv, &error)) { g_print ("option parsing failed: %s\n", error->message); exit (1); } ... } ]| On UNIX systems, the argv that is passed to main() has no particular encoding, even to the extent that different parts of it may have different encodings. In general, normal arguments and flags will be in the current locale and filenames should be considered to be opaque byte strings. Proper use of %G_OPTION_ARG_FILENAME vs %G_OPTION_ARG_STRING is therefore important. Note that on Windows, filenames do have an encoding, but using #GOptionContext with the argv as passed to main() will result in a program that can only accept commandline arguments with characters from the system codepage. This can cause problems when attempting to deal with filenames containing Unicode characters that fall outside of the codepage. A solution to this is to use g_win32_get_command_line() and g_option_context_parse_strv() which will properly handle full Unicode filenames. If you are using #GApplication, this is done automatically for you. The following example shows how you can use #GOptionContext directly in order to correctly deal with Unicode filenames on Windows: |[ int main (int argc, char **argv) { GError *error = NULL; GOptionContext *context; gchar **args; #ifdef G_OS_WIN32 args = g_win32_get_command_line (); #else args = g_strdupv (argv); #endif // set up context if (!g_option_context_parse_strv (context, &args, &error)) { // error happened } ... g_strfreev (args); ... } ]|

Parses a string containing debugging options into a %guint containing bit flags. This is used within GDK and GTK+ to parse the debug options passed on the command line or through environment variables. If @string is equal to "all", all flags are set. Any flags specified along with "all" in @string are inverted; thus, "all,foo,bar" or "foo,bar,all" sets all flags except those corresponding to "foo" and "bar". If @string is equal to "help", all the available keys in @keys are printed out to standard error.

the combined set of bit flags.

a list of debug options separated by colons, spaces, or commas, or %NULL. pointer to an array of #GDebugKey which associate strings with bit flags. the number of #GDebugKeys in the array.

Gets the last component of the filename. If @file_name ends with a directory separator it gets the component before the last slash. If @file_name consists only of directory separators (and on Windows, possibly a drive letter), a single separator is returned. If @file_name is empty, it gets ".".

a newly allocated string containing the last component of the filename

the name of the file

Gets the directory components of a file name. For example, the directory component of `/usr/bin/test` is `/usr/bin`. The directory component of `/` is `/`. If the file name has no directory components "." is returned. The returned string should be freed when no longer needed.

the directory components of the file

the name of the file

Returns %TRUE if the given @file_name is an absolute file name. Note that this is a somewhat vague concept on Windows. On POSIX systems, an absolute file name is well-defined. It always starts from the single root directory. For example "/usr/local". On Windows, the concepts of current drive and drive-specific current directory introduce vagueness. This function interprets as an absolute file name one that either begins with a directory separator such as "\Users\tml" or begins with the root on a drive, for example "C:\Windows". The first case also includes UNC paths such as "\\\\myserver\docs\foo". In all cases, either slashes or backslashes are accepted. Note that a file name relative to the current drive root does not truly specify a file uniquely over time and across processes, as the current drive is a per-process value and can be changed. File names relative the current directory on some specific drive, such as "D:foo/bar", are not interpreted as absolute by this function, but they obviously are not relative to the normal current directory as returned by getcwd() or g_get_current_dir() either. Such paths should be avoided, or need to be handled using Windows-specific code.

%TRUE if @file_name is absolute

a file name

Returns a pointer into @file_name after the root component, i.e. after the "/" in UNIX or "C:\" under Windows. If @file_name is not an absolute path it returns %NULL.

a pointer into @file_name after the root component

a file name

Use g_pattern_spec_match() instead

%TRUE if @string matches @pspec

a #GPatternSpec the length of @string (in bytes, i.e. strlen(), not g_utf8_strlen()) the UTF-8 encoded string to match the reverse of @string or %NULL

Matches a string against a pattern given as a string. If this function is to be called in a loop, it's more efficient to compile the pattern once with g_pattern_spec_new() and call g_pattern_match_string() repeatedly.

%TRUE if @string matches @pspec

the UTF-8 encoded pattern the UTF-8 encoded string to match

Matches a string against a compiled pattern. If the string is to be matched against more than one pattern, consider using g_pattern_match() instead while supplying the reversed string.

Use g_pattern_spec_match_string() instead

%TRUE if @string matches @pspec

a #GPatternSpec the UTF-8 encoded string to match

The g_pattern_match* functions match a string against a pattern containing '*' and '?' wildcards with similar semantics as the standard glob() function: '*' matches an arbitrary, possibly empty, string, '?' matches an arbitrary character. Note that in contrast to glob(), the '/' character can be matched by the wildcards, there are no '[...]' character ranges and '*' and '?' can not be escaped to include them literally in a pattern. When multiple strings must be matched against the same pattern, it is better to compile the pattern to a #GPatternSpec using g_pattern_spec_new() and use g_pattern_match_string() instead of g_pattern_match_simple(). This avoids the overhead of repeated pattern compilation. This is equivalent to g_bit_lock, but working on pointers (or other pointer-sized values). For portability reasons, you may only lock on the bottom 32 bits of the pointer. While @address has a `volatile` qualifier, this is a historical artifact and the argument passed to it should not be `volatile`.

a pointer to a #gpointer-sized value a bit value between 0 and 31

This is equivalent to g_bit_trylock(), but working on pointers (or other pointer-sized values). For portability reasons, you may only lock on the bottom 32 bits of the pointer. While @address has a `volatile` qualifier, this is a historical artifact and the argument passed to it should not be `volatile`.

%TRUE if the lock was acquired

a pointer to a #gpointer-sized value a bit value between 0 and 31

This is equivalent to g_bit_unlock, but working on pointers (or other pointer-sized values). For portability reasons, you may only lock on the bottom 32 bits of the pointer. While @address has a `volatile` qualifier, this is a historical artifact and the argument passed to it should not be `volatile`.

a pointer to a #gpointer-sized value a bit value between 0 and 31

Polls @fds, as with the poll() system call, but portably. (On systems that don't have poll(), it is emulated using select().) This is used internally by #GMainContext, but it can be called directly if you need to block until a file descriptor is ready, but don't want to run the full main loop. Each element of @fds is a #GPollFD describing a single file descriptor to poll. The @fd field indicates the file descriptor, and the @events field indicates the events to poll for. On return, the @revents fields will be filled with the events that actually occurred. On POSIX systems, the file descriptors in @fds can be any sort of file descriptor, but the situation is much more complicated on Windows. If you need to use g_poll() in code that has to run on Windows, the easiest solution is to construct all of your #GPollFDs with g_io_channel_win32_make_pollfd().

the number of entries in @fds whose @revents fields were filled in, or 0 if the operation timed out, or -1 on error or if the call was interrupted.

file descriptors to poll the number of file descriptors in @fds amount of time to wait, in milliseconds, or -1 to wait forever

Formats a string according to @format and prefix it to an existing error message. If @err is %NULL (ie: no error variable) then do nothing. If *@err is %NULL (ie: an error variable is present but there is no error condition) then also do nothing.

a return location for a #GError printf()-style format string arguments to @format

Prefixes @prefix to an existing error message. If @err or *@err is %NULL (i.e.: no error variable) then do nothing.

a return location for a #GError, or %NULL string to prefix @err with

Outputs a formatted message via the print handler. The default print handler simply outputs the message to stdout, without appending a trailing new-line character. Typically, @format should end with its own new-line character. g_print() should not be used from within libraries for debugging messages, since it may be redirected by applications to special purpose message windows or even files. Instead, libraries should use g_log(), g_log_structured(), or the convenience macros g_message(), g_warning() and g_error().

the message format. See the printf() documentation the parameters to insert into the format string

Outputs a formatted message via the error message handler. The default handler simply outputs the message to stderr, without appending a trailing new-line character. Typically, @format should end with its own new-line character. g_printerr() should not be used from within libraries. Instead g_log() or g_log_structured() should be used, or the convenience macros g_message(), g_warning() and g_error().

the message format. See the printf() documentation the parameters to insert into the format string

An implementation of the standard printf() function which supports positional parameters, as specified in the Single Unix Specification. As with the standard printf(), this does not automatically append a trailing new-line character to the message, so typically @format should end with its own new-line character. `glib/gprintf.h` must be explicitly included in order to use this function.

the number of bytes printed.

a standard printf() format string, but notice [string precision pitfalls][string-precision] the arguments to insert in the output.

Calculates the maximum space needed to store the output of the sprintf() function.

the maximum space needed to store the formatted string

the format string. See the printf() documentation the parameters to be inserted into the format string

If @dest is %NULL, free @src; otherwise, moves @src into *@dest. The error variable @dest points to must be %NULL. @src must be non-%NULL. Note that @src is no longer valid after this call. If you want to keep using the same GError*, you need to set it to %NULL after calling this function on it.

error return location error to move into the return location

If @dest is %NULL, free @src; otherwise, moves @src into *@dest. *@dest must be %NULL. After the move, add a prefix as with g_prefix_error().

error return location error to move into the return location printf()-style format string arguments to @format

%TRUE if @needle is one of the elements of @haystack

pointer array to be searched pointer to look for return location for the index of the element, if found

%TRUE if @needle is one of the elements of @haystack

Returns the pointer at the given index of the pointer array. This does not perform bounds checking on the given @index_, so you are responsible for checking it against the array length.

a #GPtrArray the index of the pointer to return

This is just like the standard C qsort() function, but the comparison routine accepts a user data argument. This is guaranteed to be a stable sort since version 2.32.

start of array to sort elements in the array size of each element function to compare elements data to pass to @compare_func

Gets the #GQuark identifying the given (static) string. If the string does not currently have an associated #GQuark, a new #GQuark is created, linked to the given string. Note that this function is identical to g_quark_from_string() except that if a new #GQuark is created the string itself is used rather than a copy. This saves memory, but can only be used if the string will continue to exist until the program terminates. It can be used with statically allocated strings in the main program, but not with statically allocated memory in dynamically loaded modules, if you expect to ever unload the module again (e.g. do not use this function in GTK+ theme engines). This function must not be used before library constructors have finished running. In particular, this means it cannot be used to initialize global variables in C++.

the #GQuark identifying the string, or 0 if @string is %NULL

a string

Gets the #GQuark identifying the given string. If the string does not currently have an associated #GQuark, a new #GQuark is created, using a copy of the string. This function must not be used before library constructors have finished running. In particular, this means it cannot be used to initialize global variables in C++.

the #GQuark identifying the string, or 0 if @string is %NULL

a string

Gets the string associated with the given #GQuark.

the string associated with the #GQuark

a #GQuark.

Gets the #GQuark associated with the given string, or 0 if string is %NULL or it has no associated #GQuark. If you want the GQuark to be created if it doesn't already exist, use g_quark_from_string() or g_quark_from_static_string(). This function must not be used before library constructors have finished running.

the #GQuark associated with the string, or 0 if @string is %NULL or there is no #GQuark associated with it

a string

Quarks are associations between strings and integer identifiers. Given either the string or the #GQuark identifier it is possible to retrieve the other. Quarks are used for both [datasets][glib-Datasets] and [keyed data lists][glib-Keyed-Data-Lists]. To create a new quark from a string, use g_quark_from_string() or g_quark_from_static_string(). To find the string corresponding to a given #GQuark, use g_quark_to_string(). To find the #GQuark corresponding to a given string, use g_quark_try_string(). Another use for the string pool maintained for the quark functions is string interning, using g_intern_string() or g_intern_static_string(). An interned string is a canonical representation for a string. One important advantage of interned strings is that they can be compared for equality by a simple pointer comparison, rather than using strcmp(). The #GQueue structure and its associated functions provide a standard queue data structure. Internally, GQueue uses the same data structure as #GList to store elements with the same complexity over insertion/deletion (O(1)) and access/search (O(n)) operations. The data contained in each element can be either integer values, by using one of the [Type Conversion Macros][glib-Type-Conversion-Macros], or simply pointers to any type of data. As with all other GLib data structures, #GQueue is not thread-safe. For a thread-safe queue, use #GAsyncQueue. To create a new GQueue, use g_queue_new(). To initialize a statically-allocated GQueue, use %G_QUEUE_INIT or g_queue_init(). To add elements, use g_queue_push_head(), g_queue_push_head_link(), g_queue_push_tail() and g_queue_push_tail_link(). To remove elements, use g_queue_pop_head() and g_queue_pop_tail(). To free the entire queue, use g_queue_free().

Returns a random #gboolean from @rand_. This corresponds to an unbiased coin toss.

a #GRand

Returns a random #gboolean. This corresponds to an unbiased coin toss.

Returns a random #gdouble equally distributed over the range [0..1).

a random number

Returns a random #gdouble equally distributed over the range [@begin..@end).

a random number

lower closed bound of the interval upper open bound of the interval

Return a random #guint32 equally distributed over the range [0..2^32-1].

a random number

Returns a random #gint32 equally distributed over the range [@begin..@end-1].

a random number

lower closed bound of the interval upper open bound of the interval

The following functions allow you to use a portable, fast and good pseudo-random number generator (PRNG). Do not use this API for cryptographic purposes such as key generation, nonces, salts or one-time pads. This PRNG is suitable for non-cryptographic use such as in games (shuffling a card deck, generating levels), generating data for a test suite, etc. If you need random data for cryptographic purposes, it is recommended to use platform-specific APIs such as `/dev/random` on UNIX, or CryptGenRandom() on Windows. GRand uses the Mersenne Twister PRNG, which was originally developed by Makoto Matsumoto and Takuji Nishimura. Further information can be found at [this page](http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html). If you just need a random number, you simply call the g_random_* functions, which will create a globally used #GRand and use the according g_rand_* functions internally. Whenever you need a stream of reproducible random numbers, you better create a #GRand yourself and use the g_rand_* functions directly, which will also be slightly faster. Initializing a #GRand with a certain seed will produce exactly the same series of random numbers on all platforms. This can thus be used as a seed for e.g. games. The g_rand*_range functions will return high quality equally distributed random numbers, whereas for example the `(g_random_int()%max)` approach often doesn't yield equally distributed numbers. GLib changed the seeding algorithm for the pseudo-random number generator Mersenne Twister, as used by #GRand. This was necessary, because some seeds would yield very bad pseudo-random streams. Also the pseudo-random integers generated by g_rand*_int_range() will have a slightly better equal distribution with the new version of GLib. The original seeding and generation algorithms, as found in GLib 2.0.x, can be used instead of the new ones by setting the environment variable `G_RANDOM_VERSION` to the value of '2.0'. Use the GLib-2.0 algorithms only if you have sequences of numbers generated with Glib-2.0 that you need to reproduce exactly. Sets the seed for the global random number generator, which is used by the g_random_* functions, to @seed.

a value to reinitialize the global random number generator

Acquires a reference on the data pointed by @mem_block.

a pointer to the data, with its reference count increased

a pointer to reference counted data

Allocates @block_size bytes of memory, and adds reference counting semantics to it. The data will be freed when its reference count drops to zero. The allocated data is guaranteed to be suitably aligned for any built-in type.

a pointer to the allocated memory

the size of the allocation, must be greater than 0

Allocates @block_size bytes of memory, and adds reference counting semantics to it. The contents of the returned data is set to zero. The data will be freed when its reference count drops to zero. The allocated data is guaranteed to be suitably aligned for any built-in type.

a pointer to the allocated memory

the size of the allocation, must be greater than 0

Allocates a new block of data with reference counting semantics, and copies @block_size bytes of @mem_block into it.

a pointer to the allocated memory

the number of bytes to copy, must be greater than 0 the memory to copy

Retrieves the size of the reference counted data pointed by @mem_block.

the size of the data, in bytes

a pointer to reference counted data

A convenience macro to allocate reference counted data with the size of the given @type. This macro calls g_rc_box_alloc() with `sizeof (@type)` and casts the returned pointer to a pointer of the given @type, avoiding a type cast in the source code.

the type to allocate, typically a structure name

A convenience macro to allocate reference counted data with the size of the given @type, and set its contents to zero. This macro calls g_rc_box_alloc0() with `sizeof (@type)` and casts the returned pointer to a pointer of the given @type, avoiding a type cast in the source code.

the type to allocate, typically a structure name

Releases a reference on the data pointed by @mem_block. If the reference was the last one, it will free the resources allocated for @mem_block.

a pointer to reference counted data

Releases a reference on the data pointed by @mem_block. If the reference was the last one, it will call @clear_func to clear the contents of @mem_block, and then will free the resources allocated for @mem_block.

a pointer to reference counted data a function to call when clearing the data

A "reference counted box", or "RcBox", is an opaque wrapper data type that is guaranteed to be as big as the size of a given data type, and which augments the given data type with reference counting semantics for its memory management. RcBox is useful if you have a plain old data type, like a structure typically placed on the stack, and you wish to provide additional API to use it on the heap; or if you want to implement a new type to be passed around by reference without necessarily implementing copy/free semantics or your own reference counting. The typical use is: |[ typedef struct { char *name; char *address; char *city; char *state; int age; } Person; Person * person_new (void) { return g_rc_box_new0 (Person); } ]| Every time you wish to acquire a reference on the memory, you should call g_rc_box_acquire(); similarly, when you wish to release a reference you should call g_rc_box_release(): |[ // Add a Person to the Database; the Database acquires ownership // of the Person instance void add_person_to_database (Database *db, Person *p) { db->persons = g_list_prepend (db->persons, g_rc_box_acquire (p)); } // Removes a Person from the Database; the reference acquired by // add_person_to_database() is released here void remove_person_from_database (Database *db, Person *p) { db->persons = g_list_remove (db->persons, p); g_rc_box_release (p); } ]| If you have additional memory allocated inside the structure, you can use g_rc_box_release_full(), which takes a function pointer, which will be called if the reference released was the last: |[ void person_clear (Person *p) { g_free (p->name); g_free (p->address); g_free (p->city); g_free (p->state); } void remove_person_from_database (Database *db, Person *p) { db->persons = g_list_remove (db->persons, p); g_rc_box_release_full (p, (GDestroyNotify) person_clear); } ]| If you wish to transfer the ownership of a reference counted data type without increasing the reference count, you can use g_steal_pointer(): |[ Person *p = g_rc_box_new (Person); // fill_person_details() is defined elsewhere fill_person_details (p); // add_person_to_database_no_ref() is defined elsewhere; it adds // a Person to the Database without taking a reference add_person_to_database_no_ref (db, g_steal_pointer (&p)); ]| ## Thread safety The reference counting operations on data allocated using g_rc_box_alloc(), g_rc_box_new(), and g_rc_box_dup() are not thread safe; it is your code's responsibility to ensure that references are acquired are released on the same thread. If you need thread safe reference counting, see the [atomic reference counted data][arcbox] API. ## Automatic pointer clean up If you want to add g_autoptr() support to your plain old data type through reference counting, you can use the G_DEFINE_AUTOPTR_CLEANUP_FUNC() and g_rc_box_release(): |[ G_DEFINE_AUTOPTR_CLEANUP_FUNC (MyDataStruct, g_rc_box_release) ]| If you need to clear the contents of the data, you will need to use an ancillary function that calls g_rc_box_release_full(): |[ static void my_data_struct_release (MyDataStruct *data) { // my_data_struct_clear() is defined elsewhere g_rc_box_release_full (data, (GDestroyNotify) my_data_struct_clear); } G_DEFINE_AUTOPTR_CLEANUP_FUNC (MyDataStruct, my_data_struct_release) ]| Reallocates the memory pointed to by @mem, so that it now has space for @n_bytes bytes of memory. It returns the new address of the memory, which may have been moved. @mem may be %NULL, in which case it's considered to have zero-length. @n_bytes may be 0, in which case %NULL will be returned and @mem will be freed unless it is %NULL. If the allocation fails (because the system is out of memory), the program is terminated.

the new address of the allocated memory

the memory to reallocate new size of the memory in bytes

This function is similar to g_realloc(), allocating (@n_blocks * @n_block_bytes) bytes, but care is taken to detect possible overflow during multiplication. If the allocation fails (because the system is out of memory), the program is terminated.

the new address of the allocated memory

the memory to reallocate the number of blocks to allocate the size of each block in bytes

Compares the current value of @rc with @val.

%TRUE if the reference count is the same as the given value

the address of a reference count variable the value to compare

Decreases the reference count. If %TRUE is returned, the reference count reached 0. After this point, @rc is an undefined state and must be reinitialized with g_ref_count_init() to be used again.

%TRUE if the reference count reached 0, and %FALSE otherwise

the address of a reference count variable

Increases the reference count.

the address of a reference count variable

Initializes a reference count variable to 1.

the address of a reference count variable

Acquires a reference on a string.

the given string, with its reference count increased

a reference counted string

Retrieves the length of @str.

the length of the given string, in bytes

a reference counted string

Creates a new reference counted string and copies the contents of @str into it.

the newly created reference counted string

a NUL-terminated string

Creates a new reference counted string and copies the content of @str into it. If you call this function multiple times with the same @str, or with the same contents of @str, it will return a new reference, instead of creating a new string.

the newly created reference counted string, or a new reference to an existing string

a NUL-terminated string

Creates a new reference counted string and copies the contents of @str into it, up to @len bytes. Since this function does not stop at nul bytes, it is the caller's responsibility to ensure that @str has at least @len addressable bytes.

the newly created reference counted string

a string length of @str to use, or -1 if @str is nul-terminated

Releases a reference on a string; if it was the last reference, the resources allocated by the string are freed as well.

a reference counted string

Reference counting is a garbage collection mechanism that is based on assigning a counter to a data type, or any memory area; the counter is increased whenever a new reference to that data type is acquired, and decreased whenever the reference is released. Once the last reference is released, the resources associated to that data type are freed. GLib uses reference counting in many of its data types, and provides the #grefcount and #gatomicrefcount types to implement safe and atomic reference counting semantics in new data types. It is important to note that #grefcount and #gatomicrefcount should be considered completely opaque types; you should always use the provided API to increase and decrease the counters, and you should never check their content directly, or compare their content with other values. Reference counted strings are normal C strings that have been augmented with a reference counter to manage their resources. You allocate a new reference counted string and acquire and release references as needed, instead of copying the string among callers; when the last reference on the string is released, the resources allocated for it are freed. Typically, reference counted strings can be used when parsing data from files and storing them into data structures that are passed to various callers: |[ PersonDetails * person_details_from_data (const char *data) { // Use g_autoptr() to simplify error cases g_autoptr(GRefString) full_name = NULL; g_autoptr(GRefString) address = NULL; g_autoptr(GRefString) city = NULL; g_autoptr(GRefString) state = NULL; g_autoptr(GRefString) zip_code = NULL; // parse_person_details() is defined elsewhere; returns refcounted strings if (!parse_person_details (data, &full_name, &address, &city, &state, &zip_code)) return NULL; if (!validate_zip_code (zip_code)) return NULL; // add_address_to_cache() and add_full_name_to_cache() are defined // elsewhere; they add strings to various caches, using refcounted // strings to avoid copying data over and over again add_address_to_cache (address, city, state, zip_code); add_full_name_to_cache (full_name); // person_details_new() is defined elsewhere; it takes a reference // on each string PersonDetails *res = person_details_new (full_name, address, city, state, zip_code); return res; } ]| In the example above, we have multiple functions taking the same strings for different uses; with typical C strings, we'd have to copy the strings every time the life time rules of the data differ from the life time of the string parsed from the original buffer. With reference counted strings, each caller can take a reference on the data, and keep it as long as it needs to own the string. Reference counted strings can also be "interned" inside a global table owned by GLib; while an interned string has at least a reference, creating a new interned reference counted string with the same contents will return a reference to the existing string instead of creating a new reference counted string instance. Once the string loses its last reference, it will be automatically removed from the global interned strings table. Checks whether @replacement is a valid replacement string (see g_regex_replace()), i.e. that all escape sequences in it are valid. If @has_references is not %NULL then @replacement is checked for pattern references. For instance, replacement text 'foo\n' does not contain references and may be evaluated without information about actual match, but '\0\1' (whole match followed by first subpattern) requires valid #GMatchInfo object.

whether @replacement is a valid replacement string

the replacement string location to store information about references in @replacement or %NULL

a newly-allocated escaped string

the string to escape the length of @string

a newly-allocated escaped string

the string to escape the length of @string, in bytes, or -1 if @string is nul-terminated

%TRUE if the string matched, %FALSE otherwise

the regular expression the string to scan for matches compile options for the regular expression, or 0 match options, or 0

Breaks the string on the pattern, and returns an array of the tokens. If the pattern contains capturing parentheses, then the text for each of the substrings will also be returned. If the pattern does not match anywhere in the string, then the whole string is returned as the first token. This function is equivalent to g_regex_split() but it does not require to compile the pattern with g_regex_new(), avoiding some lines of code when you need just to do a split without extracting substrings, capture counts, and so on. If this function is to be called on the same @pattern more than once, it's more efficient to compile the pattern once with g_regex_new() and then use g_regex_split(). As a special case, the result of splitting the empty string "" is an empty vector, not a vector containing a single string. The reason for this special case is that being able to represent an empty vector is typically more useful than consistent handling of empty elements. If you do need to represent empty elements, you'll need to check for the empty string before calling this function. A pattern that can match empty strings splits @string into separate characters wherever it matches the empty string between characters. For example splitting "ab c" using as a separator "\s*", you will get "a", "b" and "c".

a %NULL-terminated array of strings. Free it using g_strfreev()

the regular expression the string to scan for matches compile options for the regular expression, or 0 match options, or 0

Resets the cache used for g_get_user_special_dir(), so that the latest on-disk version is used. Call this only if you just changed the data on disk yourself. Due to thread safety issues this may cause leaking of strings that were previously returned from g_get_user_special_dir() that can't be freed. We ensure to only leak the data for the directories that actually changed value though.

Reallocates the memory pointed to by @mem, so that it now has space for @n_structs elements of type @struct_type. It returns the new address of the memory, which may have been moved. Care is taken to avoid overflow when calculating the size of the allocated block.

the type of the elements to allocate the currently allocated memory the number of elements to allocate

Internal function used to print messages from the public g_return_if_fail() and g_return_val_if_fail() macros.

log domain function containing the assertion expression which failed

A wrapper for the POSIX rmdir() function. The rmdir() function deletes a directory from the filesystem. See your C library manual for more details about how rmdir() works on your system.

0 if the directory was successfully removed, -1 if an error occurred

a pathname in the GLib file name encoding (UTF-8 on Windows)

The #GScanner and its associated functions provide a general purpose lexical scanner.

Adds a symbol to the default scope.

Use g_scanner_scope_add_symbol() instead.

a #GScanner the symbol to add the value of the symbol

Calls a function for each symbol in the default scope.

Use g_scanner_scope_foreach_symbol() instead.

a #GScanner the function to call with each symbol data to pass to the function

There is no reason to use this macro, since it does nothing.

This macro does nothing.

a #GScanner

Removes a symbol from the default scope.

Use g_scanner_scope_remove_symbol() instead.

a #GScanner the symbol to remove

There is no reason to use this macro, since it does nothing.

This macro does nothing.

a #GScanner

The #GSequence data structure has the API of a list, but is implemented internally with a balanced binary tree. This means that most of the operations (access, search, insertion, deletion, ...) on #GSequence are O(log(n)) in average and O(n) in worst case for time complexity. But, note that maintaining a balanced sorted list of n elements is done in time O(n log(n)). The data contained in each element can be either integer values, by using of the [Type Conversion Macros][glib-Type-Conversion-Macros], or simply pointers to any type of data. A #GSequence is accessed through "iterators", represented by a #GSequenceIter. An iterator represents a position between two elements of the sequence. For example, the "begin" iterator represents the gap immediately before the first element of the sequence, and the "end" iterator represents the gap immediately after the last element. In an empty sequence, the begin and end iterators are the same. Some methods on #GSequence operate on ranges of items. For example g_sequence_foreach_range() will call a user-specified function on each element with the given range. The range is delimited by the gaps represented by the passed-in iterators, so if you pass in the begin and end iterators, the range in question is the entire sequence. The function g_sequence_get() is used with an iterator to access the element immediately following the gap that the iterator represents. The iterator is said to "point" to that element. Iterators are stable across most operations on a #GSequence. For example an iterator pointing to some element of a sequence will continue to point to that element even after the sequence is sorted. Even moving an element to another sequence using for example g_sequence_move_range() will not invalidate the iterators pointing to it. The only operation that will invalidate an iterator is when the element it points to is removed from any sequence. To sort the data, either use g_sequence_insert_sorted() or g_sequence_insert_sorted_iter() to add data to the #GSequence or, if you want to add a large amount of data, it is more efficient to call g_sequence_sort() or g_sequence_sort_iter() after doing unsorted insertions. Returns the data that @iter points to.

the data that @iter points to

a #GSequenceIter

Inserts a new item just before the item pointed to by @iter.

an iterator pointing to the new item

a #GSequenceIter the data for the new item

a #GSequenceIter pointing to the item to move a #GSequenceIter pointing to the position to which the item is moved

a #GSequenceIter a #GSequenceIter a #GSequenceIter

a #GSequenceIter pointing somewhere in the (@begin, @end) range

a #GSequenceIter a #GSequenceIter

a #GSequenceIter

Removes all items in the (@begin, @end) range. If the sequence has a data destroy function associated with it, this function is called on the data for the removed items.

a #GSequenceIter a #GSequenceIter

Changes the data for the item pointed to by @iter to be @data. If the sequence has a data destroy function associated with it, that function is called on the existing data that @iter pointed to.

a #GSequenceIter new data for the item

Swaps the items pointed to by @a and @b. It is allowed for @a and @b to point into difference sequences.

a #GSequenceIter a #GSequenceIter

Sets a human-readable name for the application. This name should be localized if possible, and is intended for display to the user. Contrast with g_set_prgname(), which sets a non-localized name. g_set_prgname() will be called automatically by gtk_init(), but g_set_application_name() will not. Note that for thread safety reasons, this function can only be called once. The application name will be used in contexts such as error messages, or when displaying an application's name in the task list.

localized name of the application

Does nothing if @err is %NULL; if @err is non-%NULL, then *@err must be %NULL. A new #GError is created and assigned to *@err.

a return location for a #GError error domain error code printf()-style format args for @format

Does nothing if @err is %NULL; if @err is non-%NULL, then *@err must be %NULL. A new #GError is created and assigned to *@err. Unlike g_set_error(), @message is not a printf()-style format string. Use this function if @message contains text you don't have control over, that could include printf() escape sequences.

a return location for a #GError error domain error code error message

Sets the name of the program. This name should not be localized, in contrast to g_set_application_name(). If you are using #GApplication the program name is set in g_application_run(). In case of GDK or GTK+ it is set in gdk_init(), which is called by gtk_init() and the #GtkApplication::startup handler. The program name is found by taking the last component of @argv[0]. Since GLib 2.72, this function can be called multiple times and is fully thread safe. Prior to GLib 2.72, this function could only be called once per process.

the name of the program.

Sets the print handler. Any messages passed to g_print() will be output via the new handler. The default handler simply outputs the message to stdout. By providing your own handler you can redirect the output, to a GTK+ widget or a log file for example.

the old print handler

the new print handler

Sets the handler for printing error messages. Any messages passed to g_printerr() will be output via the new handler. The default handler simply outputs the message to stderr. By providing your own handler you can redirect the output, to a GTK+ widget or a log file for example.

the old error message handler

the new error message handler

Sets an environment variable. On UNIX, both the variable's name and value can be arbitrary byte strings, except that the variable's name cannot contain '='. On Windows, they should be in UTF-8. Note that on some systems, when variables are overwritten, the memory used for the previous variables and its value isn't reclaimed. You should be mindful of the fact that environment variable handling in UNIX is not thread-safe, and your program may crash if one thread calls g_setenv() while another thread is calling getenv(). (And note that many functions, such as gettext(), call getenv() internally.) This function is only safe to use at the very start of your program, before creating any other threads (or creating objects that create worker threads of their own). If you need to set up the environment for a child process, you can use g_get_environ() to get an environment array, modify that with g_environ_setenv() and g_environ_unsetenv(), and then pass that array directly to execvpe(), g_spawn_async(), or the like.

%FALSE if the environment variable couldn't be set.

the environment variable to set, must not contain '='. the value for to set the variable to. whether to change the variable if it already exists.

GLib provides the functions g_shell_quote() and g_shell_unquote() to handle shell-like quoting in strings. The function g_shell_parse_argv() parses a string similar to the way a POSIX shell (/bin/sh) would. Note that string handling in shells has many obscure and historical corner-cases which these functions do not necessarily reproduce. They are good enough in practice, though.

Parses a command line into an argument vector, in much the same way the shell would, but without many of the expansions the shell would perform (variable expansion, globs, operators, filename expansion, etc. are not supported). The results are defined to be the same as those you would get from a UNIX98 `/bin/sh`, as long as the input contains none of the unsupported shell expansions. If the input does contain such expansions, they are passed through literally. Possible errors are those from the %G_SHELL_ERROR domain. In particular, if @command_line is an empty string (or a string containing only whitespace), %G_SHELL_ERROR_EMPTY_STRING will be returned. It’s guaranteed that @argvp will be a non-empty array if this function returns successfully. Free the returned vector with g_strfreev().

%TRUE on success, %FALSE if error set

command line to parse return location for number of args return location for array of args

Quotes a string so that the shell (/bin/sh) will interpret the quoted string to mean @unquoted_string. If you pass a filename to the shell, for example, you should first quote it with this function. The return value must be freed with g_free(). The quoting style used is undefined (single or double quotes may be used).

quoted string

a literal string

Unquotes a string as the shell (/bin/sh) would. This function only handles quotes; if a string contains file globs, arithmetic operators, variables, backticks, redirections, or other special-to-the-shell features, the result will be different from the result a real shell would produce (the variables, backticks, etc. will be passed through literally instead of being expanded). This function is guaranteed to succeed if applied to the result of g_shell_quote(). If it fails, it returns %NULL and sets the error. The @quoted_string need not actually contain quoted or escaped text; g_shell_unquote() simply goes through the string and unquotes/unescapes anything that the shell would. Both single and double quotes are handled, as are escapes including escaped newlines. The return value must be freed with g_free(). Possible errors are in the %G_SHELL_ERROR domain. Shell quoting rules are a bit strange. Single quotes preserve the literal string exactly. escape sequences are not allowed; not even `\'` - if you want a `'` in the quoted text, you have to do something like `'foo'\''bar'`. Double quotes allow `$`, ```, `"`, `\`, and newline to be escaped with backslash. Otherwise double quotes preserve things literally.

an unquoted string

shell-quoted string

Performs a checked addition of @a and @b, storing the result in @dest. If the operation is successful, %TRUE is returned. If the operation overflows then the state of @dest is undefined and %FALSE is returned.

a pointer to the #gsize destination the #gsize left operand the #gsize right operand

Performs a checked multiplication of @a and @b, storing the result in @dest. If the operation is successful, %TRUE is returned. If the operation overflows then the state of @dest is undefined and %FALSE is returned.

a pointer to the #gsize destination the #gsize left operand the #gsize right operand

Allocates a block of memory from the slice allocator. The block address handed out can be expected to be aligned to at least `1 * sizeof (void*)`, though in general slices are `2 * sizeof (void*)` bytes aligned; if a `malloc()` fallback implementation is used instead, the alignment may be reduced in a libc dependent fashion. Note that the underlying slice allocation mechanism can be changed with the [`G_SLICE=always-malloc`][G_SLICE] environment variable.

a pointer to the allocated memory block, which will be %NULL if and only if @mem_size is 0

the number of bytes to allocate

Allocates a block of memory via g_slice_alloc() and initializes the returned memory to 0. Note that the underlying slice allocation mechanism can be changed with the [`G_SLICE=always-malloc`][G_SLICE] environment variable.

a pointer to the allocated block, which will be %NULL if and only if @mem_size is 0

the number of bytes to allocate

Allocates a block of memory from the slice allocator and copies @block_size bytes into it from @mem_block. @mem_block must be non-%NULL if @block_size is non-zero.

a pointer to the allocated memory block, which will be %NULL if and only if @mem_size is 0

the number of bytes to allocate the memory to copy

A convenience macro to duplicate a block of memory using the slice allocator. It calls g_slice_copy() with `sizeof (@type)` and casts the returned pointer to a pointer of the given type, avoiding a type cast in the source code. Note that the underlying slice allocation mechanism can be changed with the [`G_SLICE=always-malloc`][G_SLICE] environment variable. This can never return %NULL.

the type to duplicate, typically a structure name the memory to copy into the allocated block

A convenience macro to free a block of memory that has been allocated from the slice allocator. It calls g_slice_free1() using `sizeof (type)` as the block size. Note that the exact release behaviour can be changed with the [`G_DEBUG=gc-friendly`][G_DEBUG] environment variable, also see [`G_SLICE`][G_SLICE] for related debugging options. If @mem is %NULL, this macro does nothing.

the type of the block to free, typically a structure name a pointer to the block to free

Frees a block of memory. The memory must have been allocated via g_slice_alloc() or g_slice_alloc0() and the @block_size has to match the size specified upon allocation. Note that the exact release behaviour can be changed with the [`G_DEBUG=gc-friendly`][G_DEBUG] environment variable, also see [`G_SLICE`][G_SLICE] for related debugging options. If @mem_block is %NULL, this function does nothing.

the size of the block a pointer to the block to free

Frees a linked list of memory blocks of structure type @type. The memory blocks must be equal-sized, allocated via g_slice_alloc() or g_slice_alloc0() and linked together by a @next pointer (similar to #GSList). The name of the @next field in @type is passed as third argument. Note that the exact release behaviour can be changed with the [`G_DEBUG=gc-friendly`][G_DEBUG] environment variable, also see [`G_SLICE`][G_SLICE] for related debugging options. If @mem_chain is %NULL, this function does nothing.

the type of the @mem_chain blocks a pointer to the first block of the chain the field name of the next pointer in @type

Frees a linked list of memory blocks of structure type @type. The memory blocks must be equal-sized, allocated via g_slice_alloc() or g_slice_alloc0() and linked together by a @next pointer (similar to #GSList). The offset of the @next field in each block is passed as third argument. Note that the exact release behaviour can be changed with the [`G_DEBUG=gc-friendly`][G_DEBUG] environment variable, also see [`G_SLICE`][G_SLICE] for related debugging options. If @mem_chain is %NULL, this function does nothing.

the size of the blocks a pointer to the first block of the chain the offset of the @next field in the blocks

A convenience macro to allocate a block of memory from the slice allocator. It calls g_slice_alloc() with `sizeof (@type)` and casts the returned pointer to a pointer of the given type, avoiding a type cast in the source code. Note that the underlying slice allocation mechanism can be changed with the [`G_SLICE=always-malloc`][G_SLICE] environment variable. This can never return %NULL as the minimum allocation size from `sizeof (@type)` is 1 byte.

the type to allocate, typically a structure name

A convenience macro to allocate a block of memory from the slice allocator and set the memory to 0. It calls g_slice_alloc0() with `sizeof (@type)` and casts the returned pointer to a pointer of the given type, avoiding a type cast in the source code. Note that the underlying slice allocation mechanism can be changed with the [`G_SLICE=always-malloc`][G_SLICE] environment variable. This can never return %NULL as the minimum allocation size from `sizeof (@type)` is 1 byte.

the type to allocate, typically a structure name

A convenience macro to get the next element in a #GSList. Note that it is considered perfectly acceptable to access @slist->next directly.

an element in a #GSList.

A safer form of the standard sprintf() function. The output is guaranteed to not exceed @n characters (including the terminating nul character), so it is easy to ensure that a buffer overflow cannot occur. See also g_strdup_printf(). In versions of GLib prior to 1.2.3, this function may return -1 if the output was truncated, and the truncated string may not be nul-terminated. In versions prior to 1.3.12, this function returns the length of the output string. The return value of g_snprintf() conforms to the snprintf() function as standardized in ISO C99. Note that this is different from traditional snprintf(), which returns the length of the output string. The format string may contain positional parameters, as specified in the Single Unix Specification.

the number of bytes which would be produced if the buffer was large enough.

the buffer to hold the output. the maximum number of bytes to produce (including the terminating nul character). a standard printf() format string, but notice [string precision pitfalls][string-precision] the arguments to insert in the output.

%TRUE if the source was found and removed.

the ID of the source to remove.

Removes a source from the default main loop context given the source functions and user data. If multiple sources exist with the same source functions and user data, only one will be destroyed.

%TRUE if a source was found and removed.

The @source_funcs passed to g_source_new() the user data for the callback

Removes a source from the default main loop context given the user data for the callback. If multiple sources exist with the same user data, only one will be destroyed.

%TRUE if a source was found and removed.

the user_data for the callback.

a #GSource ID debug name for the source

Gets the smallest prime number from a built-in array of primes which is larger than @num. This is used within GLib to calculate the optimum size of a #GHashTable. The built-in array of primes ranges from 11 to 13845163 such that each prime is approximately 1.5-2 times the previous prime.

the smallest prime number from a built-in array of primes which is larger than @num

a #guint

GLib supports spawning of processes with an API that is more convenient than the bare UNIX fork() and exec(). The g_spawn family of functions has synchronous (g_spawn_sync()) and asynchronous variants (g_spawn_async(), g_spawn_async_with_pipes()), as well as convenience variants that take a complete shell-like commandline (g_spawn_command_line_sync(), g_spawn_command_line_async()). See #GSubprocess in GIO for a higher-level API that provides stream interfaces for communication with child processes. An example of using g_spawn_async_with_pipes(): |[ const gchar * const argv[] = { "my-favourite-program", "--args", NULL }; gint child_stdout, child_stderr; GPid child_pid; g_autoptr(GError) error = NULL; // Spawn child process. g_spawn_async_with_pipes (NULL, argv, NULL, G_SPAWN_DO_NOT_REAP_CHILD, NULL, NULL, &child_pid, NULL, &child_stdout, &child_stderr, &error); if (error != NULL) { g_error ("Spawning child failed: %s", error->message); return; } // Add a child watch function which will be called when the child process // exits. g_child_watch_add (child_pid, child_watch_cb, NULL); // You could watch for output on @child_stdout and @child_stderr using // #GUnixInputStream or #GIOChannel here. static void child_watch_cb (GPid pid, gint status, gpointer user_data) { g_message ("Child %" G_PID_FORMAT " exited %s", pid, g_spawn_check_wait_status (status, NULL) ? "normally" : "abnormally"); // Free any resources associated with the child here, such as I/O channels // on its stdout and stderr FDs. If you have no code to put in the // child_watch_cb() callback, you can remove it and the g_child_watch_add() // call, but you must also remove the G_SPAWN_DO_NOT_REAP_CHILD flag, // otherwise the child process will stay around as a zombie until this // process exits. g_spawn_close_pid (pid); } ]| Executes a child program asynchronously. See g_spawn_async_with_pipes() for a full description; this function simply calls the g_spawn_async_with_pipes() without any pipes. You should call g_spawn_close_pid() on the returned child process reference when you don't need it any more. If you are writing a GTK application, and the program you are spawning is a graphical application too, then to ensure that the spawned program opens its windows on the right screen, you may want to use #GdkAppLaunchContext, #GAppLaunchContext, or set the %DISPLAY environment variable. Note that the returned @child_pid on Windows is a handle to the child process and not its identifier. Process handles and process identifiers are different concepts on Windows.

%TRUE on success, %FALSE if error is set

child's current working directory, or %NULL to inherit parent's child's argument vector child's environment, or %NULL to inherit parent's flags from #GSpawnFlags function to run in the child just before exec() user data for @child_setup return location for child process reference, or %NULL

Executes a child program asynchronously. Identical to g_spawn_async_with_pipes_and_fds() but with `n_fds` set to zero, so no FD assignments are used.

%TRUE on success, %FALSE if an error was set

Identical to g_spawn_async_with_pipes_and_fds() but with `n_fds` set to zero, so no FD assignments are used.

%TRUE on success, %FALSE if an error was set

Executes a child program asynchronously (your program will not block waiting for the child to exit). The child program is specified by the only argument that must be provided, @argv. @argv should be a %NULL-terminated array of strings, to be passed as the argument vector for the child. The first string in @argv is of course the name of the program to execute. By default, the name of the program must be a full path. If @flags contains the %G_SPAWN_SEARCH_PATH flag, the `PATH` environment variable is used to search for the executable. If @flags contains the %G_SPAWN_SEARCH_PATH_FROM_ENVP flag, the `PATH` variable from @envp is used to search for the executable. If both the %G_SPAWN_SEARCH_PATH and %G_SPAWN_SEARCH_PATH_FROM_ENVP flags are set, the `PATH` variable from @envp takes precedence over the environment variable. If the program name is not a full path and %G_SPAWN_SEARCH_PATH flag is not used, then the program will be run from the current directory (or @working_directory, if specified); this might be unexpected or even dangerous in some cases when the current directory is world-writable. On Windows, note that all the string or string vector arguments to this function and the other `g_spawn*()` functions are in UTF-8, the GLib file name encoding. Unicode characters that are not part of the system codepage passed in these arguments will be correctly available in the spawned program only if it uses wide character API to retrieve its command line. For C programs built with Microsoft's tools it is enough to make the program have a `wmain()` instead of `main()`. `wmain()` has a wide character argument vector as parameter. At least currently, mingw doesn't support `wmain()`, so if you use mingw to develop the spawned program, it should call g_win32_get_command_line() to get arguments in UTF-8. On Windows the low-level child process creation API `CreateProcess()` doesn't use argument vectors, but a command line. The C runtime library's `spawn*()` family of functions (which g_spawn_async_with_pipes() eventually calls) paste the argument vector elements together into a command line, and the C runtime startup code does a corresponding reconstruction of an argument vector from the command line, to be passed to `main()`. Complications arise when you have argument vector elements that contain spaces or double quotes. The `spawn*()` functions don't do any quoting or escaping, but on the other hand the startup code does do unquoting and unescaping in order to enable receiving arguments with embedded spaces or double quotes. To work around this asymmetry, g_spawn_async_with_pipes() will do quoting and escaping on argument vector elements that need it before calling the C runtime `spawn()` function. The returned @child_pid on Windows is a handle to the child process, not its identifier. Process handles and process identifiers are different concepts on Windows. @envp is a %NULL-terminated array of strings, where each string has the form `KEY=VALUE`. This will become the child's environment. If @envp is %NULL, the child inherits its parent's environment. @flags should be the bitwise OR of any flags you want to affect the function's behaviour. The %G_SPAWN_DO_NOT_REAP_CHILD means that the child will not automatically be reaped; you must use a child watch (g_child_watch_add()) to be notified about the death of the child process, otherwise it will stay around as a zombie process until this process exits. Eventually you must call g_spawn_close_pid() on the @child_pid, in order to free resources which may be associated with the child process. (On Unix, using a child watch is equivalent to calling waitpid() or handling the `SIGCHLD` signal manually. On Windows, calling g_spawn_close_pid() is equivalent to calling `CloseHandle()` on the process handle returned in @child_pid). See g_child_watch_add(). Open UNIX file descriptors marked as `FD_CLOEXEC` will be automatically closed in the child process. %G_SPAWN_LEAVE_DESCRIPTORS_OPEN means that other open file descriptors will be inherited by the child; otherwise all descriptors except stdin/stdout/stderr will be closed before calling `exec()` in the child. %G_SPAWN_SEARCH_PATH means that @argv[0] need not be an absolute path, it will be looked for in the `PATH` environment variable. %G_SPAWN_SEARCH_PATH_FROM_ENVP means need not be an absolute path, it will be looked for in the `PATH` variable from @envp. If both %G_SPAWN_SEARCH_PATH and %G_SPAWN_SEARCH_PATH_FROM_ENVP are used, the value from @envp takes precedence over the environment. %G_SPAWN_CHILD_INHERITS_STDIN means that the child will inherit the parent's standard input (by default, the child's standard input is attached to `/dev/null`). %G_SPAWN_STDIN_FROM_DEV_NULL explicitly imposes the default behavior. Both flags cannot be enabled at the same time and, in both cases, the @stdin_pipe_out argument is ignored. %G_SPAWN_STDOUT_TO_DEV_NULL means that the child's standard output will be discarded (by default, it goes to the same location as the parent's standard output). %G_SPAWN_CHILD_INHERITS_STDOUT explicitly imposes the default behavior. Both flags cannot be enabled at the same time and, in both cases, the @stdout_pipe_out argument is ignored. %G_SPAWN_STDERR_TO_DEV_NULL means that the child's standard error will be discarded (by default, it goes to the same location as the parent's standard error). %G_SPAWN_CHILD_INHERITS_STDERR explicitly imposes the default behavior. Both flags cannot be enabled at the same time and, in both cases, the @stderr_pipe_out argument is ignored. It is valid to pass the same FD in multiple parameters (e.g. you can pass a single FD for both @stdout_fd and @stderr_fd, and include it in @source_fds too). @source_fds and @target_fds allow zero or more FDs from this process to be remapped to different FDs in the spawned process. If @n_fds is greater than zero, @source_fds and @target_fds must both be non-%NULL and the same length. Each FD in @source_fds is remapped to the FD number at the same index in @target_fds. The source and target FD may be equal to simply propagate an FD to the spawned process. FD remappings are processed after standard FDs, so any target FDs which equal @stdin_fd, @stdout_fd or @stderr_fd will overwrite them in the spawned process. @source_fds is supported on Windows since 2.72. %G_SPAWN_FILE_AND_ARGV_ZERO means that the first element of @argv is the file to execute, while the remaining elements are the actual argument vector to pass to the file. Normally g_spawn_async_with_pipes() uses @argv[0] as the file to execute, and passes all of @argv to the child. @child_setup and @user_data are a function and user data. On POSIX platforms, the function is called in the child after GLib has performed all the setup it plans to perform (including creating pipes, closing file descriptors, etc.) but before calling `exec()`. That is, @child_setup is called just before calling `exec()` in the child. Obviously actions taken in this function will only affect the child, not the parent. On Windows, there is no separate `fork()` and `exec()` functionality. Child processes are created and run with a single API call, `CreateProcess()`. There is no sensible thing @child_setup could be used for on Windows so it is ignored and not called. If non-%NULL, @child_pid will on Unix be filled with the child's process ID. You can use the process ID to send signals to the child, or to use g_child_watch_add() (or `waitpid()`) if you specified the %G_SPAWN_DO_NOT_REAP_CHILD flag. On Windows, @child_pid will be filled with a handle to the child process only if you specified the %G_SPAWN_DO_NOT_REAP_CHILD flag. You can then access the child process using the Win32 API, for example wait for its termination with the `WaitFor*()` functions, or examine its exit code with `GetExitCodeProcess()`. You should close the handle with `CloseHandle()` or g_spawn_close_pid() when you no longer need it. If non-%NULL, the @stdin_pipe_out, @stdout_pipe_out, @stderr_pipe_out locations will be filled with file descriptors for writing to the child's standard input or reading from its standard output or standard error. The caller of g_spawn_async_with_pipes() must close these file descriptors when they are no longer in use. If these parameters are %NULL, the corresponding pipe won't be created. If @stdin_pipe_out is %NULL, the child's standard input is attached to `/dev/null` unless %G_SPAWN_CHILD_INHERITS_STDIN is set. If @stderr_pipe_out is NULL, the child's standard error goes to the same location as the parent's standard error unless %G_SPAWN_STDERR_TO_DEV_NULL is set. If @stdout_pipe_out is NULL, the child's standard output goes to the same location as the parent's standard output unless %G_SPAWN_STDOUT_TO_DEV_NULL is set. @error can be %NULL to ignore errors, or non-%NULL to report errors. If an error is set, the function returns %FALSE. Errors are reported even if they occur in the child (for example if the executable in `@argv[0]` is not found). Typically the `message` field of returned errors should be displayed to users. Possible errors are those from the %G_SPAWN_ERROR domain. If an error occurs, @child_pid, @stdin_pipe_out, @stdout_pipe_out, and @stderr_pipe_out will not be filled with valid values. If @child_pid is not %NULL and an error does not occur then the returned process reference must be closed using g_spawn_close_pid(). On modern UNIX platforms, GLib can use an efficient process launching codepath driven internally by `posix_spawn()`. This has the advantage of avoiding the fork-time performance costs of cloning the parent process address space, and avoiding associated memory overcommit checks that are not relevant in the context of immediately executing a distinct process. This optimized codepath will be used provided that the following conditions are met: 1. %G_SPAWN_DO_NOT_REAP_CHILD is set 2. %G_SPAWN_LEAVE_DESCRIPTORS_OPEN is set 3. %G_SPAWN_SEARCH_PATH_FROM_ENVP is not set 4. @working_directory is %NULL 5. @child_setup is %NULL 6. The program is of a recognised binary format, or has a shebang. Otherwise, GLib will have to execute the program through the shell, which is not done using the optimized codepath. If you are writing a GTK application, and the program you are spawning is a graphical application too, then to ensure that the spawned program opens its windows on the right screen, you may want to use #GdkAppLaunchContext, #GAppLaunchContext, or set the `DISPLAY` environment variable.

%TRUE on success, %FALSE if an error was set

child's current working directory, or %NULL to inherit parent's, in the GLib file name encoding child's argument vector, in the GLib file name encoding; it must be non-empty and %NULL-terminated child's environment, or %NULL to inherit parent's, in the GLib file name encoding flags from #GSpawnFlags function to run in the child just before `exec()` user data for @child_setup file descriptor to use for child's stdin, or `-1` file descriptor to use for child's stdout, or `-1` file descriptor to use for child's stderr, or `-1` array of FDs from the parent process to make available in the child process array of FDs to remap @source_fds to in the child process number of FDs in @source_fds and @target_fds return location for child process ID, or %NULL return location for file descriptor to write to child's stdin, or %NULL return location for file descriptor to read child's stdout, or %NULL return location for file descriptor to read child's stderr, or %NULL

An old name for g_spawn_check_wait_status(), deprecated because its name is misleading. Despite the name of the function, @wait_status must be the wait status as returned by g_spawn_sync(), g_subprocess_get_status(), `waitpid()`, etc. On Unix platforms, it is incorrect for it to be the exit status as passed to `exit()` or returned by g_subprocess_get_exit_status() or `WEXITSTATUS()`.

Use g_spawn_check_wait_status() instead, and check whether your code is conflating wait and exit statuses.

%TRUE if child exited successfully, %FALSE otherwise (and @error will be set)

A status as returned from g_spawn_sync()

Set @error if @wait_status indicates the child exited abnormally (e.g. with a nonzero exit code, or via a fatal signal). The g_spawn_sync() and g_child_watch_add() family of APIs return the status of subprocesses encoded in a platform-specific way. On Unix, this is guaranteed to be in the same format waitpid() returns, and on Windows it is guaranteed to be the result of GetExitCodeProcess(). Prior to the introduction of this function in GLib 2.34, interpreting @wait_status required use of platform-specific APIs, which is problematic for software using GLib as a cross-platform layer. Additionally, many programs simply want to determine whether or not the child exited successfully, and either propagate a #GError or print a message to standard error. In that common case, this function can be used. Note that the error message in @error will contain human-readable information about the wait status. The @domain and @code of @error have special semantics in the case where the process has an "exit code", as opposed to being killed by a signal. On Unix, this happens if WIFEXITED() would be true of @wait_status. On Windows, it is always the case. The special semantics are that the actual exit code will be the code set in @error, and the domain will be %G_SPAWN_EXIT_ERROR. This allows you to differentiate between different exit codes. If the process was terminated by some means other than an exit status (for example if it was killed by a signal), the domain will be %G_SPAWN_ERROR and the code will be %G_SPAWN_ERROR_FAILED. This function just offers convenience; you can of course also check the available platform via a macro such as %G_OS_UNIX, and use WIFEXITED() and WEXITSTATUS() on @wait_status directly. Do not attempt to scan or parse the error message string; it may be translated and/or change in future versions of GLib. Prior to version 2.70, g_spawn_check_exit_status() provides the same functionality, although under a misleading name.

%TRUE if child exited successfully, %FALSE otherwise (and @error will be set)

A platform-specific wait status as returned from g_spawn_sync()

On some platforms, notably Windows, the #GPid type represents a resource which must be closed to prevent resource leaking. g_spawn_close_pid() is provided for this purpose. It should be used on all platforms, even though it doesn't do anything under UNIX.

The process reference to close

A simple version of g_spawn_async() that parses a command line with g_shell_parse_argv() and passes it to g_spawn_async(). Runs a command line in the background. Unlike g_spawn_async(), the %G_SPAWN_SEARCH_PATH flag is enabled, other flags are not. Note that %G_SPAWN_SEARCH_PATH can have security implications, so consider using g_spawn_async() directly if appropriate. Possible errors are those from g_shell_parse_argv() and g_spawn_async(). The same concerns on Windows apply as for g_spawn_command_line_sync().

%TRUE on success, %FALSE if error is set

a command line

A simple version of g_spawn_sync() with little-used parameters removed, taking a command line instead of an argument vector. See g_spawn_sync() for full details. The @command_line argument will be parsed by g_shell_parse_argv(). Unlike g_spawn_sync(), the %G_SPAWN_SEARCH_PATH flag is enabled. Note that %G_SPAWN_SEARCH_PATH can have security implications, so consider using g_spawn_sync() directly if appropriate. Possible errors are those from g_spawn_sync() and those from g_shell_parse_argv(). If @wait_status is non-%NULL, the platform-specific status of the child is stored there; see the documentation of g_spawn_check_wait_status() for how to use and interpret this. On Unix platforms, note that it is usually not equal to the integer passed to `exit()` or returned from `main()`. On Windows, please note the implications of g_shell_parse_argv() parsing @command_line. Parsing is done according to Unix shell rules, not Windows command interpreter rules. Space is a separator, and backslashes are special. Thus you cannot simply pass a @command_line containing canonical Windows paths, like "c:\\program files\\app\\app.exe", as the backslashes will be eaten, and the space will act as a separator. You need to enclose such paths with single quotes, like "'c:\\program files\\app\\app.exe' 'e:\\folder\\argument.txt'".

%TRUE on success, %FALSE if an error was set

a command line return location for child output return location for child errors return location for child wait status, as returned by waitpid()

Executes a child synchronously (waits for the child to exit before returning). All output from the child is stored in @standard_output and @standard_error, if those parameters are non-%NULL. Note that you must set the %G_SPAWN_STDOUT_TO_DEV_NULL and %G_SPAWN_STDERR_TO_DEV_NULL flags when passing %NULL for @standard_output and @standard_error. If @wait_status is non-%NULL, the platform-specific status of the child is stored there; see the documentation of g_spawn_check_wait_status() for how to use and interpret this. On Unix platforms, note that it is usually not equal to the integer passed to `exit()` or returned from `main()`. Note that it is invalid to pass %G_SPAWN_DO_NOT_REAP_CHILD in @flags, and on POSIX platforms, the same restrictions as for g_child_watch_source_new() apply. If an error occurs, no data is returned in @standard_output, @standard_error, or @wait_status. This function calls g_spawn_async_with_pipes() internally; see that function for full details on the other parameters and details on how these functions work on Windows.

%TRUE on success, %FALSE if an error was set

child's current working directory, or %NULL to inherit parent's child's argument vector, which must be non-empty and %NULL-terminated child's environment, or %NULL to inherit parent's flags from #GSpawnFlags function to run in the child just before exec() user data for @child_setup return location for child output, or %NULL return location for child error messages, or %NULL return location for child wait status, as returned by waitpid(), or %NULL

An implementation of the standard sprintf() function which supports positional parameters, as specified in the Single Unix Specification. Note that it is usually better to use g_snprintf(), to avoid the risk of buffer overflow. `glib/gprintf.h` must be explicitly included in order to use this function. See also g_strdup_printf().

the number of bytes printed.

A pointer to a memory buffer to contain the resulting string. It is up to the caller to ensure that the allocated buffer is large enough to hold the formatted result a standard printf() format string, but notice [string precision pitfalls][string-precision] the arguments to insert in the output.

Sets @pp to %NULL, returning the value that was there before. Conceptually, this transfers the ownership of the pointer from the referenced variable to the "caller" of the macro (ie: "steals" the reference). The return value will be properly typed, according to the type of @pp. This can be very useful when combined with g_autoptr() to prevent the return value of a function from being automatically freed. Consider the following example (which only works on GCC and clang): |[ GObject * create_object (void) { g_autoptr(GObject) obj = g_object_new (G_TYPE_OBJECT, NULL); if (early_error_case) return NULL; return g_steal_pointer (&obj); } ]| It can also be used in similar ways for 'out' parameters and is particularly useful for dealing with optional out parameters: |[ gboolean get_object (GObject **obj_out) { g_autoptr(GObject) obj = g_object_new (G_TYPE_OBJECT, NULL); if (early_error_case) return FALSE; if (obj_out) *obj_out = g_steal_pointer (&obj); return TRUE; } ]| In the above example, the object will be automatically freed in the early error case and also in the case that %NULL was given for @obj_out.

a pointer to a pointer

Copies a nul-terminated string into the dest buffer, include the trailing nul, and return a pointer to the trailing nul byte. This is useful for concatenating multiple strings together without having to repeatedly scan for the end.

a pointer to trailing nul byte.

destination buffer. source string.

Compares two strings for byte-by-byte equality and returns %TRUE if they are equal. It can be passed to g_hash_table_new() as the @key_equal_func parameter, when using non-%NULL strings as keys in a #GHashTable. This function is typically used for hash table comparisons, but can be used for general purpose comparisons of non-%NULL strings. For a %NULL-safe string comparison function, see g_strcmp0().

%TRUE if the two keys match

a key a key to compare with @v1

Looks whether the string @str begins with @prefix.

%TRUE if @str begins with @prefix, %FALSE otherwise.

a nul-terminated string the nul-terminated prefix to look for

Looks whether the string @str ends with @suffix.

%TRUE if @str end with @suffix, %FALSE otherwise.

a nul-terminated string the nul-terminated suffix to look for

Converts a string to a hash value. This function implements the widely used "djb" hash apparently posted by Daniel Bernstein to comp.lang.c some time ago. The 32 bit unsigned hash value starts at 5381 and for each byte 'c' in the string, is updated: `hash = hash * 33 + c`. This function uses the signed value of each byte. It can be passed to g_hash_table_new() as the @hash_func parameter, when using non-%NULL strings as keys in a #GHashTable. Note that this function may not be a perfect fit for all use cases. For example, it produces some hash collisions with strings as short as 2.

a hash value corresponding to the key

a string key

Determines if a string is pure ASCII. A string is pure ASCII if it contains no bytes with the high bit set.

%TRUE if @str is ASCII

a string

Checks if a search conducted for @search_term should match @potential_hit. This function calls g_str_tokenize_and_fold() on both @search_term and @potential_hit. ASCII alternates are never taken for @search_term but will be taken for @potential_hit according to the value of @accept_alternates. A hit occurs when each folded token in @search_term is a prefix of a folded token from @potential_hit. Depending on how you're performing the search, it will typically be faster to call g_str_tokenize_and_fold() on each string in your corpus and build an index on the returned folded tokens, then call g_str_tokenize_and_fold() on the search term and perform lookups into that index. As some examples, searching for ‘fred’ would match the potential hit ‘Smith, Fred’ and also ‘Frédéric’. Searching for ‘Fréd’ would match ‘Frédéric’ but not ‘Frederic’ (due to the one-directional nature of accent matching). Searching ‘fo’ would match ‘Foo’ and ‘Bar Foo Baz’, but not ‘SFO’ (because no word has ‘fo’ as a prefix).

%TRUE if @potential_hit is a hit

the search term from the user the text that may be a hit %TRUE to accept ASCII alternates

Transliterate @str to plain ASCII. For best results, @str should be in composed normalised form. This function performs a reasonably good set of character replacements. The particular set of replacements that is done may change by version or even by runtime environment. If the source language of @str is known, it can used to improve the accuracy of the translation by passing it as @from_locale. It should be a valid POSIX locale string (of the form `language[_territory][.codeset][@modifier]`). If @from_locale is %NULL then the current locale is used. If you want to do translation for no specific locale, and you want it to be done independently of the currently locale, specify `"C"` for @from_locale.

a string in plain ASCII

a string, in UTF-8 the source locale, if known

Tokenises @string and performs folding on each token. A token is a non-empty sequence of alphanumeric characters in the source string, separated by non-alphanumeric characters. An "alphanumeric" character for this purpose is one that matches g_unichar_isalnum() or g_unichar_ismark(). Each token is then (Unicode) normalised and case-folded. If @ascii_alternates is non-%NULL and some of the returned tokens contain non-ASCII characters, ASCII alternatives will be generated. The number of ASCII alternatives that are generated and the method for doing so is unspecified, but @translit_locale (if specified) may improve the transliteration if the language of the source string is known.

the folded tokens

a string the language code (like 'de' or 'en_GB') from which @string originates a return location for ASCII alternates

For each character in @string, if the character is not in @valid_chars, replaces the character with @substitutor. Modifies @string in place, and return @string itself, not a copy. The return value is to allow nesting such as: |[ g_ascii_strup (g_strcanon (str, "abc", '?')) ]| In order to modify a copy, you may use g_strdup(): |[ reformatted = g_strcanon (g_strdup (const_str), "abc", '?'); ... g_free (reformatted); ]|

the modified @string

a nul-terminated array of bytes bytes permitted in @string replacement character for disallowed bytes

A case-insensitive string comparison, corresponding to the standard strcasecmp() function on platforms which support it.

See g_strncasecmp() for a discussion of why this function is deprecated and how to replace it.

0 if the strings match, a negative value if @s1 < @s2, or a positive value if @s1 > @s2.

a string a string to compare with @s1

Removes trailing whitespace from a string. This function doesn't allocate or reallocate any memory; it modifies @string in place. Therefore, it cannot be used on statically allocated strings. The pointer to @string is returned to allow the nesting of functions. Also see g_strchug() and g_strstrip().

@string

a string to remove the trailing whitespace from

Removes leading whitespace from a string, by moving the rest of the characters forward. This function doesn't allocate or reallocate any memory; it modifies @string in place. Therefore, it cannot be used on statically allocated strings. The pointer to @string is returned to allow the nesting of functions. Also see g_strchomp() and g_strstrip().

@string

a string to remove the leading whitespace from

Compares @str1 and @str2 like strcmp(). Handles %NULL gracefully by sorting it before non-%NULL strings. Comparing two %NULL pointers returns 0.

an integer less than, equal to, or greater than zero, if @str1 is <, == or > than @str2.

a C string or %NULL another C string or %NULL

Replaces all escaped characters with their one byte equivalent. This function does the reverse conversion of g_strescape().

a newly-allocated copy of @source with all escaped character compressed

a string to compress

Concatenates all of the given strings into one long string. The returned string should be freed with g_free() when no longer needed. The variable argument list must end with %NULL. If you forget the %NULL, g_strconcat() will start appending random memory junk to your string. Note that this function is usually not the right function to use to assemble a translated message from pieces, since proper translation often requires the pieces to be reordered.

a newly-allocated string containing all the string arguments

the first string to add, which must not be %NULL a %NULL-terminated list of strings to append to the string

Converts any delimiter characters in @string to @new_delimiter. Any characters in @string which are found in @delimiters are changed to the @new_delimiter character. Modifies @string in place, and returns @string itself, not a copy. The return value is to allow nesting such as: |[ g_ascii_strup (g_strdelimit (str, "abc", '?')) ]| In order to modify a copy, you may use g_strdup(): |[ reformatted = g_strdelimit (g_strdup (const_str), "abc", '?'); ... g_free (reformatted); ]|

the modified @string

the string to convert a string containing the current delimiters, or %NULL to use the standard delimiters defined in %G_STR_DELIMITERS the new delimiter character

Converts a string to lower case.

This function is totally broken for the reasons discussed in the g_strncasecmp() docs - use g_ascii_strdown() or g_utf8_strdown() instead.

the string

the string to convert.

Duplicates a string. If @str is %NULL it returns %NULL. The returned string should be freed with g_free() when no longer needed.

a newly-allocated copy of @str

the string to duplicate

Similar to the standard C sprintf() function but safer, since it calculates the maximum space required and allocates memory to hold the result. The returned string should be freed with g_free() when no longer needed. The returned string is guaranteed to be non-NULL, unless @format contains `%lc` or `%ls` conversions, which can fail if no multibyte representation is available for the given character.

a newly-allocated string holding the result

a standard printf() format string, but notice [string precision pitfalls][string-precision] the parameters to insert into the format string

Similar to the standard C vsprintf() function but safer, since it calculates the maximum space required and allocates memory to hold the result. The returned string should be freed with g_free() when no longer needed. The returned string is guaranteed to be non-NULL, unless @format contains `%lc` or `%ls` conversions, which can fail if no multibyte representation is available for the given character. See also g_vasprintf(), which offers the same functionality, but additionally returns the length of the allocated string.

a newly-allocated string holding the result

a standard printf() format string, but notice [string precision pitfalls][string-precision] the list of parameters to insert into the format string

Copies %NULL-terminated array of strings. The copy is a deep copy; the new array should be freed by first freeing each string, then the array itself. g_strfreev() does this for you. If called on a %NULL value, g_strdupv() simply returns %NULL.

a new %NULL-terminated array of strings.

a %NULL-terminated array of strings

Returns a string corresponding to the given error code, e.g. "no such process". Unlike strerror(), this always returns a string in UTF-8 encoding, and the pointer is guaranteed to remain valid for the lifetime of the process. Note that the string may be translated according to the current locale. The value of %errno will not be changed by this function. However, it may be changed by intermediate function calls, so you should save its value as soon as the call returns: |[ int saved_errno; ret = read (blah); saved_errno = errno; g_strerror (saved_errno); ]|

a UTF-8 string describing the error code. If the error code is unknown, it returns a string like "Unknown error: <code>".

the system error number. See the standard C %errno documentation

Escapes the special characters '\b', '\f', '\n', '\r', '\t', '\v', '\' and '"' in the string @source by inserting a '\' before them. Additionally all characters in the range 0x01-0x1F (everything below SPACE) and in the range 0x7F-0xFF (all non-ASCII chars) are replaced with a '\' followed by their octal representation. Characters supplied in @exceptions are not escaped. g_strcompress() does the reverse conversion.

a newly-allocated copy of @source with certain characters escaped. See above.

a string to escape a string of characters not to escape in @source

Frees a %NULL-terminated array of strings, as well as each string it contains. If @str_array is %NULL, this function simply returns.

a %NULL-terminated array of strings to free

String chunks are used to store groups of strings. Memory is allocated in blocks, and as strings are added to the #GStringChunk they are copied into the next free position in a block. When a block is full a new block is allocated. When storing a large number of strings, string chunks are more efficient than using g_strdup() since fewer calls to malloc() are needed, and less memory is wasted in memory allocation overheads. By adding strings with g_string_chunk_insert_const() it is also possible to remove duplicates. To create a new #GStringChunk use g_string_chunk_new(). To add strings to a #GStringChunk use g_string_chunk_insert(). To add strings to a #GStringChunk, but without duplicating strings which are already in the #GStringChunk, use g_string_chunk_insert_const(). To free the entire #GStringChunk use g_string_chunk_free(). It is not possible to free individual strings. This section describes a number of utility functions for creating, duplicating, and manipulating strings. Note that the functions g_printf(), g_fprintf(), g_sprintf(), g_vprintf(), g_vfprintf(), g_vsprintf() and g_vasprintf() are declared in the header `gprintf.h` which is not included in `glib.h` (otherwise using `glib.h` would drag in `stdio.h`), so you'll have to explicitly include `<glib/gprintf.h>` in order to use the GLib printf() functions. ## String precision pitfalls # {#string-precision} While you may use the printf() functions to format UTF-8 strings, notice that the precision of a \%Ns parameter is interpreted as the number of bytes, not characters to print. On top of that, the GNU libc implementation of the printf() functions has the "feature" that it checks that the string given for the \%Ns parameter consists of a whole number of characters in the current encoding. So, unless you are sure you are always going to be in an UTF-8 locale or your know your text is restricted to ASCII, avoid using \%Ns. If your intention is to format strings for a certain number of columns, then \%Ns is not a correct solution anyway, since it fails to take wide characters (see g_unichar_iswide()) into account. Note also that there are various printf() parameters which are platform dependent. GLib provides platform independent macros for these parameters which should be used instead. A common example is %G_GUINT64_FORMAT, which should be used instead of `%llu` or similar parameters for formatting 64-bit integers. These macros are all named `G_*_FORMAT`; see [Basic Types][glib-Basic-Types]. A #GString is an object that handles the memory management of a C string for you. The emphasis of #GString is on text, typically UTF-8. Crucially, the "str" member of a #GString is guaranteed to have a trailing nul character, and it is therefore always safe to call functions such as strchr() or g_strdup() on it. However, a #GString can also hold arbitrary binary data, because it has a "len" member, which includes any possible embedded nul characters in the data. Conceptually then, #GString is like a #GByteArray with the addition of many convenience methods for text, and a guaranteed nul terminator. An auxiliary function for gettext() support (see Q_()).

@msgval, unless @msgval is identical to @msgid and contains a '|' character, in which case a pointer to the substring of msgid after the first '|' character is returned.

a string another string

Joins a number of strings together to form one long string, with the optional @separator inserted between each of them. The returned string should be freed with g_free().

a newly-allocated string containing all of the strings joined together, with @separator between them

a string to insert between each of the strings, or %NULL a %NULL-terminated list of strings to join

Joins a number of strings together to form one long string, with the optional @separator inserted between each of them. The returned string should be freed with g_free(). If @str_array has no items, the return value will be an empty string. If @str_array contains a single item, @separator will not appear in the resulting string.

a newly-allocated string containing all of the strings joined together, with @separator between them

a string to insert between each of the strings, or %NULL a %NULL-terminated array of strings to join

Portability wrapper that calls strlcat() on systems which have it, and emulates it otherwise. Appends nul-terminated @src string to @dest, guaranteeing nul-termination for @dest. The total size of @dest won't exceed @dest_size. At most @dest_size - 1 characters will be copied. Unlike strncat(), @dest_size is the full size of dest, not the space left over. This function does not allocate memory. It always nul-terminates (unless @dest_size == 0 or there were no nul characters in the @dest_size characters of dest to start with). Caveat: this is supposedly a more secure alternative to strcat() or strncat(), but for real security g_strconcat() is harder to mess up.

size of attempted result, which is MIN (dest_size, strlen (original dest)) + strlen (src), so if retval >= dest_size, truncation occurred.

destination buffer, already containing one nul-terminated string source buffer length of @dest buffer in bytes (not length of existing string inside @dest)

Portability wrapper that calls strlcpy() on systems which have it, and emulates strlcpy() otherwise. Copies @src to @dest; @dest is guaranteed to be nul-terminated; @src must be nul-terminated; @dest_size is the buffer size, not the number of bytes to copy. At most @dest_size - 1 characters will be copied. Always nul-terminates (unless @dest_size is 0). This function does not allocate memory. Unlike strncpy(), this function doesn't pad @dest (so it's often faster). It returns the size of the attempted result, strlen (src), so if @retval >= @dest_size, truncation occurred. Caveat: strlcpy() is supposedly more secure than strcpy() or strncpy(), but if you really want to avoid screwups, g_strdup() is an even better idea.

length of @src

destination buffer source buffer length of @dest in bytes

A case-insensitive string comparison, corresponding to the standard strncasecmp() function on platforms which support it. It is similar to g_strcasecmp() except it only compares the first @n characters of the strings.

The problem with g_strncasecmp() is that it does the comparison by calling toupper()/tolower(). These functions are locale-specific and operate on single bytes. However, it is impossible to handle things correctly from an internationalization standpoint by operating on bytes, since characters may be multibyte. Thus g_strncasecmp() is broken if your string is guaranteed to be ASCII, since it is locale-sensitive, and it's broken if your string is localized, since it doesn't work on many encodings at all, including UTF-8, EUC-JP, etc. There are therefore two replacement techniques: g_ascii_strncasecmp(), which only works on ASCII and is not locale-sensitive, and g_utf8_casefold() followed by strcmp() on the resulting strings, which is good for case-insensitive sorting of UTF-8.

0 if the strings match, a negative value if @s1 < @s2, or a positive value if @s1 > @s2.

a string a string to compare with @s1 the maximum number of characters to compare

Duplicates the first @n bytes of a string, returning a newly-allocated buffer @n + 1 bytes long which will always be nul-terminated. If @str is less than @n bytes long the buffer is padded with nuls. If @str is %NULL it returns %NULL. The returned value should be freed when no longer needed. To copy a number of characters from a UTF-8 encoded string, use g_utf8_strncpy() instead.

a newly-allocated buffer containing the first @n bytes of @str, nul-terminated

the string to duplicate the maximum number of bytes to copy from @str

Creates a new string @length bytes long filled with @fill_char. The returned string should be freed when no longer needed.

a newly-allocated string filled the @fill_char

the length of the new string the byte to fill the string with

Reverses all of the bytes in a string. For example, `g_strreverse ("abcdef")` will result in "fedcba". Note that g_strreverse() doesn't work on UTF-8 strings containing multibyte characters. For that purpose, use g_utf8_strreverse().

the same pointer passed in as @string

the string to reverse

Searches the string @haystack for the last occurrence of the string @needle.

a pointer to the found occurrence, or %NULL if not found.

a nul-terminated string the nul-terminated string to search for

Searches the string @haystack for the last occurrence of the string @needle, limiting the length of the search to @haystack_len.

a pointer to the found occurrence, or %NULL if not found.

a nul-terminated string the maximum length of @haystack in bytes. A length of -1 can be used to mean "search the entire string", like g_strrstr(). the nul-terminated string to search for

Returns a string describing the given signal, e.g. "Segmentation fault". You should use this function in preference to strsignal(), because it returns a string in UTF-8 encoding, and since not all platforms support the strsignal() function.

a UTF-8 string describing the signal. If the signal is unknown, it returns "unknown signal (<signum>)".

the signal number. See the `signal` documentation

Splits a string into a maximum of @max_tokens pieces, using the given @delimiter. If @max_tokens is reached, the remainder of @string is appended to the last token. As an example, the result of g_strsplit (":a:bc::d:", ":", -1) is a %NULL-terminated vector containing the six strings "", "a", "bc", "", "d" and "". As a special case, the result of splitting the empty string "" is an empty vector, not a vector containing a single string. The reason for this special case is that being able to represent an empty vector is typically more useful than consistent handling of empty elements. If you do need to represent empty elements, you'll need to check for the empty string before calling g_strsplit().

a newly-allocated %NULL-terminated array of strings. Use g_strfreev() to free it.

a string to split a string which specifies the places at which to split the string. The delimiter is not included in any of the resulting strings, unless @max_tokens is reached. the maximum number of pieces to split @string into. If this is less than 1, the string is split completely.

Splits @string into a number of tokens not containing any of the characters in @delimiter. A token is the (possibly empty) longest string that does not contain any of the characters in @delimiters. If @max_tokens is reached, the remainder is appended to the last token. For example the result of g_strsplit_set ("abc:def/ghi", ":/", -1) is a %NULL-terminated vector containing the three strings "abc", "def", and "ghi". The result of g_strsplit_set (":def/ghi:", ":/", -1) is a %NULL-terminated vector containing the four strings "", "def", "ghi", and "". As a special case, the result of splitting the empty string "" is an empty vector, not a vector containing a single string. The reason for this special case is that being able to represent an empty vector is typically more useful than consistent handling of empty elements. If you do need to represent empty elements, you'll need to check for the empty string before calling g_strsplit_set(). Note that this function works on bytes not characters, so it can't be used to delimit UTF-8 strings for anything but ASCII characters.

a newly-allocated %NULL-terminated array of strings. Use g_strfreev() to free it.

The string to be tokenized A nul-terminated string containing bytes that are used to split the string (it can accept an empty string, which will result in no string splitting). The maximum number of tokens to split @string into. If this is less than 1, the string is split completely

Searches the string @haystack for the first occurrence of the string @needle, limiting the length of the search to @haystack_len.

a pointer to the found occurrence, or %NULL if not found.

a nul-terminated string the maximum length of @haystack in bytes. A length of -1 can be used to mean "search the entire string", like `strstr()`. the string to search for

Removes leading and trailing whitespace from a string. See g_strchomp() and g_strchug().

a string to remove the leading and trailing whitespace from

Converts a string to a #gdouble value. It calls the standard strtod() function to handle the conversion, but if the string is not completely converted it attempts the conversion again with g_ascii_strtod(), and returns the best match. This function should seldom be used. The normal situation when reading numbers not for human consumption is to use g_ascii_strtod(). Only when you know that you must expect both locale formatted and C formatted numbers should you use this. Make sure that you don't pass strings such as comma separated lists of values, since the commas may be interpreted as a decimal point in some locales, causing unexpected results.

the #gdouble value.

the string to convert to a numeric value. if non-%NULL, it returns the character after the last character used in the conversion.

Converts a string to upper case.

This function is totally broken for the reasons discussed in the g_strncasecmp() docs - use g_ascii_strup() or g_utf8_strup() instead.

the string

the string to convert

Checks if @strv contains @str. @strv must not be %NULL.

%TRUE if @str is an element of @strv, according to g_str_equal().

a %NULL-terminated array of strings a string

Checks if @strv1 and @strv2 contain exactly the same elements in exactly the same order. Elements are compared using g_str_equal(). To match independently of order, sort the arrays first (using g_qsort_with_data() or similar). Two empty arrays are considered equal. Neither @strv1 not @strv2 may be %NULL.

%TRUE if @strv1 and @strv2 are equal

a %NULL-terminated array of strings another %NULL-terminated array of strings

Returns the length of the given %NULL-terminated string array @str_array. @str_array must not be %NULL.

length of @str_array.

a %NULL-terminated array of strings

Hook up a new test case at @testpath, similar to g_test_add_func(). A fixture data structure with setup and teardown functions may be provided, similar to g_test_create_case(). g_test_add() is implemented as a macro, so that the fsetup(), ftest() and fteardown() callbacks can expect a @Fixture pointer as their first argument in a type safe manner. They otherwise have type #GTestFixtureFunc.

The test path for a new test case. The type of a fixture data structure. Data argument for the test functions. The function to set up the fixture data. The actual test function. The function to tear down the fixture data.

Create a new test case, similar to g_test_create_case(). However the test is assumed to use no fixture, and test suites are automatically created on the fly and added to the root fixture, based on the slash-separated portions of @testpath. The @test_data argument will be passed as first argument to @test_func. If @testpath includes the component "subprocess" anywhere in it, the test will be skipped by default, and only run if explicitly required via the `-p` command-line option or g_test_trap_subprocess(). No component of @testpath may start with a dot (`.`) if the %G_TEST_OPTION_ISOLATE_DIRS option is being used; and it is recommended to do so even if it isn’t.

/-separated test case path name for the test. Test data argument for the test function. The test function to invoke for this test.

Create a new test case, as with g_test_add_data_func(), but freeing @test_data after the test run is complete.

/-separated test case path name for the test. Test data argument for the test function. The test function to invoke for this test. #GDestroyNotify for @test_data.

Create a new test case, similar to g_test_create_case(). However the test is assumed to use no fixture, and test suites are automatically created on the fly and added to the root fixture, based on the slash-separated portions of @testpath. If @testpath includes the component "subprocess" anywhere in it, the test will be skipped by default, and only run if explicitly required via the `-p` command-line option or g_test_trap_subprocess(). No component of @testpath may start with a dot (`.`) if the %G_TEST_OPTION_ISOLATE_DIRS option is being used; and it is recommended to do so even if it isn’t.

/-separated test case path name for the test. The test function to invoke for this test.

Asserts that all messages previously indicated via g_test_expect_message() have been seen and suppressed. This API may only be used with the old logging API (g_log() without %G_LOG_USE_STRUCTURED defined). It will not work with the structured logging API. See [Testing for Messages][testing-for-messages]. If messages at %G_LOG_LEVEL_DEBUG are emitted, but not explicitly expected via g_test_expect_message() then they will be ignored.

This function adds a message to test reports that associates a bug URI with a test case. Bug URIs are constructed from a base URI set with g_test_bug_base() and @bug_uri_snippet. If g_test_bug_base() has not been called, it is assumed to be the empty string, so a full URI can be provided to g_test_bug() instead. Since GLib 2.70, the base URI is not prepended to @bug_uri_snippet if it is already a valid URI.