/************************************************************/
/* THIS FILE IS GENERATED DO NOT EDIT */
/************************************************************/

/**
 * GModule:
 *
 * The #GModule struct is an opaque data structure to represent a
 * [dynamically-loaded module][glib-Dynamic-Loading-of-Modules].
 * It should only be accessed via the following functions.
 */


/**
 * GModuleCheckInit:
 * @module: the #GModule corresponding to the module which has just been loaded
 *
 * Specifies the type of the module initialization function.
 * If a module contains a function named g_module_check_init() it is called
 * automatically when the module is loaded. It is passed the #GModule structure
 * and should return %NULL on success or a string describing the initialization
 * error.
 *
 * Returns: %NULL on success, or a string describing the initialization error
 */


/**
 * GModuleUnload:
 * @module: the #GModule about to be unloaded
 *
 * Specifies the type of the module function called when it is unloaded.
 * If a module contains a function named g_module_unload() it is called
 * automatically when the module is unloaded.
 * It is passed the #GModule structure.
 */


/**
 * G_MODULE_ERROR:
 *
 * The error domain of the #GModule API.
 *
 * Since: 2.70
 */


/**
 * G_MODULE_EXPORT:
 *
 * Used to declare functions exported by libraries or modules.
 *
 * When compiling for Windows, it marks the symbol as `dllexport`.
 *
 * When compiling for Linux and Unices, it marks the symbol as having `default`
 * visibility. This is no-op unless the code is being compiled with a
 * non-default
 * [visibility flag](https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#index-fvisibility-1260)
 * such as `hidden`.
 */


/**
 * G_MODULE_IMPORT:
 *
 * Used to declare functions imported from modules.
 */


/**
 * G_MODULE_SUFFIX:
 *
 * Expands to the proper shared library suffix for the current platform
 * without the leading dot. For most Unices and Linux this is "so", and
 * for Windows this is "dll".
 */


/**
 * SECTION:modules
 * @title: Dynamic Loading of Modules
 * @short_description: portable method for dynamically loading 'plug-ins'
 *
 * These functions provide a portable way to dynamically load object files
 * (commonly known as 'plug-ins'). The current implementation supports all
 * systems that provide an implementation of dlopen() (e.g. Linux/Sun), as
 * well as Windows platforms via DLLs.
 *
 * A program which wants to use these functions must be linked to the
 * libraries output by the command `pkg-config --libs gmodule-2.0`.
 *
 * To use them you must first determine whether dynamic loading
 * is supported on the platform by calling g_module_supported().
 * If it is, you can open a module with g_module_open(),
 * find the module's symbols (e.g. function names) with g_module_symbol(),
 * and later close the module with g_module_close().
 * g_module_name() will return the file name of a currently opened module.
 *
 * If any of the above functions fail, the error status can be found with
 * g_module_error().
 *
 * The #GModule implementation features reference counting for opened modules,
 * and supports hook functions within a module which are called when the
 * module is loaded and unloaded (see #GModuleCheckInit and #GModuleUnload).
 *
 * If your module introduces static data to common subsystems in the running
 * program, e.g. through calling
 * `g_quark_from_static_string ("my-module-stuff")`,
 * it must ensure that it is never unloaded, by calling g_module_make_resident().
 *
 * Example: Calling a function defined in a GModule
 * |[<!-- language="C" -->
 * // the function signature for 'say_hello'
 * typedef void (* SayHelloFunc) (const char *message);
 *
 * gboolean
 * just_say_hello (const char *filename, GError **error)
 * {
 *   SayHelloFunc  say_hello;
 *   GModule      *module;
 *
 *   module = g_module_open (filename, G_MODULE_BIND_LAZY);
 *   if (!module)
 *     {
 *       g_set_error (error, FOO_ERROR, FOO_ERROR_BLAH,
 *                    "%s", g_module_error ());
 *       return FALSE;
 *     }
 *
 *   if (!g_module_symbol (module, "say_hello", (gpointer *)&say_hello))
 *     {
 *       g_set_error (error, SAY_ERROR, SAY_ERROR_OPEN,
 *                    "%s: %s", filename, g_module_error ());
 *       if (!g_module_close (module))
 *         g_warning ("%s: %s", filename, g_module_error ());
 *       return FALSE;
 *     }
 *
 *   if (say_hello == NULL)
 *     {
 *       g_set_error (error, SAY_ERROR, SAY_ERROR_OPEN,
 *                    "symbol say_hello is NULL");
 *       if (!g_module_close (module))
 *         g_warning ("%s: %s", filename, g_module_error ());
 *       return FALSE;
 *     }
 *
 *   // call our function in the module
 *   say_hello ("Hello world!");
 *
 *   if (!g_module_close (module))
 *     g_warning ("%s: %s", filename, g_module_error ());
 *   return TRUE;
 *  }
 * ]|
 */


