Attachment #87368 for bug #133818




# 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




# init autoconf (and check for presence of glist.c)
AC_INIT(glist.c)

AC_CANONICAL_TARGET
# Save this value here, since automake will set cflags later
cflags_set=${CFLAGS+set}

# we rewrite this file
rm -f glibconfig-sysdefs.h

GLIB_AC_DIVERT_BEFORE_HELP([
dnl are available for $ac_help expansion (don't we all *love* autoconf?)
AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)dnl
#
# The following version number definitions apply to GLib, GModule and GThread
# as a whole, so if changes occoured in any of them, they are all

GLIB_MICRO_VERSION=10
GLIB_INTERFACE_AGE=10
GLIB_BINARY_AGE=10
GLIB_VERSION="$GLIB_MAJOR_VERSION.$GLIB_MINOR_VERSION.$GLIB_MICRO_VERSION"
])
AC_DIVERT_POP()dnl

AC_SUBST(GLIB_MAJOR_VERSION)
AC_SUBST(GLIB_MINOR_VERSION)

AC_SUBST(GLIB_BINARY_AGE)

# libtool versioning
LT_RELEASE="$GLIB_MAJOR_VERSION.$GLIB_MINOR_VERSION"
LT_CURRENT=`expr $GLIB_MICRO_VERSION - $GLIB_INTERFACE_AGE`
LT_REVISION="$GLIB_INTERFACE_AGE"
LT_AGE=`expr $GLIB_BINARY_AGE - $GLIB_INTERFACE_AGE`
AC_SUBST(LT_RELEASE)
AC_SUBST(LT_CURRENT)
AC_SUBST(LT_REVISION)
AC_SUBST(LT_AGE)

VERSION="$GLIB_VERSION"
PACKAGE="glib"

AM_INIT_AUTOMAKE($PACKAGE, $VERSION, no-define)


AC_DEFINE_UNQUOTED(GLIB_BINARY_AGE, $GLIB_BINARY_AGE)

dnl Initialize libtool
AC_PROG_LIBTOOL

dnl Initialize maintainer mode
AM_MAINTAINER_MODE

AC_CANONICAL_HOST

dnl figure debugging default, prior to $ac_help setup
dnl
GLIB_AC_DIVERT_BEFORE_HELP([
if test `expr $GLIB_MINOR_VERSION \% 2` = 1 ; then
	debug_default="yes"
else
	debug_default="minimum"
fi
])

dnl declare --enable-* args and collect ac_help strings
AC_ARG_ENABLE(debug, [  --enable-debug=[no/minimum/yes] turn on debugging [default=$debug_default]],,
	enable_debug="$debug_default")
AC_ARG_ENABLE(mem_check, [  --enable-mem-check      turn on malloc/free sanity checking (not recommended) [default=no]],,
	enable_mem_check="no")
AC_ARG_ENABLE(mem_profile, [  --enable-mem-profile    turn on malloc profiling atexit (not recommended) [default=no]],,
	enable_mem_profile="no")
AC_ARG_ENABLE(ansi, [  --enable-ansi           turn on strict ansi [default=no]],,enable_ansi="no")
AC_ARG_ENABLE(threads, [  --enable-threads        turn on basic thread support [default=yes]
                          ([=no] will override --with-threads)],,enable_threads="yes")

if test "x$enable_threads" != "xyes"; then
  enable_threads="no"
fi

mem_warn="false"

AC_MSG_CHECKING(whether to enable memory checking)
if test "x$enable_mem_check" = "xyes"; then
  AC_DEFINE(ENABLE_MEM_CHECK, 1)
  AC_SUBST(ENABLE_MEM_CHECK)
  AC_MSG_RESULT(yes)
  mem_warn="true"
else
  AC_MSG_RESULT(no)
fi

  AC_DEFINE(ENABLE_MEM_PROFILE, 1)
  AC_SUBST(ENABLE_MEM_PROFILE)
  AC_MSG_RESULT(yes)
  mem_warn="true"
else
  AC_MSG_RESULT(no)
fi

if test "$mem_warn" = "true"; then

