@img/sharp-libvips-dev-wasm32 1.3.2 → 1.3.3-rc.0

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

@@ -44,96 +44,96 @@ typedef void (*GTestFixtureFunc) (gpointer      fixture,
 
 /* assertion API */
 #define g_assert_cmpstr(s1, cmp, s2)    G_STMT_START { \
-                                             const char *__s1 = (s1), *__s2 = (s2); \
-                                             if (g_strcmp0 (__s1, __s2) cmp 0) ; else \
+                                             const char *_s1 = (s1), *_s2 = (s2); \
+                                             if (g_strcmp0 (_s1, _s2) cmp 0) ; else \
                                                g_assertion_message_cmpstr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
-                                                 #s1 " " #cmp " " #s2, __s1, #cmp, __s2); \
+                                                 #s1 " " #cmp " " #s2, _s1, #cmp, _s2); \
                                         } G_STMT_END
 #if GLIB_VERSION_MIN_REQUIRED >= GLIB_VERSION_2_78
 #define g_assert_cmpint(n1, cmp, n2)    G_STMT_START { \
-                                             gint64 __n1 = (n1), __n2 = (n2); \
-                                             if (__n1 cmp __n2) ; else \
+                                             gint64 _n1 = (n1), _n2 = (n2); \
+                                             if (_n1 cmp _n2) ; else \
                                                g_assertion_message_cmpint (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
-                                                 #n1 " " #cmp " " #n2, (guint64)__n1, #cmp, (guint64)__n2, 'i'); \
+                                                 #n1 " " #cmp " " #n2, (guint64)_n1, #cmp, (guint64)_n2, 'i'); \
                                         } G_STMT_END
 #define g_assert_cmpuint(n1, cmp, n2)   G_STMT_START { \
-                                             guint64 __n1 = (n1), __n2 = (n2); \
-                                             if (__n1 cmp __n2) ; else \
+                                             guint64 _n1 = (n1), _n2 = (n2); \
+                                             if (_n1 cmp _n2) ; else \
                                                g_assertion_message_cmpint (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
-                                                 #n1 " " #cmp " " #n2, __n1, #cmp, __n2, 'u'); \
+                                                 #n1 " " #cmp " " #n2, _n1, #cmp, _n2, 'u'); \
                                         } G_STMT_END
 #define g_assert_cmphex(n1, cmp, n2)    G_STMT_START { \
-                                             guint64 __n1 = (n1), __n2 = (n2); \
-                                             if (__n1 cmp __n2) ; else \
+                                             guint64 _n1 = (n1), _n2 = (n2); \
+                                             if (_n1 cmp _n2) ; else \
                                                g_assertion_message_cmpint (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
-                                                 #n1 " " #cmp " " #n2, __n1, #cmp, __n2, 'x'); \
+                                                 #n1 " " #cmp " " #n2, _n1, #cmp, _n2, 'x'); \
                                         } G_STMT_END
 #else /* GLIB_VERSION_MIN_REQUIRED < GLIB_VERSION_2_78 */
 #define g_assert_cmpint(n1, cmp, n2)    G_STMT_START { \
-                                             gint64 __n1 = (n1), __n2 = (n2); \
-                                             if (__n1 cmp __n2) ; else \
+                                             gint64 _n1 = (n1), _n2 = (n2); \
+                                             if (_n1 cmp _n2) ; else \
                                                g_assertion_message_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
-                                                 #n1 " " #cmp " " #n2, (long double) __n1, #cmp, (long double) __n2, 'i'); \
+                                                 #n1 " " #cmp " " #n2, (long double) _n1, #cmp, (long double) _n2, 'i'); \
                                         } G_STMT_END
 #define g_assert_cmpuint(n1, cmp, n2)   G_STMT_START { \
-                                             guint64 __n1 = (n1), __n2 = (n2); \
-                                             if (__n1 cmp __n2) ; else \
+                                             guint64 _n1 = (n1), _n2 = (n2); \
+                                             if (_n1 cmp _n2) ; else \
                                                g_assertion_message_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