/**
 * g_module_build_path:
 * @directory: (nullable): the directory where the module is. This can be
 *     %NULL or the empty string to indicate that the standard platform-specific
 *     directories will be used, though that is not recommended
 * @module_name: the name of the module
 *
 * A portable way to build the filename of a module. The platform-specific
 * prefix and suffix are added to the filename, if needed, and the result
 * is added to the directory, using the correct separator character.
 *
 * The directory should specify the directory where the module can be found.
 * It can be %NULL or an empty string to indicate that the module is in a
 * standard platform-specific directory, though this is not recommended
 * since the wrong module may be found.
 *
 * For example, calling g_module_build_path() on a Linux system with a
 * @directory of `/lib` and a @module_name of "mylibrary" will return
 * `/lib/libmylibrary.so`. On a Windows system, using `\Windows` as the
 * directory it will return `\Windows\mylibrary.dll`.
 *
 * Returns: the complete path of the module, including the standard library
 *     prefix and suffix. This should be freed when no longer needed
 */


/**
 * g_module_close:
 * @module: a #GModule to close
 *
 * Closes a module.
 *
 * Returns: %TRUE on success
 */


/**
 * g_module_error:
 *
 * Gets a string describing the last module error.
 *
 * Returns: a string describing the last module error
 */


/**
 * g_module_make_resident:
 * @module: a #GModule to make permanently resident
 *
 * Ensures that a module will never be unloaded.
 * Any future g_module_close() calls on the module will be ignored.
 */


/**
 * g_module_name:
 * @module: a #GModule
 *
 * Returns the filename that the module was opened with.
 *
 * If @module refers to the application itself, "main" is returned.
 *
 * Returns: (transfer none): the filename of the module
 */


/**
 * g_module_open:
 * @file_name: (nullable): the name of the file containing the module, or %NULL
 *     to obtain a #GModule representing the main program itself
 * @flags: the flags used for opening the module. This can be the
 *     logical OR of any of the #GModuleFlags.
 *
 * A thin wrapper function around g_module_open_full()
 *
 * Returns: a #GModule on success, or %NULL on failure
 */


/**
 * g_module_open_full:
 * @file_name: (nullable): the name of the file containing the module, or %NULL
 *     to obtain a #GModule representing the main program itself
 * @flags: the flags used for opening the module. This can be the
 *     logical OR of any of the #GModuleFlags
 * @error: #GError.
 *
 * Opens a module. If the module has already been opened,
 * its reference count is incremented.
 *
 * First of all g_module_open_full() tries to open @file_name as a module.
 * If that fails and @file_name has the ".la"-suffix (and is a libtool
 * archive) it tries to open the corresponding module. If that fails
 * and it doesn't have the proper module suffix for the platform
 * (#G_MODULE_SUFFIX), this suffix will be appended and the corresponding
 * module will be opened. If that fails and @file_name doesn't have the
 * ".la"-suffix, this suffix is appended and g_module_open_full() tries to open
 * the corresponding module. If eventually that fails as well, %NULL is
 * returned.
 *
 * Returns: a #GModule on success, or %NULL on failure
 * Since: 2.70
 */


/**
 * g_module_supported:
 *
 * Checks if modules are supported on the current platform.
 *
 * Returns: %TRUE if modules are supported
 */


/**
 * g_module_symbol:
 * @module: a #GModule
 * @symbol_name: the name of the symbol to find
 * @symbol: (out): returns the pointer to the symbol value
 *
 * Gets a symbol pointer from a module, such as one exported
 * by #G_MODULE_EXPORT. Note that a valid symbol can be %NULL.
 *
 * Returns: %TRUE on success
 */



/************************************************************/
/* THIS FILE IS GENERATED DO NOT EDIT */
/************************************************************/