if $mem_warn ; then
  AC_MSG_WARN([
**********************************************************************
 You have specified --enable-mem-profile or --enable-mem-check. 

fi

if test "x$enable_debug" = "xyes"; then
  test "$cflags_set" = "set" || CFLAGS="$CFLAGS -g"
  GLIB_DEBUG_FLAGS="-DG_ENABLE_DEBUG"
else
  if test "x$enable_debug" = "xno"; then


dnl DU4 native cc currently needs -std1 for ANSI mode (instead of K&R)
AC_MSG_CHECKING([for extra flags to get ANSI library prototypes])
glib_save_LIBS="$LIBS"
LIBS="$LIBS -lm"

AC_TRY_RUN([#include <math.h>
             int main (void) { return (log(1) != log(1.)); }],
     AC_MSG_RESULT(none needed),
	glib_save_CFLAGS="$CFLAGS"
     CFLAGS="$CFLAGS -std1"
	[AC_TRY_RUN([#include <math.h>
                 int main (void) { return (log(1) != log(1.)); }],
         AC_MSG_RESULT(-std1),
         AC_MSG_RESULT()
		CFLAGS="$glib_save_CFLAGS"
         AC_MSG_WARN(
                [No ANSI prototypes found in library. (-std1 didn't work.)])
  )]
     )
LIBS="$glib_save_LIBS"
LIBS=$glib_save_LIBS

dnl NeXTStep cc seems to need this
AC_MSG_CHECKING([for extra flags for POSIX compliance])
AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
  AC_MSG_RESULT(none needed),
	glib_save_CFLAGS="$CFLAGS"
  CFLAGS="$CFLAGS -posix"
	[AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
    AC_MSG_RESULT(-posix),
    AC_MSG_RESULT()
		CFLAGS="$glib_save_CFLAGS"
		AC_MSG_WARN([Could not determine POSIX flag. (-posix didn't work.)])
    
	)]
)

# Checks for header files.
AC_HEADER_STDC

dnl truely know which ones of `inline', `__inline' and `__inline__' are
dnl actually supported.
AC_MSG_CHECKING(for __inline)
AC_CACHE_VAL(glib_cv_has__inline,
	[AC_TRY_RUN([
	__inline int foo () { return 0; }
		int main () { return foo (); }],
		glib_cv_has__inline="yes",
		glib_cv_has__inline="no"
	)]
)
        ,)
])
AC_MSG_RESULT($glib_cv_has__inline)

case "x$glib_cv_has__inline" in
xyes) AC_DEFINE(G_HAVE___INLINE)
esac

AC_MSG_CHECKING(for __inline__)
AC_CACHE_VAL(glib_cv_has__inline__,
	[AC_TRY_RUN([
	__inline__ int foo () { return 0; }
		int main () { return foo (); }],
		glib_cv_has__inline__="yes",
		glib_cv_has__inline__="no"
	)]
)
        ,)
])
AC_MSG_RESULT($glib_cv_has__inline__)

case "x$glib_cv_has__inline__" in
xyes) AC_DEFINE(G_HAVE___INLINE__)
esac

AC_MSG_CHECKING(for inline)
AC_CACHE_VAL(glib_cv_hasinline,
	[AC_TRY_RUN(
		[inline int foo () { return 0; }
		int main () { return foo (); }],
		glib_cv_hasinline="yes",
		glib_cv_hasinline="no"
	)]
)
        ,)
])
AC_MSG_RESULT($glib_cv_hasinline)

case "x$glib_cv_hasinline" in
xyes) AC_DEFINE(G_HAVE_INLINE)
esac



# 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)
fi

# Check for sys_siglist
AC_MSG_CHECKING(for sys_siglist)
AC_TRY_LINK(,
	[extern char *sys_siglist[];
	exit (sys_siglist[0]);],
	glib_ok="yes",
	glib_ok="no")
AC_MSG_RESULT($glib_ok)

if test "$glib_ok" = "no"; then
    AC_DEFINE(NO_SYS_SIGLIST)
fi

# Check for sys_siglist decl (see Tue Jan 19 00:44:24 1999 in changelog)
AC_MSG_CHECKING(for sys_siglist declaration)
AC_TRY_COMPILE(
	[#include <signal.h>
	],[strlen (sys_siglist[0]);],
	glib_ok="yes",
	glib_ok="no")
