X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=configure.in;h=00dd49855cee4d2f0b9c5dc25c31cff0c04f621f;hb=260befc999849fdca150cc2c6248473daba4423a;hp=34265785243f2508b2c14fd0407b193c3d1ddd97;hpb=acbe34e51a2903d50ee99cb46552c360905322ea;p=platform%2Fupstream%2Fglib.git diff --git a/configure.in b/configure.in index 3426578..00dd498 100644 --- a/configure.in +++ b/configure.in @@ -2,12 +2,14 @@ dnl *********************************** dnl *** include special GLib macros *** dnl *********************************** builtin(include, acglib.m4)dnl +builtin(include, glib/libcharset/codeset.m4)dnl +builtin(include, glib/libcharset/glibc21.m4)dnl -# require autoconf 2.13 -AC_PREREQ(2.13) +# require autoconf 2.52 +AC_PREREQ(2.52) # Process this file with autoconf to produce a configure script. -AC_INIT(glist.c) +AC_INIT(glib/glib.h) # Save this value here, since automake will set cflags later cflags_set=${CFLAGS+set} @@ -15,12 +17,10 @@ cflags_set=${CFLAGS+set} # we rewrite this file rm -f glibconfig-sysdefs.h -dnl we need to AC_DIVERT_PUSH/AC_DIVERT_POP these variable definitions so they -dnl are available for $ac_help expansion (don't we all *love* autoconf?) -AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)dnl +GLIB_AC_DIVERT_BEFORE_HELP([ # -# 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 +# The following version number definitions apply to GLib, GModule, GObject +# and GThread as a whole, so if changes occoured in any of them, they are all # treated with the same interface and binary age. # # Making releases: @@ -31,14 +31,13 @@ AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)dnl # if backwards compatibility has been broken, # set GLIB_BINARY_AGE _and_ GLIB_INTERFACE_AGE to 0. # -GLIB_MAJOR_VERSION=1 -GLIB_MINOR_VERSION=3 +GLIB_MAJOR_VERSION=2 +GLIB_MINOR_VERSION=0 GLIB_MICRO_VERSION=1 -GLIB_INTERFACE_AGE=0 -GLIB_BINARY_AGE=0 +GLIB_INTERFACE_AGE=1 +GLIB_BINARY_AGE=1 GLIB_VERSION=$GLIB_MAJOR_VERSION.$GLIB_MINOR_VERSION.$GLIB_MICRO_VERSION -dnl -AC_DIVERT_POP()dnl +])dnl AC_SUBST(GLIB_MAJOR_VERSION) AC_SUBST(GLIB_MINOR_VERSION) @@ -52,10 +51,12 @@ 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` +LT_CURRENT_MINUS_AGE=`expr $LT_CURRENT - $LT_AGE` AC_SUBST(LT_RELEASE) AC_SUBST(LT_CURRENT) AC_SUBST(LT_REVISION) AC_SUBST(LT_AGE) +AC_SUBST(LT_CURRENT_MINUS_AGE) VERSION=$GLIB_VERSION PACKAGE=glib @@ -65,14 +66,16 @@ 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 +AC_DEFINE_UNQUOTED(GLIB_MAJOR_VERSION, $GLIB_MAJOR_VERSION, + [Define to the GLIB major version]) +AC_DEFINE_UNQUOTED(GLIB_MINOR_VERSION, $GLIB_MINOR_VERSION, + [Define to the GLIB minor version]) +AC_DEFINE_UNQUOTED(GLIB_MICRO_VERSION, $GLIB_MICRO_VERSION, + [Define to the GLIB micro version]) +AC_DEFINE_UNQUOTED(GLIB_INTERFACE_AGE, $GLIB_INTERFACE_AGE, + [Define to the GLIB interface age]) +AC_DEFINE_UNQUOTED(GLIB_BINARY_AGE, $GLIB_BINARY_AGE, + [Define to the GLIB binary age]) dnl Initialize maintainer mode AM_MAINTAINER_MODE @@ -90,50 +93,133 @@ case $host in esac AC_MSG_RESULT([$glib_native_beos]) -dnl figure debugging default, prior to $ac_help setup dnl -AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)dnl -if test `expr $GLIB_MINOR_VERSION \% 2` = 1 ; then - debug_default=yes -else - debug_default=minimum + +AC_MSG_CHECKING([for Win32]) +case "$host" in + *-*-mingw*) + glib_native_win32=yes + G_LIB_WIN32_RESOURCE=glib-win32res.lo + G_MODULE_WIN32_RESOURCE=gmodule-win32res.lo + G_OBJECT_WIN32_RESOURCE=gobject-win32res.lo + G_THREAD_WIN32_RESOURCE=gthread-win32res.lo + GLIB_DEF=glib.def + GMODULE_DEF=gmodule.def + GOBJECT_DEF=gobject.def + GTHREAD_DEF=gthread.def + TESTGMODULE_EXP=testgmodule.exp + ;; + *) + glib_native_win32=no + G_LIB_WIN32_RESOURCE= + G_MODULE_WIN32_RESOURCE= + G_OBJECT_WIN32_RESOURCE= + G_THREAD_WIN32_RESOURCE= + GLIB_DEF= + GMODULE_DEF= + GOBJECT_DEF= + GTHREAD_DEF= + TESTGMODULE_EXP= + ;; +esac +AC_MSG_RESULT([$glib_native_win32]) +AM_CONDITIONAL(OS_WIN32, test "$glib_native_win32" = "yes") +AC_SUBST(G_LIB_WIN32_RESOURCE) +AC_SUBST(G_MODULE_WIN32_RESOURCE) +AC_SUBST(G_OBJECT_WIN32_RESOURCE) +AC_SUBST(G_THREAD_WIN32_RESOURCE) +AC_SUBST(GLIB_DEF) +AC_SUBST(GMODULE_DEF) +AC_SUBST(GOBJECT_DEF) +AC_SUBST(GTHREAD_DEF) +AC_SUBST(TESTGMODULE_EXP) + +if test "$glib_native_win32" = "yes"; then + AC_CHECK_PROG(ms_librarian, lib.exe, yes, no) fi -AC_DIVERT_POP()dnl +AM_CONDITIONAL(MS_LIB_AVAILABLE, test x$ms_librarian = xyes) + +GLIB_AC_DIVERT_BEFORE_HELP([ +# figure debugging default, prior to $ac_help setup +case $GLIB_MINOR_VERSION in +*[[13579]]) debug_default=yes ;; +*) debug_default=minimum ;; +esac[]dnl +]) 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(msg-prefix, [ --enable-msg-prefix turn on program name and PID prefixing of messages and warnings],,enable_msg_prefix=no) -AC_ARG_ENABLE(mem_check, [ --enable-mem-check turn on malloc/free sanity checking [default=no]],,enable_mem_check=no) -AC_ARG_ENABLE(mem_profile, [ --enable-mem-profile turn on malloc profiling atexit [default=no]],,enable_mem_profile=no) +AC_ARG_ENABLE(gc_friendly, [ --enable-gc-friendly turn on garbage collector friendliness [default=no]],,enable_gc_friendly=no) +AC_ARG_ENABLE(mem_pools, [ --disable-mem-pools disable all glib memory pools],,disable_mem_pools=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) +AC_ARG_ENABLE(rebuilds, [ --disable-rebuilds disable all source autogeneration rules],,enable_rebuilds=yes) if test "x$enable_threads" != "xyes"; then enable_threads=no fi -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_DEFINE_UNQUOTED(G_COMPILED_WITH_DEBUGGING, "${enable_debug}", + [Whether glib was compiled with debugging enabled]) + +AC_MSG_CHECKING(whether to enable garbage collector friendliness) +if test "x$enable_gc_friendly" = "xyes"; then + AC_DEFINE(ENABLE_GC_FRIENDLY, 1, [Whether to enable GC friendliness]) + AC_SUBST(ENABLE_GC_FRIENDLY) 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_CHECKING(whether to disable memory pools) +if test "x$disable_mem_pools" = "xno"; then + AC_MSG_RESULT(no) +else + AC_DEFINE(DISABLE_MEM_POOLS, 1, [Whether to disable memory pools]) + AC_SUBST(DISABLE_MEM_POOLS) AC_MSG_RESULT(yes) +fi + +dnl Checks for programs. +AC_PROG_CC + +dnl Check for a working C++ compiler, but do not bail out, if none is found. +AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, gcc) +AC_LANG_SAVE +AC_LANG_CPLUSPLUS +AC_TRY_COMPILE(,[class a { int b; } c;], ,CXX=) +AM_CONDITIONAL(HAVE_CXX, test "$CXX" != "") +AC_LANG_RESTORE + +AM_PROG_CC_STDC +AC_PROG_INSTALL + +AC_SYS_LARGEFILE + +# +# Find pkg-config +# +AC_PATH_PROG(PKG_CONFIG, pkg-config, no) +if test x$PKG_CONFIG = xno ; then + AC_MSG_ERROR([*** pkg-config not found. See http://www.freedesktop.org/software/pkgconfig/]) +fi + +if $PKG_CONFIG --atleast-pkgconfig-version 0.5 ; then + : else - AC_MSG_RESULT(no) + AC_MSG_ERROR([*** pkg-config too old; version 0.5 or better required.]) fi if test "x$enable_debug" = "xyes"; then - test "$cflags_set" = set || CFLAGS="$CFLAGS -g" + if test x$cflags_set != xset ; then + case " $CFLAGS " in + *[[\ \ ]]-g[[\ \ ]]*) ;; + *) CFLAGS="$CFLAGS -g" ;; + esac + fi + GLIB_DEBUG_FLAGS="-DG_ENABLE_DEBUG" else if test "x$enable_debug" = "xno"; then @@ -141,37 +227,153 @@ else fi fi -AC_DEFINE_UNQUOTED(G_COMPILED_WITH_DEBUGGING, "${enable_debug}") +# Ensure -fnative-struct is used when compiling for Win32 +if test "x$glib_native_win32" = "xyes"; then + if test "x$GCC" = "xyes"; then + case " $CFLAGS " in + *[[\ \ ]]-fnative-struct[[\ \ ]]*) ;; + *) CFLAGS="$CFLAGS -fnative-struct" ;; + esac + fi +fi -if test "x$enable_msg_prefix" = "xyes"; then - AC_DEFINE_UNQUOTED(G_ENABLE_MSG_PREFIX, 1) +AC_CYGWIN +AC_EXEEXT + +# define a MAINT-like variable REBUILD which is set if Perl +# and awk are found, so autogenerated sources can be rebuilt +AC_PROG_AWK +AC_CHECK_PROGS(PERL, perl5 perl) +# We would like indent, but don't require it. +AC_CHECK_PROG(INDENT, indent, indent) +REBUILD=\# +if test "x$enable_rebuilds" = "xyes" && \ + test -n "$PERL" && \ + $PERL -e 'exit !($] >= 5.002)' > /dev/null 2>&1 && \ + test -n "$AWK" ; then + REBUILD= fi +AC_SUBST(REBUILD) -# Checks for programs. -AC_PROG_CC -AM_PROG_CC_STDC -AC_PROG_INSTALL +# Need full path to Perl for glib-mkenums +# +if test "x$PERL" != x ; then + AC_PATH_PROG(PERL_PATH, $PERL) +else + PERL_PATH="/usr/bin/env perl" +fi +AC_SUBST(PERL_PATH) + +dnl *********************** +dnl *** Tests for iconv *** +dnl *********************** +dnl +dnl We do this before the gettext checks, to avoid distortion + +AC_ARG_WITH(libiconv, [ --with-libiconv=[no/gnu/native] use the libiconv library ],,with_libiconv=maybe) + +found_iconv=no +case $with_libiconv in + maybe) + # Check in the C library first + AC_CHECK_FUNC(iconv_open, with_libiconv=no; found_iconv=yes) + # Check if we have GNU libiconv + if test $found_iconv = "no"; then + AC_CHECK_LIB(iconv, libiconv_open, with_libiconv=gnu; found_iconv=yes) + fi + # Check if we have a iconv in -liconv, possibly from vendor + if test $found_iconv = "no"; then + AC_CHECK_LIB(iconv, iconv_open, with_libiconv=native; found_iconv=yes) + fi + ;; + no) + AC_CHECK_FUNC(iconv_open, with_libiconv=no; found_iconv=yes) + ;; + gnu|yes) + AC_CHECK_LIB(iconv, libiconv_open, with_libiconv=gnu; found_iconv=yes) + ;; + native) + AC_CHECK_LIB(iconv, iconv_open, with_libiconv=native; found_iconv=yes) + ;; +esac + +if test "x$found_iconv" = "xno" ; then + AC_MSG_ERROR([*** No iconv() implementation found in C library or libiconv]) +fi + +dnl +dnl gettext support +dnl + +ALL_LINGUAS="az ca cs de el es eu fr gl hi ja ko ms nl nn no pl pt ro ru sk sl sv ta tr uk vi zh_CN zh_TW" +AM_GLIB_GNU_GETTEXT + +if test "$gt_cv_func_dgettext_libc" = "yes" || test "$gt_cv_func_dgettext_libintl" = "yes"; then + : +else + AC_MSG_ERROR([ +*** You must have either have gettext support in your C library, or use the +*** GNU gettext library. (http://www.gnu.org/software/gettext/gettext.html +]) +fi + +LIBS="$LIBS $INTLLIBS" + +GETTEXT_PACKAGE=glib20 +AC_SUBST(GETTEXT_PACKAGE) +AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE,"$GETTEXT_PACKAGE") + +# AM_GLIB_GNU_GETTEXT above substs $DATADIRNAME +# this is the directory where the *.{mo,gmo} files are installed +GLIB_LOCALE_DIR="${prefix}/${DATADIRNAME}/locale" +AC_DEFINE_UNQUOTED(GLIB_LOCALE_DIR,"$GLIB_LOCALE_DIR") + +AC_CHECK_FUNCS(bind_textdomain_codeset) + +dnl +dnl Now we are done with gettext checks, figure out ICONV_LIBS +dnl + +if test x$with_libiconv != xno ; then + case " $INTLLIBS " in + *[[\ \ ]]-liconv[[\ \ ]]*) ;; + *) ICONV_LIBS="-liconv" ;; + esac +fi +AC_SUBST(ICONV_LIBS) + +case $with_libiconv in + gnu) + AC_DEFINE(USE_LIBICONV_GNU, [Using GNU libiconv]) + ;; + native) + AC_DEFINE(USE_LIBICONV_NATIVE, [Using a native implementation of iconv in a separate library]) + ;; +esac + +dnl Initialize libtool +AM_DISABLE_STATIC +AC_LIBTOOL_WIN32_DLL +AM_PROG_LIBTOOL -changequote(,)dnl if test "x$GCC" = "xyes"; then case " $CFLAGS " in - *[\ \ ]-Wall[\ \ ]*) ;; + *[[\ \ ]]-Wall[[\ \ ]]*) ;; *) CFLAGS="$CFLAGS -Wall" ;; esac if test "x$enable_ansi" = "xyes"; then case " $CFLAGS " in - *[\ \ ]-ansi[\ \ ]*) ;; + *[[\ \ ]]-ansi[[\ \ ]]*) ;; *) CFLAGS="$CFLAGS -ansi" ;; esac case " $CFLAGS " in - *[\ \ ]-pedantic[\ \ ]*) ;; + *[[\ \ ]]-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]) @@ -211,6 +413,8 @@ AC_HEADER_STDC # Checks for library functions. AC_FUNC_VPRINTF +AC_FUNC_ALLOCA + AC_CHECK_FUNCS(atexit on_exit) AC_CHECK_SIZEOF(char) @@ -219,35 +423,98 @@ 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$ac_cv_sizeof_long_long = x8; then # long long is a 64 bit integer. - AC_MSG_CHECKING(for format to printf and scanf a gint64) + AC_MSG_CHECKING(for format to printf and scanf a guint64) AC_CACHE_VAL(glib_cv_long_long_format,[ - AC_TRY_RUN([#include + for format in ll q I64; do + AC_TRY_RUN([#include int main() { long long b, a = -0x3AFAFAFAFAFAFAFALL; char buffer[1000]; - sprintf (buffer, "%llu", a); - sscanf (buffer, "%llu", &b); + sprintf (buffer, "%${format}u", a); + sscanf (buffer, "%${format}u", &b); exit (b!=a); } ], - glib_cv_long_long_format=ll, - glib_cv_long_long_format=q)]) - AC_MSG_RESULT(%${glib_cv_long_long_format}i) + 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) + 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 MSVC, and what the formats are + glib_cv_long_long_format=I64 + AC_MSG_RESULT(%${glib_cv_long_long_format}u) fi dnl long doubles were not used, and a portability problem dnl AC_C_LONG_DOUBLE AC_C_CONST +dnl ok, here we try to check whether the systems prototypes for +dnl malloc and friends actually match the prototypes provided +dnl by gmem.h (keep in sync). i currently only know how to check +dnl this reliably with gcc (-Werror), improvements for other +dnl compilers are apprechiated. +SANE_MALLOC_PROTOS=no +AC_MSG_CHECKING([if malloc() and friends prototypes are gmem.h compatible]) +glib_save_CFLAGS=$CFLAGS +if test "x$GCC" = "xyes"; then + CFLAGS="$CFLAGS -Werror" + AC_TRY_COMPILE([#include ], [ + void* (*my_calloc_p) (size_t, size_t) = calloc; + void* (*my_malloc_p) (size_t) = malloc; + void (*my_free_p) (void*) = free; + void* (*my_realloc_p) (void*, size_t) = realloc; + my_calloc_p = 0; + my_malloc_p = 0; + my_free_p = 0; + my_realloc_p = 0; + ], + AC_DEFINE(SANE_MALLOC_PROTOS) + SANE_MALLOC_PROTOS=yes) +fi +AC_MSG_RESULT($SANE_MALLOC_PROTOS) +CFLAGS=$glib_save_CFLAGS + +dnl +dnl check in which direction the stack grows +dnl +AC_CACHE_CHECK([for growing stack pointer],glib_cv_stack_grows,[ + AC_TRY_RUN([ + volatile int *a = 0, *b = 0; + void foo (void); + int main () { volatile int y = 7; a = &y; foo (); return b > a; } + void foo (void) { volatile int x = 5; b = &x; } + ], + glib_cv_stack_grows=no + , + glib_cv_stack_grows=yes + ,) +]) + 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_CACHE_CHECK([for __inline],glib_cv_has__inline,[ AC_TRY_RUN([ __inline int foo () { return 0; } int main () { return foo (); } @@ -257,12 +524,10 @@ AC_CACHE_VAL(glib_cv_has__inline,[ 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) +xyes) AC_DEFINE(G_HAVE___INLINE,1,[Have __inline keyword]) esac -AC_MSG_CHECKING(for __inline__) -AC_CACHE_VAL(glib_cv_has__inline__,[ +AC_CACHE_CHECK([for __inline__],glib_cv_has__inline__,[ AC_TRY_RUN([ __inline__ int foo () { return 0; } int main () { return foo (); } @@ -272,13 +537,12 @@ AC_CACHE_VAL(glib_cv_has__inline__,[ 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__) +xyes) AC_DEFINE(G_HAVE___INLINE__,1,[Have __inline__ keyword]) esac -AC_MSG_CHECKING(for inline) -AC_CACHE_VAL(glib_cv_hasinline,[ +AC_CACHE_CHECK([for inline], glib_cv_hasinline,[ AC_TRY_RUN([ + #undef inline inline int foo () { return 0; } int main () { return foo (); } ], @@ -287,28 +551,140 @@ AC_CACHE_VAL(glib_cv_hasinline,[ glib_cv_hasinline=no ,) ]) -AC_MSG_RESULT($glib_cv_hasinline) case x$glib_cv_hasinline in -xyes) AC_DEFINE(G_HAVE_INLINE) +xyes) AC_DEFINE(G_HAVE_INLINE,1,[Have inline keyword]) esac -dnl for bytesex stuff +# 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) + +# check 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 header files +AC_CHECK_HEADERS([dirent.h float.h limits.h pwd.h sys/param.h sys/poll.h sys/select.h]) +AC_CHECK_HEADERS([sys/time.h sys/times.h unistd.h values.h stdint.h sched.h]) + +# Checks for libcharset +jm_LANGINFO_CODESET +jm_GLIBC21 +AC_CHECK_HEADERS([stddef.h stdlib.h string.h]) +AC_CHECK_FUNCS(setlocale) + +AC_MSG_CHECKING(whether make is GNU Make) +STRIP_BEGIN= +STRIP_END= +if $ac_make --version 2>/dev/null | grep '^GNU Make ' >/dev/null ; then + STRIP_BEGIN='$(strip $(STRIP_DUMMY)' + STRIP_END=')' + AC_MSG_RESULT(yes) +else + AC_MSG_RESULT(no) +fi +STRIP_DUMMY= +AC_SUBST(STRIP_DUMMY) +AC_SUBST(STRIP_BEGIN) +AC_SUBST(STRIP_END) + +# check additional type sizes +size_includes=[" +#include +#include +#include +#include +"] +if test "x$ac_cv_header_stdint_h" = "xyes"; then + size_includes=["$size_includes +#include +"] +fi +if test "x$ac_cv_header_unistd_h" = "xyes"; then + size_includes=["$size_includes +#include +"] +fi +GLIB_SIZEOF([$size_includes], size_t, size_t) +GLIB_SIZEOF([$size_includes], ptrdiff_t, ptrdiff_t) +GLIB_SIZEOF([$size_includes], intmax_t, intmax_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 $glib_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_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 $glib_cv_sizeof_size_t = $ac_cv_sizeof_int && + test $glib_cv_sizeof_size_t = $ac_cv_sizeof_long ; then + GLIB_CHECK_COMPILE_WARNINGS([ +#include +int main () +{ + size_t s = 1; + unsigned int *size_int = &s; + return (int)*size_int; +} + ],glib_size_type=int, + [GLIB_CHECK_COMPILE_WARNINGS([ +#include +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 strcasecmp strncasecmp poll) +AC_CHECK_FUNCS(lstat strerror strsignal memmove mkstemp vsnprintf stpcpy strcasecmp strncasecmp poll getcwd nanosleep vasprintf unsetenv getc_unlocked) + +AC_FUNC_VSNPRINTF_C99 # Check if bcopy can be used for overlapping copies, if memmove isn't found. # The check is borrowed from the PERL Configure script. @@ -330,8 +706,8 @@ if test "$ac_cv_func_memmove" != "yes"; then } return(0); }],glib_cv_working_bcopy=yes,glib_cv_working_bcopy=no)]) - if test "$glib_cv_working_bcopy" == "yes"; then - AC_DEFINE(HAVE_WORKING_BCOPY) + if test "$glib_cv_working_bcopy" = "yes"; then + AC_DEFINE(HAVE_WORKING_BCOPY,1,[Have a working bcopy]) fi fi @@ -343,19 +719,19 @@ 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) +if test "$glib_ok" = "no"; then + AC_DEFINE(NO_SYS_ERRLIST,1,[global 'sys_errlist' not found]) fi # Check for sys_siglist AC_MSG_CHECKING(for sys_siglist) AC_TRY_LINK(, [ extern char *sys_siglist[]; -strlen (sys_siglist[0]); +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) +if test "$glib_ok" = "no"; then + AC_DEFINE(NO_SYS_SIGLIST,1,[global 'sys_siglist' not found]) fi # Check for sys_siglist decl (see Tue Jan 19 00:44:24 1999 in changelog) @@ -364,51 +740,77 @@ AC_TRY_COMPILE([#include ], [ 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) +if test "$glib_ok" = "no"; then + AC_DEFINE(NO_SYS_SIGLIST_DECL,1,[global 'sys_siglist' not declared]) fi # Check if needs to be included for fd_set AC_MSG_CHECKING([for fd_set]) AC_TRY_COMPILE([#include ], [fd_set readMask, writeMask;], gtk_ok=yes, gtk_ok=no) -if test $gtk_ok = yes; then +if test "$gtk_ok" = "yes"; then AC_MSG_RESULT([yes, found in sys/types.h]) else - AC_HEADER_EGREP(fd_set, sys/select.h, gtk_ok=yes) - if test $gtk_ok = yes; then - AC_DEFINE(HAVE_SYS_SELECT_H) + AC_EGREP_HEADER(fd_set, sys/select.h, gtk_ok=yes) + if test "$gtk_ok" = "yes"; then + # *** FIXME: give it a different name + AC_DEFINE(HAVE_SYS_SELECT_H,1,[found fd_set in sys/select.h]) AC_MSG_RESULT([yes, found in sys/select.h]) else - AC_DEFINE(NO_FD_SET) + AC_DEFINE(NO_FD_SET,1,[didn't find fd_set]) AC_MSG_RESULT(no) fi fi dnl *** check for sane realloc() *** -AC_MSG_CHECKING(whether realloc (NULL,) will work) -AC_CACHE_VAL(glib_cv_sane_realloc,[ +AC_CACHE_CHECK([whether realloc (NULL,) will work],glib_cv_sane_realloc,[ AC_TRY_RUN([ #include int main() { return realloc (0, sizeof (int)) == 0; }], - glib_cv_sane_realloc=yes - AC_DEFINE(REALLOC_0_WORKS) - , - glib_cv_sane_realloc=no - ,) + [glib_cv_sane_realloc=yes], + [glib_cv_sane_realloc=no], + []) ]) -AC_MSG_RESULT($glib_cv_sane_realloc) +if test x$glib_cv_sane_realloc = xyes; then + AC_DEFINE(REALLOC_0_WORKS,1,[whether realloc (NULL,) works]) +fi + +dnl Check for nl_langinfo and CODESET + +AC_MSG_CHECKING([for nl_langinfo (CODESET)]) +AC_TRY_COMPILE([#include ], + [char *codeset = nl_langinfo (CODESET);], + AC_DEFINE(HAVE_CODESET,1,[Have nl_langinfo (CODESET)]) + have_codeset=yes, + have_codeset=no) +AC_MSG_RESULT($have_codeset) + +dnl **************************************** +dnl *** strlcpy/strlcat *** +dnl **************************************** +# Check for strlcpy +AC_MSG_CHECKING(for strlcpy/strlcat) +AC_TRY_LINK([#include +#include ], [ +char *p = malloc(10); +(void) strlcpy(p, "hi", 10); +(void) strlcat(p, "bye", 10); +], glib_ok=yes, glib_ok=no) +AC_MSG_RESULT($glib_ok) +if test "$glib_ok" = "yes"; then + AC_DEFINE(HAVE_STRLCPY,1,[Have functions strlcpy and strlcat]) +fi + 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_CACHE_CHECK([for an implementation of va_copy()],glib_cv_va_copy,[ AC_TRY_RUN([ #include void f (int i, ...) { @@ -423,14 +825,11 @@ AC_CACHE_VAL(glib_cv_va_copy,[ f (0, 42); return 0; }], - glib_cv_va_copy=yes - , - glib_cv_va_copy=no - ,) + [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_CACHE_CHECK([for an implementation of __va_copy()],glib_cv___va_copy,[ AC_TRY_RUN([ #include void f (int i, ...) { @@ -445,14 +844,23 @@ AC_CACHE_VAL(glib_cv___va_copy,[ f (0, 42); return 0; }], - glib_cv___va_copy=yes - , - glib_cv___va_copy=no - ,) + [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,[ + +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 void f (int i, ...) { @@ -467,22 +875,14 @@ AC_CACHE_VAL(glib_cv_va_val_copy,[ f (0, 42); return 0; }], - glib_cv_va_val_copy=yes - , - glib_cv_va_val_copy=no - ,) + [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) + AC_DEFINE(G_VA_COPY_AS_ARRAY,1, ['va_lists' cannot be copies as values]) fi -AC_MSG_RESULT($glib_cv_va_val_copy) - dnl *********************** dnl *** g_module checks *** @@ -490,73 +890,94 @@ dnl *********************** G_MODULE_LIBS= G_MODULE_LIBS_EXTRA= G_MODULE_PLUGIN_LIBS= -G_MODULE_LDFLAGS= +G_MODULE_LDFLAGS=`(./libtool --config; echo eval echo \\$export_dynamic_flag_spec) | sh` 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 *** 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 - ,) - ,) + [AC_CHECK_FUNC(dlsym, + [G_MODULE_IMPL=G_MODULE_IMPL_DL],[])], + []) fi dnl *** load_image (BeOS) -if test -z "$G_MODULE_IMPL" -a "x$glib_native_beos" = "xyes"; then +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" + [G_MODULE_LIBS="-lbe -lroot -lglib" 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 -,) + 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 - ,) - ,) + [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_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 - ,) + [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 for OSF1/5.0 RTLD_GLOBAL brokenness + AC_CACHE_CHECK([for RTLD_GLOBAL brokenness], + glib_cv_rtldglobal_broken,[ + AC_TRY_RUN([ + #include + #ifndef RTLD_GLOBAL + #define RTLD_GLOBAL 0 + #endif + #ifndef RTLD_LAZY + #define RTLD_LAZY 0 + #endif + int pthread_create; + int main () { + void *handle, *global, *local; + global = &pthread_create; + handle = dlopen ("libpthread.so", RTLD_GLOBAL | RTLD_LAZY); + if (!handle) return 0; + 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 + ]) + 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_MSG_CHECKING(for preceeding underscore in symbols) - AC_CACHE_VAL(glib_cv_uscore,[ + AC_CACHE_CHECK([for preceeding underscore in symbols], + glib_cv_uscore,[ AC_TRY_RUN([ #include int glib_underscore_test (void) { return 42; } @@ -568,12 +989,11 @@ dnl *** check whether we need preceeding underscores 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 + [glib_cv_uscore=yes], + [glib_cv_uscore=no], + []) + rm -f plugin.c plugin.$ac_objext plugin.lo ]) - AC_MSG_RESULT($glib_cv_uscore) if test "x$glib_cv_uscore" = "xyes"; then G_MODULE_NEED_USCORE=1 else @@ -583,29 +1003,120 @@ dnl *** check whether we need preceeding underscores 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 *** 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 shared libraries) +case "$host_os" in + hpux9* | hpux10* | hpux11*) # taken from ltconfig + glib_gmodule_suffix='sl' + ;; + cygwin* | mingw*) + glib_gmodule_suffix='dll' + ;; + *) + glib_gmodule_suffix='so' + ;; +esac +AC_MSG_RESULT(.$glib_gmodule_suffix) + +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 ********************** +dnl *** g_spawn checks *** +dnl ********************** + +AC_MSG_CHECKING(for gspawn implementation) +case "$host" in + *-*-mingw*) + GSPAWN=gspawn-win32.lo + ;; + *) + GSPAWN=gspawn.lo + ;; +esac +AC_MSG_RESULT($GSPAWN) +AC_SUBST(GSPAWN) + +dnl ************************* +dnl *** GIOChannel checks *** +dnl ************************* + +AC_MSG_CHECKING(for GIOChannel implementation) +case "$host" in + *-*-mingw*) + GIO=giowin32.lo + ;; + *) + GIO=giounix.lo + ;; +esac +AC_MSG_RESULT($GIO) +AC_SUBST(GIO) + +dnl **************************************** +dnl *** platform dependent source checks *** +dnl **************************************** + +AC_MSG_CHECKING(for platform-dependent source) +case "$host" in + *-*-cygwin*|*-*-mingw*) + PLATFORMDEP=gwin32.lo + ;; + *) + PLATFORMDEP= + ;; +esac +AC_MSG_RESULT($PLATFORMDEP) +AC_SUBST(PLATFORMDEP) + +AC_MSG_CHECKING([whether to compile timeloop]) +case "$host" in + *-*-cygwin*|*-*-mingw*) + enable_timeloop=no + ;; + *) + enable_timeloop=yes + ;; +esac +AC_MSG_RESULT($enable_timeloop) +AM_CONDITIONAL(ENABLE_TIMELOOP, test x$enable_timeloop = xyes) + +AC_MSG_CHECKING([if building for some Win32 platform]) +case "$host" in + *-*-mingw*|*-*-cygwin*) + platform_win32=yes + ;; + *) + platform_win32=no + ;; +esac +AC_MSG_RESULT($platform_win32) +AM_CONDITIONAL(PLATFORM_WIN32, test x$platform_win32 = xyes) dnl *********************** dnl *** g_thread checks *** dnl *********************** -AC_ARG_WITH(threads, [ --with-threads=[none/posix/dce/solaris] specify a thread implementation to use], +AC_ARG_WITH(threads, [ --with-threads=[none/posix/dce/solaris/win32] specify a thread implementation to use], if test "x$with_threads" = x; then want_threads=yes else @@ -615,9 +1126,6 @@ AC_ARG_WITH(threads, [ --with-threads=[none/posix/dce/solaris] specify a thread 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 dnl ************************* @@ -625,8 +1133,8 @@ 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, that enables thread safety on your - platform (normaly it's "_REENTRANT"). I'll not use any flag on +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." @@ -645,10 +1153,24 @@ FUNC_NO_GETPWUID_R="the 'g_get_(user_name|real_name|home_dir|tmp_dir)' 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." + + dnl determination of thread implementation dnl *************************************** -have_threads=none +# 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" = xsolaris; then case $host in *-*-solaris*) @@ -658,27 +1180,37 @@ if test "x$want_threads" = xyes || test "x$want_threads" = xsolaris; then fi if test "x$want_threads" = xyes || test "x$want_threads" = xposix \ || test "x$want_threads" = xdce; then - # -D_POSIX4A_DRAFT10_SOURCE is for DG/UX - # -U_OSF_SOURCE if for Digital UNIX 4.0d - GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE" + # -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" = xnone; then - AC_EGREP_HEADER([[^a-zA-Z_]pthread_attr_init[^a-zA-Z_]], - pthread.h, + if test "x$have_threads" = xno; then + AC_TRY_COMPILE([#include ], + [pthread_attr_t attr; pthread_attr_init(&attr);], have_threads=posix) fi - if test "x$have_threads" = xnone; then - AC_EGREP_HEADER([[^a-zA-Z_]pthread_attr_create[^a-zA-Z_]], - pthread.h, + if test "x$have_threads" = xno; then + AC_TRY_COMPILE([#include ], + [pthread_attr_t attr; pthread_attr_create(&attr);], have_threads=dce) 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" = xnone && test "x$want_threads" != xno; then +if test "x$have_threads" = xno && test "x$want_threads" != xno; then AC_MSG_RESULT(none available) AC_MSG_WARN($THREAD_NO_IMPLEMENTATION) else @@ -686,21 +1218,96 @@ else fi -dnl determination of G_THREAD_LIBS -dnl ****************************** +dnl determination of G_THREAD_CFLAGS +dnl ******************************** G_THREAD_LIBS= G_THREAD_LIBS_EXTRA= G_THREAD_CFLAGS= +if test x"$have_threads" != xno; then + + 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 + # GCC 3.0 and above needs -pthread + # GCC 2.x and below needs -mthreads + AC_TRY_COMPILE(,[#if __GNUC__ <= 2 + bail out here + #endif], + G_THREAD_CFLAGS="$G_THREAD_CFLAGS -pthread", + G_THREAD_CFLAGS="$G_THREAD_CFLAGS -mthreads") + fi + ;; + *-freebsd2.2*) + G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_THREAD_SAFE" + + # FreeBSD 2.2.x shiped with gcc 2.7.2.x, which doesn't support + # -mthreads flag. + ;; + *-sysv5uw7*) # UnixWare 7 + if test "$GCC" != "yes"; then + G_THREAD_CFLAGS="$G_THREAD_CFLAGS -Kthread" + else + G_THREAD_CFLAGS="$G_THREAD_CFLAGS -pthread" + fi + ;; + *-dg-dgux*) # DG/UX + G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_POSIX4A_DRAFT10_SOURCE" + esac + + # 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 ], , + [AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include + 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) + CFLAGS="$CFLAGS $G_THREAD_CFLAGS" +fi + +dnl determination of G_THREAD_LIBS +dnl ****************************** + mutex_has_default=no case $have_threads in posix|dce) - G_THREAD_LIBS=error - glib_save_LIBS="$LIBS" - for thread_lib in "" pthread pthreads c_r thread dce; do - # This is not AC_CHECK_LIB to also work with function - # name mangling in header files. + glib_save_CPPFLAGS="$CPPFLAGS" + CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES" + G_THREAD_LIBS=error + glib_save_LIBS="$LIBS" + case $host in + *-sysv5uw7*) # UnixWare 7 + if test "$GCC" != "yes"; then + G_THREAD_LIBS="-Kthread" + else + G_THREAD_LIBS="-pthread" + fi + ;; + *-*-openbsd* | *-*-freebsd*) + # FreeBSD and OpenBSD want us to use the -pthread flag + # instead of linking to -lc_r and libtool enforces that. + G_THREAD_LIBS="-pthread" + ;; + *) + for thread_lib in "" pthread pthread32 pthreads thread dce; do if test x"$thread_lib" = x; then add_thread_lib="" IN="" @@ -708,46 +1315,93 @@ case $have_threads in 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="$glib_save_LIBS $add_thread_lib" - AC_MSG_CHECKING(for pthread_join$IN) - AC_TRY_LINK([#include ], - [pthread_join(NULL,NULL)], + AC_MSG_CHECKING(for pthread_create/pthread_join$IN) + AC_TRY_RUN([#include + int check_me = 0; + void* func(void* data) {check_me = 42;} + main() + { pthread_t t; + void *ret; + pthread_create (&t, $defattr, func, 0); + pthread_join (t, &ret); + exit (check_me != 42); + }], [AC_MSG_RESULT(yes) G_THREAD_LIBS="$add_thread_lib" break], [AC_MSG_RESULT(no)]) 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) ;; + esac + if test "x$G_THREAD_LIBS" = xerror; then + AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2) + fi + 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="$glib_save_LIBS $add_thread_lib" + + AC_MSG_CHECKING(for sched_get_priority_min$IN) + AC_TRY_RUN([#include + #include + int main() { + errno = 0; + return sched_get_priority_min(SCHED_OTHER)==-1 + && errno != 0;}], + [AC_MSG_RESULT(yes) + 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], + [AC_MSG_RESULT(no)]) + 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" + ;; 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="SOLARIS" - ;; - none) - g_threads_impl="NONE" - ;; + 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="SOLARIS" + ;; + win32) + g_threads_impl="WIN32" + G_THREAD_LIBS="" + ;; + none|no) + g_threads_impl="NONE" + ;; *) - g_threads_impl="NONE" - G_THREAD_LIBS=error - ;; + g_threads_impl="NONE" + G_THREAD_LIBS=error + ;; esac if test "x$G_THREAD_LIBS" = xerror; then @@ -763,114 +1417,68 @@ case $host in ;; esac - AC_MSG_CHECKING(thread related libraries) AC_MSG_RESULT($G_THREAD_LIBS) -dnl determination of G_THREAD_CFLAGS -dnl ******************************** - -if test x"$enable_threads" = xyes; 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 - ;; - *-freebsd2.2*) - G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_THREAD_SAFE" - - # FreeBSD 2.2.x shiped with gcc 2.7.2.x, which doesn't support - # -mthreads flag. - ;; - 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" - # Note: Digital UNIX 4.0d #defines ctime_r to _Pctime_r for gcc. - 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(thread related cflags) - - AC_MSG_RESULT($G_THREAD_CFLAGS) -else - G_THREAD_CFLAGS= -fi - dnl check for mt safe function variants and some posix functions dnl ************************************************************ -if test x"$enable_threads" = xyes; then +if test x"$have_threads" != xno; then glib_save_LIBS="$LIBS" - glib_save_CFLAGS="$CFLAGS" # 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" - CFLAGS="$CFLAGS $G_THREAD_CFLAGS" AC_CHECK_FUNCS(localtime_r) if test "$ac_cv_header_pwd_h" = "yes"; then - AC_MSG_CHECKING([for getpwuid_r]) - AC_CACHE_VAL(ac_cv_func_getpwuid_r, + AC_CACHE_CHECK([for posix getpwuid_r], + ac_cv_func_posix_getpwuid_r, [AC_TRY_RUN([#include - int main () { char buffer[10000], *pointer; - char getpwuid_r (long, void*, void*, - int, void*); - errno = 0; - getpwuid_r (0, &buffer, &buffer, - sizeof (buffer), &pointer); - return errno == 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) + #include + 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])]) + if test "$ac_cv_func_posix_getpwuid_r" = yes; then + AC_DEFINE(HAVE_POSIX_GETPWUID_R,1, + [Have POSIX function getpwuid_r]) else - AC_MSG_RESULT(no) - fi - if test "$ac_cv_func_getpwuid_r" = "yes"; then - AC_MSG_CHECKING(whether getpwuid_r is posix like) - # getpwuid_r(0, NULL, NULL, 0) is the signature on - # solaris, if that is not found, the prog below won't - # compile, then the posix signature is assumed as - # the default. - AC_TRY_COMPILE([#include ], - [getpwuid_r(0, NULL, NULL, 0);], - [AC_MSG_RESULT(no)], - [AC_MSG_RESULT(yes) - AC_DEFINE(HAVE_GETPWUID_R_POSIX)]) + AC_CACHE_CHECK([for nonposix getpwuid_r], + ac_cv_func_nonposix_getpwuid_r, + [AC_TRY_LINK([#include ], + [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])]) + 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 LIBS="$LIBS $G_THREAD_LIBS" if test x"$have_threads" = xposix; then - GLIB_SIZEOF([#include ], - pthread_t, - pthread_t) + 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_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_attr_setstacksize(NULL,0)], + [pthread_attr_t t; pthread_attr_setstacksize(&t,0)], [AC_MSG_RESULT(yes) - AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE)], + AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE,1, + [Have function pthread_attr_setstacksize])], [AC_MSG_RESULT(no)]) - # If sched_get_priority_min(SCHED_OTHER) returns something - # negative, we ignore it. This happens on Solaris. AC_MSG_CHECKING(for minimal/maximal thread priority) - AC_TRY_RUN([#include - int main () - { return sched_get_priority_min(SCHED_OTHER) < 0;}], - [posix_priority_min="sched_get_priority_min(SCHED_OTHER)" - posix_priority_max="sched_get_priority_max(SCHED_OTHER)"], - [posix_priority_min=none]) if test x"$posix_priority_min" = xnone; then AC_EGREP_CPP(PX_PRIO_MIN,[#include PX_PRIO_MIN],,[ @@ -883,27 +1491,19 @@ if test x"$enable_threads" = xyes; then posix_priority_min=PRI_OTHER_MIN posix_priority_max=PRI_OTHER_MAX]) fi - if test x"$posix_priority_min" = xnone; then - case $host in - *-*-solaris*) - posix_priority_min=1 - posix_priority_max=127 - ;; - esac - fi - if test x"$posix_priority_min" = xnone; then + 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 + posix_priority_min=-1 + posix_priority_max=-1 else AC_MSG_RESULT($posix_priority_min/$posix_priority_max) + 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]) fi - AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min) - AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max) posix_yield_func=none AC_MSG_CHECKING(for posix yield function) - for yield_func in pthread_yield_np pthread_yield sched_yield \ + for yield_func in sched_yield pthread_yield_np pthread_yield \ thr_yield; do AC_TRY_LINK([#include ], [$yield_func()], @@ -913,32 +1513,63 @@ if test x"$enable_threads" = xyes; then if test x"$posix_yield_func" = xnone; then AC_MSG_RESULT(none found) AC_MSG_WARN($POSIX_NO_YIELD) - posix_yield_func="g_thread_sleep(1000)" + 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) + AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func,[The POSIX RT yield function]) + CPPFLAGS="$glib_save_CPPFLAGS" + + AC_MSG_CHECKING(whether to use the PID niceness surrogate for thread priorities) + AC_TRY_RUN([#include + #include + #include + pid_t other_pid = 0; + + void* func(void* data) {other_pid = getpid();} + main() + { pthread_t t; + void *ret; + pthread_create (&t, $defattr, func, NULL); + pthread_join (t, &ret); + exit (getpid()==other_pid || + $posix_priority_min != $posix_priority_max); + }], + [AC_MSG_RESULT(yes) + AC_DEFINE(G_THREAD_USE_PID_SURROGATE, 1, [whether to use the PID niceness surrogate for thread priorities]) + ], + [AC_MSG_RESULT(no)]) + elif test x"$have_threads" = xwin32; then + # It's a pointer to a private struct + GLIB_SIZEOF(,struct _GThreadData *, system_thread) + elif test x"$have_threads" = xsolaris; then + GLIB_SIZEOF([#include ], thread_t, system_thread) fi + LIBS="$glib_save_LIBS" - CFLAGS="$glib_save_CFLAGS" # now spit out all the warnings. - if test "$ac_cv_func_getpwuid_r" != "yes"; then + 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 -AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c") +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_EXTRA) -CFLAGS="$CFLAGS $G_THREAD_CFLAGS" - dnl ********************************************** dnl *** GDefaultMutex setup and initialization *** dnl ********************************************** @@ -946,6 +1577,10 @@ dnl dnl if mutex_has_default = yes, we also got dnl mutex_default_type, mutex_default_init and mutex_header_file GLIB_IF_VAR_EQ(mutex_has_default, yes, + glib_save_CPPFLAGS="$CPPFLAGS" + glib_save_LIBS="$LIBS" + LIBS="$LIBS $G_THREAD_LIBS" + CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES" GLIB_SIZEOF([#include <$mutex_header_file>], $mutex_default_type, gmutex, @@ -955,14 +1590,11 @@ GLIB_IF_VAR_EQ(mutex_has_default, yes, gmutex, $glib_cv_sizeof_gmutex, $mutex_default_init) - if test x"$have_threads" = xposix; then - GLIB_BYTE_CONTENTS([#define __USE_GNU -#include <$mutex_header_file>], - $mutex_default_type, - grecmutex, - $glib_cv_sizeof_gmutex, - PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP) + if test x"$glib_cv_byte_contents_gmutex" = xno; then + mutex_has_default=no fi + CPPFLAGS="$glib_save_CPPFLAGS" + LIBS="$glib_save_LIBS" , ) @@ -977,6 +1609,99 @@ GLIB_SYSDEFS( glibconfig-sysdefs.h, =) +dnl ********************** +dnl *** Win32 API libs *** +dnl ********************** + +case $host in + *-*-cygwin*) + G_LIBS_EXTRA="-luser32 -lwsock32 -lkernel32" + ;; + *-*-mingw*) + G_LIBS_EXTRA="-lwsock32" + ;; + *) + G_LIBS_EXTRA="" + ;; +esac +AC_SUBST(G_LIBS_EXTRA) + +dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves +dnl since we need it for g_iconv() + +AC_MSG_CHECKING([for EILSEQ]) +AC_TRY_COMPILE([ +#include +], +[ +int error = EILSEQ; +], have_eilseq=yes, have_eilseq=no); +AC_MSG_RESULT($have_eilseq) + +dnl ****************************************************************** +dnl *** Look for glib-genmarshal in PATH if we are cross-compiling *** +dnl ****************************************************************** + +AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes) + +if test $cross_compiling = yes; then + AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal, no) + if test x$GLIB_GENMARSHAL = xno; then + AC_MSG_ERROR(Could not find a glib-genmarshal in your PATH) + fi +fi + +dnl ************************** +dnl *** Checks for gtk-doc *** +dnl ************************** + +AC_ARG_WITH(html-dir, [ --with-html-dir=PATH path to installed docs]) + +if test "x$with_html_dir" = "x" ; then + HTML_DIR='${datadir}/gtk-doc/html' +else + HTML_DIR=$with_html_dir +fi + +AC_SUBST(HTML_DIR) + +AC_CHECK_PROG(GTKDOC, gtkdoc-mkdb, true, false) + +gtk_doc_min_version=0.6 +if $GTKDOC ; then + gtk_doc_version=`gtkdoc-mkdb --version` + AC_MSG_CHECKING([gtk-doc version ($gtk_doc_version) >= $gtk_doc_min_version]) + if perl <= "$gtk_doc_min_version") ? 0 : 1); +EOF + AC_MSG_RESULT(yes) + else + AC_MSG_RESULT(no) + GTKDOC=false + fi +fi + +AM_CONDITIONAL(HAVE_GTK_DOC, $GTKDOC) +AC_SUBST(HAVE_GTK_DOC) + +AC_CHECK_PROG(DB2HTML, db2html, true, false) +AM_CONDITIONAL(HAVE_DOCBOOK, $DB2HTML) + +dnl Let people disable the gtk-doc stuff. +AC_ARG_ENABLE(gtk-doc, [ --enable-gtk-doc use gtk-doc to build documentation [default=auto]], enable_gtk_doc="$enableval", enable_gtk_doc=no) + +if test x$enable_gtk_doc = xyes ; then + if test x$GTKDOC = xtrue ; then + enable_gtk_doc=yes + else + enable_gtk_doc=no + fi +fi + +dnl NOTE: We need to use a separate automake conditional for this +dnl to make this work with the tarballs. +AM_CONDITIONAL(ENABLE_GTK_DOC, test x$enable_gtk_doc = xyes) dnl ****************************** dnl *** output the whole stuff *** @@ -1005,15 +1730,13 @@ case "$CONFIG_OTHER" in cat > $outfile <<\_______EOF /* glibconfig.h * - * This is a generated file. Please modify `configure.in' + * This is a generated file. Please modify 'configure.in' */ -#ifndef GLIBCONFIG_H -#define GLIBCONFIG_H +#ifndef __G_LIBCONFIG_H__ +#define __G_LIBCONFIG_H__ -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ +#include _______EOF @@ -1026,8 +1749,8 @@ _______EOF if test x$glib_values_h = xyes; then echo '#include ' >> $outfile fi - if test x$g_mutex_header_file != x; then - echo '#include <'"$g_mutex_header_file"'>' >> $outfile + 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 @@ -1035,6 +1758,8 @@ _______EOF cat >> $outfile <<_______EOF +G_BEGIN_DECLS + #define G_MINFLOAT $glib_mf #define G_MAXFLOAT $glib_Mf #define G_MINDOUBLE $glib_md @@ -1049,6 +1774,10 @@ _______EOF #define G_MAXLONG $glib_Ml #define G_MAXULONG $glib_Mul +#define G_MININT64 ((gint64) 0x8000000000000000) +#define G_MAXINT64 ((gint64) 0x7fffffffffffffff) +#define G_MAXUINT64 ((guint64) 0xffffffffffffffff) + _______EOF @@ -1078,20 +1807,37 @@ typedef unsigned $gint32 guint32; _______EOF fi - - if test -n "$gint64"; then - cat >>$outfile <<_______EOF -${glib_warning_guard}#define G_HAVE_GINT64 1 + 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 +_______EOF + + if test x$gint64_format != x ; then + cat >>$outfile <<_______EOF #define G_GINT64_FORMAT $gint64_format #define G_GUINT64_FORMAT $guint64_format -#define G_GINT64_CONSTANT(val) $gint64_constant _______EOF - fi + else + cat >>$outfile <<_______EOF +#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 + +echo "typedef signed $glib_size_type_define gssize;" >> $outfile +echo "typedef unsigned $glib_size_type_define gsize;" >> $outfile if test -z "$glib_unknown_void_p"; then cat >>$outfile <<_______EOF @@ -1121,7 +1867,57 @@ $glib_vacopy #else /* !__cplusplus */ $glib_inline #endif /* !__cplusplus */ + +_______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 + + case x$g_stack_grows in + xyes) echo "#define G_HAVE_GROWING_STACK 1" >>$outfile ;; + *) echo "#define G_HAVE_GROWING_STACK 0" >>$outfile ;; + esac + + + 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 echo >>$outfile if test x$g_mutex_has_default = xyes; then @@ -1137,11 +1933,11 @@ struct _GStaticMutex double dummy_double; void *dummy_pointer; long dummy_long; - } aligned_pad_u; + } static_mutex; }; #define G_STATIC_MUTEX_INIT { NULL, { { $g_mutex_contents} } } #define g_static_mutex_get_mutex(mutex) \ - (g_thread_use_default_impl ? ((GMutex*) &((mutex)->aligned_pad_u)) : \ + (g_thread_use_default_impl ? ((GMutex*) &((mutex)->static_mutex)) : \ g_static_mutex_get_mutex_impl (&((mutex)->runtime_mutex))) _______EOF else @@ -1153,38 +1949,24 @@ typedef struct _GMutex* GStaticMutex; #define g_static_mutex_get_mutex(mutex) (g_static_mutex_get_mutex_impl (mutex)) _______EOF fi - if test x$g_recmutex_contents != xno -a \ - x$g_recmutex_contents != x; then - # the definition of GStaticRecMutex is not done via - # typedef GStaticMutex GStaticRecMutex to avoid silent - # compilation, when a GStaticRecMutex is used where a - # GStaticMutex should have been used and vice versa, - # because that micht fail on other platforms. - cat >>$outfile <<_______EOF -typedef struct _GStaticRecMutex GStaticRecMutex; -struct _GStaticRecMutex + + 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 { - struct _GMutex *runtime_mutex; - union { - char pad[$g_mutex_sizeof]; - double dummy_double; - void *dummy_pointer; - long dummy_long; - } aligned_pad_u; + char data[$g_system_thread_sizeof]; + double dummy_double; + void *dummy_pointer; + long dummy_long; }; -#define G_STATIC_REC_MUTEX_INIT { NULL, { { $g_recmutex_contents} } } -#define g_static_rec_mutex_lock(mutex) g_static_mutex_lock (mutex) -#define g_static_rec_mutex_trylock(mutex) g_static_mutex_trylock (mutex) -#define g_static_rec_mutex_unlock(mutex) g_static_mutex_unlock (mutex) -#define g_static_rec_mutex_get_mutex(mutex) (mutex) _______EOF - fi echo >>$outfile - g_bit_sizes="16 32" - if test -n "$gint64"; then - g_bit_sizes="$g_bit_sizes 64" - fi + 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)) @@ -1213,9 +1995,9 @@ _______EOF cat >>$outfile <<_______EOF -#ifdef __cplusplus -} -#endif /* __cplusplus */ +#define G_MODULE_SUFFIX "$g_module_suffix" + +G_END_DECLS #endif /* GLIBCONFIG_H */ _______EOF @@ -1235,6 +2017,12 @@ esac # 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 @@ -1302,7 +2090,6 @@ $ac_cv_sizeof_int) gint64_format='"i"' guint64_format='"u"' glib_extension= - glib_warning_guard= gint64_constant='(val)' ;; $ac_cv_sizeof_long) @@ -1310,25 +2097,31 @@ $ac_cv_sizeof_long) gint64_format='"li"' guint64_format='"lu"' glib_extension= - glib_warning_guard= gint64_constant='(val##L)' ;; $ac_cv_sizeof_long_long) gint64='long long' - gint64_format='"'$glib_cv_long_long_format'i"' - guint64_format='"'$glib_cv_long_long_format'u"' + if test -n "$glib_cv_long_long_format"; then + gint64_format='"'$glib_cv_long_long_format'i"' + guint64_format='"'$glib_cv_long_long_format'u"' + fi glib_extension='G_GNUC_EXTENSION ' - glib_warning_guard=" -#if defined (__GNUC__) && __GNUC__ >= 2 && __GNUC_MINOR__ >= 8 -# define G_GNUC_EXTENSION __extension__ -#else -# define G_GNUC_EXTENSION -#endif - -" gint64_constant='(G_GNUC_EXTENSION (val##LL))' ;; +$ac_cv_sizeof___int64) + gint64='__int64' + if test -n "$glib_cv_long_long_format"; then + gint64_format='"'$glib_cv_long_long_format'i"' + guint64_format='"'$glib_cv_long_long_format'u"' + fi + glib_extension= + gint64_constant='(val##i64)' + ;; esac +glib_size_t=$glib_cv_sizeof_size_t +glib_size_type_define=$glib_size_type +glib_void_p=$ac_cv_sizeof_long +glib_long=$ac_cv_sizeof_void_p gintbits=`expr $ac_cv_sizeof_int \* 8` glongbits=`expr $ac_cv_sizeof_long \* 8` @@ -1403,6 +2196,10 @@ if test x$glib_cv_has__inline__ = xyes; then #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 + case xyes in x$ac_cv_c_bigendian) g_byte_order=G_BIG_ENDIAN @@ -1416,17 +2213,23 @@ x$ac_cv_c_bigendian) ;; esac -case x$enable_threads in -xyes) g_enable_threads_def="#define";; -*) g_enable_threads_def="#undef ";; +g_stack_grows=$glib_cv_stack_grows + +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_recmutex_contents="$glib_cv_byte_contents_grecmutex" + +g_module_suffix="$glib_gmodule_suffix" case $host in *-*-beos*) @@ -1434,8 +2237,13 @@ case $host in ;; *-*-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" ;; @@ -1443,38 +2251,33 @@ esac ]) AC_OUTPUT([ +glib-2.0.pc +glib-2.0-uninstalled.pc +gmodule-2.0.pc +gmodule-2.0-uninstalled.pc +gthread-2.0.pc +gthread-2.0-uninstalled.pc +gobject-2.0.pc +gobject-2.0-uninstalled.pc glib.spec +glib-zip +glib-gettextize Makefile -glib-config +build/Makefile +build/win32/Makefile +build/win32/dirent/Makefile +glib/Makefile +glib/libcharset/Makefile gmodule/gmoduleconf.h gmodule/Makefile +gobject/Makefile +gobject/glib-mkenums gthread/Makefile +po/Makefile.in docs/Makefile +docs/reference/Makefile +docs/reference/glib/Makefile +docs/reference/gobject/Makefile tests/Makefile -],[case "$CONFIG_FILES" in -*glib-config*)chmod +x glib-config;; -esac -echo "" -echo " *** IMPORTANT *** " -echo "" -echo "This is a development version of GLib. You should be using a stable" -echo "version, which is available at ftp://ftp.gtk.org/pub/gtk/v1.2/. The" -echo "version you just configured is meant for developers of GLib only:" -echo "" -echo " * You should not base stable software on this version of GLib." -echo " * GNOME developers should use a stable version of GLib." -echo "" -echo "Distributions should *NOT* ship a development package of this GLib." -echo "Do not ship the headers and do not ship the glib-config script. These" -echo "things will conflict with the stable 1.2 series. Package only enough" -echo "to satisfy the requirements of some other package. Package only the" -echo "library itself. Doing otherwise will do no favors to the community." -echo "" -echo "If you install this version of GLib, we strongly recommend that you" -echo "install it in a different prefix than GLib 1.2. Use --prefix as an" -echo "argument to configure to do this. Otherwise, you will not be able to" -echo "do development with GLib 1.2 any longer." -echo "" -echo " *** You should be using GLib 1.2 instead. ***" +m4macros/Makefile ]) -