@img/sharp-libvips-dev 1.0.1 → 1.0.3

package/include/glib-2.0/glib/gmain.h

@@ -301,15 +301,101 @@ struct _GSourceCallbackFuncs
  */
 typedef void (*GSourceDummyMarshal) (void);
 
+/**
+ * GSourceFuncsPrepareFunc:
+ * @source: The #GSource
+ * @timeout_: (out) (optional): the maximum timeout (in milliseconds) which should be passed to the poll call
+ *
+ * Checks the source for readiness.
+ *
+ * Called before all the file descriptors are polled. If the
+ * source can determine that it is ready here (without waiting for the
+ * results of the poll call) it should return %TRUE. It can also return
+ * a @timeout_ value which should be the maximum timeout (in milliseconds)
+ * which should be passed to the poll call. The actual timeout used will
+ * be `-1` if all sources returned `-1`, or it will be the minimum of all
+ * the @timeout_ values returned which were greater than or equal to `0`.
+ * If the prepare function returns a timeout and the source also has a
+ * ready time set, then the lower of the two will be used.
+ * 
+ * Since 2.36 this may be `NULL`, in which case the effect is as if the
+ * function always returns `FALSE` with a timeout of `-1`.
+ *
+ * Returns: %TRUE if the source is ready, %FALSE otherwise
+ *
+ * Since: 2.82
+ */
+typedef gboolean (*GSourceFuncsPrepareFunc) (GSource *source,
+                                             gint    *timeout_);
+
+/**
+ * GSourceFuncsCheckFunc:
+ * @source: The #GSource
+ *
+ * Checks if the source is ready to be dispatched.
+ *
+ * Called after all the file descriptors are polled. The source
+ * should return %TRUE if it is ready to be dispatched. Note that some
+ * time may have passed since the previous prepare function was called,
+ * so the source should be checked again here.
+ * 
+ * Since 2.36 this may be `NULL`, in which case the effect is
+ * as if the function always returns `FALSE`.
+ *
+ * Returns: %TRUE if ready to be dispatched, %FALSE otherwise
+ *
+ * Since: 2.82
+ */
+typedef gboolean (*GSourceFuncsCheckFunc) (GSource *source);
+
+/**
+ * GSourceFuncsDispatchFunc:
+ * @source: The #GSource
+ * @callback: (nullable): The #GSourceFunc to call
+ * @user_data: (nullable): data to pass to @callback
+ *
+ * Dispatches the source callback.
+ *
+ * Called to dispatch the event source, after it has returned
+ * `TRUE` in either its prepare or its check function, or if a ready time
+ * has been reached. The dispatch function receives a callback function and
+ * user data. The callback function may be `NULL` if the source was never
+ * connected to a callback using [method@GLib.Source.set_callback]. The dispatch
+ * function should call the callback function with @user_data and whatever
+ * additional parameters are needed for this type of event source. The
+ * return value of the dispatch function should be [const@GLib.SOURCE_REMOVE]
+ * if the source should be removed or [const@GLib.SOURCE_CONTINUE] to keep it.
+ *
+ * Returns: [const@GLib.SOURCE_REMOVE] if the source should be removed,
+ *   [const@GLib.SOURCE_CONTINUE] otherwise.
+ *
+ * Since: 2.82
+ */
+typedef gboolean (*GSourceFuncsDispatchFunc) (GSource     *source,
+                                              GSourceFunc  callback,
+                                              gpointer     user_data);
+
+/**
+ * GSourceFuncsFinalizeFunc:
+ * @source: The #GSource
+ *
+ * Finalizes the source.
+ *
+ * Called when the source is finalized. At this point, the source
+ * will have been destroyed, had its callback cleared, and have been removed
+ * from its [type@GLib.MainContext], but it will still have its final reference
+ * count, so methods can be called on it from within this function.
+ *
+ * Since: 2.82
+ */
+typedef void (*GSourceFuncsFinalizeFunc) (GSource *source);
+
 struct _GSourceFuncs
 {
-  gboolean (*prepare)  (GSource    *source,
-                        gint       *timeout_);/* Can be NULL */
-  gboolean (*check)    (GSource    *source);/* Can be NULL */
-  gboolean (*dispatch) (GSource    *source,
-                        GSourceFunc callback,
-                        gpointer    user_data);
-  void     (*finalize) (GSource    *source); /* Can be NULL */
+  GSourceFuncsPrepareFunc prepare; /* Can be NULL */
+  GSourceFuncsCheckFunc check;     /* Can be NULL */
+  GSourceFuncsDispatchFunc dispatch;
+  GSourceFuncsFinalizeFunc finalize; /* Can be NULL */
 
   /*< private >*/
   /* For use by g_source_set_closure */

package/include/glib-2.0/glib/gmessages.h

@@ -229,6 +229,11 @@ gchar           *g_log_writer_format_fields    (GLogLevelFlags   log_level,
                                                 gsize            n_fields,
                                                 gboolean         use_color);
 
+GLIB_AVAILABLE_IN_2_80
+GLogWriterOutput g_log_writer_syslog           (GLogLevelFlags   log_level,
+                                                const GLogField *fields,
+                                                gsize            n_fields,
+                                                gpointer         user_data);
 GLIB_AVAILABLE_IN_2_50
 GLogWriterOutput g_log_writer_journald         (GLogLevelFlags   log_level,
                                                 const GLogField *fields,
@@ -547,6 +552,9 @@ GPrintFunc      g_set_printerr_handler  (GPrintFunc      func);
  *
  * Logs a warning if the expression is not true.
  *
+ * Unlike g_return_if_fail(), the expression is always evaluated, even if
+ * checks and assertions are disabled.
+ *
  * Since: 2.16
  */
 #define g_warn_if_fail(expr) \

package/include/glib-2.0/glib/gqsort.h

@@ -35,13 +35,20 @@
 
 G_BEGIN_DECLS
 
-GLIB_AVAILABLE_IN_ALL
+GLIB_DEPRECATED_IN_2_82_FOR(g_sort_array)
 void g_qsort_with_data (gconstpointer    pbase,
 			gint             total_elems,
 			gsize            size,
 			GCompareDataFunc compare_func,
 			gpointer         user_data);
 
+GLIB_AVAILABLE_IN_2_82
+void g_sort_array (const void       *array,
+                   size_t            n_elements,
+                   size_t            element_size,
+                   GCompareDataFunc  compare_func,
+                   void             *user_data);
+
 G_END_DECLS
 
 #endif /* __G_QSORT_H__ */

package/include/glib-2.0/glib/gslice.h

@@ -107,10 +107,12 @@ gint64   g_slice_get_config	   (GSliceConfig ckey);
 GLIB_DEPRECATED_IN_2_34
 gint64*  g_slice_get_config_state  (GSliceConfig ckey, gint64 address, guint *n_values);
 
+#ifndef __GI_SCANNER__
 #ifdef G_ENABLE_DEBUG
 GLIB_AVAILABLE_IN_ALL
 void     g_slice_debug_tree_statistics (void);
 #endif
+#endif
 
 G_END_DECLS
 

package/include/glib-2.0/glib/gstrfuncs.h

@@ -327,21 +327,9 @@ g_strdup_inline (const char *str)
 #endif /* !defined (__GTK_DOC_IGNORE__) */
 #endif /* G_GNUC_CHECK_VERSION (2, 0) */
 
-/* Make a copy of a string interpreting C string -style escape
- * sequences. Inverse of g_strescape. The recognized sequences are \b
- * \f \n \r \t \\ \" and the octal format.
- */
 GLIB_AVAILABLE_IN_ALL
 gchar*                g_strcompress    (const gchar *source) G_GNUC_MALLOC;
 
-/* Copy a string escaping nonprintable characters like in C strings.
- * Inverse of g_strcompress. The exceptions parameter, if non-NULL, points
- * to a string containing characters that are not to be escaped.
- *
- * Deprecated API: gchar* g_strescape (const gchar *source);
- * Luckily this function wasn't used much, using NULL as second parameter
- * provides mostly identical semantics.
- */
 GLIB_AVAILABLE_IN_ALL
 gchar*                g_strescape      (const gchar *source,
 					const gchar *exceptions) G_GNUC_MALLOC;
@@ -412,8 +400,8 @@ gboolean              g_strv_equal     (const gchar * const *strv1,
 
 /**
  * GNumberParserError:
- * @G_NUMBER_PARSER_ERROR_INVALID: String was not a valid number.
- * @G_NUMBER_PARSER_ERROR_OUT_OF_BOUNDS: String was a number, but out of bounds.
+ * @G_NUMBER_PARSER_ERROR_INVALID: string was not a valid number
+ * @G_NUMBER_PARSER_ERROR_OUT_OF_BOUNDS: string was a number, but out of bounds
  *
  * Error codes returned by functions converting a string to a number.
  *
@@ -456,28 +444,34 @@ gboolean              g_ascii_string_to_unsigned   (const gchar  *str,
 
 /**
  * g_set_str: (skip)
- * @str_pointer: (inout) (not optional) (nullable): a pointer to either a string or %NULL
- * @new_str: (nullable): a string to assign to @str_pointer, or %NULL
+ * @str_pointer: (inout) (not optional) (nullable): a pointer to either
+ *   a string or `NULL`
+ * @new_str: (nullable): a string to assign to @str_pointer
+ *
+ * Updates a pointer to a string to a copy of @new_str and returns whether the
+ * string was changed.
  *
- * Updates a pointer to a string to a copy of @new_str. The previous string
- * pointed to by @str_pointer will be freed with g_free().
+ * If @new_str matches the previous string, this function is a no-op. If
+ * @new_str is different, a copy of it will be assigned to @str_pointer and
+ * the previous string pointed to by @str_pointer will be freed with
+ * [func@GLib.free].
  *
- * @str_pointer must not be %NULL, but can point to a %NULL value.
+ * @str_pointer must not be `NULL`, but can point to a `NULL` value.
  *
  * One convenient usage of this function is in implementing property settings:
- * |[
- *   void
- *   foo_set_bar (Foo        *foo,
- *                const char *new_bar)
- *   {
- *     g_return_if_fail (IS_FOO (foo));
+ * ```C
+ * void
+ * foo_set_bar (Foo        *foo,
+ *              const char *new_bar)
+ * {
+ *   g_return_if_fail (IS_FOO (foo));
  *
- *     if (g_set_str (&foo->bar, new_bar))
- *       g_object_notify (foo, "bar");
- *   }
- * ]|
+ *   if (g_set_str (&foo->bar, new_bar))
+ *     g_object_notify (foo, "bar");
+ * }
+ * ```
  *
- * Returns: %TRUE if the value of @str_pointer changed, %FALSE otherwise
+ * Returns: true if the value of @str_pointer changed, false otherwise
  *
  * Since: 2.76
  */

package/include/glib-2.0/glib/gstrvbuilder.h

@@ -38,6 +38,9 @@ GStrvBuilder *g_strv_builder_new (void);
 GLIB_AVAILABLE_IN_2_68
 void g_strv_builder_unref (GStrvBuilder *builder);
 
+GLIB_AVAILABLE_IN_2_82
+GStrv g_strv_builder_unref_to_strv (GStrvBuilder *builder);
+
 GLIB_AVAILABLE_IN_2_68
 GStrvBuilder *g_strv_builder_ref (GStrvBuilder *builder);
 

package/include/glib-2.0/glib/gthread.h

@@ -139,6 +139,10 @@ struct _GOnce
 #  define G_TRYLOCK(name) g_mutex_trylock (&G_LOCK_NAME (name))
 #endif /* !G_DEBUG_LOCKS */
 
+#ifdef g_autoptr
+#define G_AUTO_LOCK(name) G_MUTEX_AUTO_LOCK (&G_LOCK_NAME (name), g__##name##_locker)
+#endif /* g_autoptr */
+
 GLIB_AVAILABLE_IN_2_32
 GThread *       g_thread_ref                    (GThread        *thread);
 GLIB_AVAILABLE_IN_2_32
@@ -339,7 +343,7 @@ typedef void GMutexLocker;
  *
  *   // Code with mutex locked here
  *
- *   if (cond)
+ *   if (condition)
  *     // No need to unlock
  *     return;
  *
@@ -350,6 +354,10 @@ typedef void GMutexLocker;
  * }
  * ]|
  *
+ * Note that it is common for the declared variable to not be used in the scope,
+ * which causes some compilers to warn. That can be avoided by using
+ * `G_GNUC_UNUSED` or, since 2.80, [func@GLib.MUTEX_AUTO_LOCK].
+ *
  * Returns: a #GMutexLocker
  * Since: 2.44
  */
@@ -378,6 +386,49 @@ g_mutex_locker_free (GMutexLocker *locker)
   g_mutex_unlock ((GMutex *) locker);
 }
 