AC_MSG_RESULT($glib_ok)

if test "$glib_ok" = "no"; then
    AC_DEFINE(NO_SYS_SIGLIST_DECL)
fi

# Check if <sys/select.h> needs to be included for fd_set
AC_MSG_CHECKING([for fd_set])
AC_TRY_COMPILE([#include <sys/types.h>
	],[fd_set readMask, writeMask;],
	gtk_ok="yes",
	gtk_ok="no")

if test "$gtk_ok" = "yes"; then
    AC_MSG_RESULT([yes, found in sys/types.h])
else
	AC_HEADER_EGREP(fd_mask, sys/select.h, gtk_ok="yes")
	if test "$gtk_ok" = "yes"; then
        AC_DEFINE(HAVE_SYS_SELECT_H)
        AC_MSG_RESULT([yes, found in sys/select.h])
    else

# Check for wchar.h

AC_MSG_CHECKING(for wchar.h)
AC_TRY_CPP([#include <wchar.h>
	],glib_wchar_h="yes",
	glib_wchar_h="no")

if test "$glib_wchar_h" = "yes"; then
   AC_DEFINE(HAVE_WCHAR_H)
fi
AC_MSG_RESULT($glib_wchar_h)


AC_MSG_CHECKING(for wctype.h)
AC_TRY_CPP([#include <wctype.h>], glib_wctype_h=yes, glib_wctype_h=no)
if test "$glib_wctype_h" = "yes"; then
   AC_DEFINE(HAVE_WCTYPE_H)
fi
AC_MSG_RESULT($glib_wctype_h)


# The following is necessary for Linux libc-5.4.38
AC_MSG_CHECKING(if iswalnum() and friends are properly defined)
AC_TRY_LINK([#include <stdlib.h>
	],[#if (defined(HAVE_WCTYPE_H) || defined(HAVE_WCHAR_H))
#  ifdef HAVE_WCTYPE_H
#    include <wctype.h>
#  else

#else
#  define iswalnum(c) ((wchar_t)(c) <= 0xFF && isalnum(c))
#endif
	iswalnum((wchar_t) 0);],
	glib_working_wctype="yes",
	glib_working_wctype="no"
)

LIBS="$oLIBS"

if test "$glib_working_wctype" = "no"; then
   AC_DEFINE(HAVE_BROKEN_WCTYPE)
fi
AC_MSG_RESULT($glib_working_wctype)

dnl *** check for sane realloc() ***
AC_MSG_CHECKING(whether realloc (NULL,) will work)
AC_CACHE_VAL(glib_cv_sane_realloc,
	[AC_TRY_RUN([#include <stdlib.h>
	#include <stdlib.h>
	int main() {
	  return realloc (0, sizeof (int)) == 0;
	}],
		glib_cv_sane_realloc="yes",
		glib_cv_sane_realloc="no"
	)]
)
if test "$glib_cv_sane_realloc" = "yes"; then
	AC_DEFINE(REALLOC_0_WORKS)
fi	
	glib_cv_sane_realloc=no
	,)
])
AC_MSG_RESULT($glib_cv_sane_realloc)



dnl we currently check for all three va_copy possibilities, so we get
dnl all results in config.log for bug reports.
AC_MSG_CHECKING(for an implementation of va_copy())
AC_CACHE_VAL(glib_cv_va_copy,
	[AC_TRY_RUN([#include <stdarg.h>
	#include <stdarg.h>
	void f (int i, ...) {
	va_list args1, args2;
	va_start (args1, i);

	  f (0, 42);
	  return 0;
	}],
		glib_cv_va_copy="yes",
		glib_cv_va_copy="no"
	)]
	
)
AC_MSG_RESULT($glib_cv_va_copy)
AC_MSG_CHECKING(for an implementation of __va_copy())
AC_CACHE_VAL(glib_cv___va_copy,[
	AC_TRY_RUN([#include <stdarg.h>
	#include <stdarg.h>
	void f (int i, ...) {
	va_list args1, args2;
	va_start (args1, i);

	  f (0, 42);
	  return 0;
	}],
		glib_cv___va_copy="yes",
		glib_cv___va_copy="no"
	)]
)
])
AC_MSG_RESULT($glib_cv___va_copy)
AC_MSG_CHECKING([whether va_lists can be copied by value])
AC_CACHE_VAL(glib_cv_va_val_copy,
	[AC_TRY_RUN(
		[#include <stdarg.h>
	void f (int i, ...) {
	va_list args1, args2;
	va_start (args1, i);

	  f (0, 42);
	  return 0;
	}],
		glib_cv_va_val_copy="yes",
		glib_cv_va_val_copy="no",
	)]	
)

