# Process this file with autoconf to produce a configure script.
AC_INIT(glist.c)

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

# The following version number definitions apply to GLib and GModule
# as a whole, so if changes occoured in either of them, they are both
# treated with the same interface and binary age.
#
# Making releases:
#   GLIB_MICRO_VERSION += 1;
#   GLIB_INTERFACE_AGE += 1;
#   GLIB_BINARY_AGE += 1;
# if any functions have been added, set GLIB_INTERFACE_AGE to 0.
# if backwards compatibility has been broken,
# set GLIB_BINARY_AGE and GLIB_INTERFACE_AGE to 0.
#
GLIB_MAJOR_VERSION=1
GLIB_MINOR_VERSION=1
GLIB_MICRO_VERSION=7
GLIB_INTERFACE_AGE=1
GLIB_BINARY_AGE=1
GLIB_VERSION=$GLIB_MAJOR_VERSION.$GLIB_MINOR_VERSION.$GLIB_MICRO_VERSION
AC_SUBST(GLIB_VERSION)

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

# Specify a configuration file
AM_CONFIG_HEADER(config.h)

AC_DEFINE_UNQUOTED(GLIB_MAJOR_VERSION, $GLIB_MAJOR_VERSION)
AC_DEFINE_UNQUOTED(GLIB_MINOR_VERSION, $GLIB_MINOR_VERSION)
AC_DEFINE_UNQUOTED(GLIB_MICRO_VERSION, $GLIB_MICRO_VERSION)
AC_DEFINE_UNQUOTED(GLIB_INTERFACE_AGE, $GLIB_INTERFACE_AGE)
AC_DEFINE_UNQUOTED(GLIB_BINARY_AGE, $GLIB_BINARY_AGE)

dnl Initialize libtool
AM_PROG_LIBTOOL

dnl Initialize maintainer mode
AM_MAINTAINER_MODE

AC_CANONICAL_HOST

AC_ARG_ENABLE(debug, [  --enable-debug=[no/minimum/yes] turn on debugging [default=minimum]],,enable_debug=minimum)
AC_ARG_ENABLE(mem_check, [  --enable-mem-check=[no/yes] turn on malloc/free sanity checking [default=no]],,enable_mem_check=no)
AC_ARG_ENABLE(mem_profile, [  --enable-mem-profile=[no/yes] turn on malloc profiling atexit [default=no]],,enable_mem_profile=no)

AC_ARG_ENABLE(ansi, [  --enable-ansi           turn on strict ansi [default=no]],
		    , enable_ansi=no)

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)
else
  AC_MSG_RESULT(no)
fi

AC_MSG_CHECKING(whether to enable memory profiling)
if test "x$enable_mem_profile" = "xyes"; then
  AC_DEFINE(ENABLE_MEM_PROFILE, 1)
  AC_SUBST(ENABLE_MEM_PROFILE)
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
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
    GLIB_DEBUG_FLAGS="-DG_DISABLE_ASSERT -DG_DISABLE_CHECKS"
  fi
fi

AC_DEFINE_UNQUOTED(G_COMPILED_WITH_DEBUGGING, "${enable_debug}")

# Checks for programs.
AC_PROG_CC
AM_PROG_CC_STDC
AC_PROG_INSTALL

changequote(,)dnl
if test "x$GCC" = "xyes"; then
  case " $CFLAGS " in
  *[\ \	]-Wall[\ \	]*) ;;
  *) CFLAGS="$CFLAGS -Wall" ;;
  esac

  if test "x$enable_ansi" = "xyes"; then
    case " $CFLAGS " in
    *[\ \	]-ansi[\ \	]*) ;;
    *) CFLAGS="$CFLAGS -ansi" ;;
    esac

    case " $CFLAGS " in
    *[\ \	]-pedantic[\ \	]*) ;;
    *) CFLAGS="$CFLAGS -pedantic" ;;
    esac
  fi
fi
changequote([,])dnl

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

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

# Checks for library functions.
AC_FUNC_VPRINTF

AC_CHECK_FUNCS(atexit on_exit)

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)

dnl long doubles were not used, and a portability problem 
dnl AC_C_LONG_DOUBLE
AC_C_CONST

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_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

dnl for bytesex stuff
AC_C_BIGENDIAN