+/**
+ * G_MUTEX_AUTO_LOCK:
+ * @mutex: a [type@GLib.Mutex]
+ * @var: a variable name to be declared
+ *
+ * Declare a [type@GLib.MutexLocker] variable with `g_autoptr()` and lock the
+ * mutex. The mutex will be unlocked automatically when leaving the scope. The
+ * variable is declared with `G_GNUC_UNUSED` to avoid compiler warning if it is
+ * not used in the scope.
+ *
+ * This feature is only supported on GCC and clang. This macro is not defined on
+ * other compilers and should not be used in programs that are intended to be
+ * portable to those compilers.
+ *
+ * Note that this should be used in a place where it is allowed to declare a
+ * variable, which could be before any statement in the case
+ * `-Wdeclaration-after-statement` is used, or C standard prior to C99.
+ *
+ * ```c
+ * {
+ *   G_MUTEX_AUTO_LOCK (&obj->mutex, locker);
+ *
+ *   obj->stuff_with_lock ();
+ *   if (condition)
+ *     {
+ *       // No need to unlock
+ *       return;
+ *     }
+ *
+ *   // Unlock before end of scope
+ *   g_clear_pointer (&locker, g_mutex_locker_free);
+ *   obj->stuff_without_lock ();
+ * }
+ * ```
+ *
+ * Since: 2.80.0
+ */
+#ifdef g_autoptr
+#define G_MUTEX_AUTO_LOCK(mutex, var)                   \
+  GLIB_AVAILABLE_MACRO_IN_2_80 g_autoptr (GMutexLocker) \
+  G_GNUC_UNUSED var = g_mutex_locker_new (mutex)
+#endif /* g_autoptr */
+
 /**
  * GRecMutexLocker:
  *
@@ -414,7 +465,7 @@ typedef void GRecMutexLocker;
  *
  *   // Code with rec_mutex locked here
  *
- *   if (cond)
+ *   if (condition)
  *     // No need to unlock
  *     return;
  *
@@ -425,6 +476,10 @@ typedef void GRecMutexLocker;
  * }
  * ]|
  *
+ * Note that it is common for the declared variable to not be used in the scope,
+ * which causes some compilers to warn. That can be avoided by using
+ * `G_GNUC_UNUSED` or, since 2.80, [func@GLib.REC_MUTEX_AUTO_LOCK].
+ *
  * Returns: a #GRecMutexLocker
  * Since: 2.60
  */