-                                                 #n1 " " #cmp " " #n2, (long double) __n1, #cmp, (long double) __n2, 'i'); \
+                                                 #n1 " " #cmp " " #n2, (long double) _n1, #cmp, (long double) _n2, 'i'); \
                                         } G_STMT_END
 #define g_assert_cmphex(n1, cmp, n2)    G_STMT_START {\
-                                             guint64 __n1 = (n1), __n2 = (n2); \
-                                             if (__n1 cmp __n2) ; else \
+                                             guint64 _n1 = (n1), _n2 = (n2); \
+                                             if (_n1 cmp _n2) ; else \
                                                g_assertion_message_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
-                                                 #n1 " " #cmp " " #n2, (long double) __n1, #cmp, (long double) __n2, 'x'); \
+                                                 #n1 " " #cmp " " #n2, (long double) _n1, #cmp, (long double) _n2, 'x'); \
                                         } G_STMT_END
 #endif /* GLIB_VERSION_MIN_REQUIRED >= GLIB_VERSION_2_78 */
 #define g_assert_cmpfloat(n1,cmp,n2)    G_STMT_START { \
-                                             long double __n1 = (long double) (n1), __n2 = (long double) (n2); \
-                                             if (__n1 cmp __n2) ; else \
+                                             long double _n1 = (long double) (n1), _n2 = (long double) (n2); \
+                                             if (_n1 cmp _n2) ; else \
                                                g_assertion_message_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
-                                                 #n1 " " #cmp " " #n2, (long double) __n1, #cmp, (long double) __n2, 'f'); \
+                                                 #n1 " " #cmp " " #n2, (long double) _n1, #cmp, (long double) _n2, 'f'); \
                                         } G_STMT_END
 #define g_assert_cmpfloat_with_epsilon(n1,n2,epsilon) \
                                         G_STMT_START { \
-                                             double __n1 = (n1), __n2 = (n2), __epsilon = (epsilon); \
-                                             if (G_APPROX_VALUE (__n1,  __n2, __epsilon)) ; else \
+                                             double _n1 = (n1), _n2 = (n2), _epsilon = (epsilon); \
+                                             if (G_APPROX_VALUE (_n1,  _n2, _epsilon)) ; else \
                                                g_assertion_message_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
-                                                 #n1 " == " #n2 " (+/- " #epsilon ")", __n1, "==", __n2, 'f'); \
+                                                 #n1 " == " #n2 " (+/- " #epsilon ")", _n1, "==", _n2, 'f'); \
                                         } G_STMT_END
 #if GLIB_VERSION_MIN_REQUIRED >= GLIB_VERSION_2_78
 #define g_assert_cmpmem(m1, l1, m2, l2) G_STMT_START {\
-                                             gconstpointer __m1 = m1, __m2 = m2; \
-                                             size_t __l1 = (size_t) l1, __l2 = (size_t) l2; \
-                                             if (__l1 != 0 && __m1 == NULL) \
+                                             gconstpointer _m1 = m1, _m2 = m2; \
+                                             size_t _l1 = (size_t) l1, _l2 = (size_t) l2; \
+                                             if (_l1 != 0 && _m1 == NULL) \
                                                g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
                                                                     "assertion failed (" #l1 " == 0 || " #m1 " != NULL)"); \
-                                             else if (__l2 != 0 && __m2 == NULL) \
+                                             else if (_l2 != 0 && _m2 == NULL) \
                                                g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
                                                                     "assertion failed (" #l2 " == 0 || " #m2 " != NULL)"); \