if test "x$glib_cv_va_copy" = "xyes"; then
  AC_DEFINE(G_VA_COPY, va_copy)
else
	if test "x$glib_cv___va_copy" = "xyes"; then
  AC_DEFINE(G_VA_COPY, __va_copy)
fi
fi

if test "x$glib_cv_va_val_copy" = "xno"; then
  AC_DEFINE(G_VA_COPY_AS_ARRAY)
fi
AC_MSG_RESULT($glib_cv_va_val_copy)


dnl ***********************
dnl *** g_module checks ***
dnl ***********************

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 *** 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")])
			G_MODULE_IMPL=G_MODULE_IMPL_DL
		,)
	,)
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

        SAVED_LDFLAGS=$LDFLAGS
        LDFLAGS="$LDFLAGS -Wl,-E"
        AC_TRY_LINK(,[ return 0; ],
    [G_MODULE_LDFLAGS="-Wl,-E"],
		[LDFLAGS="$SAVED_LDFLAGS -bexpall"
                AC_TRY_LINK(,[ return 0; ],
                        G_MODULE_LDFLAGS="-bexpall",
                        G_MODULE_LDFLAGS="none"
    )]
                )
  LDFLAGS="$SAVED_LDFLAGS"
        LDFLAGS=$SAVED_LDFLAGS
        AC_MSG_RESULT($G_MODULE_LDFLAGS)
        if test "x$G_MODULE_LDFLAGS" = "xnone"; then
                G_MODULE_LDFLAGS=
        fi
	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
	case "$host_os" in
	  linux*)
	    G_MODULE_LDFLAGS="-rdynamic"
	    ;;
	esac
	LIBS_orig="$LIBS"

	LDFLAGS="$LDFLAGS $G_MODULE_LDFLAGS"
dnl *** check for OSF1/5.0 RTLD_GLOBAL brokenness
        AC_CACHE_CHECK([for RTLD_GLOBAL brokenness],
		glib_cv_rtldglobal_broken,
		[AC_TRY_RUN([#include<dlfcn.h>
                #include <dlfcn.h>
                #ifndef RTLD_GLOBAL
                #define RTLD_GLOBAL 0
                #endif

                local = dlsym (handle, "pthread_create");
                return global == local;
                }],
		[glib_cv_rtldglobal_broken="no"],
		[glib_cv_rtldglobal_broken="yes"],
                        [])
                rm -f plugin.c plugin.o plugin.lo
        ])

        fi
dnl *** check whether we need preceeding underscores
	AC_MSG_CHECKING(for preceeding underscore in symbols)
	AC_CACHE_VAL(glib_cv_uscore,
		[AC_TRY_RUN([#include <dlfcn.h>
		#include <dlfcn.h>
                int glib_underscore_test (void) { return 42; }
		int main() {
		  void *f1 = (void*)0, *f2 = (void*)0, *handle;

		    f2 = dlsym (handle, "_glib_underscore_test");
		  } return (!f2 || f1);
		}],
			glib_cv_uscore="yes",
			glib_cv_uscore="no"
		)
		rm -f plugin.c plugin.o plugin.lo
	])


	LDFLAGS="$LDFLAGS_orig"
dnl *** check for having dlerror()
	AC_CHECK_FUNC(dlerror,G_MODULE_HAVE_DLERROR=1,G_MODULE_HAVE_DLERROR=0)
		G_MODULE_HAVE_DLERROR=1,
		G_MODULE_HAVE_DLERROR=0)
	LIBS="$LIBS_orig"
fi
dnl *** done, have e got an implementation?

dnl ***********************

AC_ARG_WITH(threads, [  --with-threads=[none/posix/solaris/nspr] specify a thread implementation to use],
	if test "x$with_threads" = "x"; then
		want_threads="yes"
	else
		want_threads="$with_threads"
	fi,
	want_threads="yes")