@@ -457,6 +512,49 @@ g_rec_mutex_locker_free (GRecMutexLocker *locker)
 }
 G_GNUC_END_IGNORE_DEPRECATIONS
 
+/**
+ * G_REC_MUTEX_AUTO_LOCK:
+ * @mutex: a [type@GLib.RecMutex]
+ * @var: a variable name to be declared
+ *
+ * Declare a [type@GLib.RecMutexLocker] variable with `g_autoptr()` and lock the
+ * mutex. The mutex will be unlocked automatically when leaving the scope. The
+ * variable is declared with `G_GNUC_UNUSED` to avoid compiler warning if it is
+ * not used in the scope.
+ *
+ * This feature is only supported on GCC and clang. This macro is not defined on
+ * other compilers and should not be used in programs that are intended to be
+ * portable to those compilers.
+ *
+ * Note that this should be used in a place where it is allowed to declare a
+ * variable, which could be before any statement in the case
+ * `-Wdeclaration-after-statement` is used, or C standard prior to C99.
+ *
+ * ```c
+ * {
+ *   G_REC_MUTEX_AUTO_LOCK (&obj->rec_mutex, locker);
+ *
+ *   obj->stuff_with_lock ();
+ *   if (condition)
+ *     {
+ *       // No need to unlock
+ *       return;
+ *     }
+ *
+ *   // Unlock before end of scope
+ *   g_clear_pointer (&locker, g_rec_mutex_locker_free);
+ *   obj->stuff_without_lock ();
+ * }
+ * ```
+ *
+ * Since: 2.80.0
+ */
+#ifdef g_autoptr
+#define G_REC_MUTEX_AUTO_LOCK(mutex, var)                  \
+  GLIB_AVAILABLE_MACRO_IN_2_80 g_autoptr (GRecMutexLocker) \
+  G_GNUC_UNUSED var = g_rec_mutex_locker_new (mutex)
+#endif /* g_autoptr */
+
 /**
  * GRWLockWriterLocker:
  *
@@ -520,7 +618,7 @@ typedef void GRWLockWriterLocker;
  *   if (self->array == NULL)
  *     self->array = g_ptr_array_new ();
  *
- *   if (cond)
+ *   if (condition)
  *     // No need to unlock
  *     return;
  *
@@ -535,6 +633,10 @@ typedef void GRWLockWriterLocker;
  * }
  * ]|
  *
+ * Note that it is common for the declared variable to not be used in the scope,
+ * which causes some compilers to warn. That can be avoided by using
+ * `G_GNUC_UNUSED` or, since 2.80, [func@GLib.RW_LOCK_WRITER_AUTO_LOCK].
+ *
  * Returns: a #GRWLockWriterLocker
  * Since: 2.62
  */