dnl header file checks
AC_CHECK_HEADERS(float.h, AC_DEFINE(HAVE_FLOAT_H))
AC_CHECK_HEADERS(limits.h, AC_DEFINE(HAVE_LIMITS_H))
AC_CHECK_HEADERS(pwd.h, AC_DEFINE(HAVE_PWD_H))
AC_CHECK_HEADERS(sys/param.h, AC_DEFINE(HAVE_SYS_PARAM_H))
AC_CHECK_HEADERS(sys/poll.h, AC_DEFINE(HAVE_SYS_POLL_H))
AC_CHECK_HEADERS(sys/select.h, AC_DEFINE(HAVE_SYS_SELECT_H))
AC_CHECK_HEADERS(sys/time.h, AC_DEFINE(HAVE_SYS_TIME_H))
AC_CHECK_HEADERS(sys/times.h, AC_DEFINE(HAVE_SYS_TIMES_H))
AC_CHECK_HEADERS(unistd.h, AC_DEFINE(HAVE_UNISTD_H))
AC_CHECK_HEADERS(values.h, AC_DEFINE(HAVE_VALUES_H))

# Check for some functions
AC_CHECK_FUNCS(lstat strerror strsignal memmove vsnprintf strcasecmp strncasecmp poll)

# 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[];
sys_siglist[1][0] = 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 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
	AC_DEFINE(NO_FD_SET)
	AC_MSG_RESULT(no)
    fi
fi

# These are used only in GDK (gdki18n.h)
# This stuff is here only so that we can define these
# things in glibconfig.h. If gtk+ started using an installed
# gdkconfig.h file, then the definitions would belong there. 

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

# Check for wctype.h (for iswalnum)

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)

oLIBS="$LIBS"
# in Solaris 2.5, `iswalnum' is in -lw
AC_CHECK_FUNC(iswalnum,,[AC_CHECK_LIB(w,iswalnum)])

# 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
#    ifdef HAVE_WCHAR_H
#      include <wchar.h>
#    endif
#  endif
#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 **********************
dnl *** va_copy checks ***
dnl **********************
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>
	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_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>
	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_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);
	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
	,)
])
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 ***********************
G_MODULE_LIBS=
G_MODULE_LDFLAGS=
G_MODULE_IMPL=
G_MODULE_NEED_USCORE=0
G_MODULE_HAVE_DLERROR=0
dnl *** dlopen() in system libraries
if test -z "$G_MODULE_IMPL"; then
	AC_CHECK_FUNC(dlopen,
		G_MODULE_IMPL=G_MODULE_IMPL_DL
	,)
fi
dnl *** dlopen() in libdl
if test -z "$G_MODULE_IMPL"; then
	AC_CHECK_LIB(dl, dlopen,
		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_MSG_CHECKING(how to export all symbols)
        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
        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_orig="$LDFLAGS"
	LIBS="$LIBS $G_MODULE_LIBS"
	LDFLAGS="$LDFLAGS $G_MODULE_LDFLAGS"
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>
                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.o plugin.lo
	])
	AC_MSG_RESULT($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 e got an implementation?
if test -z "$G_MODULE_IMPL"; then
	G_MODULE_IMPL=0
fi
AC_SUBST(G_MODULE_IMPL)
AC_SUBST(G_MODULE_LIBS)
AC_SUBST(G_MODULE_LDFLAGS)
AC_SUBST(G_MODULE_HAVE_DLERROR)
AC_SUBST(G_MODULE_NEED_USCORE)
AC_SUBST(GLIB_DEBUG_FLAGS)


dnl ***********************
dnl *** g_thread checks ***
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$want_threads" = "xnone"; then
	want_threads=no
fi

dnl error and warning message
dnl *************************

THREAD_NO_IMPLEMENTATION="You do not have any known thread system on your
                computer. glib will not be thread safe on your computer."

THREAD_UNKNOWN_COMPILER="Your compiler is not known, so I cannot
                determine the necessary compiler options to compile programs 
                which are using threads. Please provide such information."

FLAG_DOES_NOT_WORK="I can't find the MACRO, that enables thread safety on your
                platform (normaly 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 informationon 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_LIB(pthread, pthread_cond_init, have_threads=posix)
	fi
        if test "x$have_threads" = xnone; then
     	        AC_CHECK_LIB(pthreads, pthread_cond_init, have_threads=posix)
	fi
        if test "x$have_threads" = xnone; then
		# dont let us be fooled by a defined pthread_cond_init
		# function in the standard c-lib, that doesn't have too mean, 
		# there is full thread support, it might be a weak symbol.
		AC_CHECK_FUNC(pthread_attr_init, 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
	AC_MSG_RESULT($have_threads)
fi


dnl determination of G_THREAD_LIBS
dnl ******************************

G_THREAD_LIBS=

case $have_threads in
        posix)
		G_THREAD_LIBS=error
		AC_CHECK_LIB(pthread, pthread_cond_init,
			     G_THREAD_LIBS="-lpthread") 
		if test "x$G_THREAD_LIBS" = xerror; then
                	AC_CHECK_LIB(pthreads, pthread_cond_init,
			     	G_THREAD_LIBS="-lpthreads")
		fi
		if test "x$G_THREAD_LIBS" = xerror; then
			AC_CHECK_FUNC(pthread_cond_init, G_THREAD_LIBS="")
		fi
                ;;
        solaris)
		G_THREAD_LIBS=error
                AC_CHECK_LIB(thread, cond_init, G_THREAD_LIBS="-lthread")
		# solaris has a broken initializer for mutexes, if we find it,
		# we will replace it.
		AC_MSG_CHECKING(for broken solaris mutex initialization)
		AC_EGREP_CPP([ *begin *{ *0 *, *0 *, *0 *, *0 *, *0 *, *0 *, *0 *, *0 *, *0 *, *0 *, *0 *, *0 *, *0 *, *0 *} *end *],
		             [#include <thread.h>
			     begin DEFAULTMUTEX end],
			     [solaris_mutex_init_broken=yes],
			     [solaris_mutex_init_broken=no])
		AC_MSG_RESULT($solaris_mutex_init_broken)
                ;;
	nspr)
		AC_CHECK_LIB(nspr21, PRP_NewNakedCondVar,
			     G_THREAD_LIBS="-lnspr21")
		;;
        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(necessary linker options)