if test "x$enable_threads" = "xno"; then
        want_threads="no"
fi
if test "x$want_threads" = "xnone"; then
	want_threads="no"
fi

dnl error and warning message

                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.

dnl determination of thread implementation
dnl ***************************************

have_threads="none"
if test "x$want_threads" = "xyes" || test "x$want_threads" = "xsolaris"; then
	case "$host" in
               	*-*-solaris*)
              	AC_CHECK_LIB(thread, cond_init, have_threads=solaris)
		;;
	esac
fi
if test "x$want_threads" = "xyes" || test "x$want_threads" = "xposix"; then
	if test "x$have_threads" = "xnone"; then
                AC_CHECK_HEADER(pthread.h, have_threads=posix)
        fi
fi
if test "x$want_threads" = "xyes" || test "x$want_threads" = "xnspr"; then
	if test "x$have_threads" = "xnone"; then
		AC_CHECK_LIB(nspr21, PRP_NewNakedCondVar, have_threads="nspr")
	fi
fi

AC_MSG_CHECKING(for thread implementation)

if test "x$have_threads" = "xnone" && test "x$want_threads" != "xno"; then
	AC_MSG_RESULT(none available)
        AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
else

G_THREAD_LIBS=
G_THREAD_CFLAGS=

mutex_has_default="no"
case "$have_threads" in
        posix)
	G_THREAD_LIBS="error"
		AC_CHECK_LIB(pthread, pthread_attr_init,
			     G_THREAD_LIBS="-lpthread")
	if test "x$G_THREAD_LIBS" = "xerror"; then
                	AC_CHECK_LIB(pthreads, pthread_attr_init,
			     	G_THREAD_LIBS="-lpthreads")
		fi
	if test "x$G_THREAD_LIBS" = "xerror"; then
                	AC_CHECK_LIB(thread, pthread_attr_init,
			     	G_THREAD_LIBS="-lthread")
		fi
	if test "x$G_THREAD_LIBS" = "xerror"; then
                	AC_CHECK_LIB(c_r, pthread_attr_init,
			     	G_THREAD_LIBS="-lc_r")
		fi
	if test "x$G_THREAD_LIBS" = "xerror"; then
			AC_CHECK_FUNC(pthread_attr_init, G_THREAD_LIBS="")
		fi
		dnl ********** DG/UX ************
 	if test "x$G_THREAD_LIBS" = "xerror"; then
                	AC_CHECK_LIB(thread, __d10_pthread_attr_init,
				G_THREAD_LIBS="-lthread"
				G_THREAD_CFLAGS="-D_POSIX4A_DRAFT10_SOURCE")
        	fi
		dnl ********* HPUX 11 ***********
 	if test "x$G_THREAD_LIBS" = "xerror"; then
                	AC_CHECK_LIB(pthread, __pthread_attr_init_system,
				G_THREAD_LIBS="-lpthread")
        	fi
  mutex_has_default="yes"
                mutex_default_type='pthread_mutex_t'
                mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
                mutex_header_file='pthread.h'
		g_threads_impl="POSIX"
                ;;
        solaris)
		G_THREAD_LIBS="error"
    AC_CHECK_LIB(thread, cond_init,
			G_THREAD_LIBS="-lthread")
    mutex_has_default="yes"
                mutex_default_type='mutex_t'
		mutex_default_init="DEFAULTMUTEX"
                mutex_header_file='thread.h'

                ;;
        *)
		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


dnl determination of G_THREAD_CFLAGS
dnl ********************************

if test "x$have_threads" != "xnone"; then
G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_REENTRANT" # good default guess

    case $host in
	*-aix*)
		G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_THREAD_SAFE"
		if test "x$GCC" = "xyes"; then
            	        G_THREAD_CFLAGS="$G_THREAD_CFLAGS -mthreads"
		fi
		;;

    # if we are not finding the ctime_r function, then we probably are
    # not using the proper multithread flag
    # Note: Digital UNIX 4.0d #defines ctime_r to _Pctime_r for gcc.
  old_CPPFLAGS="$CPPFLAGS"
    CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
    AC_EGREP_HEADER([[^a-zA-Z_](_P)?ctime_r[^a-zA-Z_]], time.h, ,
    G_THREAD_CFLAGS=
    AC_MSG_WARN($FLAG_DOES_NOT_WORK))
	  CPPFLAGS="$old_CPPFLAGS"

    AC_MSG_CHECKING(necessary compiler options)