@@ -568,6 +670,49 @@ g_rw_lock_writer_locker_free (GRWLockWriterLocker *locker)
 }
 G_GNUC_END_IGNORE_DEPRECATIONS
 
+/**
+ * G_RW_LOCK_WRITER_AUTO_LOCK:
+ * @mutex: a [type@GLib.RWLock]
+ * @var: a variable name to be declared
+ *
+ * Declare a [type@GLib.RWLockWriterLocker] variable with `g_autoptr()` and lock
+ * for writing. The mutex will be unlocked automatically when leaving the scope.
+ * The variable is declared with `G_GNUC_UNUSED` to avoid compiler warning if it
+ * is not used in the scope.
+ *
+ * This feature is only supported on GCC and clang. This macro is not defined on
+ * other compilers and should not be used in programs that are intended to be
+ * portable to those compilers.
+ *
+ * Note that this should be used in a place where it is allowed to declare a
+ * variable, which could be before any statement in the case
+ * `-Wdeclaration-after-statement` is used, or C standard prior to C99.
+ *
+ * ```c
+ * {
+ *   G_RW_LOCK_WRITER_AUTO_LOCK (&obj->rw_lock, locker);
+ *
+ *   obj->stuff_with_lock ();
+ *   if (condition)
+ *     {
+ *       // No need to unlock
+ *       return;
+ *     }
+ *
+ *   // Unlock before end of scope
+ *   g_clear_pointer (&locker, g_rw_lock_writer_locker_free);
+ *   obj->stuff_without_lock ();
+ * }
+ * ```
+ *
+ * Since: 2.80.0
+ */
+#ifdef g_autoptr
+#define G_RW_LOCK_WRITER_AUTO_LOCK(mutex, var)                 \
+  GLIB_AVAILABLE_MACRO_IN_2_80 g_autoptr (GRWLockWriterLocker) \
+  G_GNUC_UNUSED var = g_rw_lock_writer_locker_new (mutex)
+#endif /* g_autoptr */
+
 /**
  * GRWLockReaderLocker:
  *
@@ -623,6 +768,49 @@ g_rw_lock_reader_locker_free (GRWLockReaderLocker *locker)
 }
 G_GNUC_END_IGNORE_DEPRECATIONS
 
+/**
+ * G_RW_LOCK_READER_AUTO_LOCK:
+ * @mutex: a [type@GLib.RWLock]
+ * @var: a variable name to be declared
+ *
+ * Declare a [type@GLib.RWLockReaderLocker] variable with `g_autoptr()` and lock
+ * for reading. The mutex will be unlocked automatically when leaving the scope.
+ * The variable is declared with `G_GNUC_UNUSED` to avoid compiler warning if it
+ * is not used in the scope.
+ *
+ * This feature is only supported on GCC and clang. This macro is not defined on
+ * other compilers and should not be used in programs that are intended to be
+ * portable to those compilers.
+ *
+ * Note that this should be used in a place where it is allowed to declare a
+ * variable, which could be before any statement in the case
+ * `-Wdeclaration-after-statement` is used, or C standard prior to C99.
+ *
+ * ```c
+ * {
+ *   G_RW_LOCK_READER_AUTO_LOCK (&obj->rw_lock, locker);
+ *
+ *   obj->stuff_with_lock ();
+ *   if (condition)
+ *     {
+ *       // No need to unlock
+ *       return;
+ *     }
+ *
+ *   // Unlock before end of scope
+ *   g_clear_pointer (&locker, g_rw_lock_reader_locker_free);
+ *   obj->stuff_without_lock ();
+ * }
+ * ```
+ *
+ * Since: 2.80.0
+ */
+#ifdef g_autoptr
+#define G_RW_LOCK_READER_AUTO_LOCK(mutex, var)                 \
+  GLIB_AVAILABLE_MACRO_IN_2_80 g_autoptr (GRWLockReaderLocker) \
+  G_GNUC_UNUSED var = g_rw_lock_reader_locker_new (mutex)
+#endif /* g_autoptr */
+
 G_END_DECLS
 
 #endif /* __G_THREAD_H__ */