-                                             else if (__l1 != __l2) \
+                                             else if (_l1 != _l2) \
                                                g_assertion_message_cmpint (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
                                                                            #l1 " (len(" #m1 ")) == " #l2 " (len(" #m2 "))", \
-                                                                           __l1, "==", __l2, 'u'); \
-                                             else if (__l1 != 0 && __m2 != NULL && memcmp (__m1, __m2, __l1) != 0) \
+                                                                           _l1, "==", _l2, 'u'); \
+                                             else if (_l1 != 0 && _m2 != NULL && memcmp (_m1, _m2, _l1) != 0) \
                                                g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
                                                                     "assertion failed (" #m1 " == " #m2 ")"); \
                                         } G_STMT_END
 #else /* GLIB_VERSION_MIN_REQUIRED < GLIB_VERSION_2_78 */
 #define g_assert_cmpmem(m1, l1, m2, l2) G_STMT_START {\
-                                             gconstpointer __m1 = m1, __m2 = m2; \
-                                             size_t __l1 = (size_t) l1, __l2 = (size_t) l2; \
-                                             if (__l1 != 0 && __m1 == NULL) \
+                                             gconstpointer _m1 = m1, _m2 = m2; \
+                                             size_t _l1 = (size_t) l1, _l2 = (size_t) l2; \
+                                             if (_l1 != 0 && _m1 == NULL) \
                                                g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
                                                                     "assertion failed (" #l1 " == 0 || " #m1 " != NULL)"); \
-                                             else if (__l2 != 0 && __m2 == NULL) \
+                                             else if (_l2 != 0 && _m2 == NULL) \
                                                g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
                                                                     "assertion failed (" #l2 " == 0 || " #m2 " != NULL)"); \
-                                             else if (__l1 != __l2) \
+                                             else if (_l1 != _l2) \
                                                g_assertion_message_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
                                                                            #l1 " (len(" #m1 ")) == " #l2 " (len(" #m2 "))", \
-                                                                           (long double) __l1, "==", (long double) __l2, 'i'); \
-                                             else if (__l1 != 0 && __m2 != NULL && memcmp (__m1, __m2, __l1) != 0) \
+                                                                           (long double) _l1, "==", (long double) _l2, 'i'); \
+                                             else if (_l1 != 0 && _m2 != NULL && memcmp (_m1, _m2, _l1) != 0) \
                                                g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
                                                                     "assertion failed (" #m1 " == " #m2 ")"); \
                                         } G_STMT_END