AC_MSG_RESULT($G_THREAD_LIBS)

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

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

	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
			;;
	esac

	# if we are not finding the ctime_r function, then we probably are 
	# not using the proper multithread flag
	old_CPPFLAGS=$CPPFLAGS
	CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
	AC_EGREP_HEADER([[^a-zA-Z_]ctime_r[^a-zA-Z_]], time.h, , 
        	G_THREAD_CFLAGS=
        	AC_MSG_WARN($FLAG_DOES_NOT_WORK))
	CPPFLAGS=$old_CPPFLAGS
                
#	if test x"$GCC" = xyes; then 	
#		# older gcc's do not know the -fstack-check option and will
#		# stop compiling, so just check this here 
#		old_CPPFLAGS="$CPPFLAGS"
#		CPPFLAGS="$CPPFLAGS -fstack-check"
#		AC_TRY_COMPILE(,,
#			G_THREAD_CFLAGS="$G_THREAD_CFLAGS -fstack-check")
#		CPPFLAGS=$old_CPPFLAGS
#	else
#       	AC_MSG_WARN($THREAD_UNKNOWN_COMPILER)
#	fi

	AC_MSG_CHECKING(necessary compiler options)

	AC_MSG_RESULT($G_THREAD_CFLAGS)
else
        G_THREAD_CFLAGS=
fi

AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c")
AC_SUBST(G_THREAD_CFLAGS)
AC_SUBST(G_THREAD_LIBS)

CFLAGS="$CFLAGS $G_THREAD_CFLAGS"

dnl ******************************
dnl *** output the whole stuff ***
dnl ******************************

AC_OUTPUT_COMMANDS([

## Generate `glibconfig.h' in two cases
## 1. `config.status' is run either explicitly, or via configure.
##     Esp. not when it is run in `Makefile' to generate makefiles and
##     config.h
## 2. CONFIG_OTHER is set explicitly
##
## Case 1 is difficult.  We know that `automake' sets one of
## CONFIG_FILES or CONFIG_HEADERS to empty.  This heuristic works
## only when AM_CONFIG_HEADER is set, however.  

if test -n "${CONFIG_FILES}" && test -n "${CONFIG_HEADERS}"; then
  # Both CONFIG_FILES and CONFIG_HEADERS are non-empty ==> Case 1
  CONFIG_OTHER=${CONFIG_OTHER:-glibconfig.h}
fi
case "$CONFIG_OTHER" in
*glibconfig.h*)
  echo creating glibconfig.h
  outfile=glibconfig.h-tmp
  cat > $outfile <<\outfile_EOF
/* glibconfig.h */
/* This is a generated file.  Please modify `configure.in' */

#ifndef GLIBCONFIG_H
#define GLIBCONFIG_H

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

outfile_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 '#include <sys/types.h>' >> $outfile
    echo '#include <sys/poll.h>' >> $outfile
  fi

  cat >> $outfile <<outfile_EOF

#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_MININT $glib_mi
#define G_MAXINT $glib_Mi
#define G_MINLONG $glib_ml
#define G_MAXLONG $glib_Ml

outfile_EOF

  ## this should always be true in a modern C/C++ compiler
  cat >>$outfile <<outfile_EOF
typedef signed char gint8;
typedef unsigned char guint8;
outfile_EOF

  if test -n "$gint16"; then
    cat >>$outfile <<outfile_EOF
typedef signed $gint16 gint16;
typedef unsigned $gint16 guint16;
outfile_EOF
  fi
  if test -n "$gint32"; then
    cat >>$outfile <<outfile_EOF
typedef signed $gint32 gint32;
typedef unsigned $gint32 guint32;
outfile_EOF
  fi 
  if test -n "$gint64"; then
    cat >>$outfile <<outfile_EOF
${glib_warning_guard}#define G_HAVE_GINT64 1

${glib_extension}typedef signed $gint64 gint64;
${glib_extension}typedef unsigned $gint64 guint64;

#define G_GINT64_CONSTANT(val)	$gint64_constant
outfile_EOF
  fi 

  if test -z "$glib_unknown_void_p"; then
    cat >>$outfile <<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))