dnl check for mt safe function variants
dnl ***********************************

if test "x$have_threads" != "xnone"; then
	glib_save_LIBS="$LIBS"
	glib_save_CFLAGS="$CFLAGS"
	# we are not doing the following for now, as this might require glib 

				return errno == ENOSYS || error == ENOSYS;}],
				[ac_cv_func_getpwuid_r=yes],
				[ac_cv_func_getpwuid_r=no])])
		if test "$ac_cv_func_getpwuid_r" = "yes"; then
			AC_MSG_RESULT(yes)
			AC_DEFINE(HAVE_GETPWUID_R)
		else

			AC_MSG_CHECKING(whether getpwuid_r is posix like)
			# The signature for the POSIX version is:
			# int getpwuid_r(uid_t, struct passwd *, char *, size_t, struct passwd **)
			AC_TRY_COMPILE(
				[#include <pwd.h>
                                        #include <sys/types.h>
        #include <stdlib.h>
				],[getpwuid_r((uid_t)0, NULL, NULL, (size_t)0, NULL);],
				[AC_DEFINE(HAVE_GETPWUID_R_POSIX)
				AC_MSG_RESULT(yes)],
				[AC_MSG_RESULT(no)])
		fi
	fi
	if test "x$have_threads" = "xposix"; then
		LIBS="$LIBS $G_THREAD_LIBS"
		AC_MSG_CHECKING(whether pthread_getspecific is posix like)
		# PCThreads has pthread_getspecific(pthread_key_t, void **);

GLIB_IF_VAR_EQ(mutex_has_default, yes,
	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
	)
)



dnl ****************************************
GLIB_SYSDEFS(
[#include <sys/types.h>
	#include <sys/poll.h>
	],[POLLIN:1 POLLOUT:4 POLLPRI:2 POLLERR:8 POLLHUP:16 POLLNVAL:32],
	glibconfig-sysdefs.h,=)
	=)


dnl ******************************

	cat > $outfile <<\_______EOF
/* glibconfig.h
 *
 * This is a generated file.  Please modify 'configure.in'
 */

#ifndef GLIBCONFIG_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 "x$g_mutex_header_file" != "x"; then
	  echo '#include <'"$g_mutex_header_file"'>' >> $outfile
	fi
	if test "x$glib_sys_poll_h" = "xyes"; then
	  echo "#define GLIB_HAVE_SYS_POLL_H" >> $outfile
	fi

	cat >> $outfile <<_______EOF

_______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


_______EOF

	if test -r "glibconfig-sysdefs.h"; then
	  cat glibconfig-sysdefs.h >>$outfile
	fi




	if cmp -s $outfile glibconfig.h; then
	  echo "glibconfig.h is unchanged"
	  rm -f $outfile
	else
	  mv $outfile glibconfig.h

# on variable expansion in case labels.  Look at the generated config.status
# for a hint.

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_mi=INT_MIN  glib_Mi=INT_MAX
  glib_ml=LONG_MIN glib_Ml=LONG_MAX
  ;;
x$ac_cv_header_values_h)
  glib_values_h="yes"
  glib_ms=MINSHORT glib_Ms=MAXSHORT
  glib_mi=MININT   glib_Mi=MAXINT
  glib_ml=MINLONG  glib_Ml=MAXLONG
  ;;
esac

if test "x$ac_cv_header_sys_poll_h" = "xyes" ; then
  glib_sys_poll_h="yes"
fi

case 2 in
$ac_cv_sizeof_short)		gint16="short";;
$ac_cv_sizeof_int)		gint16="int";;
esac
case 4 in
$ac_cv_sizeof_short)		gint32="short";;
$ac_cv_sizeof_int)		gint32="int";;
$ac_cv_sizeof_long)		gint32="long";;
esac
case 8 in
$ac_cv_sizeof_int)
  gint64="int"
  glib_extension=
  glib_warning_guard=
  gint64_constant='(val)'
  ;;