@@ -141,33 +141,33 @@ typedef void (*GTestFixtureFunc) (gpointer      fixture,
 #define g_assert_cmpvariant(v1, v2) \
   G_STMT_START \
   { \
-    GVariant *__v1 = (v1), *__v2 = (v2); \
-    if (!g_variant_equal (__v1, __v2)) \
+    GVariant *_v1 = (v1), *_v2 = (v2); \
+    if (!g_variant_equal (_v1, _v2)) \
       { \
-        gchar *__s1, *__s2, *__msg; \
-        __s1 = g_variant_print (__v1, TRUE); \
-        __s2 = g_variant_print (__v2, TRUE); \
-        __msg = g_strdup_printf ("assertion failed (" #v1 " == " #v2 "): %s does not equal %s", __s1, __s2); \
-        g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, __msg); \
-        g_free (__s1); \
-        g_free (__s2); \
-        g_free (__msg); \
+        gchar *_s1, *_s2, *_msg; \
+        _s1 = g_variant_print (_v1, TRUE); \
+        _s2 = g_variant_print (_v2, TRUE); \
+        _msg = g_strdup_printf ("assertion failed (" #v1 " == " #v2 "): %s does not equal %s", _s1, _s2); \
+        g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, _msg); \
+        g_free (_s1); \
+        g_free (_s2); \
+        g_free (_msg); \
       } \
   } \
   G_STMT_END
 #define g_assert_cmpstrv(strv1, strv2) \
   G_STMT_START \
   { \
-    const char * const *__strv1 = (const char * const *) (strv1); \
-    const char * const *__strv2 = (const char * const *) (strv2); \
-    if (!__strv1 || !__strv2) \
+    const char * const *_strv1 = (const char * const *) (strv1); \
+    const char * const *_strv2 = (const char * const *) (strv2); \
+    if (!_strv1 || !_strv2) \
       { \
-        if (__strv1) \
+        if (_strv1) \
           { \
             g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
                                  "assertion failed (" #strv1 " == " #strv2 "): " #strv2 " is NULL, but " #strv1 " is not"); \
           } \
-        else if (__strv2) \
+        else if (_strv2) \
           { \
             g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
                                  "assertion failed (" #strv1 " == " #strv2 "): " #strv1 " is NULL, but " #strv2 " is not"); \
@@ -175,25 +175,25 @@ typedef void (*GTestFixtureFunc) (gpointer      fixture,
       } \
     else \
       { \
-        guint __l1 = g_strv_length ((char **) __strv1); \
-        guint __l2 = g_strv_length ((char **) __strv2); \
-        if (__l1 != __l2) \
+        guint _l1 = g_strv_length ((char **) _strv1); \
+        guint _l2 = g_strv_length ((char **) _strv2); \
+        if (_l1 != _l2) \
           { \
-            char *__msg; \
-            __msg = g_strdup_printf ("assertion failed (" #strv1 " == " #strv2 "): length %u does not equal length %u", __l1, __l2); \
-            g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, __msg); \
-            g_free (__msg); \
+            char *_msg; \
+            _msg = g_strdup_printf ("assertion failed (" #strv1 " == " #strv2 "): length %u does not equal length %u", _l1, _l2); \
+            g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, _msg); \
+            g_free (_msg); \
           } \
         else \
           { \
-            guint __i; \
-            for (__i = 0; __i < __l1; __i++) \
+            guint _i; \
+            for (_i = 0; _i < _l1; _i++) \
               { \
-                if (g_strcmp0 (__strv1[__i], __strv2[__i]) != 0) \
+                if (g_strcmp0 (_strv1[_i], _strv2[_i]) != 0) \
                   { \
                     g_assertion_message_cmpstrv (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
                                                  #strv1 " == " #strv2, \
-                                                 __strv1, __strv2, __i); \
+                                                 _strv1, _strv2, _i); \
                   } \
               } \
           } \
@@ -201,16 +201,16 @@ typedef void (*GTestFixtureFunc) (gpointer      fixture,
   } \
   G_STMT_END
 #define g_assert_no_errno(expr)         G_STMT_START { \
-                                             int __ret, __errsv; \
+                                             int _ret, _errsv; \
                                              errno = 0; \
-                                             __ret = expr; \
-                                             __errsv = errno; \
-                                             if (__ret < 0) \
+                                             _ret = expr; \
+                                             _errsv = errno; \
+                                             if (_ret < 0) \
                                                { \
-                                                 gchar *__msg; \
-                                                 __msg = g_strdup_printf ("assertion failed (" #expr " >= 0): errno %i: %s", __errsv, g_strerror (__errsv)); \
-                                                 g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, __msg); \
-                                                 g_free (__msg); \
+                                                 gchar *_msg; \
+                                                 _msg = g_strdup_printf ("assertion failed (" #expr " >= 0): errno %i: %s", _errsv, g_strerror (_errsv)); \
+                                                 g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, _msg); \
+                                                 g_free (_msg); \
                                                } \
                                         } G_STMT_END \
                                         GLIB_AVAILABLE_MACRO_IN_2_66
@@ -500,7 +500,6 @@ void    g_test_queue_destroy            (GDestroyNotify destroy_func,
 
 /**
  * GTestTrapFlags:
- * @G_TEST_TRAP_DEFAULT: Default behaviour. Since: 2.74
  * @G_TEST_TRAP_SILENCE_STDOUT: 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
@@ -522,6 +521,13 @@ void    g_test_queue_destroy            (GDestroyNotify destroy_func,
  *   [flags@GLib.TestSubprocessFlags].
  */
 typedef enum {
+  /**
+   * G_TEST_TRAP_DEFAULT:
+   *
+   * Default behaviour.
+   *
+   * Since: 2.74
+   * */
   G_TEST_TRAP_DEFAULT GLIB_AVAILABLE_ENUMERATOR_IN_2_74 = 0,
   G_TEST_TRAP_SILENCE_STDOUT    = 1 << 7,
   G_TEST_TRAP_SILENCE_STDERR    = 1 << 8,
@@ -536,7 +542,36 @@ gboolean g_test_trap_fork               (guint64              usec_timeout,
 
 G_GNUC_END_IGNORE_DEPRECATIONS
 
+/**
+ * GTestSubprocessFlags:
+ * @G_TEST_SUBPROCESS_INHERIT_STDIN: If this flag is given, the child
+ *   process will inherit the parent's stdin. Otherwise, the child's
+ *   stdin is redirected to `/dev/null`.
+ * @G_TEST_SUBPROCESS_INHERIT_STDOUT: 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 [func@GLib.test_trap_assert_stdout].
+ * @G_TEST_SUBPROCESS_INHERIT_STDERR: 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 [func@GLib.test_trap_assert_stderr].
+ * @G_TEST_SUBPROCESS_INHERIT_DESCRIPTORS: If this flag is given, the
+ *   child process will inherit the parent’s open file descriptors.
+ *
+ * Flags to pass to [func@GLib.test_trap_subprocess] to control input and output.
+ *
+ * Note that in contrast with [func@GLib.test_trap_fork], the default
+ * behavior of [func@GLib.test_trap_subprocess] is to not show stdout
+ * and stderr.
+ */
 typedef enum {
+  /**
+   * G_TEST_SUBPROCESS_DEFAULT:
+   *
+   * Default behaviour.
+   *
+   * Since: 2.74
+   */
   G_TEST_SUBPROCESS_DEFAULT GLIB_AVAILABLE_ENUMERATOR_IN_2_74 = 0,
   G_TEST_SUBPROCESS_INHERIT_STDIN  = 1 << 0,
   G_TEST_SUBPROCESS_INHERIT_STDOUT = 1 << 1,

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

@@ -255,56 +255,56 @@ typedef const gchar *   (*GTranslateFunc)       (const gchar   *str,
 #  if defined (__i386__)
 #    define GUINT16_SWAP_LE_BE_IA32(val) \
        (G_GNUC_EXTENSION					\
-	({ guint16 __v, __x = ((guint16) (val));		\
-	   if (__builtin_constant_p (__x))			\
-	     __v = GUINT16_SWAP_LE_BE_CONSTANT (__x);		\
+	({ guint16 _v, _x = ((guint16) (val));			\
+	   if (__builtin_constant_p (_x))			\
+	     _v = GUINT16_SWAP_LE_BE_CONSTANT (_x);		\
 	   else							\
 	     __asm__ ("rorw $8, %w0"				\
-		      : "=r" (__v)				\
-		      : "0" (__x)				\
+		      : "=r" (_v)				\
+		      : "0" (_x)				\
 		      : "cc");					\
-	    __v; }))
+	    _v; }))
 #    if !defined (__i486__) && !defined (__i586__) \
 	&& !defined (__pentium__) && !defined (__i686__) \
 	&& !defined (__pentiumpro__) && !defined (__pentium4__)
 #       define GUINT32_SWAP_LE_BE_IA32(val) \
 	  (G_GNUC_EXTENSION					\
-	   ({ guint32 __v, __x = ((guint32) (val));		\
-	      if (__builtin_constant_p (__x))			\
-		__v = GUINT32_SWAP_LE_BE_CONSTANT (__x);	\
+	   ({ guint32 _v, _x = ((guint32) (val));		\
+	      if (__builtin_constant_p (_x))			\
+		_v = GUINT32_SWAP_LE_BE_CONSTANT (_x);	\
 	      else						\
 		__asm__ ("rorw $8, %w0\n\t"			\
 			 "rorl $16, %0\n\t"			\
 			 "rorw $8, %w0"				\
-			 : "=r" (__v)				\
-			 : "0" (__x)				\
+			 : "=r" (_v)				\
+			 : "0" (_x)				\
 			 : "cc");				\
-	      __v; }))
+	      _v; }))
 #    else /* 486 and higher has bswap */
 #       define GUINT32_SWAP_LE_BE_IA32(val) \
 	  (G_GNUC_EXTENSION					\
-	   ({ guint32 __v, __x = ((guint32) (val));		\
-	      if (__builtin_constant_p (__x))			\
-		__v = GUINT32_SWAP_LE_BE_CONSTANT (__x);	\
+	   ({ guint32 _v, _x = ((guint32) (val));		\
+	      if (__builtin_constant_p (_x))			\
+		_v = GUINT32_SWAP_LE_BE_CONSTANT (_x);	\
 	      else						\
 		__asm__ ("bswap %0"				\
-			 : "=r" (__v)				\
-			 : "0" (__x));				\
-	      __v; }))
+			 : "=r" (_v)				\
+			 : "0" (_x));				\
+	      _v; }))
 #    endif /* processor specific 32-bit stuff */
 #    define GUINT64_SWAP_LE_BE_IA32(val) \
        (G_GNUC_EXTENSION						\
-	({ union { guint64 __ll;					\
-		   guint32 __l[2]; } __w, __r;				\
-	   __w.__ll = ((guint64) (val));				\
-	   if (__builtin_constant_p (__w.__ll))				\
-	     __r.__ll = GUINT64_SWAP_LE_BE_CONSTANT (__w.__ll);		\
+	({ union { guint64 _ll;						\
+		   guint32 _l[2]; } _w, _r;				\
+	   _w._ll = ((guint64) (val));					\
+	   if (__builtin_constant_p (_w._ll))				\
+	     _r._ll = GUINT64_SWAP_LE_BE_CONSTANT (_w._ll);		\
 	   else								\
 	     {								\
-	       __r.__l[0] = GUINT32_SWAP_LE_BE (__w.__l[1]);		\
-	       __r.__l[1] = GUINT32_SWAP_LE_BE (__w.__l[0]);		\
+	       _r._l[0] = GUINT32_SWAP_LE_BE (_w._l[1]);		\
+	       _r._l[1] = GUINT32_SWAP_LE_BE (_w._l[0]);		\
 	     }								\
-	   __r.__ll; }))
+	   _r._ll; }))
      /* Possibly just use the constant version and let gcc figure it out? */
 #    define GUINT16_SWAP_LE_BE(val) (GUINT16_SWAP_LE_BE_IA32 (val))
 #    ifndef GUINT32_SWAP_LE_BE
@@ -316,36 +316,36 @@ typedef const gchar *   (*GTranslateFunc)       (const gchar   *str,
 #  elif defined (__ia64__)
 #    define GUINT16_SWAP_LE_BE_IA64(val) \
        (G_GNUC_EXTENSION					\
-	({ guint16 __v, __x = ((guint16) (val));		\
-	   if (__builtin_constant_p (__x))			\
-	     __v = GUINT16_SWAP_LE_BE_CONSTANT (__x);		\
+	({ guint16 _v, _x = ((guint16) (val));			\
+	   if (__builtin_constant_p (_x))			\
+	     _v = GUINT16_SWAP_LE_BE_CONSTANT (_x);		\
 	   else							\
 	     __asm__ __volatile__ ("shl %0 = %1, 48 ;;"		\
 				   "mux1 %0 = %0, @rev ;;"	\
-				    : "=r" (__v)		\
-				    : "r" (__x));		\
-	    __v; }))
+				    : "=r" (_v)			\
+				    : "r" (_x));		\
+	    _v; }))
 #    define GUINT32_SWAP_LE_BE_IA64(val) \
        (G_GNUC_EXTENSION					\
-	 ({ guint32 __v, __x = ((guint32) (val));		\
-	    if (__builtin_constant_p (__x))			\
-	      __v = GUINT32_SWAP_LE_BE_CONSTANT (__x);		\
+	 ({ guint32 _v, _x = ((guint32) (val));			\
+	    if (__builtin_constant_p (_x))			\
+	      _v = GUINT32_SWAP_LE_BE_CONSTANT (_x);		\
 	    else						\
 	     __asm__ __volatile__ ("shl %0 = %1, 32 ;;"		\
 				   "mux1 %0 = %0, @rev ;;"	\
-				    : "=r" (__v)		\
-				    : "r" (__x));		\
-	    __v; }))
+				    : "=r" (_v)			\
+				    : "r" (_x));		\
+	    _v; }))
 #    define GUINT64_SWAP_LE_BE_IA64(val) \
        (G_GNUC_EXTENSION					\
-	({ guint64 __v, __x = ((guint64) (val));		\
-	   if (__builtin_constant_p (__x))			\
-	     __v = GUINT64_SWAP_LE_BE_CONSTANT (__x);		\
+	({ guint64 _v, _x = ((guint64) (val));			\
+	   if (__builtin_constant_p (_x))			\
+	     _v = GUINT64_SWAP_LE_BE_CONSTANT (_x);		\
 	   else							\
 	     __asm__ __volatile__ ("mux1 %0 = %1, @rev ;;"	\
-				   : "=r" (__v)			\
-				   : "r" (__x));		\
-	   __v; }))
+				   : "=r" (_v)			\
+				   : "r" (_x));			\
+	   _v; }))
 #    define GUINT16_SWAP_LE_BE(val) (GUINT16_SWAP_LE_BE_IA64 (val))
 #    ifndef GUINT32_SWAP_LE_BE
 #      define GUINT32_SWAP_LE_BE(val) (GUINT32_SWAP_LE_BE_IA64 (val))
