build: Allow to build cogl without an external glib dependency

This commit pushes --disable-glib to the extreme of embedding the par of
glib cogl depends on in tree to be able to generate a DSO that does not
depend on an external glib.

To do so, it:
  - keeps a lot of glib's configure.ac in as-glibconfig.m4
  - pulls the code cogl depends on and the necessary dependencies

Reviewed-by: Robert Bragg <robert@linux.intel.com>

2 files changed, 2272 insertions, 0 deletions

diff --git a/build/autotools/acglib.m4 b/build/autotools/acglib.m4
new file mode 100644
index 00000000..4778bfaf
--- /dev/null
+++ b/build/autotools/acglib.m4
@@ -0,0 +1,131 @@
+## Portability defines that help interoperate with classic and modern autoconfs
+ifdef([AC_TR_SH],[
+define([GLIB_TR_SH],[AC_TR_SH([$1])])
+define([GLIB_TR_CPP],[AC_TR_CPP([$1])])
+], [
+define([GLIB_TR_SH],
+       [patsubst(translit([[$1]], [*+], [pp]), [[^a-zA-Z0-9_]], [_])])
+define([GLIB_TR_CPP],
+       [patsubst(translit([[$1]],
+  	                  [*abcdefghijklmnopqrstuvwxyz],
+ 			  [PABCDEFGHIJKLMNOPQRSTUVWXYZ]),
+		 [[^A-Z0-9_]], [_])])
+])
+
+# GLIB_AC_DIVERT_BEFORE_HELP(STUFF)
+# ---------------------------------
+# Put STUFF early enough so that they are available for $ac_help expansion.
+# Handle both classic (<= v2.13) and modern autoconf
+AC_DEFUN([GLIB_AC_DIVERT_BEFORE_HELP],
+[ifdef([m4_divert_text], [m4_divert_text([NOTICE],[$1])],
+       [ifdef([AC_DIVERT], [AC_DIVERT([NOTICE],[$1])],
+              [AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)dnl
+$1
+AC_DIVERT_POP()])])])
+
+dnl GLIB_IF_VAR_EQ (ENV_VAR, VALUE [, EQUALS_ACTION] [, ELSE_ACTION])
+AC_DEFUN([GLIB_IF_VAR_EQ],[
+        case "$[$1]" in
+        "[$2]"[)]
+                [$3]
+                ;;
+        *[)]
+                [$4]
+                ;;
+        esac
+])
+dnl GLIB_STR_CONTAINS (SRC_STRING, SUB_STRING [, CONTAINS_ACTION] [, ELSE_ACTION])
+AC_DEFUN([GLIB_STR_CONTAINS],[
+        case "[$1]" in
+        *"[$2]"*[)]
+                [$3]
+                ;;
+        *[)]
+                [$4]
+                ;;
+        esac
+])
+dnl GLIB_ADD_TO_VAR (ENV_VARIABLE, CHECK_STRING, ADD_STRING)
+AC_DEFUN([GLIB_ADD_TO_VAR],[
+        GLIB_STR_CONTAINS($[$1], [$2], [$1]="$[$1]", [$1]="$[$1] [$3]")
+])
+
+# GLIB_SIZEOF (INCLUDES, TYPE, ALIAS)
+# ---------------------------------------------------------------
+# The definition here is based of that of AC_CHECK_SIZEOF
+AC_DEFUN([GLIB_SIZEOF],
+[AS_LITERAL_IF([$3], [],
+               [AC_FATAL([$0: requires literal arguments])])dnl
+AC_CACHE_CHECK([size of $2], AS_TR_SH([glib_cv_sizeof_$3]),
+[ # The cast to unsigned long works around a bug in the HP C Compiler
+  # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
+  # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
+  # This bug is HP SR number 8606223364.
+  _AC_COMPUTE_INT([(long) (sizeof ($2))],
+                  [AS_TR_SH([glib_cv_sizeof_$3])],
+                  [AC_INCLUDES_DEFAULT([$1])],
+                  [AC_MSG_ERROR([cannot compute sizeof ($2), 77])])
+])dnl
+AC_DEFINE_UNQUOTED(GLIB_TR_CPP(glib_sizeof_$3), $AS_TR_SH([glib_cv_sizeof_$3]),
+                   [The size of $3, as computed by sizeof.])
+])# GLIB_SIZEOF
+
+dnl GLIB_BYTE_CONTENTS (INCLUDES, TYPE, ALIAS, N_BYTES, INITIALIZER)
+AC_DEFUN([GLIB_BYTE_CONTENTS],
+[pushdef([glib_ByteContents], GLIB_TR_SH([glib_cv_byte_contents_$3]))dnl
+AC_CACHE_CHECK([byte contents of $5], glib_ByteContents,
+[AC_TRY_RUN([#include <stdio.h>
+$1
+main()
+{
+  static $2 tv = $5;
+  char *p = (char*) &tv;
+  int i;
+  FILE *f=fopen("conftestval", "w");
+  if (!f) exit(1);
+  for (i = 0; i < $4; i++)
+    fprintf(f, "%s%d", i?",":"", *(p++));
+  fprintf(f, "\n");
+  exit(0);
+}], 
+   [glib_ByteContents=`cat conftestval`  dnl''
+], 
+   [glib_ByteContents=no],
+   [glib_ByteContents=no])])
+AC_DEFINE_UNQUOTED(GLIB_TR_CPP(glib_byte_contents_$3), [$[]glib_ByteContents],
+	[Byte contents of $3])
+popdef([glib_ByteContents])dnl
+])
+
+# GLIB_CHECK_VALUE(SYMBOL, INCLUDES, ACTION-IF-FAIL)
+# ---------------------------------------------------------------
+AC_DEFUN([GLIB_CHECK_VALUE],
+[AC_CACHE_CHECK([value of $1], AS_TR_SH([glib_cv_value_$1]),
+  [_AC_COMPUTE_INT([$1], AS_TR_SH([glib_cv_value_$1]), [$2], [$3])])
+])dnl
+
+# GLIB_CHECK_COMPILE_WARNINGS(PROGRAM, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
+# ---------------------------------------------------------------------
+# Try to compile PROGRAM, check for warnings
+m4_define([GLIB_CHECK_COMPILE_WARNINGS],
+[m4_ifvaln([$1], [AC_LANG_CONFTEST([$1])])dnl
+rm -f conftest.$ac_objext
+glib_ac_compile_save="$ac_compile"
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext'
+AS_IF([_AC_EVAL_STDERR($ac_compile) &&
+         AC_TRY_COMMAND([(if test -s conftest.err; then false ; else true; fi)])],
+      [$2],
+      [echo "$as_me: failed program was:" >&AS_MESSAGE_LOG_FD
+cat conftest.$ac_ext >&AS_MESSAGE_LOG_FD
+m4_ifvaln([$3],[$3])dnl])
+ac_compile="$glib_ac_compile_save"
+rm -f conftest.$ac_objext conftest.err m4_ifval([$1], [conftest.$ac_ext])[]dnl
+])# GLIB_CHECK_COMPILE_WARNINGS
+
+# GLIB_ASSERT_SET(VARIABLE)
+# -------------------------
+AC_DEFUN([GLIB_ASSERT_SET],
+[if test "x${$1+set}" != "xset" ; then
+  AC_MSG_ERROR($1 [must be set in cache file when cross-compiling.])
+fi
+])dnl
diff --git a/build/autotools/as-glibconfig.m4 b/build/autotools/as-glibconfig.m4
new file mode 100644
index 00000000..75055b6c
--- /dev/null
+++ b/build/autotools/as-glibconfig.m4
@@ -0,0 +1,2141 @@
+dnl
+dnl Test program for basic POSIX threads functionality
+dnl
+m4_define([glib_thread_test],[
+#include <pthread.h> 
+int check_me = 0;
+void* func(void* data) {check_me = 42; return &check_me;}
+int main()
+ { pthread_t t; 
+   void *ret;
+   pthread_create (&t, $1, func, 0);
+   pthread_join (t, &ret);
+   return (check_me != 42 || ret != &check_me);
+}])
+
+AC_DEFUN([AS_GLIBCONFIG],
+[
+
+m4_define([glib_major_version], [2])
+m4_define([glib_minor_version], [30])
+m4_define([glib_micro_version], [2])
+m4_define([glib_interface_age], [0]) 
+m4_define([glib_binary_age],
+          [m4_eval(100 * glib_minor_version + glib_micro_version)])
+m4_define([glib_version],
+          [glib_major_version.glib_minor_version.glib_micro_version])
+
+GLIB_MAJOR_VERSION=glib_major_version
+GLIB_MINOR_VERSION=glib_minor_version
+GLIB_MICRO_VERSION=glib_micro_version
+GLIB_INTERFACE_AGE=glib_interface_age
+GLIB_BINARY_AGE=glib_binary_age
+GLIB_VERSION=glib_version
+
+AC_SUBST(GLIB_MAJOR_VERSION)
+AC_SUBST(GLIB_MINOR_VERSION)
+AC_SUBST(GLIB_MICRO_VERSION)
+AC_SUBST(GLIB_VERSION)
+AC_SUBST(GLIB_INTERFACE_AGE)
+AC_SUBST(GLIB_BINARY_AGE)
+
+AC_DEFINE(GLIB_INTERFACE_AGE, [glib_interface_age],
+          [Define to the GLIB interface age])
+AC_DEFINE(GLIB_BINARY_AGE, [glib_binary_age],
+          [Define to the GLIB binary age])
+
+dnl Let's use the system printf unconditionally
+enable_included_printf=no
+AC_DEFINE(HAVE_GOOD_PRINTF,1,[define to use system printf])
+
+dnl No support for static window libraries 
+glib_win32_static_compilation=no
+
+dnl that's the defaults in glib's configure (which provides a --with-threads
+dnl option we don't expose here)
+want_threads=yes
+
+AC_CANONICAL_HOST
+
+AC_MSG_CHECKING([for Win32])
+LIB_EXE_MACHINE_FLAG=X86
+case "$host" in
+  *-*-mingw*)
+    glib_native_win32=yes
+    glib_pid_type='void *'
+    glib_cv_stack_grows=no
+    # Unfortunately the mingw implementations of C99-style snprintf and vsnprintf
+    # don't seem to be quite good enough, at least not in mingw-runtime-3.14.
+    # (Sorry, I don't know exactly what is the problem, but it is related to
+    # floating point formatting and decimal point vs. comma.)
+    # The simple tests in AC_FUNC_VSNPRINTF_C99 and AC_FUNC_SNPRINTF_C99 aren't
+    # rigorous enough to notice, though.
+    # So preset the autoconf cache variables.
+    ac_cv_func_vsnprintf_c99=no
+    ac_cv_func_snprintf_c99=no
+    case "$host" in
+    x86_64-*-*)
+      LIB_EXE_MACHINE_FLAG=X64
+      ;;
+    esac
+    ;;
+  *)
+    glib_native_win32=no
+    glib_pid_type=int
+    ;;
+esac
+case $host in
+  *-*-linux*)
+    glib_os_linux=yes
+    ;;
+esac
+
+AC_MSG_RESULT([$glib_native_win32])
+
+AC_SUBST(LIB_EXE_MACHINE_FLAG)
+
+glib_have_carbon=no
+AC_MSG_CHECKING([for Mac OS X Carbon support])
+AC_TRY_CPP([
+#include <Carbon/Carbon.h>
+#include <CoreServices/CoreServices.h>
+], glib_have_carbon=yes)
+
+AC_MSG_RESULT([$glib_have_carbon])
+
+AC_CHECK_HEADERS([limits.h float.h values.h alloca.h sys/poll.h])
+AC_CHECK_FUNCS(atexit on_exit memmove)
+
+AC_CHECK_SIZEOF(char)
+AC_CHECK_SIZEOF(short)
+AC_CHECK_SIZEOF(long)
+AC_CHECK_SIZEOF(int)
+AC_CHECK_SIZEOF(void *)
+AC_CHECK_SIZEOF(long long)
+AC_CHECK_SIZEOF(__int64)
+
+if test x$ac_cv_sizeof_long = x8 || test x$ac_cv_sizeof_long_long = x8 || test x$ac_cv_sizeof___int64 = x8 ; then
+  :
+else
+  AC_MSG_ERROR([
+*** GLib requires a 64 bit type. You might want to consider
+*** using the GNU C compiler.
+])
+fi
+
+if test x$glib_native_win32 != xyes && test x$ac_cv_sizeof_long_long = x8; then
+	# long long is a 64 bit integer.
+	AC_MSG_CHECKING(for format to printf and scanf a guint64)
+	AC_CACHE_VAL(glib_cv_long_long_format,[
+		for format in ll q I64; do
+		  AC_TRY_RUN([#include <stdio.h>  
+			int main()
+			{
+			  long long b, a = -0x3AFAFAFAFAFAFAFALL;
+			  char buffer[1000];
+			  sprintf (buffer, "%${format}u", a);
+  			  sscanf (buffer, "%${format}u", &b);
+			  exit (b!=a);
+			}
+			],
+			[glib_cv_long_long_format=${format}
+			break],
+			[],[:])
+		done])
+	if test -n "$glib_cv_long_long_format"; then
+	  AC_MSG_RESULT(%${glib_cv_long_long_format}u)
+	  AC_DEFINE(HAVE_LONG_LONG_FORMAT,1,[define if system printf can print long long])
+	  if test x"$glib_cv_long_long_format" = xI64; then
+	    AC_DEFINE(HAVE_INT64_AND_I64,1,[define to support printing 64-bit integers with format I64])
+	  fi
+        else
+	  AC_MSG_RESULT(none)
+        fi
+elif test x$ac_cv_sizeof___int64 = x8; then
+	# __int64 is a 64 bit integer.
+	AC_MSG_CHECKING(for format to printf and scanf a guint64)
+	# We know this is MSVCRT.DLL, and what the formats are
+	glib_cv_long_long_format=I64
+	AC_MSG_RESULT(%${glib_cv_long_long_format}u)
+        AC_DEFINE(HAVE_LONG_LONG_FORMAT,1,[define if system printf can print long long])
+	AC_DEFINE(HAVE_INT64_AND_I64,1,[define to support printing 64-bit integers with format I64])
+fi
+
+# check additional type sizes
+AC_CHECK_SIZEOF(size_t)
+
+dnl Try to figure out whether gsize, gssize should be long or int
+AC_MSG_CHECKING([for the appropriate definition for size_t])
+
+case $ac_cv_sizeof_size_t in
+  $ac_cv_sizeof_short) 
+      glib_size_type=short
+      ;;
+  $ac_cv_sizeof_int) 
+      glib_size_type=int
+      ;;
+  $ac_cv_sizeof_long) 
+      glib_size_type=long
+      ;;
+  $ac_cv_sizeof_long_long)
+      glib_size_type='long long'
+      ;;
+  $ac_cv_sizeof__int64)
+      glib_size_type='__int64'
+      ;;
+  *)  AC_MSG_ERROR([No type matching size_t in size])
+      ;;
+esac
+
+dnl If int/long are the same size, we see which one produces
+dnl warnings when used in the location as size_t. (This matters
+dnl on AIX with xlc)
+dnl
+if test $ac_cv_sizeof_size_t = $ac_cv_sizeof_int &&
+   test $ac_cv_sizeof_size_t = $ac_cv_sizeof_long ; then
+  GLIB_CHECK_COMPILE_WARNINGS([AC_LANG_SOURCE([[
+#if defined(_AIX) && !defined(__GNUC__)
+#pragma options langlvl=stdc89
+#endif
+#include <stddef.h> 
+int main ()
+{
+  size_t s = 1;
+  unsigned int *size_int = &s;
+  return (int)*size_int;
+}
+    ]])],glib_size_type=int,
+      [GLIB_CHECK_COMPILE_WARNINGS([AC_LANG_SOURCE([[
+#if defined(_AIX) && !defined(__GNUC__)
+#pragma options langlvl=stdc89
+#endif
+#include <stddef.h> 
+int main ()
+{
+   size_t s = 1;
+   unsigned long *size_long = &s;
+   return (int)*size_long;
+}
+        ]])],glib_size_type=long)])
+fi
+
+AC_MSG_RESULT(unsigned $glib_size_type)
+
+# Check for some functions
+AC_CHECK_FUNCS(lstat strerror strsignal memmove vsnprintf stpcpy strcasecmp strncasecmp poll getcwd vasprintf setenv unsetenv getc_unlocked readlink symlink fdwalk memmem)
+AC_CHECK_FUNCS(chown lchmod lchown fchmod fchown link utimes getgrgid getpwuid)
+AC_CHECK_FUNCS(getmntent_r setmntent endmntent hasmntopt getfsstat getvfsstat)
+# Check for high-resolution sleep functions
+AC_CHECK_FUNCS(splice)
+
+# Check if bcopy can be used for overlapping copies, if memmove isn't found.
+# The check is borrowed from the PERL Configure script.
+if test "$ac_cv_func_memmove" != "yes"; then
+  AC_CACHE_CHECK(whether bcopy can handle overlapping copies,
+    glib_cv_working_bcopy,[AC_TRY_RUN([
+      int main() {
+        char buf[128], abc[128], *b;
+        int len, off, align;
+        bcopy("abcdefghijklmnopqrstuvwxyz0123456789", abc, 36);
+        for (align = 7; align >= 0; align--) {
+          for (len = 36; len; len--) {
+            b = buf+align; bcopy(abc, b, len);
+            for (off = 1; off <= len; off++) {
+              bcopy(b, b+off, len); bcopy(b+off, b, len);
+                if (bcmp(b, abc, len)) return(1);
+            }
+          }
+        }
+        return(0);
+      }],glib_cv_working_bcopy=yes,glib_cv_working_bcopy=no)])
+
+  GLIB_ASSERT_SET(glib_cv_working_bcopy)
+  if test "$glib_cv_working_bcopy" = "yes"; then
+    AC_DEFINE(HAVE_WORKING_BCOPY,1,[Have a working bcopy])
+  fi
+fi
+
+# Check for sys_errlist
+AC_MSG_CHECKING(for sys_errlist)
+AC_TRY_LINK(, [
+extern char *sys_errlist[];
+extern int sys_nerr;
+sys_errlist[sys_nerr-1][0] = 0;
+], glib_ok=yes, glib_ok=no)
+AC_MSG_RESULT($glib_ok)
+if test "$glib_ok" = "no"; then
+    AC_DEFINE(NO_SYS_ERRLIST,1,[global 'sys_errlist' not found])
+fi
+
+
+dnl va_copy checks
+dnl we currently check for all three va_copy possibilities, so we get
+dnl all results in config.log for bug reports.
+AC_CACHE_CHECK([for an implementation of va_copy()],glib_cv_va_copy,[
+	AC_LINK_IFELSE([AC_LANG_SOURCE([[#include <stdarg.h>
+#include <stdlib.h>
+	void f (int i, ...) {
+	va_list args1, args2;
+	va_start (args1, i);
+	va_copy (args2, args1);
+	if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
+	  exit (1);
+	va_end (args1); va_end (args2);
+	}
+	int main() {
+	  f (0, 42);
+	  return 0;
+	}]])],
+	[glib_cv_va_copy=yes],
+	[glib_cv_va_copy=no])
+])
+AC_CACHE_CHECK([for an implementation of __va_copy()],glib_cv___va_copy,[
+	AC_LINK_IFELSE([AC_LANG_SOURCE([[#include <stdarg.h>
+#include <stdlib.h>
+	void f (int i, ...) {
+	va_list args1, args2;
+	va_start (args1, i);
+	__va_copy (args2, args1);
+	if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
+	  exit (1);
+	va_end (args1); va_end (args2);
+	}
+	int main() {
+	  f (0, 42);
+	  return 0;
+	}]])],
+	[glib_cv___va_copy=yes],
+	[glib_cv___va_copy=no])
+])
+
+if test "x$glib_cv_va_copy" = "xyes"; then
+  g_va_copy_func=va_copy
+else if test "x$glib_cv___va_copy" = "xyes"; then
+  g_va_copy_func=__va_copy
+fi
+fi
+
+if test -n "$g_va_copy_func"; then
+  AC_DEFINE_UNQUOTED(G_VA_COPY,$g_va_copy_func,[A 'va_copy' style function])
+fi
+
+AC_CACHE_CHECK([whether va_lists can be copied by value],glib_cv_va_val_copy,[
+	AC_TRY_RUN([#include <stdarg.h>
+#include <stdlib.h> 
+	void f (int i, ...) {
+	va_list args1, args2;
+	va_start (args1, i);
+	args2 = args1;
+	if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
+	  exit (1);
+	va_end (args1); va_end (args2);
+	}
+	int main() {
+	  f (0, 42);
+	  return 0;
+	}],
+	[glib_cv_va_val_copy=yes],
+	[glib_cv_va_val_copy=no],
+	[glib_cv_va_val_copy=yes])
+])
+
+if test "x$glib_cv_va_val_copy" = "xno"; then
+  AC_DEFINE(G_VA_COPY_AS_ARRAY,1, ['va_lists' cannot be copies as values])
+fi
+
+dnl ***********************
+dnl *** g_module checks ***
+dnl ***********************
+G_MODULE_LIBS=
+G_MODULE_LIBS_EXTRA=
+G_MODULE_PLUGIN_LIBS=
+if test x"$glib_native_win32" = xyes; then
+  dnl No use for this on Win32
+  G_MODULE_LDFLAGS=
+else
+  export SED
+  G_MODULE_LDFLAGS=`(./libtool --config; echo eval echo \\$export_dynamic_flag_spec) | sh`
+fi
+dnl G_MODULE_IMPL= don't reset, so cmd-line can override
+G_MODULE_NEED_USCORE=0
+G_MODULE_BROKEN_RTLD_GLOBAL=0
+G_MODULE_HAVE_DLERROR=0
+dnl *** force native WIN32 shared lib loader 
+if test -z "$G_MODULE_IMPL"; then
+  case "$host" in
+  *-*-mingw*|*-*-cygwin*) G_MODULE_IMPL=G_MODULE_IMPL_WIN32 ;;
+  esac
+fi
+dnl *** force native AIX library loader
+dnl *** dlopen() filepath must be of the form /path/libname.a(libname.so)
+if test -z "$G_MODULE_IMPL"; then
+  case "$host" in
+  *-*-aix*) G_MODULE_IMPL=G_MODULE_IMPL_AR ;;
+  esac
+fi
+dnl *** dlopen() and dlsym() in system libraries
+if test -z "$G_MODULE_IMPL"; then
+	AC_CHECK_FUNC(dlopen,
+		      [AC_CHECK_FUNC(dlsym,
+			             [G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
+		      [])
+fi
+dnl *** load_image (BeOS)
+if test -z "$G_MODULE_IMPL" && test "x$glib_native_beos" = "xyes"; then
+  AC_CHECK_LIB(root, load_image,
+      [G_MODULE_LIBS="-lbe -lroot -lglib-2.0 "
+      G_MODULE_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
+      G_MODULE_PLUGIN_LIBS="-L\$(top_builddir_full)/gmodule/.libs -lgmodule"
+      G_MODULE_IMPL=G_MODULE_IMPL_BEOS],
+      [])
+fi   
+dnl *** NSLinkModule (dyld) in system libraries (Darwin)
+if test -z "$G_MODULE_IMPL"; then
+ 	AC_CHECK_FUNC(NSLinkModule,
+		      [G_MODULE_IMPL=G_MODULE_IMPL_DYLD
+		       G_MODULE_NEED_USCORE=1],
+		      [])
+fi
+dnl *** dlopen() and dlsym() in libdl
+if test -z "$G_MODULE_IMPL"; then
+	AC_CHECK_LIB(dl, dlopen,
+		     [AC_CHECK_LIB(dl, dlsym,
+			           [G_MODULE_LIBS=-ldl
+		                   G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
+		     [])
+fi
+dnl *** shl_load() in libdld (HP-UX)
+if test -z "$G_MODULE_IMPL"; then
+	AC_CHECK_LIB(dld, shl_load,
+		[G_MODULE_LIBS=-ldld
+		G_MODULE_IMPL=G_MODULE_IMPL_DLD],
+		[])
+fi
+dnl *** additional checks for G_MODULE_IMPL_DL
+if test "$G_MODULE_IMPL" = "G_MODULE_IMPL_DL"; then
+	LIBS_orig="$LIBS"
+	LDFLAGS_orig="$LDFLAGS"
+	LIBS="$G_MODULE_LIBS $LIBS"
+	LDFLAGS="$LDFLAGS $G_MODULE_LDFLAGS"
+dnl *** check for OSF1/5.0 RTLD_GLOBAL brokenness
+	echo "void glib_plugin_test(void) { }" > plugin.c
+	${SHELL} ./libtool --mode=compile ${CC} -shared \
+		-export-dynamic -o plugin.o plugin.c 2>&1 >/dev/null
+	AC_CACHE_CHECK([for RTLD_GLOBAL brokenness],
+		glib_cv_rtldglobal_broken,[
+		AC_TRY_RUN([
+#include <dlfcn.h>
+#ifndef RTLD_GLOBAL
+#  define RTLD_GLOBAL 0
+#endif
+#ifndef RTLD_LAZY
+#  define RTLD_LAZY 0
+#endif
+int glib_plugin_test;
+int main () {
+    void *handle, *global, *local;
+    global = &glib_plugin_test;
+    handle = dlopen ("./.libs/plugin.o", RTLD_GLOBAL | RTLD_LAZY);
+    if (!handle) return 0;
+    local = dlsym (handle, "glib_plugin_test");
+    return global == local;
+}                       ],
+			[glib_cv_rtldglobal_broken=no],
+			[glib_cv_rtldglobal_broken=yes],
+			[glib_cv_rtldglobal_broken=no])
+		rm -f plugin.c plugin.o plugin.lo .libs/plugin.o
+		rmdir .libs 2>/dev/null
+	])
+	if test "x$glib_cv_rtldglobal_broken" = "xyes"; then
+  		G_MODULE_BROKEN_RTLD_GLOBAL=1
+	else
+  		G_MODULE_BROKEN_RTLD_GLOBAL=0
+	fi
+dnl *** check whether we need preceeding underscores
+	AC_CACHE_CHECK([for preceeding underscore in symbols],
+		glib_cv_uscore,[
+		AC_TRY_RUN([#include <dlfcn.h>
+                int glib_underscore_test (void) { return 42; }
+		int main() {
+		  void *f1 = (void*)0, *f2 = (void*)0, *handle;
+		  handle = dlopen ((void*)0, 0);
+		  if (handle) {
+		    f1 = dlsym (handle, "glib_underscore_test");
+		    f2 = dlsym (handle, "_glib_underscore_test");
+		  } return (!f2 || f1);
+		}],
+			[glib_cv_uscore=yes],
+			[glib_cv_uscore=no],
+			[])
+		rm -f plugin.c plugin.$ac_objext plugin.lo
+	])
+        GLIB_ASSERT_SET(glib_cv_uscore)
+	if test "x$glib_cv_uscore" = "xyes"; then
+  		G_MODULE_NEED_USCORE=1
+	else
+  		G_MODULE_NEED_USCORE=0
+	fi
+
+	LDFLAGS="$LDFLAGS_orig"
+dnl *** check for having dlerror()
+	AC_CHECK_FUNC(dlerror,
+		[G_MODULE_HAVE_DLERROR=1],
+		[G_MODULE_HAVE_DLERROR=0])
+	LIBS="$LIBS_orig"
+fi
+dnl *** done, have we got an implementation?
+if test -z "$G_MODULE_IMPL"; then
+	G_MODULE_IMPL=0
+        G_MODULE_SUPPORTED=false
+else
+        G_MODULE_SUPPORTED=true
+fi
+
+AC_MSG_CHECKING(for the suffix of module shared libraries)
+export SED
+shrext_cmds=`./libtool --config | grep '^shrext_cmds='`
+eval $shrext_cmds
+module=yes eval std_shrext=$shrext_cmds
+# chop the initial dot
+glib_gmodule_suffix=`echo $std_shrext | sed 's/^\.//'`
+AC_MSG_RESULT(.$glib_gmodule_suffix)
+# any reason it may fail?
+if test "x$glib_gmodule_suffix" = x; then
+	AC_MSG_ERROR(Cannot determine shared library suffix from libtool)
+fi
+ 
+AC_SUBST(G_MODULE_SUPPORTED)
+AC_SUBST(G_MODULE_IMPL)
+AC_SUBST(G_MODULE_LIBS)
+AC_SUBST(G_MODULE_LIBS_EXTRA)
+AC_SUBST(G_MODULE_PLUGIN_LIBS)
+AC_SUBST(G_MODULE_LDFLAGS)
+AC_SUBST(G_MODULE_HAVE_DLERROR)
+AC_SUBST(G_MODULE_BROKEN_RTLD_GLOBAL)
+AC_SUBST(G_MODULE_NEED_USCORE)
+AC_SUBST(GLIB_DEBUG_FLAGS)
+
+dnl AC_C_INLINE is useless to us since it bails out too early, we need to
+dnl truely know which ones of `inline', `__inline' and `__inline__' are
+dnl actually supported.
+AC_CACHE_CHECK([for __inline],glib_cv_has__inline,[
+        AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
+	__inline int foo () { return 0; }
+	int main () { return foo (); }
+	]])],
+	glib_cv_has__inline=yes
+        ,
+	glib_cv_has__inline=no
+        ,)
+])
+case x$glib_cv_has__inline in
+xyes) AC_DEFINE(G_HAVE___INLINE,1,[Have __inline keyword])
+esac
+AC_CACHE_CHECK([for __inline__],glib_cv_has__inline__,[
+        AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
+	__inline__ int foo () { return 0; }
+	int main () { return foo (); }
+	]])],
+	glib_cv_has__inline__=yes
+        ,
+	glib_cv_has__inline__=no
+        ,)
+])
+case x$glib_cv_has__inline__ in
+xyes) AC_DEFINE(G_HAVE___INLINE__,1,[Have __inline__ keyword])
+esac
+AC_CACHE_CHECK([for inline], glib_cv_hasinline,[
+        AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
+	#undef inline
+	inline int foo () { return 0; }
+	int main () { return foo (); }
+	]])],
+	glib_cv_hasinline=yes
+        ,
+	glib_cv_hasinline=no
+        ,)
+])
+case x$glib_cv_hasinline in
+xyes) AC_DEFINE(G_HAVE_INLINE,1,[Have inline keyword])
+esac
+
+# if we can use inline functions in headers
+AC_MSG_CHECKING(if inline functions in headers work)
+AC_LINK_IFELSE([AC_LANG_SOURCE([[
+#if defined (G_HAVE_INLINE) && defined (__GNUC__) && defined (__STRICT_ANSI__)
+#  undef inline
+#  define inline __inline__
+#elif !defined (G_HAVE_INLINE)
+#  undef inline
+#  if defined (G_HAVE___INLINE__)
+#    define inline __inline__
+#  elif defined (G_HAVE___INLINE)
+#    define inline __inline
+#  endif
+#endif
+
+int glib_test_func2 (int);
+
+static inline int
+glib_test_func1 (void) {
+  return glib_test_func2 (1);
+}
+
+int
+main (void) {
+  int i = 1;
+}]])],[g_can_inline=yes],[g_can_inline=no])
+AC_MSG_RESULT($g_can_inline)
+
+# check for flavours of varargs macros
+AC_MSG_CHECKING(for ISO C99 varargs macros in C)
+AC_TRY_COMPILE([],[
+int a(int p1, int p2, int p3);
+#define call_a(...) a(1,__VA_ARGS__)
+call_a(2,3);
+],g_have_iso_c_varargs=yes,g_have_iso_c_varargs=no)
+AC_MSG_RESULT($g_have_iso_c_varargs)
+
+AC_MSG_CHECKING(for ISO C99 varargs macros in C++)
+if test "$CXX" = ""; then
+dnl No C++ compiler
+  g_have_iso_cxx_varargs=no
+else
+  AC_LANG_CPLUSPLUS
+  AC_TRY_COMPILE([],[
+int a(int p1, int p2, int p3);
+#define call_a(...) a(1,__VA_ARGS__)
+call_a(2,3);
+],g_have_iso_cxx_varargs=yes,g_have_iso_cxx_varargs=no)
+  AC_LANG_C
+fi
+AC_MSG_RESULT($g_have_iso_cxx_varargs)
+
+AC_MSG_CHECKING(for GNUC varargs macros)
+AC_TRY_COMPILE([],[
+int a(int p1, int p2, int p3);
+#define call_a(params...) a(1,params)
+call_a(2,3);
+],g_have_gnuc_varargs=yes,g_have_gnuc_varargs=no)
+AC_MSG_RESULT($g_have_gnuc_varargs)
+
+AC_MSG_CHECKING([for EILSEQ])
+AC_TRY_COMPILE([
+#include <errno.h>
+],
+[
+int error = EILSEQ;
+], have_eilseq=yes, have_eilseq=no);
+AC_MSG_RESULT($have_eilseq)
+
+# check for GNUC visibility support
+AC_MSG_CHECKING(for GNUC visibility attribute)
+GLIB_CHECK_COMPILE_WARNINGS([AC_LANG_SOURCE([[
+void
+__attribute__ ((visibility ("hidden")))
+     f_hidden (void)
+{
+}
+void
+__attribute__ ((visibility ("internal")))
+     f_internal (void)
+{
+}
+void
+__attribute__ ((visibility ("protected")))
+     f_protected (void)
+{
+}
+void
+__attribute__ ((visibility ("default")))
+     f_default (void)
+{
+}
+int main (int argc, char **argv)
+{
+	f_hidden();
+	f_internal();
+	f_protected();
+	f_default();
+	return 0;
+}
+]])],g_have_gnuc_visibility=yes,g_have_gnuc_visibility=no)
+AC_MSG_RESULT($g_have_gnuc_visibility)
+
+# check for bytesex stuff
+AC_C_BIGENDIAN
+if test x$ac_cv_c_bigendian = xuniversal ; then
+AC_TRY_COMPILE([#include <endian.h>], [#if __BYTE_ORDER == __BIG_ENDIAN
+#else
+#error Not a big endian. 
+#endif],
+    ac_cv_c_bigendian=yes
+    ,AC_TRY_COMPILE([#include <endian.h>], [#if __BYTE_ORDER == __LITTLE_ENDIAN
+#else
+#error Not a little endian. 
+#endif],
+    ac_cv_c_bigendian=no
+    ,AC_MSG_WARN([Could not determine endianness.])))
+fi
+
+
+# check for header files
+AC_CHECK_HEADERS([dirent.h float.h limits.h pwd.h grp.h sys/param.h sys/poll.h sys/resource.h])
+AC_CHECK_HEADERS([sys/time.h sys/times.h sys/wait.h unistd.h values.h])
+AC_CHECK_HEADERS([sys/select.h sys/types.h stdint.h inttypes.h sched.h malloc.h])
+AC_CHECK_HEADERS([sys/vfs.h sys/vmount.h sys/statfs.h sys/statvfs.h])
+AC_CHECK_HEADERS([mntent.h sys/mnttab.h sys/vfstab.h sys/mntctl.h fstab.h])
+AC_CHECK_HEADERS([sys/uio.h sys/mkdev.h])
+AC_CHECK_HEADERS([linux/magic.h])
+
+AC_CHECK_HEADERS([sys/mount.h sys/sysctl.h], [], [],
+[#if HAVE_SYS_PARAM_H
+ #include <sys/param.h>
+ #endif
+])
+
+# check for structure fields
+AC_CHECK_MEMBERS([struct stat.st_mtimensec, struct stat.st_mtim.tv_nsec, struct stat.st_atimensec, struct stat.st_atim.tv_nsec, struct stat.st_ctimensec, struct stat.st_ctim.tv_nsec])
+AC_CHECK_MEMBERS([struct stat.st_blksize, struct stat.st_blocks, struct statfs.f_fstypename, struct statfs.f_bavail],,, [#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#ifdef HAVE_SYS_STATFS_H
+#include <sys/statfs.h>
+#endif
+#ifdef HAVE_SYS_PARAM_H
+#include <sys/param.h>
+#endif
+#ifdef HAVE_SYS_MOUNT_H
+#include <sys/mount.h>
+#endif])
+# struct statvfs.f_basetype is available on Solaris but not for Linux. 
+AC_CHECK_MEMBERS([struct statvfs.f_basetype],,, [#include <sys/statvfs.h>])
+AC_CHECK_MEMBERS([struct statvfs.f_fstypename],,, [#include <sys/statvfs.h>])
+AC_CHECK_MEMBERS([struct tm.tm_gmtoff, struct tm.__tm_gmtoff],,,[#include <time.h>])
+
+dnl error and warning message
+dnl *************************
+
+THREAD_NO_IMPLEMENTATION="You do not have any known thread system on your
+                computer. GLib will not have a default thread implementation."
+
+FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your
+                platform (normally it's "_REENTRANT"). I'll not use any flag on
+                compilation now, but then your programs might not work.
+                Please provide information on how it is done on your system."
+
+LIBS_NOT_FOUND_1="I can't find the libraries for the thread implementation
+		"
+
+LIBS_NOT_FOUND_2=". Please choose another thread implementation or
+		provide information on your thread implementation.
+		You can also run 'configure --disable-threads' 
+		to compile without thread support."
+
+FUNC_NO_GETPWUID_R="the 'g_get_(user_name|real_name|home_dir|tmp_dir)'
+		functions will not be MT-safe during their first call because
+		there is no working 'getpwuid_r' on your system."
+
+FUNC_NO_LOCALTIME_R="the 'g_date_set_time' function will not be MT-safe
+		because there is no 'localtime_r' on your system."
+
+POSIX_NO_YIELD="I can not find a yield functions for your platform. A rather
+		crude surrogate will be used. If you happen to know a 
+		yield function for your system, please inform the GLib 
+		developers."
+
+POSIX_NO_PRIORITIES="I can not find the minimal and maximal priorities for 
+		threads on your system. Thus threads can only have the default 
+		priority. If you happen to know these main/max
+		priorities, please inform the GLib developers."
+
+AIX_COMPILE_INFO="AIX's C compiler needs to be called by a different name, when
+		linking threaded applications. As GLib cannot do that 
+		automatically, you will get an linkg error everytime you are 
+		not using the right compiler. In that case you have to relink 
+		with the right compiler. Ususally just '_r' is appended 
+		to the compiler name."
+
+dnl determination of thread implementation
+dnl ***************************************
+
+# have_threads=no   means no thread support
+# have_threads=none means no default thread implementation
+
+have_threads=no
+if test "x$want_threads" = xyes || test "x$want_threads" = xposix \
+				|| test "x$want_threads" = xdce; then
+	# -D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE is for DG/UX
+	# -U_OSF_SOURCE is for Digital UNIX 4.0d
+	GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE"
+	glib_save_CPPFLAGS="$CPPFLAGS"
+	CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
+        if test "x$have_threads" = xno; then
+                AC_TRY_COMPILE([#include <pthread.h>],
+			[pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
+			have_threads=posix)
+        fi
+        if test "x$have_threads" = xno; then
+                AC_TRY_COMPILE([#include <pthread.h>],
+			[pthread_mutex_t m; 
+                         pthread_mutex_init (&m, pthread_mutexattr_default);],
+			have_threads=dce)
+        fi
+	# Tru64Unix requires -pthread to find pthread.h. See #103020
+	CPPFLAGS="$CPPFLAGS -pthread"
+	if test "x$have_threads" = xno; then
+	AC_TRY_COMPILE([#include <pthread.h>],
+		       [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
+		       have_threads=posix)
+        fi
+	CPPFLAGS="$glib_save_CPPFLAGS"
+fi
+if test "x$want_threads" = xyes || test "x$want_threads" = xwin32; then
+       	case $host in
+               	*-*-mingw*)
+		have_threads=win32
+		;;
+	esac
+fi
+if test "x$want_threads" = xnone; then
+	have_threads=none
+fi
+
+AC_MSG_CHECKING(for thread implementation)
+
+if test "x$have_threads" = xno && test "x$want_threads" != xno; then
+	AC_MSG_RESULT(none available)
+        AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
+else
+	AC_MSG_RESULT($have_threads)
+fi
+
+
+dnl determination of G_THREAD_CFLAGS
+dnl ********************************
+
+G_THREAD_LIBS=
+G_THREAD_LIBS_EXTRA=
+G_THREAD_CFLAGS=
+
+dnl
+dnl Test program for sched_get_priority_min()
+dnl
+m4_define([glib_sched_priority_test],[
+#include <sched.h>
+#include <errno.h>
+int main() {
+    errno = 0;
+    return sched_get_priority_min(SCHED_OTHER)==-1
+ 	   && errno != 0;
+}])
+
+if test x"$have_threads" != xno; then
+
+  if test x"$have_threads" = xposix; then
+    # First we test for posix, whether -pthread or -pthreads do the trick as 
+    # both CPPFLAG and LIBS. 
+    # One of them does for most gcc versions and some other platforms/compilers
+    # too and could be considered as the canonical way to go. 
+    case $host in
+      *-*-cygwin*|*-*-darwin*)
+         # skip cygwin and darwin -pthread or -pthreads test
+         ;;
+      *-solaris*)
+        # These compiler/linker flags work with both Sun Studio and gcc
+	# Sun Studio expands -mt to -D_REENTRANT and -lthread
+	# gcc expands -pthreads to -D_REENTRANT -D_PTHREADS -lpthread
+        G_THREAD_CFLAGS="-D_REENTRANT -D_PTHREADS"
+        G_THREAD_LIBS="-lpthread -lthread"
+        ;;
+      *)
+        for flag in pthread pthreads mt; do
+          glib_save_CFLAGS="$CFLAGS"
+          CFLAGS="$CFLAGS -$flag"
+          AC_TRY_RUN(glib_thread_test(0),
+                     glib_flag_works=yes,
+                     glib_flag_works=no,
+                     [AC_LINK_IFELSE([AC_LANG_SOURCE(glib_thread_test(0))],
+                                     glib_flag_works=yes,
+                                     glib_flag_works=no)])
+          CFLAGS="$glib_save_CFLAGS"
+          if test $glib_flag_works = yes ; then
+             G_THREAD_CFLAGS=-$flag
+	     G_THREAD_LIBS=-$flag
+	     break;
+          fi
+        done
+         ;;
+    esac 
+  fi
+
+  if test x"$G_THREAD_CFLAGS" = x; then
+
+    # The canonical -pthread[s] does not work. Try something different.
+
+    case $host in
+	*-aix*)
+		if test x"$GCC" = xyes; then
+			# GCC 3.0 and above needs -pthread. 
+			# Should be coverd by the case above.
+			# GCC 2.x and below needs -mthreads
+			G_THREAD_CFLAGS="-mthreads"		
+			G_THREAD_LIBS=$G_THREAD_CFLAGS
+		else 
+			# We are probably using the aix compiler. Normaly a 
+			# program would have to be compiled with the _r variant
+			# of the corresponding compiler, but we as GLib cannot 
+			# do that: but the good news is that for compiling the
+			# only difference is the added -D_THREAD_SAFE compile 
+			# option. This is according to the "C for AIX User's 
+			# Guide".
+			G_THREAD_CFLAGS="-D_THREAD_SAFE"
+		fi
+		;;
+	*-dg-dgux*)  # DG/UX
+		G_THREAD_CFLAGS="-D_REENTRANT -D_POSIX4A_DRAFT10_SOURCE"
+		;;
+	*-osf*)
+		# So we are using dce threads. posix threads are already 
+		# catched above.
+		G_THREAD_CFLAGS="-threads"
+		G_THREAD_LIBS=$G_THREAD_CFLAGS
+		;;
+	*-sysv5uw7*) # UnixWare 7 
+		# We are not using gcc with -pthread. Catched above.
+		G_THREAD_CFLAGS="-Kthread"
+		G_THREAD_LIBS=$G_THREAD_CFLAGS
+		;;
+	*-mingw*)
+		# No flag needed when using MSVCRT.DLL
+		G_THREAD_CFLAGS=""
+		;;
+	*)
+		G_THREAD_CFLAGS="-D_REENTRANT" # good default guess otherwise
+		;;
+    esac
+ 
+  fi
+
+    # if we are not finding the localtime_r function, then we probably are
+    # not using the proper multithread flag
+
+    glib_save_CPPFLAGS="$CPPFLAGS"
+    CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
+
+    # First we test, whether localtime_r is declared in time.h
+    # directly. Then we test whether a macro localtime_r exists, in
+    # which case localtime_r in the test program is replaced and thus
+    # if we still find localtime_r in the output, it is not defined as 
+    # a macro.
+
+    AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>], ,
+      [AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h> 
+							   localtime_r(a,b)],
+      		   AC_MSG_WARN($FLAG_DOES_NOT_WORK))])
+
+    CPPFLAGS="$glib_save_CPPFLAGS"
+
+    AC_MSG_CHECKING(thread related cflags)
+    AC_MSG_RESULT($G_THREAD_CFLAGS)
+    CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
+fi
+
+dnl determination of G_THREAD_LIBS
+dnl ******************************
+
+mutex_has_default=no
+case $have_threads in
+        posix|dce)
+	  glib_save_CPPFLAGS="$CPPFLAGS"
+	  CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
+          if test x"$G_THREAD_LIBS" = x; then
+            case $host in
+              *-aix*)
+                # We are not using gcc (would have set G_THREAD_LIBS) and thus 
+                # probably using the aix compiler.
+		AC_MSG_WARN($AIX_COMPILE_INFO)
+                ;;
+              *)
+                G_THREAD_LIBS=error
+	        glib_save_LIBS="$LIBS"
+	        for thread_lib in "" pthread pthread32 pthreads thread dce; do
+			if test x"$thread_lib" = x; then
+				add_thread_lib=""
+				IN=""
+			else
+				add_thread_lib="-l$thread_lib"
+				IN=" in -l$thread_lib"
+			fi
+			if test x"$have_threads" = xposix; then
+				defattr=0
+			else
+				defattr=pthread_attr_default
+			fi
+			
+			LIBS="$add_thread_lib $glib_save_LIBS"
+			
+			AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
+			AC_TRY_RUN(glib_thread_test([$defattr]),
+                                   glib_result=yes,
+                                   glib_result=no,
+                                   [AC_LINK_IFELSE([AC_LANG_SOURCE(glib_thread_test([$defattr]))],
+                                                   glib_result=yes,
+                                                   glib_result=no)])
+                        AC_MSG_RESULT($glib_result)
+			
+                        if test "$glib_result" = "yes" ; then
+			  G_THREAD_LIBS="$add_thread_lib"
+                          break
+                        fi
+		done
+		if test "x$G_THREAD_LIBS" = xerror; then
+		  AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
+		fi 
+		LIBS="$glib_save_LIBS"
+                ;;
+            esac
+          fi
+
+          glib_save_LIBS="$LIBS"
+	  for thread_lib in "" rt rte; do
+	    if test x"$thread_lib" = x; then
+	      add_thread_lib=""
+	      IN=""
+	    else
+	      add_thread_lib="-l$thread_lib"
+	      IN=" in -l$thread_lib"
+	    fi
+	    LIBS="$add_thread_lib $glib_save_LIBS"
+	    
+            AC_MSG_CHECKING(for sched_get_priority_min$IN)
+	    AC_TRY_RUN(glib_sched_priority_test,
+                       glib_result=yes,
+                       glib_result=no,
+                       [AC_LINK_IFELSE([AC_LANG_SOURCE(glib_sched_priority_test)],
+                                       glib_result=yes,
+                                       glib_result=no)])
+	    AC_MSG_RESULT($glib_result)
+
+	    if test "$glib_result" = "yes" ; then	    
+ 	       G_THREAD_LIBS="$G_THREAD_LIBS $add_thread_lib"
+	       posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
+	       posix_priority_max="sched_get_priority_max(SCHED_OTHER)"
+	       break
+            fi
+	  done
+	  LIBS="$glib_save_LIBS"
+          mutex_has_default=yes
+          mutex_default_type='pthread_mutex_t'
+          mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
+          mutex_header_file='pthread.h'
+	  if test "x$have_threads" = "xposix"; then
+	    g_threads_impl="POSIX"
+	  else
+	    g_threads_impl="DCE"
+	    have_threads="posix"
+	  fi
+	  AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
+          CPPFLAGS="$glib_save_CPPFLAGS"
+          ;;
+	win32)
+	   g_threads_impl="WIN32"
+	   ;;
+        none|no)
+	   g_threads_impl="NONE"
+           ;;
+        *)
+	   g_threads_impl="NONE"
+           G_THREAD_LIBS=error
+           ;;
+esac
+
+if test "x$G_THREAD_LIBS" = xerror; then
+        AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
+fi
+
+AC_MSG_CHECKING(thread related libraries)
+AC_MSG_RESULT($G_THREAD_LIBS)
+
+dnl check for mt safe function variants and some posix functions
+dnl ************************************************************
+
+if test x"$have_threads" != xno; then
+	glib_save_LIBS="$LIBS"
+	# we are not doing the following for now, as this might require glib 
+	# to always be linked with the thread libs on some platforms. 
+	# LIBS="$LIBS $G_THREAD_LIBS"
+	AC_CHECK_FUNCS(localtime_r gmtime_r)
+	if test "$ac_cv_header_pwd_h" = "yes"; then
+	 	AC_CACHE_CHECK([for posix getpwuid_r],
+			ac_cv_func_posix_getpwuid_r,
+			[AC_TRY_RUN([
+#include <errno.h>
+#include <pwd.h>
+int main () { 
+    char buffer[10000];
+    struct passwd pwd, *pwptr = &pwd;
+    int error;
+    errno = 0;
+    error = getpwuid_r (0, &pwd, buffer, 
+                        sizeof (buffer), &pwptr);
+   return (error < 0 && errno == ENOSYS) 
+	   || error == ENOSYS; 
+}                               ],
+				[ac_cv_func_posix_getpwuid_r=yes],
+				[ac_cv_func_posix_getpwuid_r=no])])
+		GLIB_ASSERT_SET(ac_cv_func_posix_getpwuid_r)
+		if test "$ac_cv_func_posix_getpwuid_r" = yes; then
+			AC_DEFINE(HAVE_POSIX_GETPWUID_R,1,
+				[Have POSIX function getpwuid_r])
+		else
+	 		AC_CACHE_CHECK([for nonposix getpwuid_r],
+				ac_cv_func_nonposix_getpwuid_r,
+				[AC_TRY_LINK([#include <pwd.h>],
+                                	[char buffer[10000];
+                                	struct passwd pwd;
+                                	getpwuid_r (0, &pwd, buffer, 
+                                        		sizeof (buffer));],
+					[ac_cv_func_nonposix_getpwuid_r=yes],
+					[ac_cv_func_nonposix_getpwuid_r=no])])
+			GLIB_ASSERT_SET(ac_cv_func_nonposix_getpwuid_r)
+			if test "$ac_cv_func_nonposix_getpwuid_r" = yes; then
+				AC_DEFINE(HAVE_NONPOSIX_GETPWUID_R,1,
+					[Have non-POSIX function getpwuid_r])
+			fi
+		fi
+	fi
+	if test "$ac_cv_header_grp_h" = "yes"; then
+	   	AC_CACHE_CHECK([for posix getgrgid_r],
+			ac_cv_func_posix_getgrgid_r,
+			[AC_TRY_RUN([
+#include <errno.h>
+#include <grp.h>
+int main () { 
+    char buffer[10000];
+    struct group grp, *grpptr = &grp;
+    int error;
+    errno = 0;
+    error = getgrgid_r (0, &grp, buffer, 
+                        sizeof (buffer), &grpptr);
+   return (error < 0 && errno == ENOSYS) 
+	   || error == ENOSYS; 
+}                              ],
+			       [ac_cv_func_posix_getgrgid_r=yes],
+			       [ac_cv_func_posix_getgrgid_r=no])])
+		GLIB_ASSERT_SET(ac_cv_func_posix_getgrgid_r)
+		if test "$ac_cv_func_posix_getgrgid_r" = yes; then
+		   	AC_DEFINE(HAVE_POSIX_GETGRGID_R,1,
+				[Have POSIX function getgrgid_r])
+		else
+			AC_CACHE_CHECK([for nonposix getgrgid_r],
+				ac_cv_func_nonposix_getgrgid_r,
+				[AC_TRY_LINK([#include <grp.h>],
+                               		[char buffer[10000];
+					struct group grp;	
+					getgrgid_r (0, &grp, buffer, 
+                                       	sizeof (buffer));],
+				[ac_cv_func_nonposix_getgrgid_r=yes],
+				[ac_cv_func_nonposix_getgrgid_r=no])])
+			GLIB_ASSERT_SET(ac_cv_func_nonposix_getgrgid_r)
+			if test "$ac_cv_func_nonposix_getgrgid_r" = yes; then
+			   	AC_DEFINE(HAVE_NONPOSIX_GETGRGID_R,1,
+					[Have non-POSIX function getgrgid_r])
+			fi
+		fi
+	fi
+	LIBS="$G_THREAD_LIBS $LIBS"
+	if test x"$have_threads" = xposix; then
+		glib_save_CPPFLAGS="$CPPFLAGS"
+		CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
+		dnl we might grow sizeof(pthread_t) later on, so use a dummy name here
+		GLIB_SIZEOF([#include <pthread.h>], pthread_t, system_thread)
+		# This is not AC_CHECK_FUNC to also work with function
+		# name mangling in header files.
+		AC_MSG_CHECKING(for pthread_attr_setstacksize)
+		AC_TRY_LINK([#include <pthread.h>],
+			[pthread_attr_t t; pthread_attr_setstacksize(&t,0)],
+			[AC_MSG_RESULT(yes)
+			AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE,1,
+				  [Have function pthread_attr_setstacksize])],
+			[AC_MSG_RESULT(no)])
+		AC_MSG_CHECKING(for minimal/maximal thread priority)
+		if test x"$posix_priority_min" = x; then
+			AC_EGREP_CPP(PX_PRIO_MIN,[#include <pthread.h>
+				PX_PRIO_MIN],,[
+				posix_priority_min=PX_PRIO_MIN
+				posix_priority_max=PX_PRIO_MAX])
+		fi
+		if test x"$posix_priority_min" = x; then
+			# AIX
+			AC_EGREP_CPP(PTHREAD_PRIO_MIN,[#include <pthread.h>
+				PTHREAD_PRIO_MIN],,[
+				posix_priority_min=PTHREAD_PRIO_MIN
+				posix_priority_max=PTHREAD_PRIO_MAX])
+		fi
+		if test x"$posix_priority_min" = x; then
+			AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
+				PRI_OTHER_MIN],,[
+				posix_priority_min=PRI_OTHER_MIN	
+				posix_priority_max=PRI_OTHER_MAX])
+		fi
+		if test x"$posix_priority_min" = x; then
+			AC_MSG_RESULT(none found)
+			AC_MSG_WARN($POSIX_NO_PRIORITIES)
+	                posix_priority_min=-1
+			posix_priority_max=-1
+		else
+			AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
+			AC_MSG_CHECKING(for pthread_setschedparam)
+			AC_TRY_LINK([#include <pthread.h>],
+		          [pthread_t t; pthread_setschedparam(t, 0, NULL)],
+			  [AC_MSG_RESULT(yes)
+			AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
+			   AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])],
+                          [AC_MSG_RESULT(no)
+                           AC_MSG_WARN($POSIX_NO_PRIORITIES)])
+		fi
+		posix_yield_func=none
+		AC_MSG_CHECKING(for posix yield function)
+		for yield_func in sched_yield pthread_yield_np pthread_yield \
+							thr_yield; do
+			AC_TRY_LINK([#include <pthread.h>],
+				[$yield_func()],
+				[posix_yield_func="$yield_func"
+				break])
+		done		
+		if test x"$posix_yield_func" = xnone; then
+			AC_MSG_RESULT(none found)
+			AC_MSG_WARN($POSIX_NO_YIELD)
+	                posix_yield_func="g_usleep(1000)"
+		else
+			AC_MSG_RESULT($posix_yield_func)
+			posix_yield_func="$posix_yield_func()"
+		fi
+		AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func,[The POSIX RT yield function])
+		CPPFLAGS="$glib_save_CPPFLAGS"
+           
+	elif test x"$have_threads" = xwin32; then
+		# It's a pointer to a private struct
+		GLIB_SIZEOF(,struct _GThreadData *, system_thread)
+	fi
+
+	LIBS="$glib_save_LIBS"
+
+	# now spit out all the warnings.
+	if test "$ac_cv_func_posix_getpwuid_r" != "yes" && 
+	   test "$ac_cv_func_nonposix_getpwuid_r" != "yes"; then
+		AC_MSG_WARN($FUNC_NO_GETPWUID_R)
+	fi
+	if test "$ac_cv_func_localtime_r" != "yes"; then
+		AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
+	fi
+fi	
+
+if test x"$glib_cv_sizeof_system_thread" = x; then
+   # use a pointer as a fallback.
+   GLIB_SIZEOF(,void *, system_thread)
+fi
+
+#
+# Hack to deal with:
+# 
+#  a) GCC < 3.3 for Linux doesn't include -lpthread when
+#     building shared libraries with linux.
+#  b) FreeBSD doesn't do this either.
+#
+case $host in
+  *-*-freebsd*|*-*-linux*)
+    G_THREAD_LIBS_FOR_GTHREAD="`echo $G_THREAD_LIBS | sed s/-pthread/-lpthread/`"
+    ;;
+  *-*-openbsd*)
+    LDFLAGS="$LDFLAGS -pthread"
+    ;;
+  *)
+    G_THREAD_LIBS_FOR_GTHREAD="$G_THREAD_LIBS"
+    ;;
+esac
+
+AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
+		   [Source file containing theread implementation])
+AC_SUBST(G_THREAD_CFLAGS)
+AC_SUBST(G_THREAD_LIBS)
+AC_SUBST(G_THREAD_LIBS_FOR_GTHREAD)
+AC_SUBST(G_THREAD_LIBS_EXTRA)
+
+dnl **********************************************
+dnl *** GDefaultMutex setup and initialization ***
+dnl **********************************************
+dnl
+dnl if mutex_has_default = yes, we also got
+dnl mutex_default_type, mutex_default_init and mutex_header_file
+if test $mutex_has_default = yes ; then
+	glib_save_CPPFLAGS="$CPPFLAGS"
+	glib_save_LIBS="$LIBS"
+	LIBS="$G_THREAD_LIBS $LIBS"
+	CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
+	GLIB_SIZEOF([#include <$mutex_header_file>],
+                    $mutex_default_type,
+                    gmutex)
+	GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
+			   $mutex_default_type,
+			   gmutex,
+			   $glib_cv_sizeof_gmutex,
+			   $mutex_default_init)
+	if test x"$glib_cv_byte_contents_gmutex" = xno; then
+		mutex_has_default=no
+	fi
+	CPPFLAGS="$glib_save_CPPFLAGS"
+	LIBS="$glib_save_LIBS"
+fi
+
+dnl ************************
+dnl *** g_atomic_* tests ***
+dnl ************************
+
+AC_MSG_CHECKING([whether to use assembler code for atomic operations])
+    case $host_cpu in
+      i386)
+        AC_MSG_RESULT([none])
+        glib_memory_barrier_needed=no
+        ;;
+      i?86)
+        AC_MSG_RESULT([i486])
+        AC_DEFINE_UNQUOTED(G_ATOMIC_I486, 1,
+			   [i486 atomic implementation])
+        glib_memory_barrier_needed=no
+        ;;
+      sparc*)
+        SPARCV9_WARNING="Try to rerun configure with CFLAGS='-mcpu=v9',
+			 when you are using a sparc with v9 instruction set (most
+			 sparcs nowadays). This will make the code for atomic
+			 operations much faster. The resulting code will not run
+			 on very old sparcs though."
+
+        AC_LINK_IFELSE([AC_LANG_SOURCE([[
+          main ()
+          {
+            int tmp1, tmp2, tmp3;
+            __asm__ __volatile__("casx [%2], %0, %1"
+                                 : "=&r" (tmp1), "=&r" (tmp2) : "r" (&tmp3));
+          }]])],
+          AC_MSG_RESULT([sparcv9])
+          AC_DEFINE_UNQUOTED(G_ATOMIC_SPARCV9, 1,
+			     [sparcv9 atomic implementation]),
+          AC_MSG_RESULT([no])
+          AC_MSG_WARN([[$SPARCV9_WARNING]]))
+        glib_memory_barrier_needed=yes
+        ;;
+      alpha*)
+        AC_MSG_RESULT([alpha])
+        AC_DEFINE_UNQUOTED(G_ATOMIC_ALPHA, 1,
+			   [alpha atomic implementation])
+        glib_memory_barrier_needed=yes
+        ;;
+      x86_64)
+        AC_MSG_RESULT([x86_64])
+        AC_DEFINE_UNQUOTED(G_ATOMIC_X86_64, 1,
+			   [x86_64 atomic implementation])
+        glib_memory_barrier_needed=no
+       ;;
+      powerpc*)
+        AC_MSG_RESULT([powerpc])
+        AC_DEFINE_UNQUOTED(G_ATOMIC_POWERPC, 1,
+			   [powerpc atomic implementation])
+        glib_memory_barrier_needed=yes
+        AC_MSG_CHECKING([whether asm supports numbered local labels])
+        AC_TRY_COMPILE(
+		       ,[
+		       __asm__ __volatile__ ("1:       nop\n"
+			       "         bne-    1b")
+		       ],[
+		       AC_DEFINE_UNQUOTED(ASM_NUMERIC_LABELS, 1, [define if asm blocks can use numeric local labels])
+		       AC_MSG_RESULT([yes])
+		       ],[
+		       AC_MSG_RESULT([no])
+		       ])
+        ;;
+      ia64)
+        AC_MSG_RESULT([ia64])
+        AC_DEFINE_UNQUOTED(G_ATOMIC_IA64, 1,
+			   [ia64 atomic implementation])
+        glib_memory_barrier_needed=yes
+        ;;
+      s390|s390x)
+        AC_MSG_RESULT([s390])
+        AC_DEFINE_UNQUOTED(G_ATOMIC_S390, 1,
+			   [s390 atomic implementation])
+        glib_memory_barrier_needed=no
+        ;;
+      arm*)
+        AC_MSG_RESULT([arm])
+        AC_DEFINE_UNQUOTED(G_ATOMIC_ARM, 1,
+			   [arm atomic implementation])
+        glib_memory_barrier_needed=no
+        ;;
+      crisv32*|etraxfs*)
+        AC_MSG_RESULT([crisv32])
+        AC_DEFINE_UNQUOTED(G_ATOMIC_CRISV32, 1,
+			   [crisv32 atomic implementation])
+        glib_memory_barrier_needed=no
+        ;;
+      cris*|etrax*)
+        AC_MSG_RESULT([cris])
+        AC_DEFINE_UNQUOTED(G_ATOMIC_CRIS, 1,
+			   [cris atomic implementation])
+        glib_memory_barrier_needed=no
+        ;;
+      *)
+        AC_MSG_RESULT([none])
+        glib_memory_barrier_needed=yes
+        ;;
+    esac
+
+glib_cv_gcc_has_builtin_atomic_operations=no
+if test x"$GCC" = xyes; then
+  AC_MSG_CHECKING([whether GCC supports built-in atomic intrinsics])
+  AC_TRY_LINK([],
+	      [int i;
+	       __sync_synchronize ();
+	       __sync_bool_compare_and_swap (&i, 0, 1);
+	       __sync_fetch_and_add (&i, 1);
+	      ],
+	      [glib_cv_gcc_has_builtin_atomic_operations=yes],
+	      [glib_cv_gcc_has_builtin_atomic_operations=no])
+
+  AC_MSG_RESULT($glib_cv_gcc_has_builtin_atomic_operations)
+fi
+
+AC_MSG_CHECKING([for Win32 atomic intrinsics])
+glib_cv_has_win32_atomic_operations=no
+AC_TRY_LINK([],
+	[int i; _InterlockedExchangeAdd (&i, 0);],
+	[glib_cv_has_win32_atomic_operations=yes],
+	[glib_cv_has_win32_atomic_operations=no])
+AC_MSG_RESULT($glib_cv_has_win32_atomic_operations)
+if test "x$glib_cv_has_win32_atomic_operations" = xyes; then
+	AC_DEFINE(HAVE_WIN32_BUILTINS_FOR_ATOMIC_OPERATIONS,1,[Have Win32 atomic intrinsics])
+fi
+
+dnl ************************
+dnl ** Check for futex(2) **
+dnl ************************
+AC_CACHE_CHECK(for futex(2) system call,
+    glib_cv_futex,AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
+#include <linux/futex.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+],[
+int
+main (void)
+{
+  /* it is not like this actually runs or anything... */
+  syscall (__NR_futex, NULL, FUTEX_WAKE, FUTEX_WAIT);
+  return 0;
+}
+])],glib_cv_futex=yes,glib_cv_futex=no))
+if test x"$glib_cv_futex" = xyes; then
+  AC_DEFINE(HAVE_FUTEX, 1, [we have the futex(2) system call])
+fi
+
+dnl this section will only be run if config.status is invoked with no
+dnl arguments, or with "$1/glibconfig.h" as an argument.
+AC_CONFIG_COMMANDS([$1/glibconfig.h],
+[
+	outfile=$1/glibconfig.h-tmp
+	cat > $outfile <<\_______EOF
+/* glibconfig.h
+ *
+ * This is a generated file.  Please modify 'configure.ac'
+ */
+
+#ifndef __G_LIBCONFIG_H__
+#define __G_LIBCONFIG_H__
+
+#include <glib/gmacros.h>
+
+_______EOF
+
+	if test x$glib_limits_h = xyes; then
+	  echo '#include <limits.h>' >> $outfile
+	fi
+	if test x$glib_float_h = xyes; then
+	  echo '#include <float.h>' >> $outfile
+	fi
+	if test x$glib_values_h = xyes; then
+	  echo '#include <values.h>' >> $outfile
+	fi
+	if test "$glib_header_alloca_h" = "yes"; then
+	  echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
+	fi
+	if test x$glib_sys_poll_h = xyes; then
+	  echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
+	fi
+	if test x$glib_included_printf != xyes; then
+          echo "
+/* Specifies that GLib's g_print*() functions wrap the
+ * system printf functions.  This is useful to know, for example,
+ * when using glibc's register_printf_function().
+ */" >> $outfile
+	  echo '#define GLIB_USING_SYSTEM_PRINTF' >> $outfile
+	fi
+
+	cat >> $outfile <<_______EOF
+
+G_BEGIN_DECLS
+
+#define G_MINFLOAT	$glib_mf
+#define G_MAXFLOAT	$glib_Mf
+#define G_MINDOUBLE	$glib_md
+#define G_MAXDOUBLE	$glib_Md
+#define G_MINSHORT	$glib_ms
+#define G_MAXSHORT	$glib_Ms
+#define G_MAXUSHORT	$glib_Mus
+#define G_MININT	$glib_mi
+#define G_MAXINT	$glib_Mi
+#define G_MAXUINT	$glib_Mui
+#define G_MINLONG	$glib_ml
+#define G_MAXLONG	$glib_Ml
+#define G_MAXULONG	$glib_Mul
+
+_______EOF
+
+
+	### this should always be true in a modern C/C++ compiler
+	cat >>$outfile <<_______EOF
+typedef signed char gint8;
+typedef unsigned char guint8;
+_______EOF
+
+
+	if test -n "$gint16"; then
+	  cat >>$outfile <<_______EOF
+typedef signed $gint16 gint16;
+typedef unsigned $gint16 guint16;
+#define G_GINT16_MODIFIER $gint16_modifier
+#define G_GINT16_FORMAT $gint16_format
+#define G_GUINT16_FORMAT $guint16_format
+_______EOF
+	fi
+
+
+	if test -n "$gint32"; then
+	  cat >>$outfile <<_______EOF
+typedef signed $gint32 gint32;
+typedef unsigned $gint32 guint32;
+#define G_GINT32_MODIFIER $gint32_modifier
+#define G_GINT32_FORMAT $gint32_format
+#define G_GUINT32_FORMAT $guint32_format
+_______EOF
+	fi
+
+	cat >>$outfile <<_______EOF
+#define G_HAVE_GINT64 1          /* deprecated, always true */
+
+${glib_extension}typedef signed $gint64 gint64;
+${glib_extension}typedef unsigned $gint64 guint64;
+
+#define G_GINT64_CONSTANT(val)	$gint64_constant
+#define G_GUINT64_CONSTANT(val)	$guint64_constant
+_______EOF
+
+	if test x$gint64_format != x ; then
+	  cat >>$outfile <<_______EOF
+#define G_GINT64_MODIFIER $gint64_modifier
+#define G_GINT64_FORMAT $gint64_format
+#define G_GUINT64_FORMAT $guint64_format
+_______EOF
+        else
+	  cat >>$outfile <<_______EOF
+#undef G_GINT64_MODIFIER
+#undef G_GINT64_FORMAT
+#undef G_GUINT64_FORMAT
+_______EOF
+        fi           
+
+        cat >>$outfile <<_______EOF
+
+#define GLIB_SIZEOF_VOID_P $glib_void_p
+#define GLIB_SIZEOF_LONG   $glib_long
+#define GLIB_SIZEOF_SIZE_T $glib_size_t
+
+_______EOF
+
+        cat >>$outfile <<_______EOF
+typedef signed $glib_size_type_define gssize;
+typedef unsigned $glib_size_type_define gsize;
+#define G_GSIZE_MODIFIER $gsize_modifier
+#define G_GSSIZE_FORMAT $gssize_format
+#define G_GSIZE_FORMAT $gsize_format
+
+#define G_MAXSIZE	G_MAXU$glib_msize_type
+#define G_MINSSIZE	G_MIN$glib_msize_type
+#define G_MAXSSIZE	G_MAX$glib_msize_type
+
+typedef gint64 goffset;
+#define G_MINOFFSET	G_MININT64
+#define G_MAXOFFSET	G_MAXINT64
+
+#define G_GOFFSET_MODIFIER      G_GINT64_MODIFIER
+#define G_GOFFSET_FORMAT        G_GINT64_FORMAT
+#define G_GOFFSET_CONSTANT(val) G_GINT64_CONSTANT(val)
+
+_______EOF
+
+	if test -z "$glib_unknown_void_p"; then
+	  cat >>$outfile <<_______EOF
+
+#define GPOINTER_TO_INT(p)	((gint)  ${glib_gpi_cast} (p))
+#define GPOINTER_TO_UINT(p)	((guint) ${glib_gpui_cast} (p))
+
+#define GINT_TO_POINTER(i)	((gpointer) ${glib_gpi_cast} (i))
+#define GUINT_TO_POINTER(u)	((gpointer) ${glib_gpui_cast} (u))
+
+typedef signed $glib_intptr_type_define gintptr;
+typedef unsigned $glib_intptr_type_define guintptr;
+
+#define G_GINTPTR_MODIFIER      $gintptr_modifier
+#define G_GINTPTR_FORMAT        $gintptr_format
+#define G_GUINTPTR_FORMAT       $guintptr_format
+_______EOF
+	else
+	  echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
+	fi
+
+
+
+	cat >>$outfile <<_______EOF
+$glib_atexit
+$glib_memmove
+$glib_defines
+$glib_os
+$glib_static_compilation
+
+$glib_vacopy
+
+#ifdef	__cplusplus
+#define	G_HAVE_INLINE	1
+#else	/* !__cplusplus */
+$glib_inline
+#endif	/* !__cplusplus */
+
+#ifdef	__cplusplus
+#define G_CAN_INLINE	1
+_______EOF
+
+	if test x$g_can_inline = xyes ; then
+		cat >>$outfile <<_______EOF
+#else	/* !__cplusplus */
+#define G_CAN_INLINE	1
+_______EOF
+	fi
+
+	cat >>$outfile <<_______EOF
+#endif
+
+_______EOF
+
+	if test x$g_have_iso_c_varargs = xyes ; then
+		cat >>$outfile <<_______EOF
+#ifndef __cplusplus
+# define G_HAVE_ISO_VARARGS 1
+#endif
+_______EOF
+	fi
+	if test x$g_have_iso_cxx_varargs = xyes ; then
+		cat >>$outfile <<_______EOF
+#ifdef __cplusplus
+# define G_HAVE_ISO_VARARGS 1
+#endif
+_______EOF
+	fi
+	if test x$g_have_gnuc_varargs = xyes ; then
+		cat >>$outfile <<_______EOF
+
+/* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
+ * is passed ISO vararg support is turned off, and there is no work
+ * around to turn it on, so we unconditionally turn it off.
+ */
+#if __GNUC__ == 2 && __GNUC_MINOR__ == 95
+#  undef G_HAVE_ISO_VARARGS
+#endif
+
+#define G_HAVE_GNUC_VARARGS 1
+_______EOF
+	fi
+
+	echo >>$outfile
+	if test x$g_have_eilseq = xno; then
+		cat >>$outfile <<_______EOF
+#ifndef EILSEQ
+/* On some systems, like SunOS and NetBSD, EILSEQ is not defined.
+ * The correspondence between this and the corresponding definition
+ * in libiconv is essential.
+ */
+#  define EILSEQ ENOENT
+#endif
+_______EOF
+
+	fi
+
+	if test x$g_have_gnuc_visibility = xyes; then
+		cat >>$outfile <<_______EOF
+#define G_HAVE_GNUC_VISIBILITY 1
+_______EOF
+	fi
+		cat >>$outfile <<_______EOF
+#if defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
+#define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
+#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
+#define G_GNUC_INTERNAL __hidden
+#elif defined (__GNUC__) && defined (G_HAVE_GNUC_VISIBILITY)
+#define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
+#else
+#define G_GNUC_INTERNAL
+#endif 
+_______EOF
+
+
+	echo >>$outfile
+	if test x$g_mutex_has_default = xyes; then
+		cat >>$outfile <<_______EOF
+$g_enable_threads_def G_THREADS_ENABLED
+#define G_THREADS_IMPL_$g_threads_impl_def
+typedef struct _GStaticMutex GStaticMutex;
+struct _GStaticMutex
+{
+  struct _GMutex *runtime_mutex;
+  union {
+    char   pad[[$g_mutex_sizeof]];
+    double dummy_double;
+    void  *dummy_pointer;
+    long   dummy_long;
+  } static_mutex;
+};
+#define	G_STATIC_MUTEX_INIT	{ NULL, { { $g_mutex_contents} } }
+#define	g_static_mutex_get_mutex(mutex) \\
+  (g_thread_use_default_impl ? ((GMutex*)(gpointer) ((mutex)->static_mutex.pad)) : \\
+   g_static_mutex_get_mutex_impl_shortcut (&((mutex)->runtime_mutex)))
+_______EOF
+	else
+		cat >>$outfile <<_______EOF
+$g_enable_threads_def G_THREADS_ENABLED
+#define G_THREADS_IMPL_$g_threads_impl_def
+typedef struct _GMutex* GStaticMutex;
+#define G_STATIC_MUTEX_INIT NULL
+#define g_static_mutex_get_mutex(mutex) \\
+  (g_static_mutex_get_mutex_impl_shortcut (mutex))
+_______EOF
+	fi
+
+	cat >>$outfile <<_______EOF
+/* This represents a system thread as used by the implementation. An
+ * alien implementaion, as loaded by g_thread_init can only count on
+ * "sizeof (gpointer)" bytes to store their info. We however need more
+ * for some of our native implementations. */
+typedef union _GSystemThread GSystemThread;
+union _GSystemThread
+{
+  char   data[[$g_system_thread_sizeof]];
+  double dummy_double;
+  void  *dummy_pointer;
+  long   dummy_long;
+};
+_______EOF
+	if test x"$g_memory_barrier_needed" != xno; then
+	  echo >>$outfile
+	  echo "#define G_ATOMIC_OP_MEMORY_BARRIER_NEEDED 1" >>$outfile
+	fi
+	if test x"$g_gcc_atomic_ops" != xno; then
+          echo >>$outfile
+          echo "#define G_ATOMIC_OP_USE_GCC_BUILTINS 1" >>$outfile
+        fi
+	echo >>$outfile
+	g_bit_sizes="16 32 64"
+	for bits in $g_bit_sizes; do
+	  cat >>$outfile <<_______EOF
+#define GINT${bits}_TO_${g_bs_native}(val)	((gint${bits}) (val))
+#define GUINT${bits}_TO_${g_bs_native}(val)	((guint${bits}) (val))
+#define GINT${bits}_TO_${g_bs_alien}(val)	((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
+#define GUINT${bits}_TO_${g_bs_alien}(val)	(GUINT${bits}_SWAP_LE_BE (val))
+_______EOF
+	done
+
+	cat >>$outfile <<_______EOF
+#define GLONG_TO_LE(val)	((glong) GINT${glongbits}_TO_LE (val))
+#define GULONG_TO_LE(val)	((gulong) GUINT${glongbits}_TO_LE (val))
+#define GLONG_TO_BE(val)	((glong) GINT${glongbits}_TO_BE (val))
+#define GULONG_TO_BE(val)	((gulong) GUINT${glongbits}_TO_BE (val))
+#define GINT_TO_LE(val)		((gint) GINT${gintbits}_TO_LE (val))
+#define GUINT_TO_LE(val)	((guint) GUINT${gintbits}_TO_LE (val))
+#define GINT_TO_BE(val)		((gint) GINT${gintbits}_TO_BE (val))
+#define GUINT_TO_BE(val)	((guint) GUINT${gintbits}_TO_BE (val))
+#define GSIZE_TO_LE(val)	((gsize) GUINT${gsizebits}_TO_LE (val))
+#define GSSIZE_TO_LE(val)	((gssize) GINT${gsizebits}_TO_LE (val))
+#define GSIZE_TO_BE(val)	((gsize) GUINT${gsizebits}_TO_BE (val))
+#define GSSIZE_TO_BE(val)	((gssize) GINT${gsizebits}_TO_BE (val))
+#define G_BYTE_ORDER $g_byte_order
+
+#define G_MODULE_SUFFIX "$g_module_suffix"
+
+/* A GPid is an abstraction for a process "handle". It is *not* an
+ * abstraction for a process identifier in general. GPid is used in
+ * GLib only for descendant processes spawned with the g_spawn*
+ * functions. On POSIX there is no "process handle" concept as such,
+ * but on Windows a GPid is a handle to a process, a kind of pointer,
+ * not a process identifier.
+ */
+typedef $g_pid_type GPid;
+
+G_END_DECLS
+
+#endif /* GLIBCONFIG_H */
+_______EOF
+
+
+	if cmp -s $outfile $1/glibconfig.h; then
+	  AC_MSG_NOTICE([$1/glibconfig.h is unchanged])
+	  rm -f $outfile
+	else
+	  mv $outfile $1/glibconfig.h
+	fi
+],[
+
+# Note that if two cases are the same, case goes with the first one.
+# Note also that this is inside an AC_OUTPUT_COMMAND.  We do not depend
+# on variable expansion in case labels.  Look at the generated config.status
+# for a hint.
+
+if test "x${ac_cv_working_alloca_h+set}" = xset ; then
+  glib_header_alloca_h="$ac_cv_working_alloca_h"
+else
+  glib_header_alloca_h="$ac_cv_header_alloca_h"
+fi
+
+case xyes in
+x$ac_cv_header_float_h)
+  glib_float_h=yes
+  glib_mf=FLT_MIN glib_Mf=FLT_MAX
+  glib_md=DBL_MIN glib_Md=DBL_MAX
+  ;;
+x$ac_cv_header_values_h)
+  glib_values_h=yes
+  glib_mf=MINFLOAT  glib_Mf=MAXFLOAT
+  glib_md=MINDOUBLE glib_Md=MAXDOUBLE
+  ;;
+esac
+
+case xyes in
+x$ac_cv_header_limits_h)
+  glib_limits_h=yes
+  glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
+  glib_mi=INT_MIN  glib_Mi=INT_MAX  glib_Mui=UINT_MAX
+  glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
+  ;;
+x$ac_cv_header_values_h)
+  glib_values_h=yes
+  glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
+  glib_mi=MININT   glib_Mi=MAXINT   glib_Mui="(((guint)G_MAXINT)*2+1)"
+  glib_ml=MINLONG  glib_Ml=MAXLONG  glib_Mul="(((gulong)G_MAXLONG)*2+1)"
+  ;;
+esac
+
+if test x$ac_cv_header_sys_poll_h = xyes ; then
+  glib_sys_poll_h=yes
+fi
+
+if test x$enable_included_printf = xyes ; then
+  glib_included_printf=yes
+fi
+
+case x2 in
+x$ac_cv_sizeof_short)		
+  gint16=short
+  gint16_modifier='"h"'
+  gint16_format='"hi"'
+  guint16_format='"hu"'
+  ;;
+x$ac_cv_sizeof_int)		
+  gint16=int
+  gint16_modifier='""'
+  gint16_format='"i"'
+  guint16_format='"u"'
+  ;;
+esac
+case x4 in
+x$ac_cv_sizeof_short)		
+  gint32=short
+  gint32_modifier='"h"'
+  gint32_format='"hi"'
+  guint32_format='"hu"'
+  ;;
+x$ac_cv_sizeof_int)		
+  gint32=int
+  gint32_modifier='""'
+  gint32_format='"i"'
+  guint32_format='"u"'
+  ;;
+x$ac_cv_sizeof_long)		
+  gint32=long
+  gint32_modifier='"l"'
+  gint32_format='"li"'
+  guint32_format='"lu"'
+  ;;
+esac
+case x8 in
+x$ac_cv_sizeof_int)
+  gint64=int
+  gint64_modifier='""'
+  gint64_format='"i"'
+  guint64_format='"u"'
+  glib_extension=
+  gint64_constant='(val)'
+  guint64_constant='(val)'
+  ;;
+x$ac_cv_sizeof_long)
+  gint64=long
+  gint64_modifier='"l"'
+  gint64_format='"li"'
+  guint64_format='"lu"'
+  glib_extension=
+  gint64_constant='(val##L)'
+  guint64_constant='(val##UL)'
+  ;;
+x$ac_cv_sizeof_long_long)
+  gint64='long long'
+  if test -n "$glib_cv_long_long_format"; then
+    gint64_modifier='"'$glib_cv_long_long_format'"'
+    gint64_format='"'$glib_cv_long_long_format'i"'
+    guint64_format='"'$glib_cv_long_long_format'u"'
+  fi
+  glib_extension='G_GNUC_EXTENSION '
+  gint64_constant='(G_GNUC_EXTENSION (val##LL))'
+  guint64_constant='(G_GNUC_EXTENSION (val##ULL))'
+  ;;
+x$ac_cv_sizeof___int64)
+  gint64='__int64'
+  if test -n "$glib_cv_long_long_format"; then
+    gint64_modifier='"'$glib_cv_long_long_format'"'
+    gint64_format='"'$glib_cv_long_long_format'i"'
+    guint64_format='"'$glib_cv_long_long_format'u"'
+  fi
+  glib_extension=
+  gint64_constant='(val##i64)'
+  guint64_constant='(val##ui64)'
+  ;;
+esac
+glib_size_t=$ac_cv_sizeof_size_t
+glib_size_type_define="$glib_size_type"
+glib_void_p=$ac_cv_sizeof_void_p
+glib_long=$ac_cv_sizeof_long
+
+case "$glib_size_type" in
+short)
+  gsize_modifier='"h"'
+  gsize_format='"hu"'
+  gssize_format='"hi"'
+  glib_msize_type='SHRT'
+  ;;
+int)
+  gsize_modifier='""'
+  gsize_format='"u"'
+  gssize_format='"i"'
+  glib_msize_type='INT'
+  ;;
+long)
+  gsize_modifier='"l"'
+  gsize_format='"lu"'
+  gssize_format='"li"'
+  glib_msize_type='LONG'
+  ;;
+"long long"|__int64)
+  gsize_modifier='"I64"'
+  gsize_format='"I64u"'
+  gssize_format='"I64i"'
+  glib_msize_type='INT64'
+  ;;
+esac
+
+gintbits=`expr $ac_cv_sizeof_int \* 8 2>/dev/null`
+glongbits=`expr $ac_cv_sizeof_long \* 8 2>/dev/null`
+gsizebits=`expr $ac_cv_sizeof_size_t \* 8 2>/dev/null`
+
+case x"$ac_cv_sizeof_void_p" in
+x$ac_cv_sizeof_int)
+  glib_intptr_type_define=int
+  gintptr_modifier='""'
+  gintptr_format='"i"'
+  guintptr_format='"u"'
+  glib_gpi_cast=''
+  glib_gpui_cast=''
+  ;;
+x$ac_cv_sizeof_long)
+  glib_intptr_type_define=long
+  gintptr_modifier='"l"'
+  gintptr_format='"li"'
+  guintptr_format='"lu"'
+  glib_gpi_cast='(glong)'
+  glib_gpui_cast='(gulong)'
+  ;;
+x$ac_cv_sizeof_long_long)
+  glib_intptr_type_define='long long'
+  gintptr_modifier='"I64"'
+  gintptr_format='"I64i"'
+  guintptr_format='"I64u"'
+  glib_gpi_cast='(gint64)'
+  glib_gpui_cast='(guint64)'
+  ;;
+x$ac_cv_sizeof___int64)
+  glib_intptr_type_define=__int64
+  gintptr_modifier='"I64"'
+  gintptr_format='"I64i"'
+  guintptr_format='"I64u"'
+  glib_gpi_cast='(gint64)'
+  glib_gpui_cast='(guint64)'
+  ;;
+*)
+  glib_unknown_void_p=yes
+  ;;
+esac
+
+
+case xyes in
+x$ac_cv_func_atexit)
+  glib_atexit="
+#ifdef NeXT /* @#%@! NeXTStep */
+# define g_ATEXIT(proc)	(!atexit (proc))
+#else
+# define g_ATEXIT(proc)	(atexit (proc))
+#endif"
+  ;;
+x$ac_cv_func_on_exit)
+  glib_atexit="
+#define g_ATEXIT(proc)	(on_exit ((void (*)(int, void*))(proc), NULL))"
+  ;;
+esac
+
+case xyes in
+x$ac_cv_func_memmove)
+  glib_memmove='
+#define g_memmove(dest,src,len) G_STMT_START { memmove ((dest), (src), (len)); } G_STMT_END'
+  ;;
+x$glib_cv_working_bcopy)
+  glib_memmove="
+/* memmove isn't available, but bcopy can copy overlapping memory regions */
+#define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
+  ;;
+*)  
+  glib_memmove="
+/* memmove isn't found and bcopy can't copy overlapping memory regions, 
+ * so we have to roll our own copy routine. */
+void g_memmove (void* dest, const void * src, unsigned long len);"
+  ;;
+esac
+
+glib_defines="
+#define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
+#define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
+#define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
+"
+
+case xyes in
+x$glib_cv_va_copy)	glib_vacopy='#define G_VA_COPY	va_copy' ;;
+x$glib_cv___va_copy)	glib_vacopy='#define G_VA_COPY	__va_copy' ;;
+*)			glib_vacopy=''
+esac
+
+if test x$glib_cv_va_val_copy = xno; then
+  glib_vacopy="\$glib_vacopy
+#define G_VA_COPY_AS_ARRAY 1"
+fi
+
+if test x$glib_cv_hasinline = xyes; then
+    glib_inline='#define G_HAVE_INLINE 1'
+fi
+if test x$glib_cv_has__inline = xyes; then
+    glib_inline="\$glib_inline
+#define G_HAVE___INLINE 1"
+fi
+if test x$glib_cv_has__inline__ = xyes; then
+    glib_inline="\$glib_inline
+#define G_HAVE___INLINE__ 1"
+fi
+
+g_have_gnuc_varargs=$g_have_gnuc_varargs
+g_have_iso_c_varargs=$g_have_iso_c_varargs
+g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
+
+g_can_inline=$g_can_inline
+g_have_gnuc_visibility=$g_have_gnuc_visibility
+g_have_sunstudio_visibility=$g_have_sunstudio_visibility
+
+if test x$ac_cv_c_bigendian = xyes; then
+  g_byte_order=G_BIG_ENDIAN
+  g_bs_native=BE
+  g_bs_alien=LE
+else
+  g_byte_order=G_LITTLE_ENDIAN
+  g_bs_native=LE
+  g_bs_alien=BE
+fi
+
+g_pollin=$glib_cv_value_POLLIN
+g_pollout=$glib_cv_value_POLLOUT
+g_pollpri=$glib_cv_value_POLLPRI
+g_pollhup=$glib_cv_value_POLLHUP
+g_pollerr=$glib_cv_value_POLLERR
+g_pollnval=$glib_cv_value_POLLNVAL
+
+g_af_unix=$glib_cv_value_AF_UNIX
+g_af_inet=$glib_cv_value_AF_INET
+g_af_inet6=$glib_cv_value_AF_INET6
+
+g_msg_peek=$glib_cv_value_MSG_PEEK
+g_msg_oob=$glib_cv_value_MSG_OOB
+g_msg_dontroute=$glib_cv_value_MSG_DONTROUTE
+
+g_have_eilseq=$have_eilseq
+
+case x$have_threads in
+xno)	g_enable_threads_def="#undef";;
+*)	g_enable_threads_def="#define";;
+esac
+
+g_threads_impl_def=$g_threads_impl
+
+g_mutex_has_default="$mutex_has_default"
+g_mutex_sizeof="$glib_cv_sizeof_gmutex"
+g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
+g_mutex_contents="$glib_cv_byte_contents_gmutex"
+
+g_memory_barrier_needed="$glib_memory_barrier_needed"
+g_gcc_atomic_ops="$glib_cv_gcc_has_builtin_atomic_operations"
+
+g_module_suffix="$glib_gmodule_suffix"
+
+g_pid_type="$glib_pid_type"
+case $host in
+  *-*-beos*)
+    glib_os="#define G_OS_BEOS"
+    ;;
+  *-*-cygwin*)
+    glib_os="#define G_OS_UNIX
+#define G_PLATFORM_WIN32
+#define G_WITH_CYGWIN"
+    ;;
+  *-*-mingw*)
+    glib_os="#define G_OS_WIN32
+#define G_PLATFORM_WIN32"
+    ;;
+  *)
+    glib_os="#define G_OS_UNIX"
+    ;;
+esac
+glib_static_compilation=""
+if test x$glib_win32_static_compilation = xyes; then
+  glib_static_compilation="#define GLIB_STATIC_COMPILATION 1
+#define GOBJECT_STATIC_COMPILATION 1"
+fi
+])dnl AC_CONFIG_COMMANDS
+
+])dnl AC_DEFUN