glib/glib-init.c - third_party/glib - Git at Google

 /*
  * Copyright © 2011 Canonical Limited
  *
  * SPDX-License-Identifier: LGPL-2.1-or-later
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  *
  * Author: Ryan Lortie <desrt@desrt.ca>
  */

 #include "config.h"

 #include "glib-init.h"
 #include "gmacros.h"
 #include "gtypes.h"
 #include "gutils.h"     /* for GDebugKey */
 #include "gconstructor.h"
 #include "gconstructorprivate.h"
 #include "gmem.h"       /* for g_mem_gc_friendly */

 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <ctype.h>

 /* Deliberately not checking HAVE_STDINT_H here: we officially require a
  * C99 toolchain, which implies <stdint.h>, int8_t and so on. If your
  * toolchain does not have this, now would be a good time to upgrade. */
 #include <stdint.h>

 /* This seems as good a place as any to make static assertions about platform
  * assumptions we make throughout GLib. */

 /* We do not support 36-bit bytes or other historical curiosities. */
 G_STATIC_ASSERT (CHAR_BIT == 8);

 /* We assume that data pointers are the same size as function pointers... */
 G_STATIC_ASSERT (sizeof (gpointer) == sizeof (GFunc));
 G_STATIC_ASSERT (G_ALIGNOF (gpointer) == G_ALIGNOF (GFunc));
 /* ... and that all function pointers are the same size. */
 G_STATIC_ASSERT (sizeof (GFunc) == sizeof (GCompareDataFunc));
 G_STATIC_ASSERT (G_ALIGNOF (GFunc) == G_ALIGNOF (GCompareDataFunc));

 /* We assume that "small" enums (those where all values fit in INT32_MIN
  * to INT32_MAX) are exactly int-sized. In particular, we assume that if
  * an enum has no members that exceed the range of char/short, the
  * compiler will make it int-sized anyway, so adding a member later that
  * *does* exceed the range of char/short is not an ABI break. */
 typedef enum {
     TEST_CHAR_0 = 0
 } TestChar;
 typedef enum {
     TEST_SHORT_0 = 0,
     TEST_SHORT_256 = 256
 } TestShort;
 typedef enum {
     TEST_INT32_MIN = G_MININT32,
     TEST_INT32_MAX = G_MAXINT32
 } TestInt;
 G_STATIC_ASSERT (sizeof (TestChar) == sizeof (int));
 G_STATIC_ASSERT (sizeof (TestShort) == sizeof (int));
 G_STATIC_ASSERT (sizeof (TestInt) == sizeof (int));
 G_STATIC_ASSERT (G_ALIGNOF (TestChar) == G_ALIGNOF (int));
 G_STATIC_ASSERT (G_ALIGNOF (TestShort) == G_ALIGNOF (int));
 G_STATIC_ASSERT (G_ALIGNOF (TestInt) == G_ALIGNOF (int));

 G_STATIC_ASSERT (sizeof (gchar) == 1);
 G_STATIC_ASSERT (sizeof (guchar) == 1);
 G_STATIC_ASSERT (sizeof (gint8) * CHAR_BIT == 8);
 G_STATIC_ASSERT (sizeof (guint8) * CHAR_BIT == 8);
 G_STATIC_ASSERT (sizeof (gint16) * CHAR_BIT == 16);
 G_STATIC_ASSERT (sizeof (guint16) * CHAR_BIT == 16);
 G_STATIC_ASSERT (sizeof (gint32) * CHAR_BIT == 32);
 G_STATIC_ASSERT (sizeof (guint32) * CHAR_BIT == 32);
 G_STATIC_ASSERT (sizeof (gint64) * CHAR_BIT == 64);
 G_STATIC_ASSERT (sizeof (guint64) * CHAR_BIT == 64);

 G_STATIC_ASSERT (sizeof (void *) == GLIB_SIZEOF_VOID_P);
 G_STATIC_ASSERT (sizeof (gintptr) == sizeof (void *));
 G_STATIC_ASSERT (sizeof (guintptr) == sizeof (void *));

 G_STATIC_ASSERT (sizeof (short) == sizeof (gshort));
 G_STATIC_ASSERT (G_MINSHORT == SHRT_MIN);
 G_STATIC_ASSERT (G_MAXSHORT == SHRT_MAX);
 G_STATIC_ASSERT (sizeof (unsigned short) == sizeof (gushort));
 G_STATIC_ASSERT (G_MAXUSHORT == USHRT_MAX);

 G_STATIC_ASSERT (sizeof (int) == sizeof (gint));
 G_STATIC_ASSERT (G_MININT == INT_MIN);
 G_STATIC_ASSERT (G_MAXINT == INT_MAX);
 G_STATIC_ASSERT (sizeof (unsigned int) == sizeof (guint));
 G_STATIC_ASSERT (G_MAXUINT == UINT_MAX);

 G_STATIC_ASSERT (sizeof (long) == GLIB_SIZEOF_LONG);
 G_STATIC_ASSERT (sizeof (long) == sizeof (glong));
 G_STATIC_ASSERT (G_MINLONG == LONG_MIN);
 G_STATIC_ASSERT (G_MAXLONG == LONG_MAX);
 G_STATIC_ASSERT (sizeof (unsigned long) == sizeof (gulong));
 G_STATIC_ASSERT (G_MAXULONG == ULONG_MAX);

 G_STATIC_ASSERT (G_HAVE_GINT64 == 1);

 G_STATIC_ASSERT (sizeof (size_t) == GLIB_SIZEOF_SIZE_T);
 /* Not a typo: ssize_t is POSIX, not Standard C, but if it exists then
  * it's the same size as size_t. */
 G_STATIC_ASSERT (sizeof (size_t) == GLIB_SIZEOF_SSIZE_T);
 G_STATIC_ASSERT (sizeof (gsize) == GLIB_SIZEOF_SSIZE_T);
 G_STATIC_ASSERT (sizeof (gsize) == sizeof (size_t));
 G_STATIC_ASSERT (G_MAXSIZE == SIZE_MAX);
 /* Again this is size_t not ssize_t, because ssize_t is POSIX, not C99 */
 G_STATIC_ASSERT (sizeof (gssize) == sizeof (size_t));
 G_STATIC_ASSERT (G_ALIGNOF (gsize) == G_ALIGNOF (size_t));
 G_STATIC_ASSERT (G_ALIGNOF (gssize) == G_ALIGNOF (size_t));
 /* We assume that GSIZE_TO_POINTER is reversible by GPOINTER_TO_SIZE
  * without losing information.
  * However, we do not assume that GPOINTER_TO_SIZE can store an arbitrary
  * pointer in a gsize (known to be false on CHERI). */
 G_STATIC_ASSERT (sizeof (size_t) <= sizeof (void *));
 /* Standard C does not guarantee that size_t is the same as uintptr_t,
  * but GLib currently assumes they are the same: see
  * <https://gitlab.gnome.org/GNOME/glib/-/issues/2842>.
  *
  * To enable working on bringup for new architectures these assertions
  * can be disabled with -DG_ENABLE_EXPERIMENTAL_ABI_COMPILATION.
  *
  * FIXME: remove these assertions once the API/ABI has stabilized. */
 #ifndef G_ENABLE_EXPERIMENTAL_ABI_COMPILATION
 G_STATIC_ASSERT (sizeof (size_t) == sizeof (uintptr_t));
 G_STATIC_ASSERT (G_ALIGNOF (size_t) == G_ALIGNOF (uintptr_t));
 #endif
 /* goffset is always 64-bit, even if off_t is only 32-bit
  * (compiling without large-file-support on 32-bit) */
 G_STATIC_ASSERT (sizeof (goffset) == sizeof (gint64));
 G_STATIC_ASSERT (G_ALIGNOF (goffset) == G_ALIGNOF (gint64));

 G_STATIC_ASSERT (sizeof (gfloat) == sizeof (float));
 G_STATIC_ASSERT (G_ALIGNOF (gfloat) == G_ALIGNOF (float));
 G_STATIC_ASSERT (sizeof (gdouble) == sizeof (double));
 G_STATIC_ASSERT (G_ALIGNOF (gdouble) == G_ALIGNOF (double));

 G_STATIC_ASSERT (sizeof (gintptr) == sizeof (intptr_t));
 G_STATIC_ASSERT (sizeof (guintptr) == sizeof (uintptr_t));
 G_STATIC_ASSERT (G_ALIGNOF (gintptr) == G_ALIGNOF (intptr_t));
 G_STATIC_ASSERT (G_ALIGNOF (guintptr) == G_ALIGNOF (uintptr_t));

 G_STATIC_ASSERT (sizeof (gint8) == sizeof (int8_t));
 G_STATIC_ASSERT (sizeof (guint8) == sizeof (uint8_t));
 G_STATIC_ASSERT (G_ALIGNOF (gint8) == G_ALIGNOF (int8_t));
 G_STATIC_ASSERT (G_ALIGNOF (guint8) == G_ALIGNOF (uint8_t));

 G_STATIC_ASSERT (sizeof (gint16) == sizeof (int16_t));
 G_STATIC_ASSERT (sizeof (guint16) == sizeof (uint16_t));
 G_STATIC_ASSERT (G_ALIGNOF (gint16) == G_ALIGNOF (int16_t));
 G_STATIC_ASSERT (G_ALIGNOF (guint16) == G_ALIGNOF (uint16_t));

 G_STATIC_ASSERT (sizeof (gint32) == sizeof (int32_t));
 G_STATIC_ASSERT (sizeof (guint32) == sizeof (uint32_t));
 G_STATIC_ASSERT (G_ALIGNOF (gint32) == G_ALIGNOF (int32_t));
 G_STATIC_ASSERT (G_ALIGNOF (guint32) == G_ALIGNOF (uint32_t));

 G_STATIC_ASSERT (sizeof (gint64) == sizeof (int64_t));
 G_STATIC_ASSERT (sizeof (guint64) == sizeof (uint64_t));
 G_STATIC_ASSERT (G_ALIGNOF (gint64) == G_ALIGNOF (int64_t));
 G_STATIC_ASSERT (G_ALIGNOF (guint64) == G_ALIGNOF (uint64_t));

 /**
  * g_mem_gc_friendly:
  *
  * This variable is %TRUE if the `G_DEBUG` environment variable
  * includes the key `gc-friendly`.
  */
 gboolean g_mem_gc_friendly = FALSE;

 GLogLevelFlags g_log_msg_prefix = G_LOG_LEVEL_ERROR | G_LOG_LEVEL_WARNING |
                                   G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_DEBUG;
 GLogLevelFlags g_log_always_fatal = G_LOG_FATAL_MASK;

 static gboolean
 debug_key_matches (const gchar *key,
                    const gchar *token,
                    guint        length)
 {
   /* may not call GLib functions: see note in g_parse_debug_string() */
   for (; length; length--, key++, token++)
     {
       char k = (*key   == '_') ? '-' : tolower (*key  );
       char t = (*token == '_') ? '-' : tolower (*token);

       if (k != t)
         return FALSE;
     }

   return *key == '\0';
 }

 /* The GVariant documentation indirectly says that int is at least 32 bits
  * (by saying that b, y, n, q, i, u, h are promoted to int). On any
  * reasonable platform, int is in fact *exactly* 32 bits long, because
  * otherwise, {signed char, short, int} wouldn't be sufficient to provide
  * {int8_t, int16_t, int32_t}. */
 G_STATIC_ASSERT (sizeof (int) == sizeof (gint32));

 /**
  * g_parse_debug_string:
  * @string: (nullable): a list of debug options separated by colons, spaces, or
  * commas, or %NULL.
  * @keys: (array length=nkeys): pointer to an array of #GDebugKey which associate
  *     strings with bit flags.
  * @nkeys: the number of #GDebugKeys in the array.
  *
  * 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.
  *
  * Returns: the combined set of bit flags.
  */
 guint
 g_parse_debug_string  (const gchar     *string,
                        const GDebugKey *keys,
                        guint            nkeys)
 {
   guint i;
   guint result = 0;

   if (string == NULL)
     return 0;

   /* this function is used during the initialisation of gmessages, gmem
    * and gslice, so it may not do anything that causes memory to be
    * allocated or risks messages being emitted.
    *
    * this means, more or less, that this code may not call anything
    * inside GLib.
    */

   if (!strcasecmp (string, "help"))
     {
       /* using stdio directly for the reason stated above */
       fprintf (stderr, "Supported debug values:");
       for (i = 0; i < nkeys; i++)
         fprintf (stderr, " %s", keys[i].key);
       fprintf (stderr, " all help\n");
     }
   else
     {
       const gchar *p = string;
       const gchar *q;
       gboolean invert = FALSE;

       while (*p)
        {
          q = strpbrk (p, ":;, \t");
          if (!q)
            q = p + strlen (p);

          if (debug_key_matches ("all", p, q - p))
            {
              invert = TRUE;
            }
          else
            {
              for (i = 0; i < nkeys; i++)
                if (debug_key_matches (keys[i].key, p, q - p))
                  result |= keys[i].value;
            }

          p = q;
          if (*p)
            p++;
        }

       if (invert)
         {
           guint all_flags = 0;

           for (i = 0; i < nkeys; i++)
             all_flags |= keys[i].value;

           result = all_flags & (~result);
         }
     }

   return result;
 }

 static guint
 g_parse_debug_envvar (const gchar     *envvar,
                       const GDebugKey *keys,
                       gint             n_keys,
                       guint            default_value)
 {
   const gchar *value;

 #ifdef OS_WIN32
   /* "fatal-warnings,fatal-criticals,all,help" is pretty short */
   gchar buffer[100];

   if (GetEnvironmentVariable (envvar, buffer, 100) < 100)
     value = buffer;
   else
     return 0;
 #else
   value = getenv (envvar);
 #endif

   if (value == NULL)
     return default_value;

   return g_parse_debug_string (value, keys, n_keys);
 }

 static void
 g_messages_prefixed_init (void)
 {
   const GDebugKey keys[] = {
     { "error", G_LOG_LEVEL_ERROR },
     { "critical", G_LOG_LEVEL_CRITICAL },
     { "warning", G_LOG_LEVEL_WARNING },
     { "message", G_LOG_LEVEL_MESSAGE },
     { "info", G_LOG_LEVEL_INFO },
     { "debug", G_LOG_LEVEL_DEBUG }
   };

   g_log_msg_prefix = g_parse_debug_envvar ("G_MESSAGES_PREFIXED", keys, G_N_ELEMENTS (keys), g_log_msg_prefix);
 }

 static void
 g_debug_init (void)
 {
   const GDebugKey keys[] = {
     { "gc-friendly", 1 },
     {"fatal-warnings",  G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL },
     {"fatal-criticals", G_LOG_LEVEL_CRITICAL }
   };
   GLogLevelFlags flags;

   flags = g_parse_debug_envvar ("G_DEBUG", keys, G_N_ELEMENTS (keys), 0);

   g_log_always_fatal |= flags & G_LOG_LEVEL_MASK;

   g_mem_gc_friendly = flags & 1;
 }

 void
 glib_init (void)
 {
   static gboolean glib_inited;

   if (glib_inited)
     return;

   glib_inited = TRUE;

   g_messages_prefixed_init ();
   g_debug_init ();
   g_quark_init ();
   g_error_init ();
 }

 #ifdef G_PLATFORM_WIN32

 HMODULE glib_dll = NULL;
 void glib_win32_init (void);

 void
 glib_win32_init (void)
 {
   /* May be called more than once in static compilation mode */
   static gboolean win32_already_init = FALSE;
   if (!win32_already_init)
     {
       win32_already_init = TRUE;

       g_crash_handler_win32_init ();
 #ifdef THREADS_WIN32
       g_thread_win32_init ();
 #endif

       g_clock_win32_init ();
       glib_init ();
       /* must go after glib_init */
       g_console_win32_init ();
     }
 }

 static void
 glib_win32_deinit (gboolean detach_thread)
 {
 #ifdef THREADS_WIN32
   if (detach_thread)
     g_thread_win32_process_detach ();
 #endif
   g_crash_handler_win32_deinit ();
 }

 #ifndef GLIB_STATIC_COMPILATION

 BOOL WINAPI DllMain (HINSTANCE hinstDLL,
                      DWORD     fdwReason,
                      LPVOID    lpvReserved);

 BOOL WINAPI
 DllMain (HINSTANCE hinstDLL,
          DWORD     fdwReason,
          LPVOID    lpvReserved)
 {
   switch (fdwReason)
     {
     case DLL_PROCESS_ATTACH:
       glib_dll = hinstDLL;
       glib_win32_init ();
       break;

     case DLL_THREAD_DETACH:
 #ifdef THREADS_WIN32
       g_thread_win32_thread_detach ();
 #endif
       break;

     case DLL_PROCESS_DETACH:
       glib_win32_deinit (lpvReserved == NULL);
       break;

     default:
       /* do nothing */
       ;
     }

   return TRUE;
 }

 #else

 #ifndef G_HAS_CONSTRUCTORS
 #error static compilation on Windows requires constructor support
 #endif

 #ifdef G_DEFINE_CONSTRUCTOR_NEEDS_PRAGMA
 #pragma G_DEFINE_CONSTRUCTOR_PRAGMA_ARGS(glib_priv_constructor)
 #endif

 static gboolean tls_callback_invoked;

 G_DEFINE_CONSTRUCTOR (glib_priv_constructor)

 static void
 glib_priv_constructor (void)
 {
   glib_win32_init ();

   if (!tls_callback_invoked)
     g_critical ("TLS callback not invoked");
 }

 #ifndef G_HAS_TLS_CALLBACKS
 #error static compilation on Windows requires TLS callbacks support
 #endif

 G_DEFINE_TLS_CALLBACK (glib_priv_tls_callback)

 static void NTAPI
 glib_priv_tls_callback (LPVOID hinstance,
                         DWORD  reason,
                         LPVOID reserved)
 {
   switch (reason)
     {
     case DLL_PROCESS_ATTACH:
       glib_dll = hinstance;
       tls_callback_invoked = TRUE;
       break;
     case DLL_THREAD_DETACH:
 #ifdef THREADS_WIN32
       g_thread_win32_thread_detach ();
 #endif
       break;
     case DLL_PROCESS_DETACH:
       glib_win32_deinit (reserved == NULL);
       break;

     default:
       break;
     }
 }

 #endif /* GLIB_STATIC_COMPILATION */

 #elif defined(G_HAS_CONSTRUCTORS) /* && !G_PLATFORM_WIN32 */

 #ifdef G_DEFINE_CONSTRUCTOR_NEEDS_PRAGMA
 #pragma G_DEFINE_CONSTRUCTOR_PRAGMA_ARGS(glib_init_ctor)
 #endif
 G_DEFINE_CONSTRUCTOR(glib_init_ctor)

 static void
 glib_init_ctor (void)
 {
   glib_init ();
 }

 #else /* !G_PLATFORM_WIN32 && !G_HAS_CONSTRUCTORS */
 # error Your platform/compiler is missing constructor support
 #endif /* G_PLATFORM_WIN32 */
	/*
	* Copyright © 2011 Canonical Limited
	*
	* SPDX-License-Identifier: LGPL-2.1-or-later
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2.1 of the License, or (at your option) any later version.
	*
	* This library is distributed in the hope that it will be useful, but
	* WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, see <http://www.gnu.org/licenses/>.
	*
	* Author: Ryan Lortie <desrt@desrt.ca>
	*/

	#include "config.h"

	#include "glib-init.h"
	#include "gmacros.h"
	#include "gtypes.h"
	#include "gutils.h" /* for GDebugKey */
	#include "gconstructor.h"
	#include "gconstructorprivate.h"
	#include "gmem.h" /* for g_mem_gc_friendly */

	#include <string.h>
	#include <stdlib.h>
	#include <stdio.h>
	#include <ctype.h>

	/* Deliberately not checking HAVE_STDINT_H here: we officially require a
	* C99 toolchain, which implies <stdint.h>, int8_t and so on. If your
	* toolchain does not have this, now would be a good time to upgrade. */
	#include <stdint.h>

	/* This seems as good a place as any to make static assertions about platform
	* assumptions we make throughout GLib. */

	/* We do not support 36-bit bytes or other historical curiosities. */
	G_STATIC_ASSERT (CHAR_BIT == 8);

	/* We assume that data pointers are the same size as function pointers... */
	G_STATIC_ASSERT (sizeof (gpointer) == sizeof (GFunc));
	G_STATIC_ASSERT (G_ALIGNOF (gpointer) == G_ALIGNOF (GFunc));
	/* ... and that all function pointers are the same size. */
	G_STATIC_ASSERT (sizeof (GFunc) == sizeof (GCompareDataFunc));
	G_STATIC_ASSERT (G_ALIGNOF (GFunc) == G_ALIGNOF (GCompareDataFunc));

	/* We assume that "small" enums (those where all values fit in INT32_MIN
	* to INT32_MAX) are exactly int-sized. In particular, we assume that if
	* an enum has no members that exceed the range of char/short, the
	* compiler will make it int-sized anyway, so adding a member later that
	* does exceed the range of char/short is not an ABI break. */
	typedef enum {
	TEST_CHAR_0 = 0
	} TestChar;
	typedef enum {
	TEST_SHORT_0 = 0,
	TEST_SHORT_256 = 256
	} TestShort;
	typedef enum {
	TEST_INT32_MIN = G_MININT32,
	TEST_INT32_MAX = G_MAXINT32
	} TestInt;
	G_STATIC_ASSERT (sizeof (TestChar) == sizeof (int));
	G_STATIC_ASSERT (sizeof (TestShort) == sizeof (int));
	G_STATIC_ASSERT (sizeof (TestInt) == sizeof (int));
	G_STATIC_ASSERT (G_ALIGNOF (TestChar) == G_ALIGNOF (int));
	G_STATIC_ASSERT (G_ALIGNOF (TestShort) == G_ALIGNOF (int));
	G_STATIC_ASSERT (G_ALIGNOF (TestInt) == G_ALIGNOF (int));

	G_STATIC_ASSERT (sizeof (gchar) == 1);
	G_STATIC_ASSERT (sizeof (guchar) == 1);
	G_STATIC_ASSERT (sizeof (gint8) * CHAR_BIT == 8);
	G_STATIC_ASSERT (sizeof (guint8) * CHAR_BIT == 8);
	G_STATIC_ASSERT (sizeof (gint16) * CHAR_BIT == 16);
	G_STATIC_ASSERT (sizeof (guint16) * CHAR_BIT == 16);
	G_STATIC_ASSERT (sizeof (gint32) * CHAR_BIT == 32);
	G_STATIC_ASSERT (sizeof (guint32) * CHAR_BIT == 32);
	G_STATIC_ASSERT (sizeof (gint64) * CHAR_BIT == 64);
	G_STATIC_ASSERT (sizeof (guint64) * CHAR_BIT == 64);

	G_STATIC_ASSERT (sizeof (void *) == GLIB_SIZEOF_VOID_P);
	G_STATIC_ASSERT (sizeof (gintptr) == sizeof (void *));
	G_STATIC_ASSERT (sizeof (guintptr) == sizeof (void *));

	G_STATIC_ASSERT (sizeof (short) == sizeof (gshort));
	G_STATIC_ASSERT (G_MINSHORT == SHRT_MIN);
	G_STATIC_ASSERT (G_MAXSHORT == SHRT_MAX);
	G_STATIC_ASSERT (sizeof (unsigned short) == sizeof (gushort));
	G_STATIC_ASSERT (G_MAXUSHORT == USHRT_MAX);

	G_STATIC_ASSERT (sizeof (int) == sizeof (gint));
	G_STATIC_ASSERT (G_MININT == INT_MIN);
	G_STATIC_ASSERT (G_MAXINT == INT_MAX);
	G_STATIC_ASSERT (sizeof (unsigned int) == sizeof (guint));
	G_STATIC_ASSERT (G_MAXUINT == UINT_MAX);

	G_STATIC_ASSERT (sizeof (long) == GLIB_SIZEOF_LONG);
	G_STATIC_ASSERT (sizeof (long) == sizeof (glong));
	G_STATIC_ASSERT (G_MINLONG == LONG_MIN);
	G_STATIC_ASSERT (G_MAXLONG == LONG_MAX);
	G_STATIC_ASSERT (sizeof (unsigned long) == sizeof (gulong));
	G_STATIC_ASSERT (G_MAXULONG == ULONG_MAX);

	G_STATIC_ASSERT (G_HAVE_GINT64 == 1);

	G_STATIC_ASSERT (sizeof (size_t) == GLIB_SIZEOF_SIZE_T);
	/* Not a typo: ssize_t is POSIX, not Standard C, but if it exists then
	* it's the same size as size_t. */
	G_STATIC_ASSERT (sizeof (size_t) == GLIB_SIZEOF_SSIZE_T);
	G_STATIC_ASSERT (sizeof (gsize) == GLIB_SIZEOF_SSIZE_T);
	G_STATIC_ASSERT (sizeof (gsize) == sizeof (size_t));
	G_STATIC_ASSERT (G_MAXSIZE == SIZE_MAX);
	/* Again this is size_t not ssize_t, because ssize_t is POSIX, not C99 */
	G_STATIC_ASSERT (sizeof (gssize) == sizeof (size_t));
	G_STATIC_ASSERT (G_ALIGNOF (gsize) == G_ALIGNOF (size_t));
	G_STATIC_ASSERT (G_ALIGNOF (gssize) == G_ALIGNOF (size_t));
	/* We assume that GSIZE_TO_POINTER is reversible by GPOINTER_TO_SIZE
	* without losing information.
	* However, we do not assume that GPOINTER_TO_SIZE can store an arbitrary
	* pointer in a gsize (known to be false on CHERI). */
	G_STATIC_ASSERT (sizeof (size_t) <= sizeof (void *));
	/* Standard C does not guarantee that size_t is the same as uintptr_t,
	* but GLib currently assumes they are the same: see
	* <https://gitlab.gnome.org/GNOME/glib/-/issues/2842>.
	*
	* To enable working on bringup for new architectures these assertions
	* can be disabled with -DG_ENABLE_EXPERIMENTAL_ABI_COMPILATION.
	*
	* FIXME: remove these assertions once the API/ABI has stabilized. */
	#ifndef G_ENABLE_EXPERIMENTAL_ABI_COMPILATION
	G_STATIC_ASSERT (sizeof (size_t) == sizeof (uintptr_t));
	G_STATIC_ASSERT (G_ALIGNOF (size_t) == G_ALIGNOF (uintptr_t));
	#endif
	/* goffset is always 64-bit, even if off_t is only 32-bit
	* (compiling without large-file-support on 32-bit) */
	G_STATIC_ASSERT (sizeof (goffset) == sizeof (gint64));
	G_STATIC_ASSERT (G_ALIGNOF (goffset) == G_ALIGNOF (gint64));

	G_STATIC_ASSERT (sizeof (gfloat) == sizeof (float));
	G_STATIC_ASSERT (G_ALIGNOF (gfloat) == G_ALIGNOF (float));
	G_STATIC_ASSERT (sizeof (gdouble) == sizeof (double));
	G_STATIC_ASSERT (G_ALIGNOF (gdouble) == G_ALIGNOF (double));

	G_STATIC_ASSERT (sizeof (gintptr) == sizeof (intptr_t));
	G_STATIC_ASSERT (sizeof (guintptr) == sizeof (uintptr_t));
	G_STATIC_ASSERT (G_ALIGNOF (gintptr) == G_ALIGNOF (intptr_t));
	G_STATIC_ASSERT (G_ALIGNOF (guintptr) == G_ALIGNOF (uintptr_t));

	G_STATIC_ASSERT (sizeof (gint8) == sizeof (int8_t));
	G_STATIC_ASSERT (sizeof (guint8) == sizeof (uint8_t));
	G_STATIC_ASSERT (G_ALIGNOF (gint8) == G_ALIGNOF (int8_t));
	G_STATIC_ASSERT (G_ALIGNOF (guint8) == G_ALIGNOF (uint8_t));

	G_STATIC_ASSERT (sizeof (gint16) == sizeof (int16_t));
	G_STATIC_ASSERT (sizeof (guint16) == sizeof (uint16_t));
	G_STATIC_ASSERT (G_ALIGNOF (gint16) == G_ALIGNOF (int16_t));
	G_STATIC_ASSERT (G_ALIGNOF (guint16) == G_ALIGNOF (uint16_t));

	G_STATIC_ASSERT (sizeof (gint32) == sizeof (int32_t));
	G_STATIC_ASSERT (sizeof (guint32) == sizeof (uint32_t));
	G_STATIC_ASSERT (G_ALIGNOF (gint32) == G_ALIGNOF (int32_t));
	G_STATIC_ASSERT (G_ALIGNOF (guint32) == G_ALIGNOF (uint32_t));

	G_STATIC_ASSERT (sizeof (gint64) == sizeof (int64_t));
	G_STATIC_ASSERT (sizeof (guint64) == sizeof (uint64_t));
	G_STATIC_ASSERT (G_ALIGNOF (gint64) == G_ALIGNOF (int64_t));
	G_STATIC_ASSERT (G_ALIGNOF (guint64) == G_ALIGNOF (uint64_t));

	/**
	* g_mem_gc_friendly:
	*
	* This variable is %TRUE if the `G_DEBUG` environment variable
	* includes the key `gc-friendly`.
	*/
	gboolean g_mem_gc_friendly = FALSE;

	GLogLevelFlags g_log_msg_prefix = G_LOG_LEVEL_ERROR \| G_LOG_LEVEL_WARNING \|
	G_LOG_LEVEL_CRITICAL \| G_LOG_LEVEL_DEBUG;
	GLogLevelFlags g_log_always_fatal = G_LOG_FATAL_MASK;

	static gboolean
	debug_key_matches (const gchar *key,
	const gchar *token,
	guint length)
	{
	/* may not call GLib functions: see note in g_parse_debug_string() */
	for (; length; length--, key++, token++)
	{
	char k = (key == '_') ? '-' : tolower (key );
	char t = (token == '_') ? '-' : tolower (token);

	if (k != t)
	return FALSE;
	}

	return *key == '\0';
	}

	/* The GVariant documentation indirectly says that int is at least 32 bits
	* (by saying that b, y, n, q, i, u, h are promoted to int). On any
	* reasonable platform, int is in fact exactly 32 bits long, because
	* otherwise, {signed char, short, int} wouldn't be sufficient to provide
	* {int8_t, int16_t, int32_t}. */
	G_STATIC_ASSERT (sizeof (int) == sizeof (gint32));

	/**
	* g_parse_debug_string:
	* @string: (nullable): a list of debug options separated by colons, spaces, or
	* commas, or %NULL.
	* @keys: (array length=nkeys): pointer to an array of #GDebugKey which associate
	* strings with bit flags.
	* @nkeys: the number of #GDebugKeys in the array.
	*
	* 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.
	*
	* Returns: the combined set of bit flags.
	*/
	guint
	g_parse_debug_string (const gchar *string,
	const GDebugKey *keys,
	guint nkeys)
	{
	guint i;
	guint result = 0;

	if (string == NULL)
	return 0;

	/* this function is used during the initialisation of gmessages, gmem
	* and gslice, so it may not do anything that causes memory to be
	* allocated or risks messages being emitted.
	*
	* this means, more or less, that this code may not call anything
	* inside GLib.
	*/

	if (!strcasecmp (string, "help"))
	{
	/* using stdio directly for the reason stated above */
	fprintf (stderr, "Supported debug values:");
	for (i = 0; i < nkeys; i++)
	fprintf (stderr, " %s", keys[i].key);
	fprintf (stderr, " all help\n");
	}
	else
	{
	const gchar *p = string;
	const gchar *q;
	gboolean invert = FALSE;

	while (*p)
	{
	q = strpbrk (p, ":;, \t");
	if (!q)
	q = p + strlen (p);

	if (debug_key_matches ("all", p, q - p))
	{
	invert = TRUE;
	}
	else
	{
	for (i = 0; i < nkeys; i++)
	if (debug_key_matches (keys[i].key, p, q - p))
	result \|= keys[i].value;
	}

	p = q;
	if (*p)
	p++;
	}

	if (invert)
	{
	guint all_flags = 0;

	for (i = 0; i < nkeys; i++)
	all_flags \|= keys[i].value;

	result = all_flags & (~result);
	}
	}

	return result;
	}

	static guint
	g_parse_debug_envvar (const gchar *envvar,
	const GDebugKey *keys,
	gint n_keys,
	guint default_value)
	{
	const gchar *value;

	#ifdef OS_WIN32
	/* "fatal-warnings,fatal-criticals,all,help" is pretty short */
	gchar buffer[100];

	if (GetEnvironmentVariable (envvar, buffer, 100) < 100)
	value = buffer;
	else
	return 0;
	#else
	value = getenv (envvar);
	#endif

	if (value == NULL)
	return default_value;

	return g_parse_debug_string (value, keys, n_keys);
	}

	static void
	g_messages_prefixed_init (void)
	{
	const GDebugKey keys[] = {
	{ "error", G_LOG_LEVEL_ERROR },
	{ "critical", G_LOG_LEVEL_CRITICAL },
	{ "warning", G_LOG_LEVEL_WARNING },
	{ "message", G_LOG_LEVEL_MESSAGE },
	{ "info", G_LOG_LEVEL_INFO },
	{ "debug", G_LOG_LEVEL_DEBUG }
	};

	g_log_msg_prefix = g_parse_debug_envvar ("G_MESSAGES_PREFIXED", keys, G_N_ELEMENTS (keys), g_log_msg_prefix);
	}

	static void
	g_debug_init (void)
	{
	const GDebugKey keys[] = {
	{ "gc-friendly", 1 },
	{"fatal-warnings", G_LOG_LEVEL_WARNING \| G_LOG_LEVEL_CRITICAL },
	{"fatal-criticals", G_LOG_LEVEL_CRITICAL }
	};
	GLogLevelFlags flags;

	flags = g_parse_debug_envvar ("G_DEBUG", keys, G_N_ELEMENTS (keys), 0);

	g_log_always_fatal \|= flags & G_LOG_LEVEL_MASK;

	g_mem_gc_friendly = flags & 1;
	}

	void
	glib_init (void)
	{
	static gboolean glib_inited;

	if (glib_inited)
	return;

	glib_inited = TRUE;

	g_messages_prefixed_init ();
	g_debug_init ();
	g_quark_init ();
	g_error_init ();
	}

	#ifdef G_PLATFORM_WIN32

	HMODULE glib_dll = NULL;
	void glib_win32_init (void);

	void
	glib_win32_init (void)
	{
	/* May be called more than once in static compilation mode */
	static gboolean win32_already_init = FALSE;
	if (!win32_already_init)
	{
	win32_already_init = TRUE;

	g_crash_handler_win32_init ();
	#ifdef THREADS_WIN32
	g_thread_win32_init ();
	#endif

	g_clock_win32_init ();
	glib_init ();
	/* must go after glib_init */
	g_console_win32_init ();
	}
	}

	static void
	glib_win32_deinit (gboolean detach_thread)
	{
	#ifdef THREADS_WIN32
	if (detach_thread)
	g_thread_win32_process_detach ();
	#endif
	g_crash_handler_win32_deinit ();
	}

	#ifndef GLIB_STATIC_COMPILATION

	BOOL WINAPI DllMain (HINSTANCE hinstDLL,
	DWORD fdwReason,
	LPVOID lpvReserved);

	BOOL WINAPI
	DllMain (HINSTANCE hinstDLL,
	DWORD fdwReason,
	LPVOID lpvReserved)
	{
	switch (fdwReason)
	{
	case DLL_PROCESS_ATTACH:
	glib_dll = hinstDLL;
	glib_win32_init ();
	break;

	case DLL_THREAD_DETACH:
	#ifdef THREADS_WIN32
	g_thread_win32_thread_detach ();
	#endif
	break;

	case DLL_PROCESS_DETACH:
	glib_win32_deinit (lpvReserved == NULL);
	break;

	default:
	/* do nothing */
	;
	}

	return TRUE;
	}

	#else

	#ifndef G_HAS_CONSTRUCTORS
	#error static compilation on Windows requires constructor support
	#endif

	#ifdef G_DEFINE_CONSTRUCTOR_NEEDS_PRAGMA
	#pragma G_DEFINE_CONSTRUCTOR_PRAGMA_ARGS(glib_priv_constructor)
	#endif

	static gboolean tls_callback_invoked;

	G_DEFINE_CONSTRUCTOR (glib_priv_constructor)

	static void
	glib_priv_constructor (void)
	{
	glib_win32_init ();

	if (!tls_callback_invoked)
	g_critical ("TLS callback not invoked");
	}

	#ifndef G_HAS_TLS_CALLBACKS
	#error static compilation on Windows requires TLS callbacks support
	#endif

	G_DEFINE_TLS_CALLBACK (glib_priv_tls_callback)

	static void NTAPI
	glib_priv_tls_callback (LPVOID hinstance,
	DWORD reason,
	LPVOID reserved)
	{
	switch (reason)
	{
	case DLL_PROCESS_ATTACH:
	glib_dll = hinstance;
	tls_callback_invoked = TRUE;
	break;
	case DLL_THREAD_DETACH:
	#ifdef THREADS_WIN32
	g_thread_win32_thread_detach ();
	#endif
	break;
	case DLL_PROCESS_DETACH:
	glib_win32_deinit (reserved == NULL);
	break;

	default:
	break;
	}
	}

	#endif /* GLIB_STATIC_COMPILATION */

	#elif defined(G_HAS_CONSTRUCTORS) /* && !G_PLATFORM_WIN32 */

	#ifdef G_DEFINE_CONSTRUCTOR_NEEDS_PRAGMA
	#pragma G_DEFINE_CONSTRUCTOR_PRAGMA_ARGS(glib_init_ctor)
	#endif
	G_DEFINE_CONSTRUCTOR(glib_init_ctor)

	static void
	glib_init_ctor (void)
	{
	glib_init ();
	}

	#else /* !G_PLATFORM_WIN32 && !G_HAS_CONSTRUCTORS */
	# error Your platform/compiler is missing constructor support
	#endif /* G_PLATFORM_WIN32 */