$ac_cv_sizeof_long)
  gint64="long"
  glib_extension=
  glib_warning_guard=
  gint64_constant='(val##L)'

#  define G_GNUC_EXTENSION __extension__
#else
#  define G_GNUC_EXTENSION
	#endif"

"
  gint64_constant='(G_GNUC_EXTENSION (val##LL))'
  ;;
esac

case $ac_cv_sizeof_void_p in
$ac_cv_sizeof_int)  	glib_gpi_cast=''        glib_gpui_cast=''         ;;
$ac_cv_sizeof_long) 	glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
*) 			glib_unknown_void_p="yes" ;;
esac


case "xyes" in
x$ac_cv_func_atexit)
  glib_atexit="
#ifdef NeXT /* @#%@! NeXTStep */

#endif"
  ;;
x$ac_cv_func_on_exit)
  glib_atexit="#define g_ATEXIT(proc)	(on_exit ((void (*)(int, void*))(proc), NULL))"
#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(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END"
#define g_memmove(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END'
  ;;
*)
  glib_memmove="

#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

case "xyes" in
x$ac_cv_c_bigendian)
  g_byte_order=G_BIG_ENDIAN
  g_bs_native=BE

  ;;
esac

if test "x$glib_wchar_h" = "xyes"; then
  glib_wc="#define G_HAVE_WCHAR_H 1"
#define G_HAVE_WCHAR_H 1'
fi
if test "x$glib_wctype_h" = "xyes"; then
  glib_wc="\$glib_wc
#define G_HAVE_WCTYPE_H 1"
fi
if test "x$glib_working_wctype" = "xno"; then
  glib_wc="\$glib_wc
#define G_HAVE_BROKEN_WCTYPE 1"
fi

case "x$enable_threads" in
xyes)	g_enable_threads_def="#define";;
*)	g_enable_threads_def="#undef ";;
esac

g_threads_impl_def="$g_threads_impl"


g_mutex_has_default="$mutex_has_default"
g_mutex_sizeof="$glib_cv_sizeof_gmutex"
g_mutex_contents="$glib_cv_byte_contents_gmutex"
])

AC_CONFIG_FILES([
glib.spec
Makefile
glib-config

glib.pc
gmodule.pc
gthread.pc
])
AC_CONFIG_COMMANDS([chmod-scripts],[
    case "$CONFIG_FILES" in
*glib-config*)chmod +x glib-config;;
esac])
AC_OUTPUT




gmoduleconf.h:	gmoduleconf.h.in

glibincludedir=$(includedir)/glib-1.2
glibinclude_HEADERS = gmodule.h
		gmodule.h

libglib = $(top_builddir)/libglib.la # -lglib


	-release $(LT_RELEASE) \
	-export-dynamic

libgmodule_la_LIBADD = @G_MODULE_LIBS@  $(libglib)
# we should really depend on $(libglib) for libgmodule.la, but libtool has a
# problem with this ;(

libgplugin_a_la_SOURCES = libgplugin_a.c
libgplugin_a_la_DEPENDENCIES = libgmodule.la
libgplugin_a_la_LDFLAGS = @G_MODULE_LDFLAGS@ -avoid-version -module
libgplugin_a_la_LIBADD = @G_MODULE_LIBS@  $(libglib) libgmodule.la

libgplugin_b_la_SOURCES = libgplugin_b.c
libgplugin_b_la_DEPENDENCIES = libgmodule.la
libgplugin_b_la_LDFLAGS = @G_MODULE_LDFLAGS@ -avoid-version -module
libgplugin_b_la_LIBADD = @G_MODULE_LIBS@  $(libglib)

noinst_PROGRAMS = testgmodule
testgmodule_LDFLAGS += @G_MODULE_LDFLAGS@

Lines 19-25 Link Here

(-)glib-1.2.10/gthread/Makefile.am.orig (-1 / +1 lines)
19	-release $(LT_RELEASE) \	19	-release $(LT_RELEASE) \
20	-export-dynamic	20	-export-dynamic
21		21
22	libgthread_la_LIBADD = @G_THREAD_LIBS@	22	libgthread_la_LIBADD = @G_THREAD_LIBS@ $(libglib)
23		23
24	noinst_PROGRAMS = testgthread	24	noinst_PROGRAMS = testgthread
25	testgthread_LDADD = ../libglib.la libgthread.la	25	testgthread_LDADD = ../libglib.la libgthread.la