package/include/glib-2.0/glib/gunicode.h

@@ -806,7 +806,7 @@ GLIB_VAR const gchar * const g_utf8_skip;
  * Before using this macro, use g_utf8_validate() to validate strings
  * that may contain invalid UTF-8.
  */
-#define g_utf8_next_char(p) (char *)((p) + g_utf8_skip[*(const guchar *)(p)])
+#define g_utf8_next_char(p) ((p) + g_utf8_skip[*(const guchar *)(p)])
 
 GLIB_AVAILABLE_IN_ALL
 gunichar g_utf8_get_char           (const gchar  *p) G_GNUC_PURE;

package/include/glib-2.0/glib/gversionmacros.h

@@ -395,6 +395,15 @@
 * Since: 2.80
 */
 #define GLIB_VERSION_2_80       (G_ENCODE_VERSION (2, 80))
+/**
+* GLIB_VERSION_2_82:
+*
+* A macro that evaluates to the 2.82 version of GLib, in a format
+* that can be used by the C pre-processor.
+*
+* Since: 2.82
+*/
+#define GLIB_VERSION_2_82       (G_ENCODE_VERSION (2, 82))
 
 /**
  * GLIB_VERSION_CUR_STABLE:

package/include/glib-2.0/glib-unix.h

@@ -173,7 +173,7 @@ G_GNUC_BEGIN_IGNORE_DEPRECATIONS
 /**
  * g_unix_pipe_open:
  * @self: A pair of file descriptors
- * @flags: Flags to pass to g_unix_open_pipe(), typically `FD_CLOEXEC`
+ * @flags: Flags to pass to g_unix_open_pipe(), typically `O_CLOEXEC`
  * @error: Used to report an error on failure
  *
  * Open a pipe. This is the same as g_unix_open_pipe(), but uses the
@@ -326,6 +326,12 @@ g_unix_pipe_clear (GUnixPipe *self)
 
 G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC (GUnixPipe, g_unix_pipe_clear)
 
+GLIB_AVAILABLE_IN_2_80
+int g_closefrom (int lowfd);
+
+GLIB_AVAILABLE_IN_2_80
+int g_fdwalk_set_cloexec (int lowfd);
+
 G_GNUC_END_IGNORE_DEPRECATIONS
 
 G_END_DECLS

package/include/glib-2.0/gmodule/gmodule-visibility.h

@@ -984,3 +984,37 @@
 #define GMODULE_AVAILABLE_ENUMERATOR_IN_2_80
 #define GMODULE_AVAILABLE_TYPE_IN_2_80
 #endif
+
+#if GLIB_VERSION_MIN_REQUIRED >= GLIB_VERSION_2_82
+#define GMODULE_DEPRECATED_IN_2_82 GMODULE_DEPRECATED
+#define GMODULE_DEPRECATED_IN_2_82_FOR(f) GMODULE_DEPRECATED_FOR (f)
+#define GMODULE_DEPRECATED_MACRO_IN_2_82 GLIB_DEPRECATED_MACRO
+#define GMODULE_DEPRECATED_MACRO_IN_2_82_FOR(f) GLIB_DEPRECATED_MACRO_FOR (f)
+#define GMODULE_DEPRECATED_ENUMERATOR_IN_2_82 GLIB_DEPRECATED_ENUMERATOR
+#define GMODULE_DEPRECATED_ENUMERATOR_IN_2_82_FOR(f) GLIB_DEPRECATED_ENUMERATOR_FOR (f)
+#define GMODULE_DEPRECATED_TYPE_IN_2_82 GLIB_DEPRECATED_TYPE
+#define GMODULE_DEPRECATED_TYPE_IN_2_82_FOR(f) GLIB_DEPRECATED_TYPE_FOR (f)
+#else
+#define GMODULE_DEPRECATED_IN_2_82 _GMODULE_EXTERN
+#define GMODULE_DEPRECATED_IN_2_82_FOR(f) _GMODULE_EXTERN
+#define GMODULE_DEPRECATED_MACRO_IN_2_82
+#define GMODULE_DEPRECATED_MACRO_IN_2_82_FOR(f)
+#define GMODULE_DEPRECATED_ENUMERATOR_IN_2_82
+#define GMODULE_DEPRECATED_ENUMERATOR_IN_2_82_FOR(f)
+#define GMODULE_DEPRECATED_TYPE_IN_2_82
+#define GMODULE_DEPRECATED_TYPE_IN_2_82_FOR(f)
+#endif
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_82
+#define GMODULE_AVAILABLE_IN_2_82 GMODULE_UNAVAILABLE (2, 82)
+#define GMODULE_AVAILABLE_STATIC_INLINE_IN_2_82 GLIB_UNAVAILABLE_STATIC_INLINE (2, 82)
+#define GMODULE_AVAILABLE_MACRO_IN_2_82 GLIB_UNAVAILABLE_MACRO (2, 82)
+#define GMODULE_AVAILABLE_ENUMERATOR_IN_2_82 GLIB_UNAVAILABLE_ENUMERATOR (2, 82)
+#define GMODULE_AVAILABLE_TYPE_IN_2_82 GLIB_UNAVAILABLE_TYPE (2, 82)
+#else
+#define GMODULE_AVAILABLE_IN_2_82 _GMODULE_EXTERN
+#define GMODULE_AVAILABLE_STATIC_INLINE_IN_2_82
+#define GMODULE_AVAILABLE_MACRO_IN_2_82
+#define GMODULE_AVAILABLE_ENUMERATOR_IN_2_82
+#define GMODULE_AVAILABLE_TYPE_IN_2_82
+#endif

package/include/glib-2.0/gobject/genums.h

@@ -320,14 +320,14 @@ void	g_flags_complete_type_info (GType	       g_flags_type,
 #define G_DEFINE_ENUM_TYPE(TypeName, type_name, ...) \
 GType \
 type_name ## _get_type (void) { \
-  static gsize g_define_type__static = 0; \
-  if (g_once_init_enter (&g_define_type__static)) { \
+  static _g_type_once_init_type g_define_type__static = 0; \
+  if (_g_type_once_init_enter (&g_define_type__static)) { \
     static const GEnumValue enum_values[] = { \
       __VA_ARGS__ , \
       { 0, NULL, NULL }, \
     }; \
     GType g_define_type = g_enum_register_static (g_intern_static_string (#TypeName), enum_values); \
-    g_once_init_leave (&g_define_type__static, g_define_type); \
+    _g_type_once_init_leave (&g_define_type__static, g_define_type); \
   } \
   return g_define_type__static; \
 } \
@@ -363,14 +363,14 @@ type_name ## _get_type (void) { \
 #define G_DEFINE_FLAGS_TYPE(TypeName, type_name, ...) \
 GType \
 type_name ## _get_type (void) { \
-  static gsize g_define_type__static = 0; \
-  if (g_once_init_enter (&g_define_type__static)) { \
+  static _g_type_once_init_type g_define_type__static = 0; \
+  if (_g_type_once_init_enter (&g_define_type__static)) { \
     static const GFlagsValue flags_values[] = { \
       __VA_ARGS__ , \
       { 0, NULL, NULL }, \
     }; \
     GType g_define_type = g_flags_register_static (g_intern_static_string (#TypeName), flags_values); \
-    g_once_init_leave (&g_define_type__static, g_define_type); \
+    _g_type_once_init_leave (&g_define_type__static, g_define_type); \
   } \
   return g_define_type__static; \
 } \

package/include/glib-2.0/gobject/glib-types.h

@@ -345,6 +345,15 @@ typedef gsize GType;
  */
 #define G_TYPE_DIR (g_dir_get_type ())
 
+/**
+ * G_TYPE_RAND:
+ *
+ * The #GType for a boxed type holding a #GRand.
+ *
+ * Since: 2.80
+ */
+#define G_TYPE_RAND (g_rand_get_type ())
+
 /**
  * G_TYPE_STRV_BUILDER:
  *
@@ -423,6 +432,8 @@ GType   g_hmac_get_type (void) G_GNUC_CONST;
 GOBJECT_AVAILABLE_IN_2_80
 GType   g_dir_get_type (void) G_GNUC_CONST;
 GOBJECT_AVAILABLE_IN_2_80
+GType   g_rand_get_type (void) G_GNUC_CONST;
+GOBJECT_AVAILABLE_IN_2_80
 GType   g_strv_builder_get_type (void) G_GNUC_CONST;
 
 GOBJECT_DEPRECATED_FOR('G_TYPE_VARIANT')