@@ -356,24 +356,24 @@ typedef const gchar *   (*GTranslateFunc)       (const gchar   *str,
 #  elif defined (__x86_64__)
 #    define GUINT32_SWAP_LE_BE_X86_64(val) \
        (G_GNUC_EXTENSION					\
-	 ({ guint32 __v, __x = ((guint32) (val));		\
-	    if (__builtin_constant_p (__x))			\
-	      __v = GUINT32_SWAP_LE_BE_CONSTANT (__x);		\
+	 ({ guint32 _v, _x = ((guint32) (val));			\
+	    if (__builtin_constant_p (_x))			\
+	      _v = GUINT32_SWAP_LE_BE_CONSTANT (_x);		\
 	    else						\
 	     __asm__ ("bswapl %0"				\
-		      : "=r" (__v)				\
-		      : "0" (__x));				\
-	    __v; }))
+		      : "=r" (_v)				\
+		      : "0" (_x));				\
+	    _v; }))
 #    define GUINT64_SWAP_LE_BE_X86_64(val) \
        (G_GNUC_EXTENSION					\
-	({ guint64 __v, __x = ((guint64) (val));		\
-	   if (__builtin_constant_p (__x))			\
-	     __v = GUINT64_SWAP_LE_BE_CONSTANT (__x);		\
+	({ guint64 _v, _x = ((guint64) (val));			\
+	   if (__builtin_constant_p (_x))			\
+	     _v = GUINT64_SWAP_LE_BE_CONSTANT (_x);		\
 	   else							\
 	     __asm__ ("bswapq %0"				\
-		      : "=r" (__v)				\
-		      : "0" (__x));				\
-	   __v; }))
+		      : "=r" (_v)				\
+		      : "0" (_x));				\
+	   _v; }))
      /* gcc seems to figure out optimal code for this on its own */
 #    define GUINT16_SWAP_LE_BE(val) (GUINT16_SWAP_LE_BE_CONSTANT (val))
 #    ifndef GUINT32_SWAP_LE_BE