outfile_EOF
  else
    echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
  fi

  cat >>$outfile <<outfile_EOF
$glib_atexit
$glib_memmove
$glib_defines

$glib_vacopy

#ifdef	__cplusplus
#define	G_HAVE_INLINE	1
#else	/* !__cplusplus */
$glib_inline
#endif	/* !__cplusplus */

#define G_BYTE_ORDER $g_byte_order
outfile_EOF

cat >>$outfile <<outfile_EOF                                               

/* definitions for the default mutex implementation */
outfile_EOF

  if test x$g_mutex_has_default = xyes; then
cat >>$outfile <<outfile_EOF                                               

typedef struct _GStaticMutex GStaticMutex;
struct _GStaticMutex 
{
  $g_mutex_default_type default_mutex;
  struct _GMutex* runtime_mutex;
};
#define G_STATIC_MUTEX_INIT { $g_mutex_default_init, NULL }
#define g_static_mutex_get_mutex(mutex) \
  ( g_thread_use_default_impl ? (GMutex*)&mutex.default_mutex : \
    g_static_mutex_get_mutex_impl(&mutex.runtime_mutex) )
outfile_EOF
  else
cat >>$outfile <<outfile_EOF                                               

typedef struct _GMutex* GStaticMutex;
#define G_STATIC_MUTEX_INIT NULL
#define g_static_mutex_get_mutex(mutex) g_static_mutex_get_mutex_impl(&mutex)
outfile_EOF
  fi

  g_bit_sizes="16 32"
  if test -n "$gint64"; then
    g_bit_sizes="$g_bit_sizes 64"
  fi

  for bits in $g_bit_sizes; do                                                  
    cat >>$outfile <<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))
outfile_EOF
done

  cat >>$outfile <<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))
$glib_wc

#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif /* GLIBCONFIG_H */

outfile_EOF

  if cmp -s $outfile glibconfig.h; then
    echo glibconfig.h is unchanged
    rm -f $outfile
  else
    mv $outfile glibconfig.h
  fi ;;
esac
],[

# 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.

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)'
  ;;
$ac_cv_sizeof_long_long)
  gint64='long long'
  glib_extension='GLIB_WARNINGS_MAKE_PEOPLE_CRY '
  glib_warning_guard="
#if defined (__GNUC__) && __GNUC__ >= 2 && __GNUC_MINOR__ >= 8
#  define GLIB_WARNINGS_MAKE_PEOPLE_CRY __extension__
#else
#  define GLIB_WARNINGS_MAKE_PEOPLE_CRY
#endif

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

gintbits=`expr $ac_cv_sizeof_int \* 8`
glongbits=`expr $ac_cv_sizeof_long \* 8`


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 */
# 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(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END'
  ;;
*)
  glib_memmove="
/* We make the assumption that if memmove isn't available, then
 * bcopy will do the job. This isn't safe everywhere. (bcopy can't
 * necessarily handle overlapping copies) */
#define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
  ;;
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

case xyes in
x$ac_cv_c_bigendian)
  g_byte_order=G_BIG_ENDIAN
  g_bs_native=BE
  g_bs_alien=LE
  ;;
*)
  g_byte_order=G_LITTLE_ENDIAN
  g_bs_native=LE
  g_bs_alien=BE
  ;;
esac

if test x$glib_wchar_h = xyes; then
  glib_wc='
#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 $have_threads in
	posix)
		g_mutex_has_default=yes
		g_mutex_default_type='pthread_mutex_t'
		g_mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
		g_mutex_header_file='pthread.h'
		;;
	solaris)
		g_mutex_has_default=yes
		g_mutex_default_type='mutex_t'
		if test x$solaris_mutex_init_broken = xyes; then
		  g_mutex_default_init="{ { { 0, 0, 0, 0 }, USYNC_THREAD }, { { { 0, 0, 0, 0, 0, 0, 0, 0 } } }, 0}"
		else
		  g_mutex_default_init="DEFAULTMUTEX"
		fi
		g_mutex_header_file='thread.h'
		;;
	nspr)
		g_mutex_has_default=no
		;;
	*)		
		g_mutex_has_default=no
		;;
esac
])

AC_OUTPUT([
Makefile
glib-config
gmodule/gmoduleconf.h
gmodule/Makefile
gthread/Makefile
docs/Makefile
],[case "$CONFIG_FILES" in
*glib-config*)chmod +x glib-config;;
esac])