Return to bug 133818

Lines 1-3 Link Here

(-)glib-1.2.10/acglib.m4.orig (+11 lines)
		1	# GLIB_AC_DIVERT_BEFORE_HELP(STUFF)
		2	# ---------------------------------
		3	# Put STUFF early enough so that they are available for $ac_help expansion.
		4	# Handle both classic (<= v2.13) and modern autoconf
		5	AC_DEFUN([GLIB_AC_DIVERT_BEFORE_HELP],
		6	[ifdef([m4_divert_text], [m4_divert_text([NOTICE],[$1])],
		7	[ifdef([AC_DIVERT], [AC_DIVERT([NOTICE],[$1])],
		8	[AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)dnl
		9	$1
		10	AC_DIVERT_POP()])])])
		11
1	dnl GLIB_IF_VAR_EQ (ENV_VAR, VALUE [, EQUALS_ACTION] [, ELSE_ACTION])	12	dnl GLIB_IF_VAR_EQ (ENV_VAR, VALUE [, EQUALS_ACTION] [, ELSE_ACTION])
2	AC_DEFUN(GLIB_IF_VAR_EQ,[	13	AC_DEFUN(GLIB_IF_VAR_EQ,[
3	case "$[$1]" in	14	case "$[$1]" in

Lines 15-22 Link Here

(-)glib-1.2.10/gmodule/Makefile.am.orig (-7 / +6 lines)
15	gmoduleconf.h: gmoduleconf.h.in	15	gmoduleconf.h: gmoduleconf.h.in
16		16
17	glibincludedir=$(includedir)/glib-1.2	17	glibincludedir=$(includedir)/glib-1.2
18	glibinclude_HEADERS = \	18	glibinclude_HEADERS = gmodule.h
19	gmodule.h
20		19
21	libglib = $(top_builddir)/libglib.la # -lglib	20	libglib = $(top_builddir)/libglib.la # -lglib
22		21
Lines 29-45 Link Here
29	-release $(LT_RELEASE) \	28	-release $(LT_RELEASE) \
30	-export-dynamic	29	-export-dynamic
31		30
32	libgmodule_la_LIBADD = @G_MODULE_LIBS@ # $(libglib)	31	libgmodule_la_LIBADD = @G_MODULE_LIBS@ $(libglib)
33	# we should really depend on $(libglib) for libgmodule.la, but libtool has a
34	# problem with this ;(
35		32
36	libgplugin_a_la_SOURCES = libgplugin_a.c	33	libgplugin_a_la_SOURCES = libgplugin_a.c
		34	libgplugin_a_la_DEPENDENCIES = libgmodule.la
37	libgplugin_a_la_LDFLAGS = @G_MODULE_LDFLAGS@ -avoid-version -module	35	libgplugin_a_la_LDFLAGS = @G_MODULE_LDFLAGS@ -avoid-version -module
38	libgplugin_a_la_LIBADD = @G_MODULE_LIBS@ # $(libglib)	36	libgplugin_a_la_LIBADD = @G_MODULE_LIBS@ $(libglib) libgmodule.la
39		37
40	libgplugin_b_la_SOURCES = libgplugin_b.c	38	libgplugin_b_la_SOURCES = libgplugin_b.c
		39	libgplugin_b_la_DEPENDENCIES = libgmodule.la
41	libgplugin_b_la_LDFLAGS = @G_MODULE_LDFLAGS@ -avoid-version -module	40	libgplugin_b_la_LDFLAGS = @G_MODULE_LDFLAGS@ -avoid-version -module
42	libgplugin_b_la_LIBADD = @G_MODULE_LIBS@ # $(libglib)	41	libgplugin_b_la_LIBADD = @G_MODULE_LIBS@ $(libglib)
43		42
44	noinst_PROGRAMS = testgmodule	43	noinst_PROGRAMS = testgmodule
45	testgmodule_LDFLAGS += @G_MODULE_LDFLAGS@	44	testgmodule_LDFLAGS += @G_MODULE_LDFLAGS@