mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2024-11-05 08:56:16 +01:00
fe2efd06a0
2004-02-29 Sebastian Wilhelmi <seppi@seppi.de> * configure.in, glib/gatomic.c, glib/gatomic.h: Moved the assembler functions from gatomic.h to gatomic.c, which makes for better maintainability. Also use gint instead of gint32 to be able to use reference counting for ABI-fixed structures with gint/guint. * glib/gthread.h: Adapted accordingly. * tests/atomic-test.c: Updated to test for G_MAXINT and G_MININT. * glib/glib-overrides.txt, glib/glib-sections.txt, glib/tmpl/atomic_operations.sgml: Updated according to code changes.
2639 lines
72 KiB
Plaintext
2639 lines
72 KiB
Plaintext
# Process this file with autoconf to produce a configure script.
|
|
# require autoconf 2.54
|
|
AC_PREREQ(2.54)
|
|
|
|
dnl ***********************************
|
|
dnl *** include special GLib macros ***
|
|
dnl ***********************************
|
|
|
|
m4_define(glib_configure_in)
|
|
m4_include(acglib.m4)dnl
|
|
m4_include(glib/libcharset/codeset.m4)dnl
|
|
m4_include(glib/libcharset/glibc21.m4)dnl
|
|
m4_include(m4macros/glib-gettext.m4)dnl
|
|
|
|
#
|
|
# 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:
|
|
# 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.
|
|
#
|
|
m4_define([glib_major_version], [2])
|
|
m4_define([glib_minor_version], [3])
|
|
m4_define([glib_micro_version], [3])
|
|
m4_define([glib_interface_age], [0])
|
|
m4_define([glib_binary_age],
|
|
[m4_eval(100 * glib_minor_version + glib_micro_version)])
|
|
m4_define([glib_version],
|
|
[glib_major_version.glib_minor_version.glib_micro_version])
|
|
|
|
# libtool version related macros
|
|
m4_define([glib_lt_release], [glib_major_version.glib_minor_version])
|
|
m4_define([glib_lt_current],
|
|
[m4_eval(100 * glib_minor_version + glib_micro_version - glib_interface_age)])
|
|
m4_define([glib_lt_revision], [glib_interface_age])
|
|
m4_define([glib_lt_age], [m4_eval(glib_binary_age - glib_interface_age)])
|
|
m4_define([glib_lt_current_minus_age],
|
|
[m4_eval(glib_lt_current - glib_lt_age)])
|
|
|
|
# if the minor version number is odd, then we want debugging. Otherwise
|
|
# we only want minimal debugging support.
|
|
m4_define([glib_debug_default],
|
|
[m4_if(m4_eval(glib_minor_version % 2), [1], [yes], [minimum])])dnl
|
|
|
|
|
|
AC_INIT(glib, [glib_version],
|
|
[http://bugzilla.gnome.org/enter_bug.cgi?product=glib])
|
|
|
|
AC_CONFIG_SRCDIR([glib/glib.h])
|
|
|
|
# Save this value here, since automake will set cflags later
|
|
cflags_set=${CFLAGS+set}
|
|
|
|
AM_INIT_AUTOMAKE([no-define])
|
|
|
|
# Specify a configuration file
|
|
AM_CONFIG_HEADER([config.h])
|
|
|
|
|
|
GLIB_MAJOR_VERSION=glib_major_version
|
|
GLIB_MINOR_VERSION=glib_minor_version
|
|
GLIB_MICRO_VERSION=glib_micro_version
|
|
GLIB_INTERFACE_AGE=glib_interface_age
|
|
GLIB_BINARY_AGE=glib_binary_age
|
|
GLIB_VERSION=glib_version
|
|
|
|
AC_SUBST(GLIB_MAJOR_VERSION)
|
|
AC_SUBST(GLIB_MINOR_VERSION)
|
|
AC_SUBST(GLIB_MICRO_VERSION)
|
|
AC_SUBST(GLIB_VERSION)
|
|
AC_SUBST(GLIB_INTERFACE_AGE)
|
|
AC_SUBST(GLIB_BINARY_AGE)
|
|
|
|
AC_DEFINE(GLIB_MAJOR_VERSION, [glib_major_version],
|
|
[Define to the GLIB major version])
|
|
AC_DEFINE(GLIB_MINOR_VERSION, [glib_minor_version],
|
|
[Define to the GLIB minor version])
|
|
AC_DEFINE(GLIB_MICRO_VERSION, [glib_micro_version],
|
|
[Define to the GLIB micro version])
|
|
AC_DEFINE(GLIB_INTERFACE_AGE, [glib_interface_age],
|
|
[Define to the GLIB interface age])
|
|
AC_DEFINE(GLIB_BINARY_AGE, [glib_binary_age],
|
|
[Define to the GLIB binary age])
|
|
|
|
# libtool versioning
|
|
LT_RELEASE=glib_lt_release
|
|
LT_CURRENT=glib_lt_current
|
|
LT_REVISION=glib_lt_revision
|
|
LT_AGE=glib_lt_age
|
|
LT_CURRENT_MINUS_AGE=glib_lt_current_minus_age
|
|
AC_SUBST(LT_RELEASE)
|
|
AC_SUBST(LT_CURRENT)
|
|
AC_SUBST(LT_REVISION)
|
|
AC_SUBST(LT_AGE)
|
|
AC_SUBST(LT_CURRENT_MINUS_AGE)
|
|
|
|
dnl Initialize maintainer mode
|
|
AM_MAINTAINER_MODE
|
|
|
|
AC_CANONICAL_HOST
|
|
|
|
AC_MSG_CHECKING([for the BeOS])
|
|
case $host in
|
|
*-*-beos*)
|
|
glib_native_beos="yes"
|
|
;;
|
|
*)
|
|
glib_native_beos="no"
|
|
;;
|
|
esac
|
|
AC_MSG_RESULT([$glib_native_beos])
|
|
|
|
dnl
|
|
|
|
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_pid_type=HANDLE
|
|
;;
|
|
*)
|
|
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=
|
|
glib_pid_type=int
|
|
;;
|
|
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
|
|
AM_CONDITIONAL(MS_LIB_AVAILABLE, [test x$ms_librarian = xyes])
|
|
|
|
dnl declare --enable-* args and collect ac_help strings
|
|
AC_ARG_ENABLE(debug,
|
|
AC_HELP_STRING([--enable-debug=@<:@no/minimum/yes@:>@],
|
|
[turn on debugging @<:@default=glib_debug_default@:>@]),,
|
|
enable_debug=glib_debug_default)
|
|
|
|
AC_ARG_ENABLE(gc_friendly,
|
|
[AC_HELP_STRING([--enable-gc-friendly],
|
|
[turn on garbage collector friendliness [default=no]])],,
|
|
[enable_gc_friendly=no])
|
|
AC_ARG_ENABLE(mem_pools,
|
|
[AC_HELP_STRING([--disable-mem-pools],
|
|
[disable all glib memory pools])],,
|
|
[disable_mem_pools=no])
|
|
AC_ARG_ENABLE(ansi,
|
|
[AC_HELP_STRING([--enable-ansi],
|
|
[turn on strict ansi [default=no]])],,
|
|
[enable_ansi=no])
|
|
AC_ARG_ENABLE(threads,
|
|
[AC_HELP_STRING([--enable-threads],
|
|
[turn on basic thread support [default=yes]
|
|
([=no] will override --with-threads)])],,
|
|
[enable_threads=yes])
|
|
AC_ARG_ENABLE(rebuilds,
|
|
[AC_HELP_STRING([--disable-rebuilds],
|
|
[disable all source autogeneration rules])],,
|
|
[enable_rebuilds=yes])
|
|
|
|
if test "x$enable_threads" != "xyes"; then
|
|
enable_threads=no
|
|
fi
|
|
|
|
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 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
|
|
|
|
if test "$glib_native_win32" = "yes"; then
|
|
if test x$enable_static = xyes -o x$enable_static = x; then
|
|
AC_MSG_WARN([Disabling static library build, must build as DLL on Windows.])
|
|
enable_static=no
|
|
fi
|
|
if test x$enable_shared = xno; then
|
|
AC_MSG_WARN([Enabling shared library build, must build as DLL on Windows.])
|
|
fi
|
|
enable_shared=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.14 ; then
|
|
:
|
|
else
|
|
AC_MSG_ERROR([*** pkg-config too old; version 0.14 or better required.])
|
|
fi
|
|
|
|
if test "x$enable_debug" = "xyes"; then
|
|
if test x$cflags_set != xset ; then
|
|
case " $CFLAGS " in
|
|
*[[\ \ ]]-g[[\ \ ]]*) ;;
|
|
*) CFLAGS="$CFLAGS -g" ;;
|
|
esac
|
|
fi
|
|
|
|
GLIB_DEBUG_FLAGS="-DG_ENABLE_DEBUG"
|
|
else
|
|
GLIB_DEBUG_FLAGS="-DG_DISABLE_CAST_CHECKS"
|
|
|
|
if test "x$enable_debug" = "xno"; then
|
|
GLIB_DEBUG_FLAGS="$GLIB_DEBUG_FLAGS -DG_DISABLE_ASSERT -DG_DISABLE_CHECKS"
|
|
fi
|
|
fi
|
|
|
|
# Ensure MSVC-compatible struct packing convention is used when
|
|
# compiling for Win32 with gcc.
|
|
# What flag to depends on gcc version: gcc3 uses "-mms-bitfields", while
|
|
# gcc2 uses "-fnative-struct".
|
|
if test x"$glib_native_win32" = xyes; then
|
|
if test x"$GCC" = xyes; then
|
|
msnative_struct=''
|
|
AC_MSG_CHECKING([how to get MSVC-compatible struct packing])
|
|
if test -z "$ac_cv_prog_CC"; then
|
|
our_gcc="$CC"
|
|
else
|
|
our_gcc="$ac_cv_prog_CC"
|
|
fi
|
|
case `$our_gcc --version | sed -e 's,\..*,.,' -e q` in
|
|
2.)
|
|
if $our_gcc -v --help 2>/dev/null | grep fnative-struct >/dev/null; then
|
|
msnative_struct='-fnative-struct'
|
|
fi
|
|
;;
|
|
*)
|
|
if $our_gcc -v --help 2>/dev/null | grep ms-bitfields >/dev/null; then
|
|
msnative_struct='-mms-bitfields'
|
|
fi
|
|
;;
|
|
esac
|
|
if test x"$msnative_struct" = x ; then
|
|
AC_MSG_RESULT([no way])
|
|
AC_MSG_WARN([produced libraries might be incompatible with MSVC-compiled code])
|
|
else
|
|
CFLAGS="$CFLAGS $msnative_struct"
|
|
AC_MSG_RESULT([${msnative_struct}])
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
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)
|
|
|
|
# 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,
|
|
[AC_HELP_STRING([--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="am ar az be bg bn ca cs cy da de el eo es et eu fa fi fr gl he hi hr id is it ja ko lt lv mk mn ms nl nn no pl pt pt_BR ro ru sk sl sq sr sr@Latn sv ta tr uk vi yi zh_CN zh_TW"
|
|
GLIB_GNU_GETTEXT
|
|
|
|
if test "$gt_cv_have_gettext" != "yes" ; then
|
|
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="$INTLLIBS $LIBS"
|
|
|
|
GETTEXT_PACKAGE=glib20
|
|
AC_SUBST(GETTEXT_PACKAGE)
|
|
AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE, ["$GETTEXT_PACKAGE"],
|
|
[Define the gettext package to be used])
|
|
|
|
GLIB_DEFINE_LOCALEDIR(GLIB_LOCALE_DIR)
|
|
|
|
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, 1, [Using GNU libiconv])
|
|
;;
|
|
native)
|
|
AC_DEFINE(USE_LIBICONV_NATIVE, 1, [Using a native implementation of iconv in a separate library])
|
|
;;
|
|
esac
|
|
|
|
dnl Initialize libtool
|
|
AM_DISABLE_STATIC
|
|
AM_PROG_LIBTOOL
|
|
|
|
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
|
|
|
|
dnl
|
|
dnl DU4 native cc currently needs -std1 for ANSI mode (instead of K&R)
|
|
dnl
|
|
if test $cross_compiling != yes ; then
|
|
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
|
|
fi
|
|
|
|
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_FUNC_ALLOCA
|
|
|
|
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)
|
|
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 guint64)
|
|
AC_CACHE_VAL(glib_cv_long_long_format,[
|
|
for format in ll q I64; do
|
|
AC_TRY_RUN([#include <stdio.h>
|
|
int main()
|
|
{
|
|
long long b, a = -0x3AFAFAFAFAFAFAFALL;
|
|
char buffer[1000];
|
|
sprintf (buffer, "%${format}u", a);
|
|
sscanf (buffer, "%${format}u", &b);
|
|
exit (b!=a);
|
|
}
|
|
],
|
|
[glib_cv_long_long_format=${format}
|
|
break],
|
|
[],[:])
|
|
done])
|
|
if test -n "$glib_cv_long_long_format"; then
|
|
AC_MSG_RESULT(%${glib_cv_long_long_format}u)
|
|
AC_DEFINE(HAVE_LONG_LONG_FORMAT,1,[define if system printf can print long long])
|
|
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)
|
|
AC_DEFINE(HAVE_LONG_LONG_FORMAT,1,[define if system printf can print long long])
|
|
AC_DEFINE(HAVE_INT64_AND_I64,1,[define to support printing __int64 with format I64])
|
|
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 <stdlib.h>], [
|
|
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, 1,
|
|
[Define if you have correct malloc prototypes])
|
|
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_CACHE_CHECK([for __inline],glib_cv_has__inline,[
|
|
AC_COMPILE_IFELSE([
|
|
__inline int foo () { return 0; }
|
|
int main () { return foo (); }
|
|
],
|
|
glib_cv_has__inline=yes
|
|
,
|
|
glib_cv_has__inline=no
|
|
,)
|
|
])
|
|
case x$glib_cv_has__inline in
|
|
xyes) AC_DEFINE(G_HAVE___INLINE,1,[Have __inline keyword])
|
|
esac
|
|
AC_CACHE_CHECK([for __inline__],glib_cv_has__inline__,[
|
|
AC_COMPILE_IFELSE([
|
|
__inline__ int foo () { return 0; }
|
|
int main () { return foo (); }
|
|
],
|
|
glib_cv_has__inline__=yes
|
|
,
|
|
glib_cv_has__inline__=no
|
|
,)
|
|
])
|
|
case x$glib_cv_has__inline__ in
|
|
xyes) AC_DEFINE(G_HAVE___INLINE__,1,[Have __inline__ keyword])
|
|
esac
|
|
AC_CACHE_CHECK([for inline], glib_cv_hasinline,[
|
|
AC_COMPILE_IFELSE([
|
|
#undef inline
|
|
inline int foo () { return 0; }
|
|
int main () { return foo (); }
|
|
],
|
|
glib_cv_hasinline=yes
|
|
,
|
|
glib_cv_hasinline=no
|
|
,)
|
|
])
|
|
case x$glib_cv_hasinline in
|
|
xyes) AC_DEFINE(G_HAVE_INLINE,1,[Have inline keyword])
|
|
esac
|
|
|
|
# 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
|
|
|
|
# check for header files
|
|
AC_CHECK_HEADERS([dirent.h float.h limits.h pwd.h sys/param.h sys/poll.h sys/select.h sys/types.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)
|
|
|
|
# check additional type sizes
|
|
AC_CHECK_SIZEOF(size_t)
|
|
|
|
dnl Try to figure out whether gsize, gssize should be long or int
|
|
AC_MSG_CHECKING([for the appropriate definition for size_t])
|
|
|
|
case $ac_cv_sizeof_size_t in
|
|
$ac_cv_sizeof_short)
|
|
glib_size_type=short
|
|
;;
|
|
$ac_cv_sizeof_int)
|
|
glib_size_type=int
|
|
;;
|
|
$ac_cv_sizeof_long)
|
|
glib_size_type=long
|
|
;;
|
|
*) AC_MSG_ERROR([No type matching size_t in size])
|
|
;;
|
|
esac
|
|
|
|
dnl If int/long are the same size, we see which one produces
|
|
dnl warnings when used in the location as size_t. (This matters
|
|
dnl on AIX with xlc)
|
|
dnl
|
|
if test $ac_cv_sizeof_size_t = $ac_cv_sizeof_int &&
|
|
test $ac_cv_sizeof_size_t = $ac_cv_sizeof_long ; then
|
|
GLIB_CHECK_COMPILE_WARNINGS([
|
|
#include <stddef.h>
|
|
int main ()
|
|
{
|
|
size_t s = 1;
|
|
unsigned int *size_int = &s;
|
|
return (int)*size_int;
|
|
}
|
|
],glib_size_type=int,
|
|
[GLIB_CHECK_COMPILE_WARNINGS([
|
|
#include <stddef.h>
|
|
int main ()
|
|
{
|
|
size_t s = 1;
|
|
unsigned long *size_long = &s;
|
|
return (int)*size_long;
|
|
}
|
|
],glib_size_type=long)])
|
|
fi
|
|
|
|
AC_MSG_RESULT(unsigned $glib_size_type)
|
|
|
|
# Check for some functions
|
|
AC_CHECK_FUNCS(lstat strerror strsignal memmove mkstemp vsnprintf stpcpy strcasecmp strncasecmp poll getcwd nanosleep vasprintf setenv unsetenv getc_unlocked readlink symlink)
|
|
|
|
AC_FUNC_VSNPRINTF_C99
|
|
AC_FUNC_PRINTF_UNIX98
|
|
|
|
#
|
|
# Check whether to use an included printf
|
|
#
|
|
|
|
AC_ARG_ENABLE(included-printf,
|
|
[AC_HELP_STRING([--enable-included-printf],
|
|
[use included printf [default=auto]])],
|
|
enable_included_printf="$enableval")
|
|
|
|
need_included_printf=no
|
|
if test "x$enable_included_printf" = "xyes" ; then
|
|
need_included_printf=yes
|
|
fi
|
|
if test "$ac_cv_func_vsnprintf_c99" != "yes" ; then
|
|
need_included_printf=yes
|
|
fi
|
|
if test "$ac_cv_func_printf_unix98" != "yes" ; then
|
|
need_included_printf=yes
|
|
fi
|
|
if test "x$ac_cv_sizeof_long_long" = "x8" &&
|
|
test -z "$glib_cv_long_long_format" ; then
|
|
need_included_printf=yes
|
|
fi
|
|
|
|
if test "x$enable_included_printf" = "xno" &&
|
|
test "x$need_included_printf" = "xyes" ; then
|
|
AC_MSG_ERROR([
|
|
*** Your C library's printf doesn't appear to have the features that
|
|
*** GLib needs, but you specified --enable-included-printf=no.])
|
|
fi
|
|
|
|
enable_included_printf=$need_included_printf
|
|
|
|
AM_CONDITIONAL(HAVE_GOOD_PRINTF, test "$enable_included_printf" != "yes")
|
|
if test "$enable_included_printf" != "yes" ; then
|
|
AC_DEFINE(HAVE_GOOD_PRINTF,1,[define to use system printf])
|
|
else
|
|
if test -z "$glib_cv_long_long_format" ; then
|
|
glib_cv_long_long_format="ll"
|
|
fi
|
|
AC_DEFINE(HAVE_VASPRINTF,1)
|
|
fi
|
|
|
|
# Checks needed for gnulib vasnprintf
|
|
bh_C_SIGNED
|
|
jm_AC_TYPE_LONG_LONG
|
|
gt_TYPE_LONGDOUBLE
|
|
gt_TYPE_WCHAR_T
|
|
gt_TYPE_WINT_T
|
|
AC_TYPE_SIZE_T
|
|
AC_CHECK_TYPES(ptrdiff_t)
|
|
jm_AC_TYPE_INTMAX_T
|
|
AC_CHECK_FUNCS(snprintf)
|
|
AC_FUNC_SNPRINTF_C99
|
|
|
|
# Check if bcopy can be used for overlapping copies, if memmove isn't found.
|
|
# The check is borrowed from the PERL Configure script.
|
|
if test "$ac_cv_func_memmove" != "yes"; then
|
|
AC_CACHE_CHECK(whether bcopy can handle overlapping copies,
|
|
glib_cv_working_bcopy,[AC_TRY_RUN([
|
|
int main() {
|
|
char buf[128], abc[128], *b;
|
|
int len, off, align;
|
|
bcopy("abcdefghijklmnopqrstuvwxyz0123456789", abc, 36);
|
|
for (align = 7; align >= 0; align--) {
|
|
for (len = 36; len; len--) {
|
|
b = buf+align; bcopy(abc, b, len);
|
|
for (off = 1; off <= len; off++) {
|
|
bcopy(b, b+off, len); bcopy(b+off, b, len);
|
|
if (bcmp(b, abc, len)) return(1);
|
|
}
|
|
}
|
|
}
|
|
return(0);
|
|
}],glib_cv_working_bcopy=yes,glib_cv_working_bcopy=no)])
|
|
|
|
GLIB_ASSERT_SET(glib_cv_working_bcopy)
|
|
if test "$glib_cv_working_bcopy" = "yes"; then
|
|
AC_DEFINE(HAVE_WORKING_BCOPY,1,[Have a working bcopy])
|
|
fi
|
|
fi
|
|
|
|
# Check for sys_errlist
|
|
AC_MSG_CHECKING(for sys_errlist)
|
|
AC_TRY_LINK(, [
|
|
extern char *sys_errlist[];
|
|
extern int sys_nerr;
|
|
sys_errlist[sys_nerr-1][0] = 0;
|
|
], glib_ok=yes, glib_ok=no)
|
|
AC_MSG_RESULT($glib_ok)
|
|
if test "$glib_ok" = "no"; then
|
|
AC_DEFINE(NO_SYS_ERRLIST,1,[global 'sys_errlist' not found])
|
|
fi
|
|
|
|
# Check for sys_siglist
|
|
AC_MSG_CHECKING(for sys_siglist)
|
|
AC_TRY_LINK(, [
|
|
extern char *sys_siglist[];
|
|
exit (sys_siglist[0]);
|
|
], glib_ok=yes, glib_ok=no)
|
|
AC_MSG_RESULT($glib_ok)
|
|
if test "$glib_ok" = "no"; then
|
|
AC_DEFINE(NO_SYS_SIGLIST,1,[global 'sys_siglist' not found])
|
|
fi
|
|
|
|
# Check for sys_siglist decl (see Tue Jan 19 00:44:24 1999 in changelog)
|
|
AC_MSG_CHECKING(for sys_siglist declaration)
|
|
AC_TRY_COMPILE([#include <signal.h>], [
|
|
strlen (sys_siglist[0]);
|
|
], glib_ok=yes, glib_ok=no)
|
|
AC_MSG_RESULT($glib_ok)
|
|
if test "$glib_ok" = "no"; then
|
|
AC_DEFINE(NO_SYS_SIGLIST_DECL,1,[global 'sys_siglist' not declared])
|
|
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_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,1,[didn't find fd_set])
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
fi
|
|
|
|
dnl *** check for sane realloc() ***
|
|
AC_CACHE_CHECK([whether realloc (NULL,) will work],glib_cv_sane_realloc,[
|
|
AC_TRY_RUN([#include <stdlib.h>
|
|
int main() {
|
|
return realloc (0, sizeof (int)) == 0;
|
|
}],
|
|
[glib_cv_sane_realloc=yes],
|
|
[glib_cv_sane_realloc=no],
|
|
[glib_cv_sane_realloc=yes])
|
|
])
|
|
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 <langinfo.h>],
|
|
[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_CACHE_CHECK([for OpenBSD strlcpy/strlcat],glib_cv_have_strlcpy,[
|
|
AC_TRY_RUN([#include <stdlib.h>
|
|
#include <string.h>
|
|
int main() {
|
|
char p[10];
|
|
(void) strlcpy (p, "hi", 10);
|
|
if (strlcat (p, "bye", 0) != 3)
|
|
return 1;
|
|
return 0;
|
|
}], glib_cv_have_strlcpy=yes,
|
|
glib_cv_have_strlcpy=no,
|
|
glib_cv_have_strlcpy=no)])
|
|
if test "$glib_cv_have_strlcpy" = "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_CACHE_CHECK([for an implementation of va_copy()],glib_cv_va_copy,[
|
|
AC_LINK_IFELSE([#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_CACHE_CHECK([for an implementation of __va_copy()],glib_cv___va_copy,[
|
|
AC_LINK_IFELSE([#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])
|
|
])
|
|
|
|
if test "x$glib_cv_va_copy" = "xyes"; then
|
|
g_va_copy_func=va_copy
|
|
else if test "x$glib_cv___va_copy" = "xyes"; then
|
|
g_va_copy_func=__va_copy
|
|
fi
|
|
fi
|
|
|
|
if test -n "$g_va_copy_func"; then
|
|
AC_DEFINE_UNQUOTED(G_VA_COPY,$g_va_copy_func,[A 'va_copy' style function])
|
|
fi
|
|
|
|
AC_CACHE_CHECK([whether va_lists can be copied by value],glib_cv_va_val_copy,[
|
|
AC_TRY_RUN([#include <stdarg.h>
|
|
void f (int i, ...) {
|
|
va_list args1, args2;
|
|
va_start (args1, i);
|
|
args2 = args1;
|
|
if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
|
|
exit (1);
|
|
va_end (args1); va_end (args2);
|
|
}
|
|
int main() {
|
|
f (0, 42);
|
|
return 0;
|
|
}],
|
|
[glib_cv_va_val_copy=yes],
|
|
[glib_cv_va_val_copy=no],
|
|
[glib_cv_va_val_copy=yes])
|
|
])
|
|
|
|
if test "x$glib_cv_va_val_copy" = "xno"; then
|
|
AC_DEFINE(G_VA_COPY_AS_ARRAY,1, ['va_lists' cannot be copies as values])
|
|
fi
|
|
|
|
dnl ***********************
|
|
dnl *** g_module checks ***
|
|
dnl ***********************
|
|
G_MODULE_LIBS=
|
|
G_MODULE_LIBS_EXTRA=
|
|
G_MODULE_PLUGIN_LIBS=
|
|
if test x"$glib_native_win32" = xyes; then
|
|
dnl No use for this on Win32
|
|
G_MODULE_LDFLAGS=
|
|
else
|
|
G_MODULE_LDFLAGS=`(./libtool --config; echo eval echo \\$export_dynamic_flag_spec) | sh`
|
|
fi
|
|
dnl G_MODULE_IMPL= don't reset, so cmd-line can override
|
|
G_MODULE_NEED_USCORE=0
|
|
G_MODULE_BROKEN_RTLD_GLOBAL=0
|
|
G_MODULE_HAVE_DLERROR=0
|
|
dnl *** force native WIN32 shared lib loader
|
|
if test -z "$G_MODULE_IMPL"; then
|
|
case "$host" in
|
|
*-*-mingw*|*-*-cygwin*) G_MODULE_IMPL=G_MODULE_IMPL_WIN32 ;;
|
|
esac
|
|
fi
|
|
dnl *** force native AIX library loader
|
|
dnl *** dlopen() filepath must be of the form /path/libname.a(libname.so)
|
|
if test -z "$G_MODULE_IMPL"; then
|
|
case "$host" in
|
|
*-*-aix*) G_MODULE_IMPL=G_MODULE_IMPL_AR ;;
|
|
esac
|
|
fi
|
|
dnl *** dlopen() and dlsym() in system libraries
|
|
if test -z "$G_MODULE_IMPL"; then
|
|
AC_CHECK_FUNC(dlopen,
|
|
[AC_CHECK_FUNC(dlsym,
|
|
[G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
|
|
[])
|
|
fi
|
|
dnl *** load_image (BeOS)
|
|
if test -z "$G_MODULE_IMPL" && test "x$glib_native_beos" = "xyes"; then
|
|
AC_CHECK_LIB(root, load_image,
|
|
[G_MODULE_LIBS="-lbe -lroot -lglib"
|
|
G_MODULE_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
|
|
G_MODULE_PLUGIN_LIBS="-L\$(top_builddir_full)/gmodule/.libs -lgmodule"
|
|
G_MODULE_IMPL=G_MODULE_IMPL_BEOS],
|
|
[])
|
|
fi
|
|
dnl *** NSLinkModule (dyld) in system libraries (Darwin)
|
|
if test -z "$G_MODULE_IMPL"; then
|
|
AC_CHECK_FUNC(NSLinkModule,
|
|
[G_MODULE_IMPL=G_MODULE_IMPL_DYLD
|
|
G_MODULE_NEED_USCORE=1],
|
|
[])
|
|
fi
|
|
dnl *** dlopen() and dlsym() in libdl
|
|
if test -z "$G_MODULE_IMPL"; then
|
|
AC_CHECK_LIB(dl, dlopen,
|
|
[AC_CHECK_LIB(dl, dlsym,
|
|
[G_MODULE_LIBS=-ldl
|
|
G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
|
|
[])
|
|
fi
|
|
dnl *** shl_load() in libdld (HP-UX)
|
|
if test -z "$G_MODULE_IMPL"; then
|
|
AC_CHECK_LIB(dld, shl_load,
|
|
[G_MODULE_LIBS=-ldld
|
|
G_MODULE_IMPL=G_MODULE_IMPL_DLD],
|
|
[])
|
|
fi
|
|
dnl *** additional checks for G_MODULE_IMPL_DL
|
|
if test "$G_MODULE_IMPL" = "G_MODULE_IMPL_DL"; then
|
|
LIBS_orig="$LIBS"
|
|
LDFLAGS_orig="$LDFLAGS"
|
|
LIBS="$G_MODULE_LIBS $LIBS"
|
|
LDFLAGS="$LDFLAGS $G_MODULE_LDFLAGS"
|
|
dnl *** check for OSF1/5.0 RTLD_GLOBAL brokenness
|
|
AC_CACHE_CHECK([for RTLD_GLOBAL brokenness],
|
|
glib_cv_rtldglobal_broken,[
|
|
AC_TRY_RUN([
|
|
#include <dlfcn.h>
|
|
#ifndef RTLD_GLOBAL
|
|
# define RTLD_GLOBAL 0
|
|
#endif
|
|
#ifndef RTLD_LAZY
|
|
# define RTLD_LAZY 0
|
|
#endif
|
|
int 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],
|
|
[glib_cv_rtldglobal_broken=no])
|
|
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_CACHE_CHECK([for preceeding underscore in symbols],
|
|
glib_cv_uscore,[
|
|
AC_TRY_RUN([#include <dlfcn.h>
|
|
int glib_underscore_test (void) { return 42; }
|
|
int main() {
|
|
void *f1 = (void*)0, *f2 = (void*)0, *handle;
|
|
handle = dlopen ((void*)0, 0);
|
|
if (handle) {
|
|
f1 = dlsym (handle, "glib_underscore_test");
|
|
f2 = dlsym (handle, "_glib_underscore_test");
|
|
} return (!f2 || f1);
|
|
}],
|
|
[glib_cv_uscore=yes],
|
|
[glib_cv_uscore=no],
|
|
[])
|
|
rm -f plugin.c plugin.$ac_objext plugin.lo
|
|
])
|
|
GLIB_ASSERT_SET(glib_cv_uscore)
|
|
if test "x$glib_cv_uscore" = "xyes"; then
|
|
G_MODULE_NEED_USCORE=1
|
|
else
|
|
G_MODULE_NEED_USCORE=0
|
|
fi
|
|
|
|
LDFLAGS="$LDFLAGS_orig"
|
|
dnl *** check for having dlerror()
|
|
AC_CHECK_FUNC(dlerror,
|
|
[G_MODULE_HAVE_DLERROR=1],
|
|
[G_MODULE_HAVE_DLERROR=0])
|
|
LIBS="$LIBS_orig"
|
|
fi
|
|
dnl *** done, have we got an implementation?
|
|
if test -z "$G_MODULE_IMPL"; then
|
|
G_MODULE_IMPL=0
|
|
G_MODULE_SUPPORTED=false
|
|
else
|
|
G_MODULE_SUPPORTED=true
|
|
fi
|
|
|
|
AC_MSG_CHECKING(for the suffix of shared libraries)
|
|
case "$host_os" in
|
|
hpux9* | hpux10* | hpux11*) # taken from ltconfig
|
|
glib_gmodule_suffix='sl'
|
|
;;
|
|
cygwin* | mingw*)
|
|
glib_gmodule_suffix='dll'
|
|
;;
|
|
aix*)
|
|
glib_gmodule_suffix='a'
|
|
;;
|
|
*)
|
|
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,
|
|
[AC_HELP_STRING([--with-threads=@<:@none/posix/dce/solaris/win32@:>@],
|
|
[specify a thread implementation to use])],
|
|
[if test "x$with_threads" = x; then
|
|
want_threads=yes
|
|
else
|
|
want_threads=$with_threads
|
|
fi],
|
|
[want_threads=yes])
|
|
if test "x$enable_threads" = "xno"; then
|
|
want_threads=no
|
|
fi
|
|
|
|
dnl error and warning message
|
|
dnl *************************
|
|
|
|
THREAD_NO_IMPLEMENTATION="You do not have any known thread system on your
|
|
computer. GLib will not have a default thread implementation."
|
|
|
|
FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your
|
|
platform (normally it's "_REENTRANT"). I'll not use any flag on
|
|
compilation now, but then your programs might not work.
|
|
Please provide information on how it is done on your system."
|
|
|
|
LIBS_NOT_FOUND_1="I can't find the libraries for the thread implementation
|
|
"
|
|
|
|
LIBS_NOT_FOUND_2=". Please choose another thread implementation or
|
|
provide information on your thread implementation.
|
|
You can also run 'configure --disable-threads'
|
|
to compile without thread support."
|
|
|
|
FUNC_NO_GETPWUID_R="the 'g_get_(user_name|real_name|home_dir|tmp_dir)'
|
|
functions will not be MT-safe during their first call because
|
|
there is no working 'getpwuid_r' on your system."
|
|
|
|
FUNC_NO_LOCALTIME_R="the 'g_date_set_time' function will not be MT-safe
|
|
because there is no 'localtime_r' on your system."
|
|
|
|
POSIX_NO_YIELD="I can not find a yield functions for your platform. A rather
|
|
crude surrogate will be used. If you happen to know a
|
|
yield function for your system, please inform the GLib
|
|
developers."
|
|
|
|
POSIX_NO_PRIORITIES="I can not find the minimal and maximal priorities for
|
|
threads on your system. Thus threads can only have the default
|
|
priority. If you happen to know these main/max
|
|
priorities, please inform the GLib developers."
|
|
|
|
AIX_COMPILE_INFO="AIX's C compiler needs to be called by a different name, when
|
|
linking threaded applications. As GLib cannot do that
|
|
automatically, you will get an linkg error everytime you are
|
|
not using the right compiler. In that case you have to relink
|
|
with the right compiler. Ususally just '_r' is appended
|
|
to the compiler name."
|
|
|
|
dnl determination of thread implementation
|
|
dnl ***************************************
|
|
|
|
# have_threads=no means no thread support
|
|
# have_threads=none means no default thread implementation
|
|
|
|
have_threads=no
|
|
if test "x$want_threads" = xyes || test "x$want_threads" = 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 \
|
|
|| test "x$want_threads" = xdce; then
|
|
# -D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE is for DG/UX
|
|
# -U_OSF_SOURCE is for Digital UNIX 4.0d
|
|
GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE"
|
|
glib_save_CPPFLAGS="$CPPFLAGS"
|
|
CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
|
|
if test "x$have_threads" = xno; then
|
|
AC_TRY_COMPILE([#include <pthread.h>],
|
|
[pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
|
|
have_threads=posix)
|
|
fi
|
|
if test "x$have_threads" = xno; then
|
|
AC_TRY_COMPILE([#include <pthread.h>],
|
|
[pthread_mutex_t m;
|
|
pthread_mutex_init (&m, pthread_mutexattr_default);],
|
|
have_threads=dce)
|
|
fi
|
|
# Tru64Unix requires -pthread to find pthread.h. See #103020
|
|
CPPFLAGS="$CPPFLAGS -pthread"
|
|
if test "x$have_threads" = xno; then
|
|
AC_TRY_COMPILE([#include <pthread.h>],
|
|
[pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
|
|
have_threads=posix)
|
|
fi
|
|
CPPFLAGS="$glib_save_CPPFLAGS"
|
|
fi
|
|
if test "x$want_threads" = xyes || test "x$want_threads" = xwin32; then
|
|
case $host in
|
|
*-*-mingw*)
|
|
have_threads=win32
|
|
;;
|
|
esac
|
|
fi
|
|
if test "x$want_threads" = xnone; then
|
|
have_threads=none
|
|
fi
|
|
|
|
AC_MSG_CHECKING(for thread implementation)
|
|
|
|
if test "x$have_threads" = xno && test "x$want_threads" != xno; then
|
|
AC_MSG_RESULT(none available)
|
|
AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
|
|
else
|
|
AC_MSG_RESULT($have_threads)
|
|
fi
|
|
|
|
|
|
dnl determination of G_THREAD_CFLAGS
|
|
dnl ********************************
|
|
|
|
G_THREAD_LIBS=
|
|
G_THREAD_LIBS_EXTRA=
|
|
G_THREAD_CFLAGS=
|
|
|
|
dnl
|
|
dnl Test program for basic POSIX threads functionality
|
|
dnl
|
|
m4_define([glib_thread_test],[
|
|
#include <pthread.h>
|
|
int check_me = 0;
|
|
void* func(void* data) {check_me = 42; return &check_me;}
|
|
int main()
|
|
{ pthread_t t;
|
|
void *ret;
|
|
pthread_create (&t, $1, func, 0);
|
|
pthread_join (t, &ret);
|
|
exit (check_me != 42 || ret != &check_me);
|
|
}])
|
|
|
|
dnl
|
|
dnl Test program for sched_get_priority_min()
|
|
dnl
|
|
m4_define([glib_sched_priority_test],[
|
|
#include <sched.h>
|
|
#include <errno.h>
|
|
int main() {
|
|
errno = 0;
|
|
return sched_get_priority_min(SCHED_OTHER)==-1
|
|
&& errno != 0;
|
|
}])
|
|
|
|
if test x"$have_threads" != xno; then
|
|
|
|
if test x"$have_threads" = xposix; then
|
|
# First we test for posix, whether -pthread or -pthreads do the trick as
|
|
# both CPPFLAG and LIBS.
|
|
# One of them does for most gcc versions and some other platforms/compilers
|
|
# too and could be considered as the canonical way to go.
|
|
for flag in pthread pthreads; do
|
|
glib_save_CFLAGS="$CFLAGS"
|
|
CFLAGS="$CFLAGS -$flag"
|
|
AC_TRY_RUN(glib_thread_test(0),
|
|
glib_flag_works=yes,
|
|
glib_flag_works=no,
|
|
[AC_LINK_IFELSE(glib_thread_test(0),
|
|
glib_flag_works=yes,
|
|
glib_flag_works=no)])
|
|
CFLAGS="$glib_save_CFLAGS"
|
|
if test $glib_flag_works = yes ; then
|
|
G_THREAD_CFLAGS=-$flag
|
|
G_THREAD_LIBS=-$flag
|
|
fi
|
|
done
|
|
fi
|
|
|
|
if test x"$G_THREAD_CFLAGS" = x; then
|
|
|
|
# The canonical -pthread[s] does not work. Try something different.
|
|
|
|
case $host in
|
|
*-aix*)
|
|
if test x"$GCC" = xyes; then
|
|
# GCC 3.0 and above needs -pthread.
|
|
# Should be coverd by the case above.
|
|
# GCC 2.x and below needs -mthreads
|
|
G_THREAD_CFLAGS="-mthreads"
|
|
G_THREAD_LIBS=$G_THREAD_CFLAGS
|
|
else
|
|
# We are probably using the aix compiler. Normaly a
|
|
# program would have to be compiled with the _r variant
|
|
# of the corresponding compiler, but we as GLib cannot
|
|
# do that: but the good news is that for compiling the
|
|
# only difference is the added -D_THREAD_SAFE compile
|
|
# option. This is according to the "C for AIX User's
|
|
# Guide".
|
|
G_THREAD_CFLAGS="-D_THREAD_SAFE"
|
|
fi
|
|
;;
|
|
*-dg-dgux*) # DG/UX
|
|
G_THREAD_CFLAGS="-D_REENTRANT -D_POSIX4A_DRAFT10_SOURCE"
|
|
;;
|
|
*-osf*)
|
|
# So we are using dce threads. posix threads are already
|
|
# catched above.
|
|
G_THREAD_CFLAGS="-threads"
|
|
G_THREAD_LIBS=$G_THREAD_CFLAGS
|
|
;;
|
|
*-solaris*)
|
|
if test x"$GCC" = xyes; then
|
|
# We are using solaris threads. posix threads are
|
|
# already catched above.
|
|
G_THREAD_CFLAGS="-threads"
|
|
else
|
|
G_THREAD_CFLAGS="-mt"
|
|
fi
|
|
G_THREAD_LIBS=$G_THREAD_CFLAGS
|
|
;;
|
|
*-sysv5uw7*) # UnixWare 7
|
|
# We are not using gcc with -pthread. Catched above.
|
|
G_THREAD_CFLAGS="-Kthread"
|
|
G_THREAD_LIBS=$G_THREAD_CFLAGS
|
|
;;
|
|
*-mingw*)
|
|
# No flag needed when using MSVCRT.DLL
|
|
G_THREAD_CFLAGS=""
|
|
;;
|
|
*)
|
|
G_THREAD_CFLAGS="-D_REENTRANT" # good default guess otherwise
|
|
;;
|
|
esac
|
|
|
|
fi
|
|
|
|
# if we are not finding the localtime_r function, then we probably are
|
|
# not using the proper multithread flag
|
|
|
|
glib_save_CPPFLAGS="$CPPFLAGS"
|
|
CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
|
|
|
|
# First we test, whether localtime_r is declared in time.h
|
|
# directly. Then we test whether a macro localtime_r exists, in
|
|
# which case localtime_r in the test program is replaced and thus
|
|
# if we still find localtime_r in the output, it is not defined as
|
|
# a macro.
|
|
|
|
AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>], ,
|
|
[AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>
|
|
localtime_r(a,b)],
|
|
AC_MSG_WARN($FLAG_DOES_NOT_WORK))])
|
|
|
|
CPPFLAGS="$glib_save_CPPFLAGS"
|
|
|
|
AC_MSG_CHECKING(thread related cflags)
|
|
AC_MSG_RESULT($G_THREAD_CFLAGS)
|
|
CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
|
|
fi
|
|
|
|
dnl determination of G_THREAD_LIBS
|
|
dnl ******************************
|
|
|
|
mutex_has_default=no
|
|
case $have_threads in
|
|
posix|dce)
|
|
glib_save_CPPFLAGS="$CPPFLAGS"
|
|
CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
|
|
if test x"$G_THREAD_LIBS" = x; then
|
|
case $host in
|
|
*-aix*)
|
|
# We are not using gcc (would have set G_THREAD_LIBS) and thus
|
|
# probably using the aix compiler.
|
|
AC_MSG_WARN($AIX_COMPILE_INFO)
|
|
;;
|
|
*)
|
|
G_THREAD_LIBS=error
|
|
glib_save_LIBS="$LIBS"
|
|
for thread_lib in "" pthread pthread32 pthreads thread dce; do
|
|
if test x"$thread_lib" = x; then
|
|
add_thread_lib=""
|
|
IN=""
|
|
else
|
|
add_thread_lib="-l$thread_lib"
|
|
IN=" in -l$thread_lib"
|
|
fi
|
|
if test x"$have_threads" = xposix; then
|
|
defattr=0
|
|
else
|
|
defattr=pthread_attr_default
|
|
fi
|
|
|
|
LIBS="$add_thread_lib $glib_save_LIBS"
|
|
|
|
AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
|
|
AC_TRY_RUN(glib_thread_test($defattr),
|
|
glib_result=yes,
|
|
glib_result=no,
|
|
[AC_LINK_IFELSE(glib_thread_test($defattr),
|
|
glib_result=yes,
|
|
glib_result=no)])
|
|
AC_MSG_RESULT($glib_result)
|
|
|
|
if test "$glib_result" = "yes" ; then
|
|
G_THREAD_LIBS="$add_thread_lib"
|
|
break
|
|
fi
|
|
done
|
|
if test "x$G_THREAD_LIBS" = xerror; then
|
|
AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
|
|
fi
|
|
LIBS="$glib_save_LIBS"
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
glib_save_LIBS="$LIBS"
|
|
for thread_lib in "" rt rte; do
|
|
if test x"$thread_lib" = x; then
|
|
add_thread_lib=""
|
|
IN=""
|
|
else
|
|
add_thread_lib="-l$thread_lib"
|
|
IN=" in -l$thread_lib"
|
|
fi
|
|
LIBS="$add_thread_lib $glib_save_LIBS"
|
|
|
|
AC_MSG_CHECKING(for sched_get_priority_min$IN)
|
|
AC_TRY_RUN(glib_sched_priority_test,
|
|
glib_result=yes,
|
|
glib_result=no,
|
|
[AC_LINK_IFELSE(glib_sched_priority_test,
|
|
glib_result=yes,
|
|
glib_result=no)])
|
|
AC_MSG_RESULT($glib_result)
|
|
|
|
if test "$glib_result" = "yes" ; then
|
|
G_THREAD_LIBS="$G_THREAD_LIBS $add_thread_lib"
|
|
posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
|
|
posix_priority_max="sched_get_priority_max(SCHED_OTHER)"
|
|
break
|
|
fi
|
|
done
|
|
LIBS="$glib_save_LIBS"
|
|
mutex_has_default=yes
|
|
mutex_default_type='pthread_mutex_t'
|
|
mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
|
|
mutex_header_file='pthread.h'
|
|
if test "x$have_threads" = "xposix"; then
|
|
g_threads_impl="POSIX"
|
|
else
|
|
g_threads_impl="DCE"
|
|
have_threads="posix"
|
|
fi
|
|
AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
|
|
CPPFLAGS="$glib_save_CPPFLAGS"
|
|
;;
|
|
solaris)
|
|
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"
|
|
;;
|
|
none|no)
|
|
g_threads_impl="NONE"
|
|
;;
|
|
*)
|
|
g_threads_impl="NONE"
|
|
G_THREAD_LIBS=error
|
|
;;
|
|
esac
|
|
|
|
if test "x$G_THREAD_LIBS" = xerror; then
|
|
AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
|
|
fi
|
|
|
|
case $host in
|
|
*-*-beos*)
|
|
G_THREAD_LIBS="-lbe -lroot -lglib "
|
|
G_THREAD_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
|
|
;;
|
|
*)
|
|
;;
|
|
esac
|
|
|
|
AC_MSG_CHECKING(thread related libraries)
|
|
AC_MSG_RESULT($G_THREAD_LIBS)
|
|
|
|
dnl check for mt safe function variants and some posix functions
|
|
dnl ************************************************************
|
|
|
|
if test x"$have_threads" != xno; then
|
|
glib_save_LIBS="$LIBS"
|
|
# we are not doing the following for now, as this might require glib
|
|
# to always be linked with the thread libs on some platforms.
|
|
# LIBS="$LIBS $G_THREAD_LIBS"
|
|
AC_CHECK_FUNCS(localtime_r)
|
|
if test "$ac_cv_header_pwd_h" = "yes"; then
|
|
AC_CACHE_CHECK([for posix getpwuid_r],
|
|
ac_cv_func_posix_getpwuid_r,
|
|
[AC_TRY_RUN([
|
|
#include <errno.h>
|
|
#include <pwd.h>
|
|
int main () {
|
|
char buffer[10000];
|
|
struct passwd pwd, *pwptr = &pwd;
|
|
int error;
|
|
errno = 0;
|
|
error = getpwuid_r (0, &pwd, buffer,
|
|
sizeof (buffer), &pwptr);
|
|
return (error < 0 && errno == ENOSYS)
|
|
|| error == ENOSYS;
|
|
} ],
|
|
[ac_cv_func_posix_getpwuid_r=yes],
|
|
[ac_cv_func_posix_getpwuid_r=no])])
|
|
GLIB_ASSERT_SET(ac_cv_func_posix_getpwuid_r)
|
|
if test "$ac_cv_func_posix_getpwuid_r" = yes; then
|
|
AC_DEFINE(HAVE_POSIX_GETPWUID_R,1,
|
|
[Have POSIX function getpwuid_r])
|
|
else
|
|
AC_CACHE_CHECK([for nonposix getpwuid_r],
|
|
ac_cv_func_nonposix_getpwuid_r,
|
|
[AC_TRY_LINK([#include <pwd.h>],
|
|
[char buffer[10000];
|
|
struct passwd pwd;
|
|
getpwuid_r (0, &pwd, buffer,
|
|
sizeof (buffer));],
|
|
[ac_cv_func_nonposix_getpwuid_r=yes],
|
|
[ac_cv_func_nonposix_getpwuid_r=no])])
|
|
GLIB_ASSERT_SET(ac_cv_func_nonposix_getpwuid_r)
|
|
if test "$ac_cv_func_nonposix_getpwuid_r" = yes; then
|
|
AC_DEFINE(HAVE_NONPOSIX_GETPWUID_R,1,
|
|
[Have non-POSIX function getpwuid_r])
|
|
fi
|
|
fi
|
|
fi
|
|
LIBS="$G_THREAD_LIBS $LIBS"
|
|
if test x"$have_threads" = xposix; then
|
|
glib_save_CPPFLAGS="$CPPFLAGS"
|
|
CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
|
|
dnl we might grow sizeof(pthread_t) later on, so use a dummy name here
|
|
GLIB_SIZEOF([#include <pthread.h>], pthread_t, system_thread)
|
|
# This is not AC_CHECK_FUNC to also work with function
|
|
# name mangling in header files.
|
|
AC_MSG_CHECKING(for pthread_attr_setstacksize)
|
|
AC_TRY_LINK([#include <pthread.h>],
|
|
[pthread_attr_t t; pthread_attr_setstacksize(&t,0)],
|
|
[AC_MSG_RESULT(yes)
|
|
AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE,1,
|
|
[Have function pthread_attr_setstacksize])],
|
|
[AC_MSG_RESULT(no)])
|
|
AC_MSG_CHECKING(for minimal/maximal thread priority)
|
|
if test x"$posix_priority_min" = x; then
|
|
AC_EGREP_CPP(PX_PRIO_MIN,[#include <pthread.h>
|
|
PX_PRIO_MIN],,[
|
|
posix_priority_min=PX_PRIO_MIN
|
|
posix_priority_max=PX_PRIO_MAX])
|
|
fi
|
|
if test x"$posix_priority_min" = x; then
|
|
# AIX
|
|
AC_EGREP_CPP(PTHREAD_PRIO_MIN,[#include <pthread.h>
|
|
PTHREAD_PRIO_MIN],,[
|
|
posix_priority_min=PTHREAD_PRIO_MIN
|
|
posix_priority_max=PTHREAD_PRIO_MAX])
|
|
fi
|
|
if test x"$posix_priority_min" = x; then
|
|
AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
|
|
PRI_OTHER_MIN],,[
|
|
posix_priority_min=PRI_OTHER_MIN
|
|
posix_priority_max=PRI_OTHER_MAX])
|
|
fi
|
|
if test x"$posix_priority_min" = x; then
|
|
AC_MSG_RESULT(none found)
|
|
AC_MSG_WARN($POSIX_NO_PRIORITIES)
|
|
posix_priority_min=-1
|
|
posix_priority_max=-1
|
|
else
|
|
AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
|
|
AC_MSG_CHECKING(for pthread_setschedparam)
|
|
AC_TRY_LINK([#include <pthread.h>],
|
|
[pthread_t t; pthread_setschedparam(t, 0, NULL)],
|
|
[AC_MSG_RESULT(yes)
|
|
AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
|
|
AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])],
|
|
[AC_MSG_RESULT(no)
|
|
AC_MSG_WARN($POSIX_NO_PRIORITIES)])
|
|
fi
|
|
posix_yield_func=none
|
|
AC_MSG_CHECKING(for posix yield function)
|
|
for yield_func in sched_yield pthread_yield_np pthread_yield \
|
|
thr_yield; do
|
|
AC_TRY_LINK([#include <pthread.h>],
|
|
[$yield_func()],
|
|
[posix_yield_func="$yield_func"
|
|
break])
|
|
done
|
|
if test x"$posix_yield_func" = xnone; then
|
|
AC_MSG_RESULT(none found)
|
|
AC_MSG_WARN($POSIX_NO_YIELD)
|
|
posix_yield_func="g_usleep(1000)"
|
|
else
|
|
AC_MSG_RESULT($posix_yield_func)
|
|
posix_yield_func="$posix_yield_func()"
|
|
fi
|
|
AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func,[The POSIX RT yield function])
|
|
CPPFLAGS="$glib_save_CPPFLAGS"
|
|
|
|
elif test x"$have_threads" = xwin32; then
|
|
# It's a pointer to a private struct
|
|
GLIB_SIZEOF(,struct _GThreadData *, system_thread)
|
|
elif test x"$have_threads" = xsolaris; then
|
|
GLIB_SIZEOF([#include <thread.h>], thread_t, system_thread)
|
|
fi
|
|
|
|
LIBS="$glib_save_LIBS"
|
|
|
|
# now spit out all the warnings.
|
|
if test "$ac_cv_func_posix_getpwuid_r" != "yes" &&
|
|
test "$ac_cv_func_nonposix_getpwuid_r" != "yes"; then
|
|
AC_MSG_WARN($FUNC_NO_GETPWUID_R)
|
|
fi
|
|
if test "$ac_cv_func_localtime_r" != "yes"; then
|
|
AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
|
|
fi
|
|
fi
|
|
|
|
if test x"$glib_cv_sizeof_system_thread" = x; then
|
|
# use a pointer as a fallback.
|
|
GLIB_SIZEOF(,void *, system_thread)
|
|
fi
|
|
|
|
#
|
|
# Hack to deal with:
|
|
#
|
|
# a) GCC < 3.3 for Linux doesn't include -lpthread when
|
|
# building shared libraries with linux.
|
|
# b) libtool doesn't recognize -pthread as a library dependency.
|
|
#
|
|
case $host in
|
|
*-*-linux*)
|
|
G_THREAD_LIBS_FOR_GTHREAD="`echo $G_THREAD_LIBS | sed s/-pthread/-lpthread/`"
|
|
;;
|
|
*)
|
|
G_THREAD_LIBS_FOR_GTHREAD="`echo $G_THREAD_LIBS | sed s/-pthread/-Wc,-pthread/`"
|
|
;;
|
|
esac
|
|
|
|
AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
|
|
[Source file containing theread implementation])
|
|
AC_SUBST(G_THREAD_CFLAGS)
|
|
AC_SUBST(G_THREAD_LIBS)
|
|
AC_SUBST(G_THREAD_LIBS_FOR_GTHREAD)
|
|
AC_SUBST(G_THREAD_LIBS_EXTRA)
|
|
|
|
dnl **********************************************
|
|
dnl *** GDefaultMutex setup and initialization ***
|
|
dnl **********************************************
|
|
dnl
|
|
dnl if mutex_has_default = yes, we also got
|
|
dnl mutex_default_type, mutex_default_init and mutex_header_file
|
|
if test $mutex_has_default = yes ; then
|
|
glib_save_CPPFLAGS="$CPPFLAGS"
|
|
glib_save_LIBS="$LIBS"
|
|
LIBS="$G_THREAD_LIBS $LIBS"
|
|
CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
|
|
GLIB_SIZEOF([#include <$mutex_header_file>],
|
|
$mutex_default_type,
|
|
gmutex)
|
|
GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
|
|
$mutex_default_type,
|
|
gmutex,
|
|
$glib_cv_sizeof_gmutex,
|
|
$mutex_default_init)
|
|
if test x"$glib_cv_byte_contents_gmutex" = xno; then
|
|
mutex_has_default=no
|
|
fi
|
|
CPPFLAGS="$glib_save_CPPFLAGS"
|
|
LIBS="$glib_save_LIBS"
|
|
fi
|
|
|
|
dnl ********************************
|
|
dnl *** g_atomic_* tests for gcc ***
|
|
dnl ********************************
|
|
|
|
AC_MSG_CHECKING([whether to use assembler code for atomic operations])
|
|
|
|
if test x"$GCC" = xyes; then
|
|
case $host_cpu in
|
|
i386)
|
|
AC_MSG_RESULT([none])
|
|
glib_memory_barrier_needed=no
|
|
;;
|
|
i?86)
|
|
AC_MSG_RESULT([i486])
|
|
AC_DEFINE_UNQUOTED(G_ATOMIC_I486, 1,
|
|
[i486 atomic implementation])
|
|
glib_memory_barrier_needed=no
|
|
;;
|
|
sparc*)
|
|
SPARCV9_WARNING="Try to rerun configure with CFLAGS='-mcpu=v9',
|
|
when you are using a sparc with v9 instruction set (most
|
|
sparcs nowadays). This will make the code for atomic
|
|
operations much faster. The resulting code will not run
|
|
on very old sparcs though."
|
|
|
|
AC_LINK_IFELSE([[
|
|
main ()
|
|
{
|
|
int tmp1, tmp2, tmp3;
|
|
__asm__ __volatile__("casx [%2], %0, %1"
|
|
: "=&r" (tmp1), "=&r" (tmp2) : "r" (&tmp3));
|
|
}]],
|
|
AC_MSG_RESULT([sparcv9])
|
|
AC_DEFINE_UNQUOTED(G_ATOMIC_SPARCV9, 1,
|
|
[sparcv9 atomic implementation]),
|
|
AC_MSG_RESULT([no])
|
|
AC_MSG_WARN([[$SPARCV9_WARNING]]))
|
|
glib_memory_barrier_needed=yes
|
|
;;
|
|
alpha*)
|
|
AC_MSG_RESULT([alpha])
|
|
AC_DEFINE_UNQUOTED(G_ATOMIC_ALPHA, 1,
|
|
[alpha atomic implementation])
|
|
glib_memory_barrier_needed=yes
|
|
;;
|
|
x86_64)
|
|
AC_MSG_RESULT([x86_64])
|
|
AC_DEFINE_UNQUOTED(G_ATOMIC_X86_64, 1,
|
|
[x86_64 atomic implementation])
|
|
glib_memory_barrier_needed=no
|
|
;;
|
|
powerpc*)
|
|
AC_MSG_RESULT([powerpc])
|
|
AC_DEFINE_UNQUOTED(G_ATOMIC_POWERPC, 1,
|
|
[powerpc atomic implementation])
|
|
glib_memory_barrier_needed=yes
|
|
;;
|
|
ia64)
|
|
AC_MSG_RESULT([ia64])
|
|
AC_DEFINE_UNQUOTED(G_ATOMIC_IA64, 1,
|
|
[ia64 atomic implementation])
|
|
glib_memory_barrier_needed=yes
|
|
;;
|
|
*)
|
|
AC_MSG_RESULT([none])
|
|
glib_memory_barrier_needed=yes
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
dnl ****************************************
|
|
dnl *** GLib POLL* compatibility defines ***
|
|
dnl ****************************************
|
|
|
|
glib_poll_includes=["
|
|
#include <sys/types.h>
|
|
#include <sys/poll.h>
|
|
"]
|
|
|
|
if test $ac_cv_header_sys_types_h = yes &&
|
|
test $ac_cv_header_sys_poll_h = yes ; then
|
|
glib_failed=false
|
|
GLIB_CHECK_VALUE(POLLIN, $glib_poll_includes, glib_failed=true)
|
|
GLIB_CHECK_VALUE(POLLOUT, $glib_poll_includes, glib_failed=true)
|
|
GLIB_CHECK_VALUE(POLLPRI, $glib_poll_includes, glib_failed=true)
|
|
GLIB_CHECK_VALUE(POLLERR, $glib_poll_includes, glib_failed=true)
|
|
GLIB_CHECK_VALUE(POLLHUP, $glib_poll_includes, glib_failed=true)
|
|
GLIB_CHECK_VALUE(POLLNVAL, $glib_poll_includes, glib_failed=true)
|
|
if $glib_failed ; then
|
|
AC_MSG_ERROR([Could not determine values for POLL* constants])
|
|
fi
|
|
else
|
|
glib_cv_value_POLLIN=1
|
|
glib_cv_value_POLLOUT=4
|
|
glib_cv_value_POLLPRI=2
|
|
glib_cv_value_POLLERR=8
|
|
glib_cv_value_POLLHUP=16
|
|
glib_cv_value_POLLNVAL=32
|
|
fi
|
|
|
|
dnl **********************
|
|
dnl *** Win32 API libs ***
|
|
dnl **********************
|
|
|
|
case $host in
|
|
*-*-cygwin*)
|
|
G_LIBS_EXTRA="-luser32 -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 <errno.h>
|
|
],
|
|
[
|
|
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 **************************
|
|
|
|
GTK_DOC_CHECK([1.0])
|
|
|
|
AC_ARG_ENABLE(man,
|
|
[AC_HELP_STRING([--enable-man],
|
|
[regenerate man pages from Docbook [default=no]])],enable_man=yes,
|
|
enable_man=no)
|
|
|
|
if test "${enable_man}" != no; then
|
|
dnl
|
|
dnl Check for xsltproc
|
|
dnl
|
|
AC_PATH_PROG([XSLTPROC], [xsltproc])
|
|
if test -z "$XSLTPROC"; then
|
|
enable_man=no
|
|
fi
|
|
|
|
dnl check for DocBook DTD and stylesheets in the local catalog.
|
|
JH_CHECK_XML_CATALOG([-//OASIS//DTD DocBook XML V4.1.2//EN],
|
|
[DocBook XML DTD V4.1.2],,enable_man=no)
|
|
JH_CHECK_XML_CATALOG([http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl],
|
|
[DocBook XSL Stylesheets],,enable_man=no)
|
|
fi
|
|
|
|
AM_CONDITIONAL(ENABLE_MAN, test x$enable_man != xno)
|
|
|
|
dnl ******************************
|
|
dnl *** output the whole stuff ***
|
|
dnl ******************************
|
|
|
|
dnl this section will only be run if config.status is invoked with no
|
|
dnl arguments, or with "glibconfig.h" as an argument.
|
|
AC_CONFIG_COMMANDS([glibconfig.h],
|
|
[
|
|
outfile=glibconfig.h-tmp
|
|
cat > $outfile <<\_______EOF
|
|
/* glibconfig.h
|
|
*
|
|
* This is a generated file. Please modify 'configure.in'
|
|
*/
|
|
|
|
#ifndef __G_LIBCONFIG_H__
|
|
#define __G_LIBCONFIG_H__
|
|
|
|
#include <glib/gmacros.h>
|
|
|
|
_______EOF
|
|
|
|
if test x$glib_limits_h = xyes; then
|
|
echo '#include <limits.h>' >> $outfile
|
|
fi
|
|
if test x$glib_float_h = xyes; then
|
|
echo '#include <float.h>' >> $outfile
|
|
fi
|
|
if test x$glib_values_h = xyes; then
|
|
echo '#include <values.h>' >> $outfile
|
|
fi
|
|
if test "$glib_header_alloca_h" = "yes"; then
|
|
echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
|
|
fi
|
|
if test x$glib_sys_poll_h = xyes; then
|
|
echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
|
|
fi
|
|
|
|
cat >> $outfile <<_______EOF
|
|
|
|
G_BEGIN_DECLS
|
|
|
|
#define G_MINFLOAT $glib_mf
|
|
#define G_MAXFLOAT $glib_Mf
|
|
#define G_MINDOUBLE $glib_md
|
|
#define G_MAXDOUBLE $glib_Md
|
|
#define G_MINSHORT $glib_ms
|
|
#define G_MAXSHORT $glib_Ms
|
|
#define G_MAXUSHORT $glib_Mus
|
|
#define G_MININT $glib_mi
|
|
#define G_MAXINT $glib_Mi
|
|
#define G_MAXUINT $glib_Mui
|
|
#define G_MINLONG $glib_ml
|
|
#define G_MAXLONG $glib_Ml
|
|
#define G_MAXULONG $glib_Mul
|
|
|
|
_______EOF
|
|
|
|
|
|
### this should always be true in a modern C/C++ compiler
|
|
cat >>$outfile <<_______EOF
|
|
typedef signed char gint8;
|
|
typedef unsigned char guint8;
|
|
_______EOF
|
|
|
|
|
|
if test -n "$gint16"; then
|
|
cat >>$outfile <<_______EOF
|
|
typedef signed $gint16 gint16;
|
|
typedef unsigned $gint16 guint16;
|
|
#define G_GINT16_MODIFIER $gint16_modifier
|
|
#define G_GINT16_FORMAT $gint16_format
|
|
#define G_GUINT16_FORMAT $guint16_format
|
|
_______EOF
|
|
fi
|
|
|
|
|
|
if test -n "$gint32"; then
|
|
cat >>$outfile <<_______EOF
|
|
typedef signed $gint32 gint32;
|
|
typedef unsigned $gint32 guint32;
|
|
#define G_GINT32_MODIFIER $gint32_modifier
|
|
#define G_GINT32_FORMAT $gint32_format
|
|
#define G_GUINT32_FORMAT $guint32_format
|
|
_______EOF
|
|
fi
|
|
|
|
cat >>$outfile <<_______EOF
|
|
#define G_HAVE_GINT64 1 /* deprecated, always true */
|
|
|
|
${glib_extension}typedef signed $gint64 gint64;
|
|
${glib_extension}typedef unsigned $gint64 guint64;
|
|
|
|
#define G_GINT64_CONSTANT(val) $gint64_constant
|
|
_______EOF
|
|
|
|
if test x$gint64_format != x ; then
|
|
cat >>$outfile <<_______EOF
|
|
#define G_GINT64_MODIFIER $gint64_modifier
|
|
#define G_GINT64_FORMAT $gint64_format
|
|
#define G_GUINT64_FORMAT $guint64_format
|
|
_______EOF
|
|
else
|
|
cat >>$outfile <<_______EOF
|
|
#undef G_GINT64_MODIFIER
|
|
#undef G_GINT64_FORMAT
|
|
#undef G_GUINT64_FORMAT
|
|
_______EOF
|
|
fi
|
|
|
|
cat >>$outfile <<_______EOF
|
|
|
|
#define GLIB_SIZEOF_VOID_P $glib_void_p
|
|
#define GLIB_SIZEOF_LONG $glib_long
|
|
#define GLIB_SIZEOF_SIZE_T $glib_size_t
|
|
|
|
_______EOF
|
|
|
|
cat >>$outfile <<_______EOF
|
|
typedef signed $glib_size_type_define gssize;
|
|
typedef unsigned $glib_size_type_define gsize;
|
|
#define G_GSIZE_MODIFIER $gsize_modifier
|
|
#define G_GSSIZE_FORMAT $gssize_format
|
|
#define G_GSIZE_FORMAT $gsize_format
|
|
|
|
#define G_MAXSIZE G_MAXU$glib_msize_type
|
|
_______EOF
|
|
|
|
if test -z "$glib_unknown_void_p"; then
|
|
cat >>$outfile <<_______EOF
|
|
|
|
#define GPOINTER_TO_INT(p) ((gint) ${glib_gpi_cast} (p))
|
|
#define GPOINTER_TO_UINT(p) ((guint) ${glib_gpui_cast} (p))
|
|
|
|
#define GINT_TO_POINTER(i) ((gpointer) ${glib_gpi_cast} (i))
|
|
#define GUINT_TO_POINTER(u) ((gpointer) ${glib_gpui_cast} (u))
|
|
_______EOF
|
|
else
|
|
echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
|
|
fi
|
|
|
|
|
|
|
|
cat >>$outfile <<_______EOF
|
|
$glib_atexit
|
|
$glib_memmove
|
|
$glib_defines
|
|
$glib_os
|
|
|
|
$glib_vacopy
|
|
|
|
#ifdef __cplusplus
|
|
#define G_HAVE_INLINE 1
|
|
#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
|
|
cat >>$outfile <<_______EOF
|
|
$g_enable_threads_def G_THREADS_ENABLED
|
|
#define G_THREADS_IMPL_$g_threads_impl_def
|
|
typedef struct _GStaticMutex GStaticMutex;
|
|
struct _GStaticMutex
|
|
{
|
|
struct _GMutex *runtime_mutex;
|
|
union {
|
|
char pad[[$g_mutex_sizeof]];
|
|
double dummy_double;
|
|
void *dummy_pointer;
|
|
long dummy_long;
|
|
} static_mutex;
|
|
};
|
|
#define G_STATIC_MUTEX_INIT { NULL, { { $g_mutex_contents} } }
|
|
#define g_static_mutex_get_mutex(mutex) \\
|
|
(g_thread_use_default_impl ? ((GMutex*) &((mutex)->static_mutex)) : \\
|
|
g_static_mutex_get_mutex_impl_shortcut (&((mutex)->runtime_mutex)))
|
|
_______EOF
|
|
else
|
|
cat >>$outfile <<_______EOF
|
|
$g_enable_threads_def G_THREADS_ENABLED
|
|
#define G_THREADS_IMPL_$g_threads_impl_def
|
|
typedef struct _GMutex* GStaticMutex;
|
|
#define G_STATIC_MUTEX_INIT NULL
|
|
#define g_static_mutex_get_mutex(mutex) \\
|
|
(g_static_mutex_get_mutex_impl_shortcut (mutex))
|
|
_______EOF
|
|
fi
|
|
|
|
cat >>$outfile <<_______EOF
|
|
/* This represents a system thread as used by the implementation. An
|
|
* alien implementaion, as loaded by g_thread_init can only count on
|
|
* "sizeof (gpointer)" bytes to store their info. We however need more
|
|
* for some of our native implementations. */
|
|
typedef union _GSystemThread GSystemThread;
|
|
union _GSystemThread
|
|
{
|
|
char data[[$g_system_thread_sizeof]];
|
|
double dummy_double;
|
|
void *dummy_pointer;
|
|
long dummy_long;
|
|
};
|
|
_______EOF
|
|
if test x"$g_memory_barrier_needed" != xno; then
|
|
echo >>$outfile
|
|
echo "#define G_ATOMIC_OP_MEMORY_BARRIER_NEEDED 1" >>$outfile
|
|
fi
|
|
|
|
echo >>$outfile
|
|
g_bit_sizes="16 32 64"
|
|
for bits in $g_bit_sizes; do
|
|
cat >>$outfile <<_______EOF
|
|
#define GINT${bits}_TO_${g_bs_native}(val) ((gint${bits}) (val))
|
|
#define GUINT${bits}_TO_${g_bs_native}(val) ((guint${bits}) (val))
|
|
#define GINT${bits}_TO_${g_bs_alien}(val) ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
|
|
#define GUINT${bits}_TO_${g_bs_alien}(val) (GUINT${bits}_SWAP_LE_BE (val))
|
|
_______EOF
|
|
done
|
|
|
|
cat >>$outfile <<_______EOF
|
|
#define GLONG_TO_LE(val) ((glong) GINT${glongbits}_TO_LE (val))
|
|
#define GULONG_TO_LE(val) ((gulong) GUINT${glongbits}_TO_LE (val))
|
|
#define GLONG_TO_BE(val) ((glong) GINT${glongbits}_TO_BE (val))
|
|
#define GULONG_TO_BE(val) ((gulong) GUINT${glongbits}_TO_BE (val))
|
|
#define GINT_TO_LE(val) ((gint) GINT${gintbits}_TO_LE (val))
|
|
#define GUINT_TO_LE(val) ((guint) GUINT${gintbits}_TO_LE (val))
|
|
#define GINT_TO_BE(val) ((gint) GINT${gintbits}_TO_BE (val))
|
|
#define GUINT_TO_BE(val) ((guint) GUINT${gintbits}_TO_BE (val))
|
|
#define G_BYTE_ORDER $g_byte_order
|
|
|
|
#define GLIB_SYSDEF_POLLIN =$g_pollin
|
|
#define GLIB_SYSDEF_POLLOUT =$g_pollout
|
|
#define GLIB_SYSDEF_POLLPRI =$g_pollpri
|
|
#define GLIB_SYSDEF_POLLHUP =$g_pollhup
|
|
#define GLIB_SYSDEF_POLLERR =$g_pollerr
|
|
#define GLIB_SYSDEF_POLLNVAL =$g_pollnval
|
|
|
|
#define G_MODULE_SUFFIX "$g_module_suffix"
|
|
|
|
typedef $g_pid_type GPid;
|
|
|
|
G_END_DECLS
|
|
|
|
#endif /* GLIBCONFIG_H */
|
|
_______EOF
|
|
|
|
|
|
if cmp -s $outfile glibconfig.h; then
|
|
AC_MSG_NOTICE([glibconfig.h is unchanged])
|
|
rm -f $outfile
|
|
else
|
|
mv $outfile glibconfig.h
|
|
fi
|
|
],[
|
|
|
|
# Note that if two cases are the same, case goes with the first one.
|
|
# Note also that this is inside an AC_OUTPUT_COMMAND. We do not depend
|
|
# on variable expansion in case labels. Look at the generated config.status
|
|
# for a hint.
|
|
|
|
if test "x${ac_cv_working_alloca_h+set}" = xset ; then
|
|
glib_header_alloca_h="$ac_cv_working_alloca_h"
|
|
else
|
|
glib_header_alloca_h="$ac_cv_header_alloca_h"
|
|
fi
|
|
|
|
case xyes in
|
|
x$ac_cv_header_float_h)
|
|
glib_float_h=yes
|
|
glib_mf=FLT_MIN glib_Mf=FLT_MAX
|
|
glib_md=DBL_MIN glib_Md=DBL_MAX
|
|
;;
|
|
x$ac_cv_header_values_h)
|
|
glib_values_h=yes
|
|
glib_mf=MINFLOAT glib_Mf=MAXFLOAT
|
|
glib_md=MINDOUBLE glib_Md=MAXDOUBLE
|
|
;;
|
|
esac
|
|
|
|
case xyes in
|
|
x$ac_cv_header_limits_h)
|
|
glib_limits_h=yes
|
|
glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
|
|
glib_mi=INT_MIN glib_Mi=INT_MAX glib_Mui=UINT_MAX
|
|
glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
|
|
;;
|
|
x$ac_cv_header_values_h)
|
|
glib_values_h=yes
|
|
glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
|
|
glib_mi=MININT glib_Mi=MAXINT glib_Mui="(((guint)G_MAXINT)*2+1)"
|
|
glib_ml=MINLONG glib_Ml=MAXLONG glib_Mul="(((gulong)G_MAXLONG)*2+1)"
|
|
;;
|
|
esac
|
|
|
|
if test x$ac_cv_header_sys_poll_h = xyes ; then
|
|
glib_sys_poll_h=yes
|
|
fi
|
|
|
|
case 2 in
|
|
$ac_cv_sizeof_short)
|
|
gint16=short
|
|
gint16_modifier='"h"'
|
|
gint16_format='"hi"'
|
|
guint16_format='"hu"'
|
|
;;
|
|
$ac_cv_sizeof_int)
|
|
gint16=int
|
|
gint16_modifier='""'
|
|
gint16_format='"i"'
|
|
guint16_format='"u"'
|
|
;;
|
|
esac
|
|
case 4 in
|
|
$ac_cv_sizeof_short)
|
|
gint32=short
|
|
gint32_modifier='"h"'
|
|
gint32_format='"hi"'
|
|
guint32_format='"hu"'
|
|
;;
|
|
$ac_cv_sizeof_int)
|
|
gint32=int
|
|
gint32_modifier='""'
|
|
gint32_format='"i"'
|
|
guint32_format='"u"'
|
|
;;
|
|
$ac_cv_sizeof_long)
|
|
gint32=long
|
|
gint32_modifier='"l"'
|
|
gint32_format='"li"'
|
|
guint32_format='"lu"'
|
|
;;
|
|
esac
|
|
case 8 in
|
|
$ac_cv_sizeof_int)
|
|
gint64=int
|
|
gint64_modifier='""'
|
|
gint64_format='"i"'
|
|
guint64_format='"u"'
|
|
glib_extension=
|
|
gint64_constant='(val)'
|
|
;;
|
|
$ac_cv_sizeof_long)
|
|
gint64=long
|
|
gint64_modifier='"l"'
|
|
gint64_format='"li"'
|
|
guint64_format='"lu"'
|
|
glib_extension=
|
|
gint64_constant='(val##L)'
|
|
;;
|
|
$ac_cv_sizeof_long_long)
|
|
gint64='long long'
|
|
if test -n "$glib_cv_long_long_format"; then
|
|
gint64_modifier='"'$glib_cv_long_long_format'"'
|
|
gint64_format='"'$glib_cv_long_long_format'i"'
|
|
guint64_format='"'$glib_cv_long_long_format'u"'
|
|
fi
|
|
glib_extension='G_GNUC_EXTENSION '
|
|
gint64_constant='(G_GNUC_EXTENSION (val##LL))'
|
|
;;
|
|
$ac_cv_sizeof___int64)
|
|
gint64='__int64'
|
|
if test -n "$glib_cv_long_long_format"; then
|
|
gint64_modifier='"'$glib_cv_long_long_format'"'
|
|
gint64_format='"'$glib_cv_long_long_format'i"'
|
|
guint64_format='"'$glib_cv_long_long_format'u"'
|
|
fi
|
|
glib_extension=
|
|
gint64_constant='(val##i64)'
|
|
;;
|
|
esac
|
|
glib_size_t=$ac_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
|
|
|
|
case $glib_size_type in
|
|
short)
|
|
gsize_modifier='"h"'
|
|
gsize_format='"hu"'
|
|
gssize_format='"hi"'
|
|
glib_msize_type='SHRT'
|
|
;;
|
|
int)
|
|
gsize_modifier='""'
|
|
gsize_format='"u"'
|
|
gssize_format='"i"'
|
|
glib_msize_type='INT'
|
|
;;
|
|
long)
|
|
gsize_modifier='"l"'
|
|
gsize_format='"lu"'
|
|
gssize_format='"li"'
|
|
glib_msize_type='LONG'
|
|
;;
|
|
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'
|
|
;;
|
|
x$glib_cv_working_bcopy)
|
|
glib_memmove="
|
|
/* memmove isn't available, but bcopy can copy overlapping memory regions */
|
|
#define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
|
|
;;
|
|
*)
|
|
glib_memmove="
|
|
/* memmove isn't found and bcopy can't copy overlapping memory regions,
|
|
* so we have to roll our own copy routine. */
|
|
void g_memmove (void* dest, const void * src, unsigned long len);"
|
|
;;
|
|
esac
|
|
|
|
glib_defines="
|
|
#define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
|
|
#define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
|
|
#define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
|
|
"
|
|
|
|
case xyes in
|
|
x$glib_cv_va_copy) glib_vacopy='#define G_VA_COPY va_copy' ;;
|
|
x$glib_cv___va_copy) glib_vacopy='#define G_VA_COPY __va_copy' ;;
|
|
*) glib_vacopy=''
|
|
esac
|
|
|
|
if test x$glib_cv_va_val_copy = xno; then
|
|
glib_vacopy="\$glib_vacopy
|
|
#define G_VA_COPY_AS_ARRAY 1"
|
|
fi
|
|
|
|
if test x$glib_cv_hasinline = xyes; then
|
|
glib_inline='#define G_HAVE_INLINE 1'
|
|
fi
|
|
if test x$glib_cv_has__inline = xyes; then
|
|
glib_inline="\$glib_inline
|
|
#define G_HAVE___INLINE 1"
|
|
fi
|
|
if test x$glib_cv_has__inline__ = xyes; then
|
|
glib_inline="\$glib_inline
|
|
#define G_HAVE___INLINE__ 1"
|
|
fi
|
|
|
|
g_have_gnuc_varargs=$g_have_gnuc_varargs
|
|
g_have_iso_c_varargs=$g_have_iso_c_varargs
|
|
g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
|
|
|
|
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
|
|
|
|
g_pollin=$glib_cv_value_POLLIN
|
|
g_pollout=$glib_cv_value_POLLOUT
|
|
g_pollpri=$glib_cv_value_POLLPRI
|
|
g_pollhup=$glib_cv_value_POLLHUP
|
|
g_pollerr=$glib_cv_value_POLLERR
|
|
g_pollnval=$glib_cv_value_POLLNVAL
|
|
|
|
g_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_memory_barrier_needed="$glib_memory_barrier_needed"
|
|
|
|
g_module_suffix="$glib_gmodule_suffix"
|
|
|
|
g_pid_type="$glib_pid_type"
|
|
case $host in
|
|
*-*-beos*)
|
|
glib_os="#define G_OS_BEOS"
|
|
;;
|
|
*-*-cygwin*)
|
|
glib_os="#define G_OS_UNIX
|
|
#define G_PLATFORM_WIN32
|
|
#define G_WITH_CYGWIN"
|
|
;;
|
|
*-*-mingw*)
|
|
glib_os="#define G_OS_WIN32
|
|
#define G_PLATFORM_WIN32"
|
|
;;
|
|
*)
|
|
glib_os="#define G_OS_UNIX"
|
|
;;
|
|
esac
|
|
])
|
|
|
|
AC_CONFIG_FILES([
|
|
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-zip
|
|
glib-gettextize
|
|
Makefile
|
|
build/Makefile
|
|
build/win32/Makefile
|
|
build/win32/dirent/Makefile
|
|
glib/Makefile
|
|
glib/libcharset/Makefile
|
|
glib/gnulib/Makefile
|
|
gmodule/Makefile
|
|
gmodule/gmoduleconf.h
|
|
gobject/Makefile
|
|
gobject/glib-mkenums
|
|
gthread/Makefile
|
|
po/Makefile.in
|
|
docs/Makefile
|
|
docs/reference/Makefile
|
|
docs/reference/glib/Makefile
|
|
docs/reference/glib/version.xml
|
|
docs/reference/gobject/Makefile
|
|
docs/reference/gobject/version.xml
|
|
tests/Makefile
|
|
tests/gobject/Makefile
|
|
m4macros/Makefile
|
|
])
|
|
|
|
AC_CONFIG_COMMANDS([chmod-scripts],
|
|
[chmod 0755 glib-zip
|
|
chmod 0755 glib-gettextize
|
|
chmod 0755 gobject/glib-mkenums])
|
|
|
|
# we want to invoke this macro solely so that the config.status script
|
|
# and automake generated makefiles know about these generated files.
|
|
# They are only needed to distcheck the package
|
|
if false; then
|
|
AC_CONFIG_FILES([
|
|
INSTALL
|
|
README
|
|
config.h.win32
|
|
glibconfig.h.win32
|
|
glib/makefile.mingw
|
|
glib/makefile.msc
|
|
glib/glib.rc
|
|
gmodule/makefile.mingw
|
|
gmodule/makefile.msc
|
|
gmodule/gmodule.rc
|
|
gobject/makefile.mingw
|
|
gobject/makefile.msc
|
|
gobject/gobject.rc
|
|
gthread/makefile.mingw
|
|
gthread/makefile.msc
|
|
gthread/gthread.rc
|
|
tests/makefile.mingw
|
|
tests/makefile.msc
|
|
])
|
|
fi
|
|
|
|
AC_OUTPUT
|