2003-03-04 11:10:48 +01:00
|
|
|
# Process this file with autoconf to produce a configure script.
|
2010-07-13 05:05:48 +02:00
|
|
|
AC_PREREQ([2.62])
|
2003-03-04 11:10:48 +01:00
|
|
|
|
1998-12-19 03:13:34 +01:00
|
|
|
dnl ***********************************
|
|
|
|
dnl *** include special GLib macros ***
|
|
|
|
dnl ***********************************
|
2002-12-11 20:42:31 +01:00
|
|
|
|
2010-07-13 17:59:16 +02:00
|
|
|
m4_define(glib_configure_ac)
|
1998-06-11 01:21:14 +02:00
|
|
|
|
1999-02-15 07:50:15 +01:00
|
|
|
#
|
2009-03-02 06:52:09 +01:00
|
|
|
# The following version number definitions apply to GLib, GModule, GObject,
|
|
|
|
# GThread and GIO as a whole, so if changes occurred in any of them, they are
|
|
|
|
# all treated with the same interface and binary age.
|
1998-09-21 04:32:30 +02:00
|
|
|
#
|
1998-06-11 01:21:14 +02:00
|
|
|
# Making releases:
|
2003-03-04 11:10:48 +01:00
|
|
|
# glib_micro_version += 1;
|
|
|
|
# glib_interface_age += 1;
|
|
|
|
# glib_binary_age += 1;
|
|
|
|
# if any functions have been added, set glib_interface_age to 0.
|
1998-06-11 01:21:14 +02:00
|
|
|
# if backwards compatibility has been broken,
|
2003-03-04 11:10:48 +01:00
|
|
|
# set glib_binary_age _and_ glib_interface_age to 0.
|
1998-06-11 01:21:14 +02:00
|
|
|
#
|
2011-02-11 16:27:44 +01:00
|
|
|
# in easier to understand terms:
|
|
|
|
#
|
|
|
|
# <mclasen> on the stable branch, interface age == micro
|
|
|
|
# <mclasen> on the unstable (ie master), interface age = 0
|
|
|
|
|
2003-03-04 11:10:48 +01:00
|
|
|
m4_define([glib_major_version], [2])
|
2011-02-11 16:27:44 +01:00
|
|
|
m4_define([glib_minor_version], [29])
|
2011-07-22 09:48:34 +02:00
|
|
|
m4_define([glib_micro_version], [15])
|
2011-02-11 16:27:44 +01:00
|
|
|
m4_define([glib_interface_age], [0])
|
2003-03-04 11:10:48 +01:00
|
|
|
m4_define([glib_binary_age],
|
|
|
|
[m4_eval(100 * glib_minor_version + glib_micro_version)])
|
|
|
|
m4_define([glib_version],
|
2005-12-05 22:09:20 +01:00
|
|
|
[glib_major_version.glib_minor_version.glib_micro_version])
|
2003-03-04 11:10:48 +01:00
|
|
|
|
|
|
|
# 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])
|
|
|
|
|
2010-07-13 05:05:48 +02:00
|
|
|
AC_CONFIG_HEADER([config.h])
|
2003-03-04 11:10:48 +01:00
|
|
|
AC_CONFIG_SRCDIR([glib/glib.h])
|
2011-01-07 18:55:20 +01:00
|
|
|
AC_CONFIG_MACRO_DIR([m4macros])
|
2003-03-04 11:10:48 +01:00
|
|
|
|
|
|
|
# Save this value here, since automake will set cflags later
|
|
|
|
cflags_set=${CFLAGS+set}
|
|
|
|
|
2011-06-20 12:48:25 +02:00
|
|
|
AM_INIT_AUTOMAKE([1.11 no-define no-dist-gzip dist-xz tar-ustar])
|
2011-06-27 12:28:55 +02:00
|
|
|
AM_MAINTAINER_MODE([enable])
|
2003-03-04 11:10:48 +01:00
|
|
|
|
2011-06-20 12:48:25 +02:00
|
|
|
# Support silent build rules. Disable
|
2011-01-29 03:09:52 +01:00
|
|
|
# by either passing --disable-silent-rules to configure or passing V=1
|
2009-07-17 16:49:53 +02:00
|
|
|
# to make
|
2011-06-20 12:48:25 +02:00
|
|
|
AM_SILENT_RULES([yes])
|
2003-03-04 11:10:48 +01:00
|
|
|
|
|
|
|
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
|
1999-02-15 07:50:15 +01:00
|
|
|
|
1999-05-06 19:33:15 +02:00
|
|
|
AC_SUBST(GLIB_MAJOR_VERSION)
|
|
|
|
AC_SUBST(GLIB_MINOR_VERSION)
|
1999-07-24 20:50:58 +02:00
|
|
|
AC_SUBST(GLIB_MICRO_VERSION)
|
1998-06-11 01:21:14 +02:00
|
|
|
AC_SUBST(GLIB_VERSION)
|
1999-05-06 19:33:15 +02:00
|
|
|
AC_SUBST(GLIB_INTERFACE_AGE)
|
|
|
|
AC_SUBST(GLIB_BINARY_AGE)
|
1998-06-11 01:21:14 +02:00
|
|
|
|
2003-03-04 11:10:48 +01:00
|
|
|
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])
|
|
|
|
|
1998-06-11 01:21:14 +02:00
|
|
|
# libtool versioning
|
2003-03-04 11:10:48 +01:00
|
|
|
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
|
1998-06-11 01:21:14 +02:00
|
|
|
AC_SUBST(LT_RELEASE)
|
|
|
|
AC_SUBST(LT_CURRENT)
|
|
|
|
AC_SUBST(LT_REVISION)
|
|
|
|
AC_SUBST(LT_AGE)
|
2001-09-17 02:41:39 +02:00
|
|
|
AC_SUBST(LT_CURRENT_MINUS_AGE)
|
1998-06-11 01:21:14 +02:00
|
|
|
|
2010-08-05 07:53:15 +02:00
|
|
|
dnl Checks for programs.
|
|
|
|
AC_PROG_CC
|
|
|
|
AC_PROG_CPP
|
|
|
|
|
1998-06-11 01:21:14 +02:00
|
|
|
AC_CANONICAL_HOST
|
|
|
|
|
2003-03-04 11:10:48 +01:00
|
|
|
AC_MSG_CHECKING([for the BeOS])
|
1999-05-08 09:40:44 +02:00
|
|
|
case $host in
|
|
|
|
*-*-beos*)
|
|
|
|
glib_native_beos="yes"
|
|
|
|
;;
|
1999-10-04 04:32:50 +02:00
|
|
|
*)
|
1999-05-08 09:40:44 +02:00
|
|
|
glib_native_beos="no"
|
|
|
|
;;
|
|
|
|
esac
|
1999-10-04 04:32:50 +02:00
|
|
|
AC_MSG_RESULT([$glib_native_beos])
|
1999-05-08 09:40:44 +02:00
|
|
|
|
1999-02-15 07:50:15 +01:00
|
|
|
dnl
|
2000-10-09 23:06:01 +02:00
|
|
|
|
2001-09-26 08:20:31 +02:00
|
|
|
AC_MSG_CHECKING([for Win32])
|
2008-07-27 17:54:15 +02:00
|
|
|
LIB_EXE_MACHINE_FLAG=X86
|
2001-09-26 08:20:31 +02:00
|
|
|
case "$host" in
|
|
|
|
*-*-mingw*)
|
2001-09-27 08:11:48 +02:00
|
|
|
glib_native_win32=yes
|
2004-03-01 21:47:49 +01:00
|
|
|
glib_pid_type='void *'
|
2008-07-24 02:29:56 +02:00
|
|
|
glib_cv_stack_grows=no
|
2008-02-07 14:07:19 +01:00
|
|
|
# Unfortunately the mingw implementations of C99-style snprintf and vsnprintf
|
|
|
|
# don't seem to be quite good enough, at least not in mingw-runtime-3.14.
|
|
|
|
# (Sorry, I don't know exactly what is the problem, but it is related to
|
|
|
|
# floating point formatting and decimal point vs. comma.)
|
|
|
|
# The simple tests in AC_FUNC_VSNPRINTF_C99 and AC_FUNC_SNPRINTF_C99 aren't
|
|
|
|
# rigorous enough to notice, though.
|
|
|
|
# So preset the autoconf cache variables.
|
|
|
|
ac_cv_func_vsnprintf_c99=no
|
|
|
|
ac_cv_func_snprintf_c99=no
|
2008-07-27 17:54:15 +02:00
|
|
|
case "$host" in
|
|
|
|
x86_64-*-*)
|
|
|
|
LIB_EXE_MACHINE_FLAG=X64
|
|
|
|
;;
|
|
|
|
esac
|
2001-09-26 08:20:31 +02:00
|
|
|
;;
|
|
|
|
*)
|
2001-09-27 08:11:48 +02:00
|
|
|
glib_native_win32=no
|
2004-02-14 01:23:36 +01:00
|
|
|
glib_pid_type=int
|
2001-09-26 08:20:31 +02:00
|
|
|
;;
|
|
|
|
esac
|
2004-12-27 07:55:08 +01:00
|
|
|
case $host in
|
|
|
|
*-*-linux*)
|
|
|
|
glib_os_linux=yes
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
|
2001-09-27 08:11:48 +02:00
|
|
|
AC_MSG_RESULT([$glib_native_win32])
|
2007-06-04 16:54:49 +02:00
|
|
|
|
2008-07-27 17:54:15 +02:00
|
|
|
AC_SUBST(LIB_EXE_MACHINE_FLAG)
|
|
|
|
|
2007-06-04 16:54:49 +02:00
|
|
|
glib_have_carbon=no
|
|
|
|
AC_MSG_CHECKING([for Mac OS X Carbon support])
|
|
|
|
AC_TRY_CPP([
|
|
|
|
#include <Carbon/Carbon.h>
|
|
|
|
#include <CoreServices/CoreServices.h>
|
|
|
|
], glib_have_carbon=yes)
|
|
|
|
|
|
|
|
AC_MSG_RESULT([$glib_have_carbon])
|
|
|
|
|
2003-03-04 11:10:48 +01:00
|
|
|
AM_CONDITIONAL(OS_WIN32, [test "$glib_native_win32" = "yes"])
|
Fix problems on 64-bit Windows. Avoid warnings, some of which indicated
2008-07-28 Tor Lillqvist <tml@novell.com>
Fix problems on 64-bit Windows. Avoid warnings, some of which
indicated actual problems, some which were just annoyances.
Where casts to an integer type are needed for pointers, use
gssize. Technically intptr_t would be the more proper type, but we
still want to be compilable with MSVS6 and 7 which don't have
intptr_t. MSVS8 and 9 do have intptr_t, but in <crtdefs.h>, not
<stdint.h>.
Use %p to print out handles. Use gssize casts when assigning
GPollFD::fd fields.
Use G_GSIZE_FORMAT when printing size_t values.
* configure.in: Define automake conditional G_OS_WIN32_X64 which
is true on Win64.
* glib/giochannel.h: Use slightly different prototype for
g_io_channel_win32_new_messages() on Win64 with gsize instead of
guint.
* glib/giowin32.c
* glib/gmain.c
* glib/gspawn-win32.c
* tests/testglib.c: Generic changes as described above.
* glib/gmain.h: Don't bother mentioning GIMP in comment.
* glib/grel.c (tuple_hash_2): Use all bits of pointer.
* glib/gspawn-win32.c
* glib/gspawn-win32-helper.c: Use gssize types in the
communication between parent and helper process, so that we can
pass process handles, which are pointers, also on Win64.
* glib/gtimer.c (g_time_val_to_iso8601): time_t is 64 bits on
Win64 so we can't pass the address of a GTimeVal::tv_sec which is
a long directly to gmtime(). On the other hand, changing
GTimeVal::tv_sec to be a gint64 on Win64 is not really feasible
either, as that would then require changes in much code that uses
GTimeVals.
* glib/gspawn-win32.c
* glib/Makefile.am: Call the helper programs
gspawn-win64-helper.exe and gspawn-win64-helper-console.exe on
Win64, to avoid potential risk of running a 32-bit version of the
helper.
svn path=/trunk/; revision=7260
2008-07-28 02:24:14 +02:00
|
|
|
AM_CONDITIONAL(OS_WIN32_X64, [test "$LIB_EXE_MACHINE_FLAG" = "X64"])
|
2004-09-16 08:05:53 +02:00
|
|
|
AM_CONDITIONAL(OS_UNIX, [test "$glib_native_win32" != "yes"])
|
2004-12-27 07:55:08 +01:00
|
|
|
AM_CONDITIONAL(OS_LINUX, [test "$glib_os_linux" = "yes"])
|
2007-06-04 16:54:49 +02:00
|
|
|
AM_CONDITIONAL(OS_CARBON, [test "$glib_have_carbon" = "yes"])
|
2001-09-26 08:20:31 +02:00
|
|
|
|
2001-09-28 23:03:02 +02:00
|
|
|
if test "$glib_native_win32" = "yes"; then
|
2005-07-09 01:04:06 +02:00
|
|
|
AC_CHECK_TOOL(WINDRES, windres, no)
|
|
|
|
if test "$WINDRES" = no; then
|
|
|
|
AC_MSG_ERROR([*** Could not find an implementation of windres in your PATH.])
|
|
|
|
fi
|
2005-01-06 20:15:49 +01:00
|
|
|
AC_CHECK_TOOL(NM, nm, no)
|
2005-01-15 23:40:16 +01:00
|
|
|
if test "$NM" = no; then
|
2005-01-06 20:15:49 +01:00
|
|
|
AC_MSG_ERROR([*** Could not find an implementation of nm in your PATH.])
|
|
|
|
fi
|
|
|
|
AC_CHECK_TOOL(RANLIB, ranlib, :)
|
2003-03-04 11:10:48 +01:00
|
|
|
AC_CHECK_PROG(ms_librarian, [lib.exe], [yes], [no])
|
2001-09-26 08:20:31 +02:00
|
|
|
fi
|
2003-03-04 11:10:48 +01:00
|
|
|
AM_CONDITIONAL(MS_LIB_AVAILABLE, [test x$ms_librarian = xyes])
|
1999-02-15 07:50:15 +01:00
|
|
|
|
2004-09-16 08:05:53 +02:00
|
|
|
if test "$glib_native_win32" != yes; then
|
|
|
|
# libtool option to control which symbols are exported
|
|
|
|
# right now, symbols starting with _ are not exported
|
2007-03-15 14:01:31 +01:00
|
|
|
LIBTOOL_EXPORT_OPTIONS='-export-symbols-regex "^g.*"'
|
2004-09-16 08:05:53 +02:00
|
|
|
else
|
|
|
|
# We currently use .def files on Windows
|
|
|
|
LIBTOOL_EXPORT_OPTIONS=
|
|
|
|
fi
|
|
|
|
AC_SUBST(LIBTOOL_EXPORT_OPTIONS)
|
|
|
|
|
2007-06-04 16:54:49 +02:00
|
|
|
if test "x$glib_have_carbon" = "xyes"; then
|
|
|
|
AC_DEFINE(HAVE_CARBON, 1, [define to 1 if Carbon is available])
|
|
|
|
LDFLAGS="$LDFLAGS -framework Carbon"
|
|
|
|
fi
|
|
|
|
|
2011-05-01 17:17:14 +02:00
|
|
|
gl_GLIBC21
|
|
|
|
if test "x$GLIBC21" = "xyes"; then
|
|
|
|
AC_DEFINE([_GNU_SOURCE], 1, [Make all glibc extensions visible])
|
|
|
|
fi
|
2007-06-04 16:54:49 +02:00
|
|
|
|
1999-02-15 07:50:15 +01:00
|
|
|
dnl declare --enable-* args and collect ac_help strings
|
2003-03-04 11:10:48 +01:00
|
|
|
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(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])
|
1998-12-16 06:38:35 +01:00
|
|
|
|
|
|
|
if test "x$enable_threads" != "xyes"; then
|
|
|
|
enable_threads=no
|
|
|
|
fi
|
1998-06-11 01:21:14 +02:00
|
|
|
|
2003-03-04 11:10:48 +01:00
|
|
|
AC_MSG_CHECKING([whether to enable garbage collector friendliness])
|
Add configure test for garbage collector friendliness for GLib. If
2000-04-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in, acconfig.h: Add configure test for garbage
collector friendliness for GLib. If enabled, ENABLE_GC_FRIENDLY
will be defined.
* garray.c, ghash.c, glist.c, gmain.c, gmem.c, gnode.c, gqueue.c,
gslist.c, gtree.c: If ENABLE_GC_FRIENDLY is defined, NULLify all
memory released by the user, but cached by GLib. This lets a
garbage collector have a more correct view of the actually used
memory.
2000-04-17 15:23:27 +02:00
|
|
|
if test "x$enable_gc_friendly" = "xyes"; then
|
2006-01-25 16:51:43 +01:00
|
|
|
AC_DEFINE(ENABLE_GC_FRIENDLY_DEFAULT, 1, [Whether to enable GC friendliness by default])
|
2003-03-04 11:10:48 +01:00
|
|
|
AC_MSG_RESULT([yes])
|
Add configure test for garbage collector friendliness for GLib. If
2000-04-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in, acconfig.h: Add configure test for garbage
collector friendliness for GLib. If enabled, ENABLE_GC_FRIENDLY
will be defined.
* garray.c, ghash.c, glist.c, gmain.c, gmem.c, gnode.c, gqueue.c,
gslist.c, gtree.c: If ENABLE_GC_FRIENDLY is defined, NULLify all
memory released by the user, but cached by GLib. This lets a
garbage collector have a more correct view of the actually used
memory.
2000-04-17 15:23:27 +02:00
|
|
|
else
|
2003-03-04 11:10:48 +01:00
|
|
|
AC_MSG_RESULT([no])
|
Add configure test for garbage collector friendliness for GLib. If
2000-04-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in, acconfig.h: Add configure test for garbage
collector friendliness for GLib. If enabled, ENABLE_GC_FRIENDLY
will be defined.
* garray.c, ghash.c, glist.c, gmain.c, gmem.c, gnode.c, gqueue.c,
gslist.c, gtree.c: If ENABLE_GC_FRIENDLY is defined, NULLify all
memory released by the user, but cached by GLib. This lets a
garbage collector have a more correct view of the actually used
memory.
2000-04-17 15:23:27 +02:00
|
|
|
fi
|
2000-02-13 08:18:23 +01:00
|
|
|
|
2003-03-04 11:10:48 +01:00
|
|
|
AC_MSG_CHECKING([whether to disable memory pools])
|
2000-12-19 10:35:44 +01:00
|
|
|
if test "x$disable_mem_pools" = "xno"; then
|
2003-03-04 11:10:48 +01:00
|
|
|
AC_MSG_RESULT([no])
|
2000-12-19 10:35:44 +01:00
|
|
|
else
|
2003-03-04 11:10:48 +01:00
|
|
|
AC_DEFINE(DISABLE_MEM_POOLS, [1], [Whether to disable memory pools])
|
2000-12-19 10:35:44 +01:00
|
|
|
AC_SUBST(DISABLE_MEM_POOLS)
|
2003-03-04 11:10:48 +01:00
|
|
|
AC_MSG_RESULT([yes])
|
2000-12-19 10:35:44 +01:00
|
|
|
fi
|
|
|
|
|
2009-06-22 21:33:41 +02:00
|
|
|
dnl location to install runtime libraries, e.g. ../../lib to install
|
|
|
|
dnl to /lib if libdir is /usr/lib
|
|
|
|
AC_ARG_WITH(runtime-libdir,
|
|
|
|
[AC_HELP_STRING([--with-runtime-libdir=RELPATH],
|
|
|
|
[Install runtime libraries relative to libdir])],
|
|
|
|
[],
|
|
|
|
[with_runtime_libdir=""])
|
2009-09-24 16:26:46 +02:00
|
|
|
GLIB_RUNTIME_LIBDIR="$with_runtime_libdir"
|
|
|
|
ABS_GLIB_RUNTIME_LIBDIR="`readlink -f $libdir/$with_runtime_libdir`"
|
2009-06-22 21:33:41 +02:00
|
|
|
AC_SUBST(GLIB_RUNTIME_LIBDIR)
|
2009-09-24 16:26:46 +02:00
|
|
|
AC_SUBST(ABS_GLIB_RUNTIME_LIBDIR)
|
2009-06-22 21:33:41 +02:00
|
|
|
AM_CONDITIONAL(HAVE_GLIB_RUNTIME_LIBDIR, [test "x$with_runtime_libdir" != "x"])
|
|
|
|
|
2001-05-29 15:47:05 +02:00
|
|
|
dnl Check for a working C++ compiler, but do not bail out, if none is found.
|
2009-11-03 14:06:29 +01:00
|
|
|
AC_CHECK_TOOLS(CXX, [$CCC c++ g++ gcc CC cxx cc++ cl], [gcc])
|
2001-05-29 15:47:05 +02:00
|
|
|
AC_LANG_SAVE
|
|
|
|
AC_LANG_CPLUSPLUS
|
|
|
|
AC_TRY_COMPILE(,[class a { int b; } c;], ,CXX=)
|
2003-03-04 11:10:48 +01:00
|
|
|
AM_CONDITIONAL(HAVE_CXX, [test "$CXX" != ""])
|
2001-05-29 15:47:05 +02:00
|
|
|
AC_LANG_RESTORE
|
2001-01-16 03:24:24 +01:00
|
|
|
|
2000-02-13 08:18:23 +01:00
|
|
|
AM_PROG_CC_STDC
|
2007-11-10 00:40:41 +01:00
|
|
|
AM_PROG_CC_C_O
|
2000-02-13 08:18:23 +01:00
|
|
|
AC_PROG_INSTALL
|
|
|
|
|
2002-02-15 17:41:54 +01:00
|
|
|
AC_SYS_LARGEFILE
|
|
|
|
|
2010-08-05 07:45:26 +02:00
|
|
|
PKG_PROG_PKG_CONFIG(0.16)
|
2001-04-03 20:27:59 +02:00
|
|
|
|
2001-01-05 22:22:47 +01:00
|
|
|
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
|
2002-11-05 01:27:15 +01:00
|
|
|
GLIB_DEBUG_FLAGS="-DG_DISABLE_CAST_CHECKS"
|
|
|
|
|
2001-01-05 22:22:47 +01:00
|
|
|
if test "x$enable_debug" = "xno"; then
|
2002-11-05 01:27:15 +01:00
|
|
|
GLIB_DEBUG_FLAGS="$GLIB_DEBUG_FLAGS -DG_DISABLE_ASSERT -DG_DISABLE_CHECKS"
|
2001-01-05 22:22:47 +01:00
|
|
|
fi
|
|
|
|
fi
|
|
|
|
|
2002-09-29 01:52:52 +02:00
|
|
|
# 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
|
|
|
|
;;
|
2001-09-27 08:11:48 +02:00
|
|
|
esac
|
2002-09-29 01:52:52 +02:00
|
|
|
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
|
2001-09-27 08:11:48 +02:00
|
|
|
fi
|
|
|
|
fi
|
2008-04-21 14:24:49 +02:00
|
|
|
GLIB_EXTRA_CFLAGS="${msnative_struct}"
|
|
|
|
AC_SUBST(GLIB_EXTRA_CFLAGS)
|
2001-09-27 08:11:48 +02:00
|
|
|
|
2001-03-09 22:18:33 +01:00
|
|
|
AC_EXEEXT
|
|
|
|
|
fixed dealing with collection/lcopy of NULL values.
Mon Dec 11 04:44:11 2000 Tim Janik <timj@gtk.org>
* gboxed.c: fixed dealing with collection/lcopy of NULL values.
* gclosure.h: removed insane ramblings, added G_CALLBACK() a casting
convenience macro.
* Makefile.am: cleanups, marshaller generation rules.
* gmarshal.[hc]: new files with GRuntime standard marshallers.
* glib-genmarshal.c: fix log domain, support gruntime standard
marshallers, suport G_TYPE_PARAM, come with extern "C" and
#include gmarshal.h.
* glib-genmarshal.1: reflect glib-genmarshal.c updates.
* gobject.[hc]: implement object constructor. rework parameter
changed notification queueing, we support queue freezes now and
don't dispatch from an idle handler anymore.
parameter->property rename hassle.
implemented ::properties_changed and ::notify::* signals for
property change notification (the later supports property names
as details). added signal connection and named data properties.
(g_signal_connect_object): new function to setup while_alive
connections.
(g_object_class_install_property): sink properties now, since they
are initially floating.
(g_object_steal_data):
(g_object_set_data_full):
(g_object_set_data):
(g_object_get_data): set/get data by using g_datalist_*() functions
directly.
(g_object_queue_param_changed): nuked.
(g_object_freeze_notify): start queueing of property changes (freeze/
thaw calls stack).
(g_object_notify): announce changes of a certain property directly.
(g_object_thaw_notify): process queue of property changes, therefore
emitting GObject::notify::detail with detail being the changed
properties names.
(G_OBJECT_WARN_INVALID_PROPERTY_ID): saner macro variant of former
G_WARN_INVALID_PARAM_ID().
* gparam.[hc]: param specs are now initially floating and need to be
sunken with g_param_spec_sink(), support G_TYPE_PARAM values.
added G_PARAM_CONSTRUCT and G_PARAM_CONSTRUCT_ONLY parameter flags,
required by GObjectClass.constructor().
* gparamspecs.[hc]: added GParamSpecParam, GParamSpecPointer and
GParamSpecCCallback, param specs for G_TYPE_PARAM, G_TYPE_POINTER
and G_TYPE_CCALLBACK respectively.
* gsignal.[hc]: cleanups.
(signal_id_lookup): after walking the anchestry, try interfaces as well.
(g_signal_new): new function to create signals from varargs type list.
(g_signal_connect_closure): closure connection variant that works from
signal name+detail.
(g_signal_connect_data): c handler connection variant that works from
signal name+detail.
(g_signal_emit_valist): emit signal for an instance with paraneters
collected from a va_list.
(g_signal_emit): emit signal, taking parameters from varargs list.
(g_signal_emit_by_name): same as g_signal_emit, working from
signal name+detail.
(signal_emit_R): return whether return_value needs to be altered.
* gtype.[hc]: set log-domain to GRuntime, i'm slowly getting to all
the points that need to reflect the upcoming rename.
melt g_type_conforms_to() functionality into g_type_is_a(), as that
is what we really want (liskov substitution principle).
assorted changes to other files due to conforms_to->is_a.
* gvalue.[hc]: implemented g_value_set_instance() that sets a value
from an instantiatable type via the value_table's collect_value()
function (based on an idea from James Henstridge <james@daa.com.au>).
cleanups/fixes.
* gvaluetypes.[hc]: implement G_TYPE_CCALLBACK and G_TYPE_PARAM.
2000-12-12 08:32:00 +01:00
|
|
|
# define a MAINT-like variable REBUILD which is set if Perl
|
|
|
|
# and awk are found, so autogenerated sources can be rebuilt
|
|
|
|
AC_PROG_AWK
|
2003-03-04 11:10:48 +01:00
|
|
|
AC_CHECK_PROGS(PERL, [perl5 perl])
|
fixed dealing with collection/lcopy of NULL values.
Mon Dec 11 04:44:11 2000 Tim Janik <timj@gtk.org>
* gboxed.c: fixed dealing with collection/lcopy of NULL values.
* gclosure.h: removed insane ramblings, added G_CALLBACK() a casting
convenience macro.
* Makefile.am: cleanups, marshaller generation rules.
* gmarshal.[hc]: new files with GRuntime standard marshallers.
* glib-genmarshal.c: fix log domain, support gruntime standard
marshallers, suport G_TYPE_PARAM, come with extern "C" and
#include gmarshal.h.
* glib-genmarshal.1: reflect glib-genmarshal.c updates.
* gobject.[hc]: implement object constructor. rework parameter
changed notification queueing, we support queue freezes now and
don't dispatch from an idle handler anymore.
parameter->property rename hassle.
implemented ::properties_changed and ::notify::* signals for
property change notification (the later supports property names
as details). added signal connection and named data properties.
(g_signal_connect_object): new function to setup while_alive
connections.
(g_object_class_install_property): sink properties now, since they
are initially floating.
(g_object_steal_data):
(g_object_set_data_full):
(g_object_set_data):
(g_object_get_data): set/get data by using g_datalist_*() functions
directly.
(g_object_queue_param_changed): nuked.
(g_object_freeze_notify): start queueing of property changes (freeze/
thaw calls stack).
(g_object_notify): announce changes of a certain property directly.
(g_object_thaw_notify): process queue of property changes, therefore
emitting GObject::notify::detail with detail being the changed
properties names.
(G_OBJECT_WARN_INVALID_PROPERTY_ID): saner macro variant of former
G_WARN_INVALID_PARAM_ID().
* gparam.[hc]: param specs are now initially floating and need to be
sunken with g_param_spec_sink(), support G_TYPE_PARAM values.
added G_PARAM_CONSTRUCT and G_PARAM_CONSTRUCT_ONLY parameter flags,
required by GObjectClass.constructor().
* gparamspecs.[hc]: added GParamSpecParam, GParamSpecPointer and
GParamSpecCCallback, param specs for G_TYPE_PARAM, G_TYPE_POINTER
and G_TYPE_CCALLBACK respectively.
* gsignal.[hc]: cleanups.
(signal_id_lookup): after walking the anchestry, try interfaces as well.
(g_signal_new): new function to create signals from varargs type list.
(g_signal_connect_closure): closure connection variant that works from
signal name+detail.
(g_signal_connect_data): c handler connection variant that works from
signal name+detail.
(g_signal_emit_valist): emit signal for an instance with paraneters
collected from a va_list.
(g_signal_emit): emit signal, taking parameters from varargs list.
(g_signal_emit_by_name): same as g_signal_emit, working from
signal name+detail.
(signal_emit_R): return whether return_value needs to be altered.
* gtype.[hc]: set log-domain to GRuntime, i'm slowly getting to all
the points that need to reflect the upcoming rename.
melt g_type_conforms_to() functionality into g_type_is_a(), as that
is what we really want (liskov substitution principle).
assorted changes to other files due to conforms_to->is_a.
* gvalue.[hc]: implemented g_value_set_instance() that sets a value
from an instantiatable type via the value_table's collect_value()
function (based on an idea from James Henstridge <james@daa.com.au>).
cleanups/fixes.
* gvaluetypes.[hc]: implement G_TYPE_CCALLBACK and G_TYPE_PARAM.
2000-12-12 08:32:00 +01:00
|
|
|
# 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)
|
|
|
|
|
2001-10-29 17:13:36 +01:00
|
|
|
# Need full path to Perl for glib-mkenums
|
|
|
|
#
|
|
|
|
if test "x$PERL" != x ; then
|
2003-03-04 11:10:48 +01:00
|
|
|
AC_PATH_PROG(PERL_PATH, [$PERL])
|
2007-05-18 06:22:46 +02:00
|
|
|
fi
|
|
|
|
if test "x$PERL_PATH" = x ; then
|
2001-10-29 17:13:36 +01:00
|
|
|
PERL_PATH="/usr/bin/env perl"
|
|
|
|
fi
|
|
|
|
AC_SUBST(PERL_PATH)
|
2001-01-16 03:24:24 +01:00
|
|
|
|
initialize automake variables EXTRA_DIST and TEST_PROGS for unconditional
2007-11-21 21:06:47 Tim Janik <timj@imendio.com>
* Makefile.decl: initialize automake variables EXTRA_DIST and
TEST_PROGS for unconditional appending via += in other makefiles.
define recursive test targets: test, test-report, perf-report,
full-report, as described here:
http://mail.gnome.org/archives/gtk-devel-list/2007-November/msg00000.html
* Makefile.am:
* build/win32/vs8/Makefile.am, build/win32/dirent/Makefile.am:
* build/win32/Makefile.am, build/Makefile.am:
* docs/Makefile.am, docs/reference/Makefile.am:
* docs/reference/glib/Makefile.am, docs/reference/gobject/Makefile.am:
* gmodule/Makefile.am, tests/Makefile.am:
* tests/refcount/Makefile.am, tests/gobject/Makefile.am:
* glib/update-pcre/Makefile.am, glib/libcharset/Makefile.am:
* glib/tests/Makefile.am, glib/pcre/Makefile.am:
* glib/gnulib/Makefile.am, gobject/Makefile.am, m4macros/Makefile.am:
* gthread/Makefile.am, glib/Makefile.am:
include $(top_srcdir)/Makefile.decl, adapted EXTRA_DIST assignments.
* glib/tests/Makefile.am: removed example testing rules.
* glib/tests/testing.c: conditionalized performance and slow tests.
* glib/gtestutils.h:
* glib/gtestutils.c: work around g_test_config_vars not changing its
exported value after value assignments, aparently due to symbol aliases.
* glib/gtester.c: fixed off-by-one error which produced junk in logs.
* configure.in: check for python >= 2.4 and provide $PYTHON for scripts.
svn path=/trunk/; revision=5914
2007-11-21 21:09:46 +01:00
|
|
|
# Need suitable python path for greport
|
|
|
|
AM_PATH_PYTHON(2.4,,PYTHON="/usr/bin/env python2.4")
|
|
|
|
|
|
|
|
|
2002-05-21 21:09:37 +02:00
|
|
|
dnl ***********************
|
|
|
|
dnl *** Tests for iconv ***
|
|
|
|
dnl ***********************
|
|
|
|
dnl
|
|
|
|
dnl We do this before the gettext checks, to avoid distortion
|
|
|
|
|
2007-11-26 00:27:45 +01:00
|
|
|
dnl On Windows we use a native implementation
|
2002-05-21 21:09:37 +02:00
|
|
|
|
2007-11-26 00:27:45 +01:00
|
|
|
if test x"$glib_native_win32" = xyes; then
|
|
|
|
with_libiconv=native
|
|
|
|
else
|
|
|
|
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)
|
2003-03-04 11:10:48 +01:00
|
|
|
AC_CHECK_LIB(iconv, libiconv_open, [with_libiconv=gnu; found_iconv=yes])
|
2007-11-26 00:27:45 +01:00
|
|
|
;;
|
|
|
|
native)
|
2003-03-04 11:10:48 +01:00
|
|
|
AC_CHECK_LIB(iconv, iconv_open, [with_libiconv=native; found_iconv=yes])
|
2007-11-26 00:27:45 +01:00
|
|
|
;;
|
|
|
|
esac
|
2002-05-21 21:09:37 +02:00
|
|
|
|
2007-11-26 00:27:45 +01:00
|
|
|
if test "x$found_iconv" = "xno" ; then
|
|
|
|
AC_MSG_ERROR([*** No iconv() implementation found in C library or libiconv])
|
|
|
|
fi
|
2002-05-21 21:09:37 +02:00
|
|
|
fi
|
|
|
|
|
2005-08-08 21:50:38 +02:00
|
|
|
AC_ARG_ENABLE(iconv-cache,
|
|
|
|
[AC_HELP_STRING([--enable-iconv-cache=@<:@yes/no/auto@:>@],
|
|
|
|
[cache iconv descriptors [default=auto]])],,
|
|
|
|
[enable_iconv_cache=auto])
|
|
|
|
|
|
|
|
AC_MSG_CHECKING([Whether to cache iconv descriptors])
|
|
|
|
case $enable_iconv_cache in
|
|
|
|
auto)
|
|
|
|
if test $ac_cv_gnu_library_2_1 = yes; then
|
|
|
|
enable_iconv_cache=no
|
|
|
|
else
|
|
|
|
enable_iconv_cache=yes
|
|
|
|
fi
|
|
|
|
;;
|
|
|
|
yes|no)
|
|
|
|
;;
|
|
|
|
*) AC_MSG_ERROR([Value given to --enable-iconv-cache must be one of yes, no or auto])
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
|
|
|
|
if test $enable_iconv_cache = yes; then
|
|
|
|
AC_DEFINE(NEED_ICONV_CACHE,1,[Do we cache iconv descriptors])
|
|
|
|
fi
|
|
|
|
|
|
|
|
AC_MSG_RESULT($enable_iconv_cache)
|
|
|
|
|
|
|
|
|
2009-11-19 17:16:29 +01:00
|
|
|
dnl
|
|
|
|
dnl zlib support
|
|
|
|
dnl
|
2010-07-08 20:12:28 +02:00
|
|
|
PKG_CHECK_MODULES([ZLIB], [zlib], [found_zlib=yes], [found_zlib=no])
|
2009-11-19 17:16:29 +01:00
|
|
|
if test "x$found_zlib" = "xno" ; then
|
2010-07-08 20:12:28 +02:00
|
|
|
AC_CHECK_LIB(z, inflate, [AC_CHECK_HEADER(zlib.h, found_zlib=yes)])
|
|
|
|
if test "x$found_zlib" = "xno" ; then
|
|
|
|
AC_MSG_ERROR([*** Working zlib library and headers not found ***])
|
|
|
|
fi
|
|
|
|
ZLIB_LIBS='-lz'
|
|
|
|
AC_SUBST(ZLIB_LIBS)
|
2009-11-19 17:16:29 +01:00
|
|
|
fi
|
2010-07-08 20:12:28 +02:00
|
|
|
|
2011-04-09 17:39:32 +02:00
|
|
|
PKG_CHECK_MODULES(LIBFFI, [libffi >= 3.0.0])
|
|
|
|
AC_SUBST(LIBFFI_CFLAGS)
|
|
|
|
AC_SUBST(LIBFFI_LIBS)
|
|
|
|
|
2001-01-16 03:24:24 +01:00
|
|
|
dnl
|
|
|
|
dnl gettext support
|
|
|
|
dnl
|
|
|
|
|
2008-06-12 20:37:44 +02:00
|
|
|
ALL_LINGUAS="`grep -v '^#' "$srcdir/po/LINGUAS" | tr '\n' ' '`"
|
2008-06-11 22:31:44 +02:00
|
|
|
AC_SUBST([CONFIG_STATUS_DEPENDENCIES],['$(top_srcdir)/po/LINGUAS'])
|
2002-12-11 20:42:31 +01:00
|
|
|
GLIB_GNU_GETTEXT
|
2001-09-19 17:40:38 +02:00
|
|
|
|
2002-12-11 20:42:31 +01:00
|
|
|
if test "$gt_cv_have_gettext" != "yes" ; then
|
2001-09-19 17:40:38 +02:00
|
|
|
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
|
|
|
|
|
2002-12-13 05:11:32 +01:00
|
|
|
LIBS="$INTLLIBS $LIBS"
|
2001-01-16 03:24:24 +01:00
|
|
|
|
|
|
|
GETTEXT_PACKAGE=glib20
|
|
|
|
AC_SUBST(GETTEXT_PACKAGE)
|
2003-03-04 11:10:48 +01:00
|
|
|
AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE, ["$GETTEXT_PACKAGE"],
|
2002-12-04 03:16:59 +01:00
|
|
|
[Define the gettext package to be used])
|
2001-01-16 03:24:24 +01:00
|
|
|
|
2002-12-11 20:42:31 +01:00
|
|
|
GLIB_DEFINE_LOCALEDIR(GLIB_LOCALE_DIR)
|
2001-01-16 03:24:24 +01:00
|
|
|
|
2002-05-21 21:09:37 +02:00
|
|
|
dnl
|
|
|
|
dnl Now we are done with gettext checks, figure out ICONV_LIBS
|
|
|
|
dnl
|
|
|
|
|
2007-11-26 00:27:45 +01:00
|
|
|
if test x"$glib_native_win32" != xyes; then
|
|
|
|
if test x$with_libiconv != xno ; then
|
|
|
|
case " $INTLLIBS " in
|
|
|
|
*[[\ \ ]]-liconv[[\ \ ]]*) ;;
|
|
|
|
*) ICONV_LIBS="-liconv" ;;
|
|
|
|
esac
|
|
|
|
fi
|
2002-05-21 21:09:37 +02:00
|
|
|
fi
|
|
|
|
AC_SUBST(ICONV_LIBS)
|
|
|
|
|
|
|
|
case $with_libiconv in
|
|
|
|
gnu)
|
2002-12-04 03:16:59 +01:00
|
|
|
AC_DEFINE(USE_LIBICONV_GNU, 1, [Using GNU libiconv])
|
2002-05-21 21:09:37 +02:00
|
|
|
;;
|
|
|
|
native)
|
2002-12-04 03:16:59 +01:00
|
|
|
AC_DEFINE(USE_LIBICONV_NATIVE, 1, [Using a native implementation of iconv in a separate library])
|
2002-05-21 21:09:37 +02:00
|
|
|
;;
|
|
|
|
esac
|
|
|
|
|
2000-10-16 03:02:19 +02:00
|
|
|
dnl Initialize libtool
|
2010-07-13 05:05:48 +02:00
|
|
|
LT_PREREQ([2.2])
|
|
|
|
LT_INIT([disable-static win32-dll])
|
2008-10-11 01:55:38 +02:00
|
|
|
dnl when using libtool 2.x create libtool early, because it's used in configure
|
|
|
|
m4_ifdef([LT_OUTPUT], [LT_OUTPUT])
|
|
|
|
|
2000-10-16 03:02:19 +02:00
|
|
|
|
2000-02-13 08:18:23 +01:00
|
|
|
if test "x$GCC" = "xyes"; then
|
|
|
|
case " $CFLAGS " in
|
2000-10-16 03:02:19 +02:00
|
|
|
*[[\ \ ]]-Wall[[\ \ ]]*) ;;
|
2000-02-13 08:18:23 +01:00
|
|
|
*) CFLAGS="$CFLAGS -Wall" ;;
|
|
|
|
esac
|
|
|
|
fi
|
|
|
|
|
2008-05-28 18:18:27 +02:00
|
|
|
CPPFLAGS="$CPPFLAGS -DG_DISABLE_SINGLE_INCLUDES"
|
|
|
|
|
2008-04-04 00:03:32 +02:00
|
|
|
if test "$glib_native_win32" = "yes"; then
|
|
|
|
if test x$enable_static = xyes -a x$enable_shared = xyes; then
|
|
|
|
AC_MSG_ERROR([Can not build both shared and static at the same time on Windows.])
|
|
|
|
fi
|
|
|
|
if test x$enable_static = xyes; then
|
|
|
|
glib_win32_static_compilation=yes
|
2008-04-21 10:38:36 +02:00
|
|
|
GLIB_WIN32_STATIC_COMPILATION_DEFINE="#define GLIB_STATIC_COMPILATION 1
|
|
|
|
#define GOBJECT_STATIC_COMPILATION 1"
|
2008-04-04 00:43:31 +02:00
|
|
|
AC_SUBST(GLIB_WIN32_STATIC_COMPILATION_DEFINE)
|
2008-04-04 00:03:32 +02:00
|
|
|
fi
|
|
|
|
fi
|
2008-04-21 10:38:36 +02:00
|
|
|
AM_CONDITIONAL(OS_WIN32_AND_DLL_COMPILATION, [test x$glib_native_win32 = xyes -a x$glib_win32_static_compilation != xyes])
|
2008-04-04 00:03:32 +02:00
|
|
|
|
2002-12-05 21:33:26 +01:00
|
|
|
dnl
|
2000-02-13 08:18:23 +01:00
|
|
|
dnl DU4 native cc currently needs -std1 for ANSI mode (instead of K&R)
|
2002-12-05 21:33:26 +01:00
|
|
|
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
|
2000-02-13 08:18:23 +01:00
|
|
|
|
|
|
|
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
|
2000-09-18 00:18:48 +02:00
|
|
|
AC_FUNC_ALLOCA
|
2009-06-20 05:44:29 +02:00
|
|
|
AC_CHECK_FUNCS(mmap posix_memalign memalign valloc fsync pipe2)
|
2011-06-09 13:36:19 +02:00
|
|
|
AC_CHECK_FUNCS(atexit on_exit timegm gmtime_r)
|
|
|
|
|
|
|
|
dnl don't use AC_CHECK_FUNCS here, otherwise HAVE_QSORT_R will
|
|
|
|
dnl be automatically defined, which we don't want to do
|
|
|
|
dnl until we have checked this function is actually usable
|
|
|
|
AC_CHECK_FUNC([qsort_r])
|
2011-06-05 13:34:33 +02:00
|
|
|
|
2011-02-16 07:28:27 +01:00
|
|
|
# BSD has a qsort_r with wrong argument order
|
2011-06-05 13:34:33 +02:00
|
|
|
if test x$ac_cv_func_qsort_r = xyes ; then
|
|
|
|
AC_CACHE_CHECK([if qsort_r uses glibc compatible argument order], glib_cv_have_qsort_r, [
|
|
|
|
AC_RUN_IFELSE([AC_LANG_SOURCE([[
|
|
|
|
#define _GNU_SOURCE
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
|
|
|
static int
|
|
|
|
cmp (const void *a, const void *b, void *c)
|
|
|
|
{
|
|
|
|
const int *ia = a;
|
|
|
|
const int *ib = b;
|
|
|
|
|
|
|
|
if (*ia < *ib)
|
|
|
|
return -1;
|
|
|
|
else if (*ia > *ib)
|
|
|
|
return 1;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
main (int argc, char **argv)
|
|
|
|
{
|
|
|
|
int arr[3] = { 1, 2, 0 };
|
|
|
|
int d = 3;
|
|
|
|
|
|
|
|
qsort_r (arr, 3, sizeof (int), cmp, &d);
|
|
|
|
|
|
|
|
if (arr[0] == 0 && arr[1] == 1 && arr[2] == 2)
|
|
|
|
return 0;
|
|
|
|
else
|
|
|
|
return 1;
|
|
|
|
}]])],[glib_cv_have_qsort_r=yes],[glib_cv_have_qsort_r=no])])
|
|
|
|
fi
|
2011-02-16 07:28:27 +01:00
|
|
|
|
2011-06-05 13:26:12 +02:00
|
|
|
if test x$glib_cv_have_qsort_r = xyes ; then
|
|
|
|
AC_DEFINE(HAVE_QSORT_R, 1, [Define to 1 if you have the 'qsort_r' function])
|
2011-02-16 07:28:27 +01:00
|
|
|
fi
|
2006-03-23 03:54:29 +01:00
|
|
|
|
2000-02-13 08:18:23 +01:00
|
|
|
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)
|
2001-09-27 08:11:48 +02:00
|
|
|
AC_CHECK_SIZEOF(__int64)
|
2000-02-13 08:18:23 +01:00
|
|
|
|
2001-10-18 23:07:29 +02:00
|
|
|
if test x$ac_cv_sizeof_long = x8 || test x$ac_cv_sizeof_long_long = x8 || test x$ac_cv_sizeof___int64 = x8 ; then
|
2001-10-11 04:43:40 +02:00
|
|
|
:
|
|
|
|
else
|
|
|
|
AC_MSG_ERROR([
|
|
|
|
*** GLib requires a 64 bit type. You might want to consider
|
|
|
|
*** using the GNU C compiler.
|
|
|
|
])
|
|
|
|
fi
|
|
|
|
|
2005-01-03 01:20:47 +01:00
|
|
|
if test x$glib_native_win32 != xyes && test x$ac_cv_sizeof_long_long = x8; then
|
2000-02-13 08:18:23 +01:00
|
|
|
# long long is a 64 bit integer.
|
2002-05-01 17:21:07 +02:00
|
|
|
AC_MSG_CHECKING(for format to printf and scanf a guint64)
|
2000-02-13 08:18:23 +01:00
|
|
|
AC_CACHE_VAL(glib_cv_long_long_format,[
|
2001-03-09 22:18:33 +01:00
|
|
|
for format in ll q I64; do
|
2000-09-28 09:54:40 +02:00
|
|
|
AC_TRY_RUN([#include <stdio.h>
|
2000-02-13 08:18:23 +01:00
|
|
|
int main()
|
|
|
|
{
|
|
|
|
long long b, a = -0x3AFAFAFAFAFAFAFALL;
|
|
|
|
char buffer[1000];
|
2000-09-28 09:45:04 +02:00
|
|
|
sprintf (buffer, "%${format}u", a);
|
|
|
|
sscanf (buffer, "%${format}u", &b);
|
2000-02-13 08:18:23 +01:00
|
|
|
exit (b!=a);
|
|
|
|
}
|
|
|
|
],
|
2002-12-13 03:09:48 +01:00
|
|
|
[glib_cv_long_long_format=${format}
|
|
|
|
break],
|
|
|
|
[],[:])
|
2000-09-28 09:45:04 +02:00
|
|
|
done])
|
|
|
|
if test -n "$glib_cv_long_long_format"; then
|
2001-03-09 22:18:33 +01:00
|
|
|
AC_MSG_RESULT(%${glib_cv_long_long_format}u)
|
2003-07-29 01:00:05 +02:00
|
|
|
AC_DEFINE(HAVE_LONG_LONG_FORMAT,1,[define if system printf can print long long])
|
2004-03-17 20:07:37 +01:00
|
|
|
if test x"$glib_cv_long_long_format" = xI64; then
|
|
|
|
AC_DEFINE(HAVE_INT64_AND_I64,1,[define to support printing 64-bit integers with format I64])
|
|
|
|
fi
|
2000-09-28 09:45:04 +02:00
|
|
|
else
|
|
|
|
AC_MSG_RESULT(none)
|
|
|
|
fi
|
2001-09-27 08:11:48 +02:00
|
|
|
elif test x$ac_cv_sizeof___int64 = x8; then
|
|
|
|
# __int64 is a 64 bit integer.
|
2002-05-01 17:21:07 +02:00
|
|
|
AC_MSG_CHECKING(for format to printf and scanf a guint64)
|
2005-01-03 01:20:47 +01:00
|
|
|
# We know this is MSVCRT.DLL, and what the formats are
|
2001-09-27 08:11:48 +02:00
|
|
|
glib_cv_long_long_format=I64
|
|
|
|
AC_MSG_RESULT(%${glib_cv_long_long_format}u)
|
2003-07-29 01:00:05 +02:00
|
|
|
AC_DEFINE(HAVE_LONG_LONG_FORMAT,1,[define if system printf can print long long])
|
2004-03-17 20:07:37 +01:00
|
|
|
AC_DEFINE(HAVE_INT64_AND_I64,1,[define to support printing 64-bit integers with format I64])
|
2000-02-13 08:18:23 +01:00
|
|
|
fi
|
|
|
|
|
|
|
|
dnl long doubles were not used, and a portability problem
|
|
|
|
dnl AC_C_LONG_DOUBLE
|
|
|
|
AC_C_CONST
|
|
|
|
|
2000-12-29 03:16:51 +01:00
|
|
|
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;
|
|
|
|
],
|
2002-12-04 03:16:59 +01:00
|
|
|
AC_DEFINE(SANE_MALLOC_PROTOS, 1,
|
|
|
|
[Define if you have correct malloc prototypes])
|
2000-12-29 03:16:51 +01:00
|
|
|
SANE_MALLOC_PROTOS=yes)
|
|
|
|
fi
|
|
|
|
AC_MSG_RESULT($SANE_MALLOC_PROTOS)
|
|
|
|
CFLAGS=$glib_save_CFLAGS
|
|
|
|
|
2001-12-18 21:39:53 +01:00
|
|
|
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
|
|
|
|
,)
|
|
|
|
])
|
2000-12-29 03:16:51 +01:00
|
|
|
|
2000-02-13 08:18:23 +01:00
|
|
|
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.
|
2000-10-16 03:02:19 +02:00
|
|
|
AC_CACHE_CHECK([for __inline],glib_cv_has__inline,[
|
2011-05-02 17:44:46 +02:00
|
|
|
AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
|
2000-02-13 08:18:23 +01:00
|
|
|
__inline int foo () { return 0; }
|
|
|
|
int main () { return foo (); }
|
2011-05-02 17:44:46 +02:00
|
|
|
]])],
|
2000-02-13 08:18:23 +01:00
|
|
|
glib_cv_has__inline=yes
|
|
|
|
,
|
|
|
|
glib_cv_has__inline=no
|
|
|
|
,)
|
|
|
|
])
|
|
|
|
case x$glib_cv_has__inline in
|
2000-10-16 03:02:19 +02:00
|
|
|
xyes) AC_DEFINE(G_HAVE___INLINE,1,[Have __inline keyword])
|
2000-02-13 08:18:23 +01:00
|
|
|
esac
|
2000-10-16 03:02:19 +02:00
|
|
|
AC_CACHE_CHECK([for __inline__],glib_cv_has__inline__,[
|
2011-05-02 17:44:46 +02:00
|
|
|
AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
|
2000-02-13 08:18:23 +01:00
|
|
|
__inline__ int foo () { return 0; }
|
|
|
|
int main () { return foo (); }
|
2011-05-02 17:44:46 +02:00
|
|
|
]])],
|
2000-02-13 08:18:23 +01:00
|
|
|
glib_cv_has__inline__=yes
|
|
|
|
,
|
|
|
|
glib_cv_has__inline__=no
|
|
|
|
,)
|
|
|
|
])
|
|
|
|
case x$glib_cv_has__inline__ in
|
2000-10-16 03:02:19 +02:00
|
|
|
xyes) AC_DEFINE(G_HAVE___INLINE__,1,[Have __inline__ keyword])
|
2000-02-13 08:18:23 +01:00
|
|
|
esac
|
2000-10-16 03:02:19 +02:00
|
|
|
AC_CACHE_CHECK([for inline], glib_cv_hasinline,[
|
2011-05-02 17:44:46 +02:00
|
|
|
AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
|
2001-07-30 11:02:37 +02:00
|
|
|
#undef inline
|
2000-02-13 08:18:23 +01:00
|
|
|
inline int foo () { return 0; }
|
|
|
|
int main () { return foo (); }
|
2011-05-02 17:44:46 +02:00
|
|
|
]])],
|
2000-02-13 08:18:23 +01:00
|
|
|
glib_cv_hasinline=yes
|
|
|
|
,
|
|
|
|
glib_cv_hasinline=no
|
|
|
|
,)
|
|
|
|
])
|
|
|
|
case x$glib_cv_hasinline in
|
2000-10-16 03:02:19 +02:00
|
|
|
xyes) AC_DEFINE(G_HAVE_INLINE,1,[Have inline keyword])
|
2000-02-13 08:18:23 +01:00
|
|
|
esac
|
|
|
|
|
2005-01-04 06:31:44 +01:00
|
|
|
# if we can use inline functions in headers
|
|
|
|
AC_MSG_CHECKING(if inline functions in headers work)
|
2011-05-02 17:44:46 +02:00
|
|
|
AC_LINK_IFELSE([AC_LANG_SOURCE([[
|
2005-01-04 06:31:44 +01:00
|
|
|
#if defined (G_HAVE_INLINE) && defined (__GNUC__) && defined (__STRICT_ANSI__)
|
|
|
|
# undef inline
|
|
|
|
# define inline __inline__
|
|
|
|
#elif !defined (G_HAVE_INLINE)
|
|
|
|
# undef inline
|
|
|
|
# if defined (G_HAVE___INLINE__)
|
|
|
|
# define inline __inline__
|
|
|
|
# elif defined (G_HAVE___INLINE)
|
|
|
|
# define inline __inline
|
|
|
|
# endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
int glib_test_func2 (int);
|
|
|
|
|
|
|
|
static inline int
|
|
|
|
glib_test_func1 (void) {
|
|
|
|
return glib_test_func2 (1);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
main (void) {
|
|
|
|
int i = 1;
|
2011-05-02 17:44:46 +02:00
|
|
|
}]])],[g_can_inline=yes],[g_can_inline=no])
|
2005-01-04 06:31:44 +01:00
|
|
|
AC_MSG_RESULT($g_can_inline)
|
|
|
|
|
2005-11-30 05:54:57 +01:00
|
|
|
dnl *** check for working do while(0) macros ***
|
2008-07-02 17:56:27 +02:00
|
|
|
AC_CACHE_CHECK([for working do while(0) macros], g_cv_support_dowhile_macros, [
|
2005-11-30 05:54:57 +01:00
|
|
|
AC_TRY_COMPILE([],[
|
|
|
|
#define STMT_START do
|
|
|
|
#define STMT_END while(0)
|
|
|
|
#define STMT_TEST STMT_START { i = 0; } STMT_END
|
|
|
|
int main(void) { int i = 1; STMT_TEST; return i; }],
|
2008-07-02 17:56:27 +02:00
|
|
|
[g_cv_support_dowhile_macros=yes],
|
|
|
|
[g_cv_support_dowhile_macros=no],
|
|
|
|
[g_cv_support_dowhile_macros=yes])
|
2005-11-30 05:54:57 +01:00
|
|
|
])
|
2008-07-02 17:56:27 +02:00
|
|
|
if test x$g_cv_support_dowhile_macros = xyes; then
|
2005-11-30 05:54:57 +01:00
|
|
|
AC_DEFINE(HAVE_DOWHILE_MACROS, 1, [define for working do while(0) macros])
|
|
|
|
fi
|
|
|
|
|
2001-05-18 18:00:54 +02:00
|
|
|
# check for flavours of varargs macros
|
2001-05-28 17:41:24 +02:00
|
|
|
AC_MSG_CHECKING(for ISO C99 varargs macros in C)
|
2001-05-18 18:00:54 +02:00
|
|
|
AC_TRY_COMPILE([],[
|
|
|
|
int a(int p1, int p2, int p3);
|
|
|
|
#define call_a(...) a(1,__VA_ARGS__)
|
|
|
|
call_a(2,3);
|
2001-05-28 17:41:24 +02:00
|
|
|
],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++)
|
2001-05-29 15:47:05 +02:00
|
|
|
if test "$CXX" = ""; then
|
2001-05-28 17:41:24 +02:00
|
|
|
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)
|
2001-05-18 18:00:54 +02:00
|
|
|
|
|
|
|
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)
|
|
|
|
|
2004-08-10 20:52:30 +02:00
|
|
|
# check for GNUC visibility support
|
|
|
|
AC_MSG_CHECKING(for GNUC visibility attribute)
|
2011-05-02 17:44:46 +02:00
|
|
|
GLIB_CHECK_COMPILE_WARNINGS([AC_LANG_SOURCE([[
|
2004-08-10 20:52:30 +02:00
|
|
|
void
|
|
|
|
__attribute__ ((visibility ("hidden")))
|
2004-08-17 22:28:24 +02:00
|
|
|
f_hidden (void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
void
|
|
|
|
__attribute__ ((visibility ("internal")))
|
|
|
|
f_internal (void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
void
|
|
|
|
__attribute__ ((visibility ("protected")))
|
|
|
|
f_protected (void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
void
|
|
|
|
__attribute__ ((visibility ("default")))
|
|
|
|
f_default (void)
|
2004-08-10 20:52:30 +02:00
|
|
|
{
|
|
|
|
}
|
|
|
|
int main (int argc, char **argv)
|
|
|
|
{
|
2004-08-17 22:28:24 +02:00
|
|
|
f_hidden();
|
|
|
|
f_internal();
|
|
|
|
f_protected();
|
|
|
|
f_default();
|
2004-08-10 20:52:30 +02:00
|
|
|
return 0;
|
|
|
|
}
|
2011-05-02 17:44:46 +02:00
|
|
|
]])],g_have_gnuc_visibility=yes,g_have_gnuc_visibility=no)
|
2004-08-10 20:52:30 +02:00
|
|
|
AC_MSG_RESULT($g_have_gnuc_visibility)
|
2005-02-05 04:02:20 +01:00
|
|
|
AM_CONDITIONAL(HAVE_GNUC_VISIBILITY, [test x$g_have_gnuc_visibility = xyes])
|
2004-08-10 20:52:30 +02:00
|
|
|
|
2007-01-27 04:34:48 +01:00
|
|
|
AC_MSG_CHECKING([whether using Sun Studio C compiler])
|
|
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#if defined(__SUNPRO_C) || (__SUNPRO_C >= 0x550)
|
|
|
|
#else
|
|
|
|
# include "error: this is not Sun Studio."
|
|
|
|
#endif
|
|
|
|
]], [[]])], [ g_have_sunstudio_visibility=yes ], [ g_have_sunstudio_visibility=no ])
|
|
|
|
AC_MSG_RESULT($g_have_sunstudio_visibility)
|
|
|
|
AM_CONDITIONAL(HAVE_SUNSTUDIO_VISIBILITY, [test x$g_have_sunstudio_visibility = xyes])
|
|
|
|
|
2000-02-13 08:18:23 +01:00
|
|
|
# check for bytesex stuff
|
|
|
|
AC_C_BIGENDIAN
|
2008-07-02 21:21:53 +02:00
|
|
|
if test x$ac_cv_c_bigendian = xuniversal ; then
|
|
|
|
AC_TRY_COMPILE([#include <endian.h>], [#if __BYTE_ORDER == __BIG_ENDIAN
|
|
|
|
#else
|
|
|
|
#error Not a big endian.
|
|
|
|
#endif],
|
|
|
|
ac_cv_c_bigendian=yes
|
|
|
|
,AC_TRY_COMPILE([#include <endian.h>], [#if __BYTE_ORDER == __LITTLE_ENDIAN
|
|
|
|
#else
|
|
|
|
#error Not a little endian.
|
|
|
|
#endif],
|
|
|
|
ac_cv_c_bigendian=no
|
|
|
|
,AC_MSG_WARN([Could not determine endianness.])))
|
|
|
|
fi
|
|
|
|
|
2000-02-13 08:18:23 +01:00
|
|
|
|
2000-05-12 17:23:16 +02:00
|
|
|
# check for header files
|
2007-11-26 17:13:05 +01:00
|
|
|
AC_CHECK_HEADERS([dirent.h float.h limits.h pwd.h grp.h sys/param.h sys/poll.h sys/resource.h])
|
2005-12-27 20:15:12 +01:00
|
|
|
AC_CHECK_HEADERS([sys/time.h sys/times.h sys/wait.h unistd.h values.h])
|
2010-02-21 21:55:10 +01:00
|
|
|
AC_CHECK_HEADERS([sys/select.h sys/types.h stdint.h inttypes.h sched.h malloc.h])
|
2007-11-26 17:13:05 +01:00
|
|
|
AC_CHECK_HEADERS([sys/vfs.h sys/mount.h sys/vmount.h sys/statfs.h sys/statvfs.h])
|
|
|
|
AC_CHECK_HEADERS([mntent.h sys/mnttab.h sys/vfstab.h sys/mntctl.h sys/sysctl.h fstab.h])
|
2011-01-29 02:50:43 +01:00
|
|
|
AC_CHECK_HEADERS([sys/uio.h sys/mkdev.h])
|
2011-03-08 07:36:15 +01:00
|
|
|
AC_CHECK_HEADERS([linux/magic.h])
|
2007-11-26 17:13:05 +01:00
|
|
|
|
|
|
|
# check for structure fields
|
|
|
|
AC_CHECK_MEMBERS([struct stat.st_mtimensec, struct stat.st_mtim.tv_nsec, struct stat.st_atimensec, struct stat.st_atim.tv_nsec, struct stat.st_ctimensec, struct stat.st_ctim.tv_nsec])
|
2008-07-02 18:49:04 +02:00
|
|
|
AC_CHECK_MEMBERS([struct stat.st_blksize, struct stat.st_blocks, struct statfs.f_fstypename, struct statfs.f_bavail],,, [#include <sys/types.h>
|
2008-03-12 17:19:10 +01:00
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <unistd.h>
|
2008-08-14 05:01:23 +02:00
|
|
|
#ifdef HAVE_SYS_STATFS_H
|
2008-07-22 00:22:59 +02:00
|
|
|
#include <sys/statfs.h>
|
2008-08-14 05:01:23 +02:00
|
|
|
#endif
|
2008-03-20 12:44:12 +01:00
|
|
|
#ifdef HAVE_SYS_PARAM_H
|
2008-03-14 10:19:09 +01:00
|
|
|
#include <sys/param.h>
|
|
|
|
#endif
|
2008-03-20 12:44:12 +01:00
|
|
|
#ifdef HAVE_SYS_MOUNT_H
|
2008-03-14 10:19:09 +01:00
|
|
|
#include <sys/mount.h>
|
|
|
|
#endif])
|
2008-05-27 09:51:13 +02:00
|
|
|
# struct statvfs.f_basetype is available on Solaris but not for Linux.
|
|
|
|
AC_CHECK_MEMBERS([struct statvfs.f_basetype],,, [#include <sys/statvfs.h>])
|
2011-02-13 04:23:04 +01:00
|
|
|
AC_CHECK_MEMBERS([struct tm.tm_gmtoff, struct tm.__tm_gmtoff],,,[#include <time.h>])
|
2000-02-13 08:18:23 +01:00
|
|
|
|
2001-09-27 04:49:05 +02:00
|
|
|
# Checks for libcharset
|
2008-05-21 00:49:16 +02:00
|
|
|
AM_LANGINFO_CODESET
|
2001-09-27 04:49:05 +02:00
|
|
|
AC_CHECK_HEADERS([stddef.h stdlib.h string.h])
|
|
|
|
AC_CHECK_FUNCS(setlocale)
|
|
|
|
|
2000-02-13 08:18:23 +01:00
|
|
|
# check additional type sizes
|
2002-12-05 21:33:26 +01:00
|
|
|
AC_CHECK_SIZEOF(size_t)
|
2000-02-13 08:18:23 +01:00
|
|
|
|
2002-05-13 17:57:25 +02:00
|
|
|
dnl Try to figure out whether gsize, gssize should be long or int
|
|
|
|
AC_MSG_CHECKING([for the appropriate definition for size_t])
|
|
|
|
|
2002-12-05 21:33:26 +01:00
|
|
|
case $ac_cv_sizeof_size_t in
|
2002-05-13 17:57:25 +02:00
|
|
|
$ac_cv_sizeof_short)
|
|
|
|
glib_size_type=short
|
|
|
|
;;
|
|
|
|
$ac_cv_sizeof_int)
|
|
|
|
glib_size_type=int
|
|
|
|
;;
|
|
|
|
$ac_cv_sizeof_long)
|
|
|
|
glib_size_type=long
|
|
|
|
;;
|
2008-07-24 02:29:56 +02:00
|
|
|
$ac_cv_sizeof_long_long)
|
|
|
|
glib_size_type='long long'
|
|
|
|
;;
|
|
|
|
$ac_cv_sizeof__int64)
|
|
|
|
glib_size_type='__int64'
|
|
|
|
;;
|
2002-05-13 17:57:25 +02:00
|
|
|
*) 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
|
2002-12-05 21:33:26 +01:00
|
|
|
if test $ac_cv_sizeof_size_t = $ac_cv_sizeof_int &&
|
|
|
|
test $ac_cv_sizeof_size_t = $ac_cv_sizeof_long ; then
|
2011-05-02 17:44:46 +02:00
|
|
|
GLIB_CHECK_COMPILE_WARNINGS([AC_LANG_SOURCE([[
|
2005-07-08 05:28:26 +02:00
|
|
|
#if defined(_AIX) && !defined(__GNUC__)
|
2005-07-07 22:37:54 +02:00
|
|
|
#pragma options langlvl=stdc89
|
|
|
|
#endif
|
2002-05-13 17:57:25 +02:00
|
|
|
#include <stddef.h>
|
|
|
|
int main ()
|
|
|
|
{
|
|
|
|
size_t s = 1;
|
|
|
|
unsigned int *size_int = &s;
|
|
|
|
return (int)*size_int;
|
|
|
|
}
|
2011-05-02 17:44:46 +02:00
|
|
|
]])],glib_size_type=int,
|
|
|
|
[GLIB_CHECK_COMPILE_WARNINGS([AC_LANG_SOURCE([[
|
2005-07-08 05:30:24 +02:00
|
|
|
#if defined(_AIX) && !defined(__GNUC__)
|
2005-07-07 22:37:54 +02:00
|
|
|
#pragma options langlvl=stdc89
|
|
|
|
#endif
|
2002-05-13 17:57:25 +02:00
|
|
|
#include <stddef.h>
|
|
|
|
int main ()
|
|
|
|
{
|
|
|
|
size_t s = 1;
|
|
|
|
unsigned long *size_long = &s;
|
|
|
|
return (int)*size_long;
|
|
|
|
}
|
2011-05-02 17:44:46 +02:00
|
|
|
]])],glib_size_type=long)])
|
2002-05-13 17:57:25 +02:00
|
|
|
fi
|
|
|
|
|
|
|
|
AC_MSG_RESULT(unsigned $glib_size_type)
|
|
|
|
|
2000-02-13 08:18:23 +01:00
|
|
|
# Check for some functions
|
2010-05-14 00:53:42 +02:00
|
|
|
AC_CHECK_FUNCS(lstat strerror strsignal memmove vsnprintf stpcpy strcasecmp strncasecmp poll getcwd vasprintf setenv unsetenv getc_unlocked readlink symlink fdwalk memmem)
|
2011-07-18 18:58:01 +02:00
|
|
|
AC_CHECK_FUNCS(chown lchmod lchown fchmod fchown link utimes getgrgid getpwuid)
|
2008-02-10 06:22:39 +01:00
|
|
|
AC_CHECK_FUNCS(getmntent_r setmntent endmntent hasmntopt getmntinfo)
|
2006-10-01 07:53:49 +02:00
|
|
|
# Check for high-resolution sleep functions
|
2010-02-07 17:23:38 +01:00
|
|
|
AC_CHECK_FUNCS(splice)
|
2006-10-01 07:53:49 +02:00
|
|
|
|
2011-07-18 18:58:01 +02:00
|
|
|
# To avoid finding a compatibility unusable statfs, which typically
|
|
|
|
# successfully compiles, but warns to use the newer statvfs interface:
|
|
|
|
AS_IF([test $ac_cv_header_sys_statvfs_h = yes], [AC_CHECK_FUNCS([statvfs])])
|
|
|
|
AS_IF([test $ac_cv_header_sys_statfs_h = yes], [AC_CHECK_FUNCS([statfs])])
|
|
|
|
|
|
|
|
AC_MSG_CHECKING([whether to use statfs or statvfs])
|
|
|
|
# Some systems have both statfs and statvfs, pick the most "native" for these
|
|
|
|
AS_IF([test x$ac_cv_func_statfs = xyes && test x$ac_cv_func_statvfs = yes],
|
|
|
|
[
|
|
|
|
# on solaris and irix, statfs doesn't even have the f_bavail field
|
|
|
|
AS_IF([test $ac_cv_member_struct_statfs_f_bavail = yes],
|
|
|
|
[ac_cv_func_statfs=no],
|
|
|
|
# else, at least on linux, statfs is the actual syscall
|
|
|
|
[ac_cv_func_statvfs=no])
|
|
|
|
])
|
|
|
|
|
|
|
|
AS_IF([test x$ac_cv_func_statfs = xyes],
|
|
|
|
[
|
|
|
|
AC_DEFINE([USE_STATFS], [1], [Define to use statfs()])
|
|
|
|
AC_MSG_RESULT([statfs])
|
|
|
|
],
|
|
|
|
[test x$ac_cv_func_statvfs = xyes],
|
|
|
|
[
|
|
|
|
AC_DEFINE([USE_STATVFS], [1], [Define to use statvfs()])
|
|
|
|
AC_MSG_RESULT([statvfs])
|
|
|
|
],
|
|
|
|
[ AC_MSG_RESULT([neither])])
|
|
|
|
|
2005-08-17 20:31:08 +02:00
|
|
|
AC_CHECK_HEADERS(crt_externs.h)
|
2005-10-19 20:37:48 +02:00
|
|
|
AC_CHECK_FUNCS(_NSGetEnviron)
|
2005-08-17 20:31:08 +02:00
|
|
|
|
2001-12-06 23:37:05 +01:00
|
|
|
AC_FUNC_VSNPRINTF_C99
|
2002-11-21 01:35:15 +01:00
|
|
|
AC_FUNC_PRINTF_UNIX98
|
|
|
|
|
2008-12-12 19:13:55 +01:00
|
|
|
# Internet address families
|
|
|
|
if test $glib_native_win32 = yes; then
|
|
|
|
glib_inet_includes=["
|
|
|
|
#include <winsock2.h>
|
|
|
|
"]
|
|
|
|
else
|
|
|
|
glib_inet_includes=["
|
2009-04-26 19:16:34 +02:00
|
|
|
#include <sys/types.h>
|
2008-12-12 19:13:55 +01:00
|
|
|
#include <sys/socket.h>
|
|
|
|
"]
|
|
|
|
fi
|
|
|
|
|
|
|
|
glib_failed=false
|
|
|
|
GLIB_CHECK_VALUE(AF_INET, $glib_inet_includes, glib_failed=true)
|
|
|
|
GLIB_CHECK_VALUE(AF_INET6, $glib_inet_includes, glib_failed=true)
|
|
|
|
# winsock defines this even though it doesn't support it
|
|
|
|
GLIB_CHECK_VALUE(AF_UNIX, $glib_inet_includes, glib_failed=true)
|
|
|
|
if $glib_failed ; then
|
|
|
|
AC_MSG_ERROR([Could not determine values for AF_INET* constants])
|
|
|
|
fi
|
|
|
|
|
2009-05-14 15:26:37 +02:00
|
|
|
glib_failed=false
|
|
|
|
GLIB_CHECK_VALUE(MSG_PEEK, $glib_inet_includes, glib_failed=true)
|
|
|
|
GLIB_CHECK_VALUE(MSG_OOB, $glib_inet_includes, glib_failed=true)
|
|
|
|
GLIB_CHECK_VALUE(MSG_DONTROUTE, $glib_inet_includes, glib_failed=true)
|
|
|
|
if $glib_failed ; then
|
|
|
|
AC_MSG_ERROR([Could not determine values for MSG_* constants])
|
|
|
|
fi
|
|
|
|
|
2009-05-14 10:53:53 +02:00
|
|
|
AC_CHECK_FUNCS(getprotobyname_r endservent)
|
2009-12-14 02:16:55 +01:00
|
|
|
AC_CHECK_HEADERS([netdb.h wspiapi.h])
|
2009-05-14 10:53:53 +02:00
|
|
|
|
2008-12-29 18:53:47 +01:00
|
|
|
# For gio/libasyncns
|
|
|
|
if test $glib_native_win32 = no; then
|
|
|
|
AC_CHECK_FUNCS(strndup setresuid setreuid)
|
|
|
|
AC_CHECK_HEADERS(sys/prctl.h arpa/nameser_compat.h)
|
2010-01-13 17:24:28 +01:00
|
|
|
|
|
|
|
# We can't just use AC_CHECK_FUNC/AC_CHECK_LIB here. Bug 586150
|
|
|
|
AC_MSG_CHECKING([for res_query])
|
2010-01-18 15:46:19 +01:00
|
|
|
AC_TRY_LINK([#include <sys/types.h>
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#include <arpa/nameser.h>
|
|
|
|
#include <resolv.h>],
|
2010-01-13 17:24:28 +01:00
|
|
|
[res_query("test", 0, 0, (void *)0, 0);],
|
|
|
|
[AC_MSG_RESULT([yes])],
|
|
|
|
[save_libs="$LIBS"
|
|
|
|
LIBS="-lresolv $LIBS"
|
2010-01-18 15:46:19 +01:00
|
|
|
AC_TRY_LINK([#include <sys/types.h>
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#include <arpa/nameser.h>
|
|
|
|
#include <resolv.h>],
|
2010-01-13 17:24:28 +01:00
|
|
|
[res_query("test", 0, 0, (void *)0, 0);],
|
|
|
|
[AC_MSG_RESULT([in -lresolv])
|
|
|
|
LIBASYNCNS_LIBADD="-lresolv"],
|
|
|
|
[LIBS="-lbind $save_libs"
|
|
|
|
AC_TRY_LINK([#include <resolv.h>],
|
|
|
|
[res_query("test", 0, 0, (void *)0, 0);],
|
|
|
|
[AC_MSG_RESULT([in -lbind])
|
|
|
|
LIBASYNCNS_LIBADD="-lbind"],
|
|
|
|
[AC_MSG_ERROR(not found)])])
|
|
|
|
LIBS="$save_libs"])
|
2008-12-29 18:53:47 +01:00
|
|
|
AC_SUBST(LIBASYNCNS_LIBADD)
|
|
|
|
fi
|
|
|
|
|
2009-05-27 11:11:37 +02:00
|
|
|
case $host in
|
|
|
|
*-*-solaris* )
|
|
|
|
AC_DEFINE(_XOPEN_SOURCE_EXTENDED, 1, Needed to get declarations for msg_control and msg_controllen on Solaris)
|
|
|
|
AC_DEFINE(_XOPEN_SOURCE, 2, Needed to get declarations for msg_control and msg_controllen on Solaris)
|
|
|
|
AC_DEFINE(__EXTENSIONS__, 1, Needed to get declarations for msg_control and msg_controllen on Solaris)
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
|
2007-11-26 17:13:05 +01:00
|
|
|
dnl
|
|
|
|
dnl if statfs() takes 2 arguments (Posix) or 4 (Solaris)
|
|
|
|
dnl
|
|
|
|
if test "$ac_cv_func_statfs" = yes ; then
|
|
|
|
AC_MSG_CHECKING([number of arguments to statfs()])
|
|
|
|
AC_TRY_COMPILE([#include <unistd.h>
|
|
|
|
#ifdef HAVE_SYS_PARAM_H
|
|
|
|
#include <sys/param.h>
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_SYS_VFS_H
|
|
|
|
#include <sys/vfs.h>
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_SYS_MOUNT_H
|
|
|
|
#include <sys/mount.h>
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_SYS_STATFS_H
|
|
|
|
#include <sys/statfs.h>
|
|
|
|
#endif], [struct statfs st;
|
|
|
|
statfs(NULL, &st);],[
|
|
|
|
AC_MSG_RESULT([2])
|
|
|
|
AC_DEFINE(STATFS_ARGS, 2, [Number of arguments to statfs()])],[
|
|
|
|
AC_TRY_COMPILE([#include <unistd.h>
|
|
|
|
#ifdef HAVE_SYS_PARAM_H
|
|
|
|
#include <sys/param.h>
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_SYS_VFS_H
|
|
|
|
#include <sys/vfs.h>
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_SYS_MOUNT_H
|
|
|
|
#include <sys/mount.h>
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_SYS_STATFS_H
|
|
|
|
#include <sys/statfs.h>
|
|
|
|
#endif], [struct statfs st;
|
|
|
|
statfs(NULL, &st, sizeof (st), 0);],[
|
|
|
|
AC_MSG_RESULT([4])
|
|
|
|
AC_DEFINE(STATFS_ARGS, 4, [Number of arguments to statfs()])],[
|
|
|
|
AC_MSG_RESULT(unknown)
|
|
|
|
AC_MSG_ERROR([unable to determine number of arguments to statfs()])])])
|
|
|
|
fi
|
|
|
|
|
2002-11-21 01:35:15 +01:00
|
|
|
#
|
2003-07-29 01:00:05 +02:00
|
|
|
# Check whether to use an included printf
|
2002-11-21 01:35:15 +01:00
|
|
|
#
|
|
|
|
|
2003-03-04 11:10:48 +01:00
|
|
|
AC_ARG_ENABLE(included-printf,
|
|
|
|
[AC_HELP_STRING([--enable-included-printf],
|
|
|
|
[use included printf [default=auto]])],
|
2003-07-29 01:00:05 +02:00
|
|
|
enable_included_printf="$enableval")
|
2002-11-21 01:35:15 +01:00
|
|
|
|
2003-07-29 01:00:05 +02:00
|
|
|
need_included_printf=no
|
|
|
|
if test "x$enable_included_printf" = "xyes" ; then
|
|
|
|
need_included_printf=yes
|
2002-12-13 02:49:42 +01:00
|
|
|
fi
|
|
|
|
if test "$ac_cv_func_vsnprintf_c99" != "yes" ; then
|
2003-07-29 01:00:05 +02:00
|
|
|
need_included_printf=yes
|
2002-12-13 02:49:42 +01:00
|
|
|
fi
|
|
|
|
if test "$ac_cv_func_printf_unix98" != "yes" ; then
|
2003-07-29 01:00:05 +02:00
|
|
|
need_included_printf=yes
|
2002-11-21 01:35:15 +01:00
|
|
|
fi
|
2002-12-13 02:49:42 +01:00
|
|
|
if test "x$ac_cv_sizeof_long_long" = "x8" &&
|
|
|
|
test -z "$glib_cv_long_long_format" ; then
|
2003-07-29 01:00:05 +02:00
|
|
|
need_included_printf=yes
|
2002-12-13 02:49:42 +01:00
|
|
|
fi
|
|
|
|
|
2003-07-29 01:00:05 +02:00
|
|
|
if test "x$enable_included_printf" = "xno" &&
|
|
|
|
test "x$need_included_printf" = "xyes" ; then
|
2002-12-13 02:49:42 +01:00
|
|
|
AC_MSG_ERROR([
|
2002-12-13 03:09:48 +01:00
|
|
|
*** Your C library's printf doesn't appear to have the features that
|
2002-12-15 01:42:37 +01:00
|
|
|
*** GLib needs, but you specified --enable-included-printf=no.])
|
2002-12-13 02:49:42 +01:00
|
|
|
fi
|
|
|
|
|
2003-07-29 01:00:05 +02:00
|
|
|
enable_included_printf=$need_included_printf
|
2002-11-21 01:35:15 +01:00
|
|
|
|
2003-07-29 01:00:05 +02:00
|
|
|
AM_CONDITIONAL(HAVE_GOOD_PRINTF, test "$enable_included_printf" != "yes")
|
|
|
|
if test "$enable_included_printf" != "yes" ; then
|
2002-11-21 01:35:15 +01:00
|
|
|
AC_DEFINE(HAVE_GOOD_PRINTF,1,[define to use system printf])
|
2002-11-28 19:50:41 +01:00
|
|
|
else
|
2003-11-15 00:48:03 +01:00
|
|
|
if test -z "$glib_cv_long_long_format" ; then
|
|
|
|
glib_cv_long_long_format="ll"
|
|
|
|
fi
|
2002-11-21 01:35:15 +01:00
|
|
|
AC_DEFINE(HAVE_VASPRINTF,1)
|
|
|
|
fi
|
2003-07-29 01:00:05 +02:00
|
|
|
|
|
|
|
# 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
|
2006-12-18 15:38:07 +01:00
|
|
|
AC_CHECK_FUNCS([snprintf wcslen])
|
2003-07-29 01:00:05 +02:00
|
|
|
AC_FUNC_SNPRINTF_C99
|
2001-12-06 23:37:05 +01:00
|
|
|
|
2000-02-13 08:18:23 +01:00
|
|
|
# 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)])
|
2002-12-11 23:21:32 +01:00
|
|
|
|
|
|
|
GLIB_ASSERT_SET(glib_cv_working_bcopy)
|
2000-10-23 16:15:22 +02:00
|
|
|
if test "$glib_cv_working_bcopy" = "yes"; then
|
2000-10-16 03:02:19 +02:00
|
|
|
AC_DEFINE(HAVE_WORKING_BCOPY,1,[Have a working bcopy])
|
2000-02-13 08:18:23 +01:00
|
|
|
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)
|
2001-09-28 23:03:02 +02:00
|
|
|
if test "$glib_ok" = "no"; then
|
2000-10-16 03:02:19 +02:00
|
|
|
AC_DEFINE(NO_SYS_ERRLIST,1,[global 'sys_errlist' not found])
|
2000-02-13 08:18:23 +01:00
|
|
|
fi
|
|
|
|
|
|
|
|
# Check for sys_siglist
|
|
|
|
AC_MSG_CHECKING(for sys_siglist)
|
|
|
|
AC_TRY_LINK(, [
|
|
|
|
extern char *sys_siglist[];
|
2000-07-19 16:01:22 +02:00
|
|
|
exit (sys_siglist[0]);
|
2000-02-13 08:18:23 +01:00
|
|
|
], glib_ok=yes, glib_ok=no)
|
|
|
|
AC_MSG_RESULT($glib_ok)
|
2001-09-28 23:03:02 +02:00
|
|
|
if test "$glib_ok" = "no"; then
|
2000-10-16 03:02:19 +02:00
|
|
|
AC_DEFINE(NO_SYS_SIGLIST,1,[global 'sys_siglist' not found])
|
2000-02-13 08:18:23 +01:00
|
|
|
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)
|
2001-09-28 23:03:02 +02:00
|
|
|
if test "$glib_ok" = "no"; then
|
2000-10-16 03:02:19 +02:00
|
|
|
AC_DEFINE(NO_SYS_SIGLIST_DECL,1,[global 'sys_siglist' not declared])
|
2000-02-13 08:18:23 +01:00
|
|
|
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)
|
2001-09-28 23:03:02 +02:00
|
|
|
if test "$gtk_ok" = "yes"; then
|
2000-02-13 08:18:23 +01:00
|
|
|
AC_MSG_RESULT([yes, found in sys/types.h])
|
|
|
|
else
|
2000-12-08 23:48:45 +01:00
|
|
|
AC_EGREP_HEADER(fd_set, sys/select.h, gtk_ok=yes)
|
2001-09-28 23:03:02 +02:00
|
|
|
if test "$gtk_ok" = "yes"; then
|
2000-10-16 03:02:19 +02:00
|
|
|
# *** FIXME: give it a different name
|
|
|
|
AC_DEFINE(HAVE_SYS_SELECT_H,1,[found fd_set in sys/select.h])
|
2000-02-13 08:18:23 +01:00
|
|
|
AC_MSG_RESULT([yes, found in sys/select.h])
|
|
|
|
else
|
2000-10-16 03:02:19 +02:00
|
|
|
AC_DEFINE(NO_FD_SET,1,[didn't find fd_set])
|
2000-02-13 08:18:23 +01:00
|
|
|
AC_MSG_RESULT(no)
|
|
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
dnl *** check for sane realloc() ***
|
2000-10-16 03:02:19 +02:00
|
|
|
AC_CACHE_CHECK([whether realloc (NULL,) will work],glib_cv_sane_realloc,[
|
2002-12-05 21:49:26 +01:00
|
|
|
AC_TRY_RUN([#include <stdlib.h>
|
2000-02-13 08:18:23 +01:00
|
|
|
int main() {
|
|
|
|
return realloc (0, sizeof (int)) == 0;
|
|
|
|
}],
|
2000-10-16 03:02:19 +02:00
|
|
|
[glib_cv_sane_realloc=yes],
|
|
|
|
[glib_cv_sane_realloc=no],
|
2002-12-06 18:29:52 +01:00
|
|
|
[glib_cv_sane_realloc=yes])
|
2000-02-13 08:18:23 +01:00
|
|
|
])
|
2000-10-09 23:06:01 +02:00
|
|
|
if test x$glib_cv_sane_realloc = xyes; then
|
2000-10-16 03:02:19 +02:00
|
|
|
AC_DEFINE(REALLOC_0_WORKS,1,[whether realloc (NULL,) works])
|
2000-10-09 23:06:01 +02:00
|
|
|
fi
|
2000-02-13 08:18:23 +01:00
|
|
|
|
2000-05-29 20:48:29 +02:00
|
|
|
dnl Check for nl_langinfo and CODESET
|
2006-12-28 05:41:23 +01:00
|
|
|
AC_CACHE_CHECK([for nl_langinfo (CODESET)],glib_cv_langinfo_codeset,[
|
|
|
|
AC_TRY_COMPILE([#include <langinfo.h>],
|
|
|
|
[char *codeset = nl_langinfo (CODESET);],
|
|
|
|
[glib_cv_langinfo_codeset=yes],
|
|
|
|
[glib_cv_langinfo_codeset=no])])
|
|
|
|
if test x$glib_cv_langinfo_codeset = xyes; then
|
|
|
|
AC_DEFINE(HAVE_CODESET,1,[Have nl_langinfo (CODESET)])
|
|
|
|
fi
|
added g_strlcat() and g_strlcpy() wrappers, supplied by David Wheeler
Wed Jul 26 05:47:48 2000 Tim Janik <timj@gtk.org>
* configure.in:
* testglib.c:
* gstrfuncs.c:
* glib.h: added g_strlcat() and g_strlcpy() wrappers, supplied by
David Wheeler <dwheeler@ida.org>:
* glib.h, gstrfuncs.c: added g_strlcpy and g_strlcat to support
safe manipulation of fixed-length string buffers.
These functions were originally developed by Todd Miller to simplify
development of security-related programs, and
are available on many (but not all) Unix-like systems,
including OpenBSD, FreeBSD, and Solaris. See
ftp://ftp.openbsd.org/pub/OpenBSD/src/lib/libc/string/strlcpy.3
and http://www.openbsd.org/security.html.
If there's a strlcpy/strlcat on the system, it's called, otherwise
an implementation is provided.
* testglib.c: Added tests for g_strlcpy, g_strlcat.
2000-07-26 05:51:07 +02:00
|
|
|
|
2006-01-24 17:56:17 +01:00
|
|
|
dnl ****************************************
|
|
|
|
dnl *** posix_memalign ***
|
|
|
|
dnl ****************************************
|
|
|
|
AC_MSG_CHECKING(for a compliant posix_memalign() implementation)
|
|
|
|
AC_CACHE_VAL(glib_cv_compliant_posix_memalign,[
|
|
|
|
glib_cv_compliant_posix_memalign=0
|
|
|
|
if test "$ac_cv_func_posix_memalign" = "yes" ; then
|
|
|
|
AC_TRY_RUN([
|
|
|
|
#define _XOPEN_SOURCE 600
|
2006-02-14 17:31:37 +01:00
|
|
|
#include <stdlib.h> /* posix_memalign() should be defined here */
|
|
|
|
/* some systems break if #include <malloc.h> used */
|
2006-01-24 17:56:17 +01:00
|
|
|
static void test_memalign (size_t boundary, size_t size) {
|
|
|
|
void *mem = 0;
|
|
|
|
if (posix_memalign (&mem, boundary, size) != 0 || !mem)
|
|
|
|
exit (1);
|
2006-01-25 19:20:28 +01:00
|
|
|
else
|
|
|
|
free (mem);
|
2006-01-24 17:56:17 +01:00
|
|
|
}
|
|
|
|
int main() {
|
|
|
|
test_memalign ( 128, 128 - 2 * sizeof (void*));
|
|
|
|
test_memalign ( 256, 256 - 2 * sizeof (void*));
|
|
|
|
test_memalign ( 512, 512 - 2 * sizeof (void*));
|
|
|
|
test_memalign ( 1024, 1024 - 2 * sizeof (void*));
|
|
|
|
test_memalign ( 2048, 2048 - 2 * sizeof (void*));
|
|
|
|
test_memalign ( 4096, 4096 - 2 * sizeof (void*));
|
|
|
|
test_memalign ( 8192, 8192 - 2 * sizeof (void*));
|
|
|
|
test_memalign (16384, 16384 - 2 * sizeof (void*));
|
|
|
|
test_memalign (32768, 32768 - 2 * sizeof (void*));
|
|
|
|
exit (0); /* success */
|
|
|
|
}
|
|
|
|
],
|
|
|
|
[glib_cv_compliant_posix_memalign=1], [], [:])
|
|
|
|
:
|
|
|
|
fi
|
|
|
|
])
|
|
|
|
if test "$glib_cv_compliant_posix_memalign" = "1"; then
|
|
|
|
AC_MSG_RESULT(yes)
|
|
|
|
AC_DEFINE(POSIX_MEMALIGN_WITH_COMPLIANT_ALLOCS, 1, [define if posix_memalign() can allocate any size])
|
|
|
|
else
|
|
|
|
AC_MSG_RESULT(no)
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
added g_strlcat() and g_strlcpy() wrappers, supplied by David Wheeler
Wed Jul 26 05:47:48 2000 Tim Janik <timj@gtk.org>
* configure.in:
* testglib.c:
* gstrfuncs.c:
* glib.h: added g_strlcat() and g_strlcpy() wrappers, supplied by
David Wheeler <dwheeler@ida.org>:
* glib.h, gstrfuncs.c: added g_strlcpy and g_strlcat to support
safe manipulation of fixed-length string buffers.
These functions were originally developed by Todd Miller to simplify
development of security-related programs, and
are available on many (but not all) Unix-like systems,
including OpenBSD, FreeBSD, and Solaris. See
ftp://ftp.openbsd.org/pub/OpenBSD/src/lib/libc/string/strlcpy.3
and http://www.openbsd.org/security.html.
If there's a strlcpy/strlcat on the system, it's called, otherwise
an implementation is provided.
* testglib.c: Added tests for g_strlcpy, g_strlcat.
2000-07-26 05:51:07 +02:00
|
|
|
dnl ****************************************
|
|
|
|
dnl *** strlcpy/strlcat ***
|
|
|
|
dnl ****************************************
|
|
|
|
# Check for strlcpy
|
2002-12-03 23:22:22 +01:00
|
|
|
AC_CACHE_CHECK([for OpenBSD strlcpy/strlcat],glib_cv_have_strlcpy,[
|
|
|
|
AC_TRY_RUN([#include <stdlib.h>
|
2002-11-28 01:02:17 +01:00
|
|
|
#include <string.h>
|
|
|
|
int main() {
|
2002-12-03 23:22:22 +01:00
|
|
|
char p[10];
|
2002-11-28 01:02:17 +01:00
|
|
|
(void) strlcpy (p, "hi", 10);
|
|
|
|
if (strlcat (p, "bye", 0) != 3)
|
2002-12-03 23:22:22 +01:00
|
|
|
return 1;
|
2002-11-28 01:02:17 +01:00
|
|
|
return 0;
|
2002-12-03 23:22:22 +01:00
|
|
|
}], glib_cv_have_strlcpy=yes,
|
|
|
|
glib_cv_have_strlcpy=no,
|
|
|
|
glib_cv_have_strlcpy=no)])
|
|
|
|
if test "$glib_cv_have_strlcpy" = "yes"; then
|
2000-10-16 03:02:19 +02:00
|
|
|
AC_DEFINE(HAVE_STRLCPY,1,[Have functions strlcpy and strlcat])
|
added g_strlcat() and g_strlcpy() wrappers, supplied by David Wheeler
Wed Jul 26 05:47:48 2000 Tim Janik <timj@gtk.org>
* configure.in:
* testglib.c:
* gstrfuncs.c:
* glib.h: added g_strlcat() and g_strlcpy() wrappers, supplied by
David Wheeler <dwheeler@ida.org>:
* glib.h, gstrfuncs.c: added g_strlcpy and g_strlcat to support
safe manipulation of fixed-length string buffers.
These functions were originally developed by Todd Miller to simplify
development of security-related programs, and
are available on many (but not all) Unix-like systems,
including OpenBSD, FreeBSD, and Solaris. See
ftp://ftp.openbsd.org/pub/OpenBSD/src/lib/libc/string/strlcpy.3
and http://www.openbsd.org/security.html.
If there's a strlcpy/strlcat on the system, it's called, otherwise
an implementation is provided.
* testglib.c: Added tests for g_strlcpy, g_strlcat.
2000-07-26 05:51:07 +02:00
|
|
|
fi
|
2000-05-29 20:48:29 +02:00
|
|
|
|
2000-02-13 08:18:23 +01:00
|
|
|
|
|
|
|
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.
|
2000-10-16 03:02:19 +02:00
|
|
|
AC_CACHE_CHECK([for an implementation of va_copy()],glib_cv_va_copy,[
|
2011-05-02 17:44:46 +02:00
|
|
|
AC_LINK_IFELSE([AC_LANG_SOURCE([[#include <stdarg.h>
|
2006-09-01 01:16:57 +02:00
|
|
|
#include <stdlib.h>
|
2000-02-13 08:18:23 +01:00
|
|
|
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;
|
2011-05-02 17:44:46 +02:00
|
|
|
}]])],
|
2000-10-16 03:02:19 +02:00
|
|
|
[glib_cv_va_copy=yes],
|
2002-12-06 18:29:52 +01:00
|
|
|
[glib_cv_va_copy=no])
|
2000-02-13 08:18:23 +01:00
|
|
|
])
|
2000-10-16 03:02:19 +02:00
|
|
|
AC_CACHE_CHECK([for an implementation of __va_copy()],glib_cv___va_copy,[
|
2011-05-02 17:44:46 +02:00
|
|
|
AC_LINK_IFELSE([AC_LANG_SOURCE([[#include <stdarg.h>
|
2006-09-01 01:16:57 +02:00
|
|
|
#include <stdlib.h>
|
2000-02-13 08:18:23 +01:00
|
|
|
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;
|
2011-05-02 17:44:46 +02:00
|
|
|
}]])],
|
2000-10-16 03:02:19 +02:00
|
|
|
[glib_cv___va_copy=yes],
|
2002-12-06 18:29:52 +01:00
|
|
|
[glib_cv___va_copy=no])
|
2000-02-13 08:18:23 +01:00
|
|
|
])
|
2000-10-16 03:02:19 +02:00
|
|
|
|
|
|
|
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,[
|
2002-12-05 21:49:26 +01:00
|
|
|
AC_TRY_RUN([#include <stdarg.h>
|
2006-09-01 01:16:57 +02:00
|
|
|
#include <stdlib.h>
|
2000-02-13 08:18:23 +01:00
|
|
|
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;
|
|
|
|
}],
|
2000-10-16 03:02:19 +02:00
|
|
|
[glib_cv_va_val_copy=yes],
|
|
|
|
[glib_cv_va_val_copy=no],
|
2002-12-06 18:29:52 +01:00
|
|
|
[glib_cv_va_val_copy=yes])
|
2000-02-13 08:18:23 +01:00
|
|
|
])
|
2000-10-16 03:02:19 +02:00
|
|
|
|
2000-02-13 08:18:23 +01:00
|
|
|
if test "x$glib_cv_va_val_copy" = "xno"; then
|
2000-10-16 03:02:19 +02:00
|
|
|
AC_DEFINE(G_VA_COPY_AS_ARRAY,1, ['va_lists' cannot be copies as values])
|
2000-02-13 08:18:23 +01:00
|
|
|
fi
|
|
|
|
|
|
|
|
dnl ***********************
|
|
|
|
dnl *** g_module checks ***
|
|
|
|
dnl ***********************
|
|
|
|
G_MODULE_LIBS=
|
|
|
|
G_MODULE_LIBS_EXTRA=
|
|
|
|
G_MODULE_PLUGIN_LIBS=
|
2002-10-27 00:53:21 +02:00
|
|
|
if test x"$glib_native_win32" = xyes; then
|
|
|
|
dnl No use for this on Win32
|
|
|
|
G_MODULE_LDFLAGS=
|
|
|
|
else
|
2007-01-02 14:58:54 +01:00
|
|
|
export SED
|
2002-10-27 00:53:21 +02:00
|
|
|
G_MODULE_LDFLAGS=`(./libtool --config; echo eval echo \\$export_dynamic_flag_spec) | sh`
|
|
|
|
fi
|
2000-02-13 08:18:23 +01:00
|
|
|
dnl G_MODULE_IMPL= don't reset, so cmd-line can override
|
|
|
|
G_MODULE_NEED_USCORE=0
|
2001-02-17 07:32:30 +01:00
|
|
|
G_MODULE_BROKEN_RTLD_GLOBAL=0
|
2000-02-13 08:18:23 +01:00
|
|
|
G_MODULE_HAVE_DLERROR=0
|
2001-03-09 22:18:33 +01:00
|
|
|
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
|
2004-02-22 02:31:24 +01:00
|
|
|
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
|
2000-02-13 08:18:23 +01:00
|
|
|
dnl *** dlopen() and dlsym() in system libraries
|
|
|
|
if test -z "$G_MODULE_IMPL"; then
|
|
|
|
AC_CHECK_FUNC(dlopen,
|
2000-10-09 23:06:01 +02:00
|
|
|
[AC_CHECK_FUNC(dlsym,
|
|
|
|
[G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
|
|
|
|
[])
|
2000-02-13 08:18:23 +01:00
|
|
|
fi
|
|
|
|
dnl *** load_image (BeOS)
|
2001-10-05 03:36:56 +02:00
|
|
|
if test -z "$G_MODULE_IMPL" && test "x$glib_native_beos" = "xyes"; then
|
2000-02-13 08:18:23 +01:00
|
|
|
AC_CHECK_LIB(root, load_image,
|
2005-06-30 21:43:48 +02:00
|
|
|
[G_MODULE_LIBS="-lbe -lroot -lglib-2.0 "
|
2000-02-13 08:18:23 +01:00
|
|
|
G_MODULE_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
|
|
|
|
G_MODULE_PLUGIN_LIBS="-L\$(top_builddir_full)/gmodule/.libs -lgmodule"
|
2000-10-16 03:02:19 +02:00
|
|
|
G_MODULE_IMPL=G_MODULE_IMPL_BEOS],
|
|
|
|
[])
|
2000-02-13 08:18:23 +01:00
|
|
|
fi
|
2002-05-06 18:07:03 +02:00
|
|
|
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
|
2001-04-20 19:08:57 +02:00
|
|
|
dnl *** dlopen() and dlsym() in libdl
|
2000-02-13 08:18:23 +01:00
|
|
|
if test -z "$G_MODULE_IMPL"; then
|
|
|
|
AC_CHECK_LIB(dl, dlopen,
|
2000-10-09 23:06:01 +02:00
|
|
|
[AC_CHECK_LIB(dl, dlsym,
|
|
|
|
[G_MODULE_LIBS=-ldl
|
|
|
|
G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
|
|
|
|
[])
|
2000-02-13 08:18:23 +01:00
|
|
|
fi
|
|
|
|
dnl *** shl_load() in libdld (HP-UX)
|
|
|
|
if test -z "$G_MODULE_IMPL"; then
|
|
|
|
AC_CHECK_LIB(dld, shl_load,
|
2000-10-16 03:02:19 +02:00
|
|
|
[G_MODULE_LIBS=-ldld
|
|
|
|
G_MODULE_IMPL=G_MODULE_IMPL_DLD],
|
|
|
|
[])
|
2000-02-13 08:18:23 +01:00
|
|
|
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"
|
2002-12-13 05:11:32 +01:00
|
|
|
LIBS="$G_MODULE_LIBS $LIBS"
|
2000-02-13 08:18:23 +01:00
|
|
|
LDFLAGS="$LDFLAGS $G_MODULE_LDFLAGS"
|
2001-02-17 07:28:07 +01:00
|
|
|
dnl *** check for OSF1/5.0 RTLD_GLOBAL brokenness
|
2004-07-04 07:59:37 +02:00
|
|
|
echo "void glib_plugin_test(void) { }" > plugin.c
|
|
|
|
${SHELL} ./libtool --mode=compile ${CC} -shared \
|
|
|
|
-export-dynamic -o plugin.o plugin.c 2>&1 >/dev/null
|
2001-02-17 07:28:07 +01:00
|
|
|
AC_CACHE_CHECK([for RTLD_GLOBAL brokenness],
|
|
|
|
glib_cv_rtldglobal_broken,[
|
|
|
|
AC_TRY_RUN([
|
2002-12-05 21:49:26 +01:00
|
|
|
#include <dlfcn.h>
|
|
|
|
#ifndef RTLD_GLOBAL
|
|
|
|
# define RTLD_GLOBAL 0
|
|
|
|
#endif
|
|
|
|
#ifndef RTLD_LAZY
|
|
|
|
# define RTLD_LAZY 0
|
|
|
|
#endif
|
2004-07-04 07:59:37 +02:00
|
|
|
int glib_plugin_test;
|
2002-12-05 21:49:26 +01:00
|
|
|
int main () {
|
|
|
|
void *handle, *global, *local;
|
2004-07-04 07:59:37 +02:00
|
|
|
global = &glib_plugin_test;
|
|
|
|
handle = dlopen ("./.libs/plugin.o", RTLD_GLOBAL | RTLD_LAZY);
|
2002-12-05 21:49:26 +01:00
|
|
|
if (!handle) return 0;
|
2004-07-04 07:59:37 +02:00
|
|
|
local = dlsym (handle, "glib_plugin_test");
|
2002-12-05 21:49:26 +01:00
|
|
|
return global == local;
|
|
|
|
} ],
|
2001-02-17 07:28:07 +01:00
|
|
|
[glib_cv_rtldglobal_broken=no],
|
|
|
|
[glib_cv_rtldglobal_broken=yes],
|
2002-12-06 18:29:52 +01:00
|
|
|
[glib_cv_rtldglobal_broken=no])
|
2004-07-04 07:59:37 +02:00
|
|
|
rm -f plugin.c plugin.o plugin.lo .libs/plugin.o
|
|
|
|
rmdir .libs 2>/dev/null
|
2001-02-17 07:28:07 +01:00
|
|
|
])
|
|
|
|
if test "x$glib_cv_rtldglobal_broken" = "xyes"; then
|
|
|
|
G_MODULE_BROKEN_RTLD_GLOBAL=1
|
|
|
|
else
|
|
|
|
G_MODULE_BROKEN_RTLD_GLOBAL=0
|
|
|
|
fi
|
2000-02-13 08:18:23 +01:00
|
|
|
dnl *** check whether we need preceeding underscores
|
2000-10-16 03:02:19 +02:00
|
|
|
AC_CACHE_CHECK([for preceeding underscore in symbols],
|
|
|
|
glib_cv_uscore,[
|
2002-12-05 21:49:26 +01:00
|
|
|
AC_TRY_RUN([#include <dlfcn.h>
|
2000-02-13 08:18:23 +01:00
|
|
|
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);
|
|
|
|
}],
|
2000-10-16 03:02:19 +02:00
|
|
|
[glib_cv_uscore=yes],
|
|
|
|
[glib_cv_uscore=no],
|
|
|
|
[])
|
2001-03-09 22:18:33 +01:00
|
|
|
rm -f plugin.c plugin.$ac_objext plugin.lo
|
2000-02-13 08:18:23 +01:00
|
|
|
])
|
2002-12-11 23:21:32 +01:00
|
|
|
GLIB_ASSERT_SET(glib_cv_uscore)
|
2000-02-13 08:18:23 +01:00
|
|
|
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,
|
2000-10-16 03:02:19 +02:00
|
|
|
[G_MODULE_HAVE_DLERROR=1],
|
|
|
|
[G_MODULE_HAVE_DLERROR=0])
|
2000-02-13 08:18:23 +01:00
|
|
|
LIBS="$LIBS_orig"
|
|
|
|
fi
|
2001-02-17 07:28:07 +01:00
|
|
|
dnl *** done, have we got an implementation?
|
2000-02-13 08:18:23 +01:00
|
|
|
if test -z "$G_MODULE_IMPL"; then
|
|
|
|
G_MODULE_IMPL=0
|
2001-06-07 18:39:54 +02:00
|
|
|
G_MODULE_SUPPORTED=false
|
|
|
|
else
|
|
|
|
G_MODULE_SUPPORTED=true
|
2000-02-13 08:18:23 +01:00
|
|
|
fi
|
Determine the suffix of the shared librarries for this system. This is
2000-12-22 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in: Determine the suffix of the shared librarries for
this system. This is done analogous to
ltconfig.sh. G_MODULE_SUFFIX in glibconfig.h is set to either
"sl", "dll", or (most often) "so".
* tests/Makefile.am, tests/module-test.c,
tests/libmoduletestplugin_a.c, tests/libmoduletestplugin_b.c:
Added new testcase for gmodule. This is mostly copied from
gmodule/testgmodule.c, but unlike that is is quiet. (Why BTW are
some tests that verbose, not to say loquacious...)
* gmodule.c: Make g_module_open more tolerant wrt to the module
name. First it tries to open the module as named, if that fails,
it checks, whether it is a libtool archive and parses it, if that
fails it appends the systems shared library suffix
(i.e. ".so") (if not already found) and tries again and if that
fails it tries to append the ".la" libtool suffix (if not already
found) and parses it.
* gmodule.c: Lock recursive mutex during most module functions for
safety.
* gmodule-dl.c: Return an error from _g_module_symbol only, if
dlerror says so. All other functions return an error as well, if
dlerror returns NULL.
* testgmodule.c: Thanks to the above change the #ifdefs have
vanished.
* glib/glib-sections.txt: Added G_MODULE_SUFFIX.
* glib/tmpl/modules.sgml: Updated.
2000-12-22 14:44:25 +01:00
|
|
|
|
2008-09-15 20:59:25 +02:00
|
|
|
AC_MSG_CHECKING(for the suffix of module shared libraries)
|
2007-01-03 19:32:04 +01:00
|
|
|
export SED
|
2006-12-26 21:18:58 +01:00
|
|
|
shrext_cmds=`./libtool --config | grep '^shrext_cmds='`
|
|
|
|
eval $shrext_cmds
|
|
|
|
module=yes eval std_shrext=$shrext_cmds
|
|
|
|
# chop the initial dot
|
|
|
|
glib_gmodule_suffix=`echo $std_shrext | sed 's/^\.//'`
|
Determine the suffix of the shared librarries for this system. This is
2000-12-22 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in: Determine the suffix of the shared librarries for
this system. This is done analogous to
ltconfig.sh. G_MODULE_SUFFIX in glibconfig.h is set to either
"sl", "dll", or (most often) "so".
* tests/Makefile.am, tests/module-test.c,
tests/libmoduletestplugin_a.c, tests/libmoduletestplugin_b.c:
Added new testcase for gmodule. This is mostly copied from
gmodule/testgmodule.c, but unlike that is is quiet. (Why BTW are
some tests that verbose, not to say loquacious...)
* gmodule.c: Make g_module_open more tolerant wrt to the module
name. First it tries to open the module as named, if that fails,
it checks, whether it is a libtool archive and parses it, if that
fails it appends the systems shared library suffix
(i.e. ".so") (if not already found) and tries again and if that
fails it tries to append the ".la" libtool suffix (if not already
found) and parses it.
* gmodule.c: Lock recursive mutex during most module functions for
safety.
* gmodule-dl.c: Return an error from _g_module_symbol only, if
dlerror says so. All other functions return an error as well, if
dlerror returns NULL.
* testgmodule.c: Thanks to the above change the #ifdefs have
vanished.
* glib/glib-sections.txt: Added G_MODULE_SUFFIX.
* glib/tmpl/modules.sgml: Updated.
2000-12-22 14:44:25 +01:00
|
|
|
AC_MSG_RESULT(.$glib_gmodule_suffix)
|
2006-12-26 21:18:58 +01:00
|
|
|
# any reason it may fail?
|
|
|
|
if test "x$glib_gmodule_suffix" = x; then
|
|
|
|
AC_MSG_ERROR(Cannot determine shared library suffix from libtool)
|
|
|
|
fi
|
Determine the suffix of the shared librarries for this system. This is
2000-12-22 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in: Determine the suffix of the shared librarries for
this system. This is done analogous to
ltconfig.sh. G_MODULE_SUFFIX in glibconfig.h is set to either
"sl", "dll", or (most often) "so".
* tests/Makefile.am, tests/module-test.c,
tests/libmoduletestplugin_a.c, tests/libmoduletestplugin_b.c:
Added new testcase for gmodule. This is mostly copied from
gmodule/testgmodule.c, but unlike that is is quiet. (Why BTW are
some tests that verbose, not to say loquacious...)
* gmodule.c: Make g_module_open more tolerant wrt to the module
name. First it tries to open the module as named, if that fails,
it checks, whether it is a libtool archive and parses it, if that
fails it appends the systems shared library suffix
(i.e. ".so") (if not already found) and tries again and if that
fails it tries to append the ".la" libtool suffix (if not already
found) and parses it.
* gmodule.c: Lock recursive mutex during most module functions for
safety.
* gmodule-dl.c: Return an error from _g_module_symbol only, if
dlerror says so. All other functions return an error as well, if
dlerror returns NULL.
* testgmodule.c: Thanks to the above change the #ifdefs have
vanished.
* glib/glib-sections.txt: Added G_MODULE_SUFFIX.
* glib/tmpl/modules.sgml: Updated.
2000-12-22 14:44:25 +01:00
|
|
|
|
2001-06-07 18:39:54 +02:00
|
|
|
AC_SUBST(G_MODULE_SUPPORTED)
|
2000-02-13 08:18:23 +01:00
|
|
|
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)
|
2001-02-17 07:28:07 +01:00
|
|
|
AC_SUBST(G_MODULE_BROKEN_RTLD_GLOBAL)
|
2000-02-13 08:18:23 +01:00
|
|
|
AC_SUBST(G_MODULE_NEED_USCORE)
|
|
|
|
AC_SUBST(GLIB_DEBUG_FLAGS)
|
|
|
|
|
2001-03-09 22:18:33 +01:00
|
|
|
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)
|
|
|
|
|
2007-11-27 13:39:14 +01:00
|
|
|
dnl *********************************
|
|
|
|
dnl *** Directory for GIO modules ***
|
|
|
|
dnl *********************************
|
|
|
|
|
|
|
|
AC_ARG_WITH(gio-module-dir,
|
|
|
|
[AC_HELP_STRING([--with-gio-module-dir=PATH],
|
|
|
|
[Load gio modules from this directory [LIBDIR/gio/modules]])],
|
|
|
|
[],
|
|
|
|
[with_gio_module_dir='${libdir}/gio/modules'])
|
|
|
|
GIO_MODULE_DIR=$with_gio_module_dir
|
|
|
|
AC_SUBST(GIO_MODULE_DIR)
|
2007-11-26 17:13:05 +01:00
|
|
|
|
|
|
|
dnl **********************************
|
|
|
|
dnl *** Check for libselinux (GIO) ***
|
|
|
|
dnl **********************************
|
|
|
|
AC_ARG_ENABLE(selinux, [ --disable-selinux build without selinux support])
|
|
|
|
msg_selinux=no
|
|
|
|
SELINUX_LIBS=
|
|
|
|
if test "x$enable_selinux" != "xno"; then
|
|
|
|
|
|
|
|
AC_CHECK_LIB(selinux, is_selinux_enabled,
|
|
|
|
[AC_CHECK_HEADERS(selinux/selinux.h,
|
2008-08-28 21:45:58 +02:00
|
|
|
[AC_CHECK_LIB(selinux, lgetfilecon_raw,
|
2007-11-26 17:13:05 +01:00
|
|
|
[AC_DEFINE(HAVE_SELINUX, 1, [Define to 1 if libselinux is available])
|
|
|
|
SELINUX_LIBS="-lselinux"
|
|
|
|
msg_selinux=yes])
|
|
|
|
])
|
|
|
|
])
|
|
|
|
fi
|
|
|
|
AC_SUBST(SELINUX_LIBS)
|
|
|
|
|
|
|
|
dnl *****************************
|
|
|
|
dnl ** Check for inotify (GIO) **
|
|
|
|
dnl *****************************
|
|
|
|
inotify_support=no
|
|
|
|
AC_CHECK_HEADERS([sys/inotify.h],
|
|
|
|
[
|
|
|
|
inotify_support=yes
|
2009-06-15 04:26:52 +02:00
|
|
|
AC_CHECK_FUNCS(inotify_init1)
|
2007-11-26 17:13:05 +01:00
|
|
|
])
|
|
|
|
|
|
|
|
AM_CONDITIONAL(HAVE_INOTIFY, [test "$inotify_support" = "yes"])
|
|
|
|
|
2008-03-14 09:58:24 +01:00
|
|
|
dnl *********************************
|
|
|
|
dnl ** Check for Solaris FEN (GIO) **
|
|
|
|
dnl *********************************
|
|
|
|
fen_support=no
|
2011-05-02 17:44:46 +02:00
|
|
|
AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
|
2008-03-14 09:58:24 +01:00
|
|
|
#include <port.h>
|
|
|
|
#ifndef PORT_SOURCE_FILE
|
|
|
|
#error "Please upgrade to Nevada 72 or above to suppoert FEN"
|
|
|
|
#endif
|
2011-05-02 17:44:46 +02:00
|
|
|
int main() { return 0; } ]])],
|
2008-03-14 09:58:24 +01:00
|
|
|
[
|
|
|
|
fen_support=yes
|
|
|
|
],)
|
|
|
|
|
|
|
|
AM_CONDITIONAL(HAVE_FEN, [test "$fen_support" = "yes"])
|
|
|
|
|
2007-11-26 17:13:05 +01:00
|
|
|
dnl ****************************
|
|
|
|
dnl *** Checks for FAM (GIO) ***
|
|
|
|
dnl ****************************
|
|
|
|
|
|
|
|
should_disable_fam=no
|
|
|
|
|
|
|
|
AC_ARG_ENABLE(fam, [ --disable-fam build without enabling fam for file system monitoring],
|
|
|
|
[
|
|
|
|
if test "x$enable_fam" = "xno"; then
|
|
|
|
should_disable_fam=yes
|
|
|
|
echo "Not building FAM support"
|
|
|
|
fi
|
|
|
|
]
|
|
|
|
)
|
|
|
|
fam_support=no
|
|
|
|
FAM_LIBS=
|
|
|
|
if test "x$should_disable_fam" = "xno"; then
|
|
|
|
AC_CHECK_LIB(fam, FAMOpen,
|
|
|
|
[AC_CHECK_HEADERS(fam.h,
|
|
|
|
[AC_DEFINE(HAVE_FAM, [], [Define if we have FAM])
|
|
|
|
AC_CHECK_LIB(fam, FAMNoExists,
|
|
|
|
AC_DEFINE(HAVE_FAM_NO_EXISTS, [], [Define if we have FAMNoExists in fam]))
|
|
|
|
FAM_LIBS="-lfam"]
|
|
|
|
fam_support=yes,
|
|
|
|
AC_MSG_WARN(*** FAM support will not be built (header files not found) ***))],
|
|
|
|
AC_MSG_WARN(*** FAM support will not be built (FAM library not found) ***))
|
|
|
|
AC_SUBST(FAM_LIBS)
|
|
|
|
fi
|
|
|
|
AM_CONDITIONAL(HAVE_FAM, [test "$fam_support" = "yes"])
|
|
|
|
|
|
|
|
|
|
|
|
dnl *****************************
|
|
|
|
dnl *** Check for xattr (GIO) ***
|
|
|
|
dnl *****************************
|
|
|
|
AC_ARG_ENABLE(xattr, [ --disable-xattr build without xattr support])
|
|
|
|
msg_xattr=no
|
|
|
|
XATTR_LIBS=
|
|
|
|
if test "x$enable_xattr" != "xno"; then
|
|
|
|
|
|
|
|
dnl either glibc or libattr can provide xattr support
|
|
|
|
|
|
|
|
dnl for both of them, we check for getxattr being in
|
|
|
|
dnl the library and a valid xattr header.
|
|
|
|
|
|
|
|
dnl try glibc
|
|
|
|
AC_CHECK_LIB(c, getxattr,
|
|
|
|
[AC_CHECK_HEADERS(sys/xattr.h,
|
|
|
|
[AC_DEFINE(HAVE_XATTR, 1, [Define to 1 if xattr is available])
|
|
|
|
msg_xattr=yes])
|
|
|
|
])
|
|
|
|
|
|
|
|
if test "x$msg_xattr" != "xyes"; then
|
|
|
|
dnl failure. try libattr
|
|
|
|
AC_CHECK_LIB(attr, getxattr,
|
|
|
|
[AC_CHECK_HEADERS(attr/xattr.h,
|
|
|
|
[AC_DEFINE(HAVE_XATTR, 1, [Define to 1 if xattr is available])
|
|
|
|
XATTR_LIBS="-lattr"
|
|
|
|
msg_xattr=yes])
|
|
|
|
])
|
|
|
|
fi
|
2007-12-03 11:23:03 +01:00
|
|
|
|
|
|
|
if test "x$msg_xattr" = "xyes"; then
|
|
|
|
AC_MSG_CHECKING([for XATTR_NOFOLLOW])
|
|
|
|
AC_TRY_COMPILE([
|
|
|
|
#include <stdio.h>
|
|
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
|
|
#include <sys/types.h>
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_SYS_XATTR_H
|
|
|
|
#include <sys/xattr.h>
|
|
|
|
#elif HAVE_ATTR_XATTR_H
|
|
|
|
#include <attr/xattr.h>
|
|
|
|
#endif
|
|
|
|
],
|
|
|
|
[ssize_t len = getxattr("", "", NULL, 0, 0, XATTR_NOFOLLOW);],
|
|
|
|
[
|
|
|
|
AC_DEFINE([HAVE_XATTR_NOFOLLOW], [1], [Define to 1 if xattr API uses XATTR_NOFOLLOW])
|
|
|
|
AC_MSG_RESULT([yes])
|
|
|
|
],
|
|
|
|
[AC_MSG_RESULT([no])]
|
|
|
|
)
|
|
|
|
fi
|
|
|
|
|
2007-11-26 17:13:05 +01:00
|
|
|
fi
|
|
|
|
AC_SUBST(XATTR_LIBS)
|
|
|
|
|
2001-03-09 22:18:33 +01:00
|
|
|
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
|
2006-05-24 14:58:26 +02:00
|
|
|
*-*-cygwin*|*-*-mingw*|*-*-minix)
|
2001-03-09 22:18:33 +01:00
|
|
|
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)
|
|
|
|
|
2000-02-13 08:18:23 +01:00
|
|
|
dnl ***********************
|
|
|
|
dnl *** g_thread checks ***
|
|
|
|
dnl ***********************
|
|
|
|
|
2003-03-04 11:10:48 +01:00
|
|
|
AC_ARG_WITH(threads,
|
2005-12-02 22:37:25 +01:00
|
|
|
[AC_HELP_STRING([--with-threads=@<:@none/posix/dce/win32@:>@],
|
2003-03-04 11:10:48 +01:00
|
|
|
[specify a thread implementation to use])],
|
|
|
|
[if test "x$with_threads" = x; then
|
2000-02-13 08:18:23 +01:00
|
|
|
want_threads=yes
|
2003-03-04 11:10:48 +01:00
|
|
|
else
|
2000-02-13 08:18:23 +01:00
|
|
|
want_threads=$with_threads
|
2003-03-04 11:10:48 +01:00
|
|
|
fi],
|
|
|
|
[want_threads=yes])
|
2000-02-13 08:18:23 +01:00
|
|
|
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."
|
|
|
|
|
Added the missing POSIX_NO_YIELD and POSIX_NO_PRIORITIES warning messages.
2000-03-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in: Added the missing POSIX_NO_YIELD and
POSIX_NO_PRIORITIES warning messages.
* configure.in: Use AC_TRY_RUN instead of AC_TRY_LINK, to test for
real thread support. On solaris pthread_create can be linked to
even in -lc, but it doesn't work then.
* configure.in: Don't use priorities for threads, when the
minimal/maximal priorities couldn't be determined at configure
time.
* configure.in, gthread.c: Always define GSystemThread in
glibconfig.h to represent a system thread.
* configure.in: Do not use native recursive threads, when
possibe. We use some features, that they do not expose (namely the
depth counter).
* glib.h, gthread.c: Redefined GStaticRecMutex. The functions are
now implemented in a different way, which should be way
faster. Alsothere are now functions g_static_rec_mutex_unlock_full
and g_static_rec_mutex_lock_full to leave/enter a recursive mutex
completly.
* gthread.c (g_thread_self): Do not test the system_thread to be
non-zero to speed things up.
* gthread.c (g_mutex_init): Therefore set the system_thread of the
main thread here.
* tests/thread-test.c: Rerun all tests once again, but this time
we fool the system into thinking, that the available thread system
is not native, but userprovided.
* gthread/gthread-posix.c: Don't use priorities for threads,
when the minimal/maximal priorities couldn't be determined at
configure time.
* gthread/gthread-posix.c: Don't check for errors, when
setting the scope of a tread to system, as some posix
implementations can't do that and we don't want the thing to
fail because of that.
2000-03-17 15:49:59 +01:00
|
|
|
FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your
|
2001-03-08 10:37:01 +01:00
|
|
|
platform (normally it's "_REENTRANT"). I'll not use any flag on
|
2000-02-13 08:18:23 +01:00
|
|
|
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."
|
|
|
|
|
Added the missing POSIX_NO_YIELD and POSIX_NO_PRIORITIES warning messages.
2000-03-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in: Added the missing POSIX_NO_YIELD and
POSIX_NO_PRIORITIES warning messages.
* configure.in: Use AC_TRY_RUN instead of AC_TRY_LINK, to test for
real thread support. On solaris pthread_create can be linked to
even in -lc, but it doesn't work then.
* configure.in: Don't use priorities for threads, when the
minimal/maximal priorities couldn't be determined at configure
time.
* configure.in, gthread.c: Always define GSystemThread in
glibconfig.h to represent a system thread.
* configure.in: Do not use native recursive threads, when
possibe. We use some features, that they do not expose (namely the
depth counter).
* glib.h, gthread.c: Redefined GStaticRecMutex. The functions are
now implemented in a different way, which should be way
faster. Alsothere are now functions g_static_rec_mutex_unlock_full
and g_static_rec_mutex_lock_full to leave/enter a recursive mutex
completly.
* gthread.c (g_thread_self): Do not test the system_thread to be
non-zero to speed things up.
* gthread.c (g_mutex_init): Therefore set the system_thread of the
main thread here.
* tests/thread-test.c: Rerun all tests once again, but this time
we fool the system into thinking, that the available thread system
is not native, but userprovided.
* gthread/gthread-posix.c: Don't use priorities for threads,
when the minimal/maximal priorities couldn't be determined at
configure time.
* gthread/gthread-posix.c: Don't check for errors, when
setting the scope of a tread to system, as some posix
implementations can't do that and we don't want the thing to
fail because of that.
2000-03-17 15:49:59 +01:00
|
|
|
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."
|
|
|
|
|
2002-07-03 18:43:22 +02:00
|
|
|
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."
|
Added the missing POSIX_NO_YIELD and POSIX_NO_PRIORITIES warning messages.
2000-03-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in: Added the missing POSIX_NO_YIELD and
POSIX_NO_PRIORITIES warning messages.
* configure.in: Use AC_TRY_RUN instead of AC_TRY_LINK, to test for
real thread support. On solaris pthread_create can be linked to
even in -lc, but it doesn't work then.
* configure.in: Don't use priorities for threads, when the
minimal/maximal priorities couldn't be determined at configure
time.
* configure.in, gthread.c: Always define GSystemThread in
glibconfig.h to represent a system thread.
* configure.in: Do not use native recursive threads, when
possibe. We use some features, that they do not expose (namely the
depth counter).
* glib.h, gthread.c: Redefined GStaticRecMutex. The functions are
now implemented in a different way, which should be way
faster. Alsothere are now functions g_static_rec_mutex_unlock_full
and g_static_rec_mutex_lock_full to leave/enter a recursive mutex
completly.
* gthread.c (g_thread_self): Do not test the system_thread to be
non-zero to speed things up.
* gthread.c (g_mutex_init): Therefore set the system_thread of the
main thread here.
* tests/thread-test.c: Rerun all tests once again, but this time
we fool the system into thinking, that the available thread system
is not native, but userprovided.
* gthread/gthread-posix.c: Don't use priorities for threads,
when the minimal/maximal priorities couldn't be determined at
configure time.
* gthread/gthread-posix.c: Don't check for errors, when
setting the scope of a tread to system, as some posix
implementations can't do that and we don't want the thing to
fail because of that.
2000-03-17 15:49:59 +01:00
|
|
|
|
2000-02-13 08:18:23 +01:00
|
|
|
dnl determination of thread implementation
|
|
|
|
dnl ***************************************
|
|
|
|
|
2001-10-31 16:40:52 +01:00
|
|
|
# have_threads=no means no thread support
|
|
|
|
# have_threads=none means no default thread implementation
|
|
|
|
|
|
|
|
have_threads=no
|
2000-02-13 08:18:23 +01:00
|
|
|
if test "x$want_threads" = xyes || test "x$want_threads" = xposix \
|
|
|
|
|| test "x$want_threads" = xdce; then
|
2000-11-15 18:48:43 +01:00
|
|
|
# -D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE is for DG/UX
|
Added the missing POSIX_NO_YIELD and POSIX_NO_PRIORITIES warning messages.
2000-03-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in: Added the missing POSIX_NO_YIELD and
POSIX_NO_PRIORITIES warning messages.
* configure.in: Use AC_TRY_RUN instead of AC_TRY_LINK, to test for
real thread support. On solaris pthread_create can be linked to
even in -lc, but it doesn't work then.
* configure.in: Don't use priorities for threads, when the
minimal/maximal priorities couldn't be determined at configure
time.
* configure.in, gthread.c: Always define GSystemThread in
glibconfig.h to represent a system thread.
* configure.in: Do not use native recursive threads, when
possibe. We use some features, that they do not expose (namely the
depth counter).
* glib.h, gthread.c: Redefined GStaticRecMutex. The functions are
now implemented in a different way, which should be way
faster. Alsothere are now functions g_static_rec_mutex_unlock_full
and g_static_rec_mutex_lock_full to leave/enter a recursive mutex
completly.
* gthread.c (g_thread_self): Do not test the system_thread to be
non-zero to speed things up.
* gthread.c (g_mutex_init): Therefore set the system_thread of the
main thread here.
* tests/thread-test.c: Rerun all tests once again, but this time
we fool the system into thinking, that the available thread system
is not native, but userprovided.
* gthread/gthread-posix.c: Don't use priorities for threads,
when the minimal/maximal priorities couldn't be determined at
configure time.
* gthread/gthread-posix.c: Don't check for errors, when
setting the scope of a tread to system, as some posix
implementations can't do that and we don't want the thing to
fail because of that.
2000-03-17 15:49:59 +01:00
|
|
|
# -U_OSF_SOURCE is for Digital UNIX 4.0d
|
2000-11-15 18:48:43 +01:00
|
|
|
GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE"
|
2000-02-13 08:18:23 +01:00
|
|
|
glib_save_CPPFLAGS="$CPPFLAGS"
|
|
|
|
CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
|
2001-10-31 16:40:52 +01:00
|
|
|
if test "x$have_threads" = xno; then
|
2000-11-15 18:48:43 +01:00
|
|
|
AC_TRY_COMPILE([#include <pthread.h>],
|
2002-07-02 14:41:46 +02:00
|
|
|
[pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
|
2000-02-13 08:18:23 +01:00
|
|
|
have_threads=posix)
|
|
|
|
fi
|
2001-10-31 16:40:52 +01:00
|
|
|
if test "x$have_threads" = xno; then
|
2000-11-15 18:48:43 +01:00
|
|
|
AC_TRY_COMPILE([#include <pthread.h>],
|
2002-07-02 14:41:46 +02:00
|
|
|
[pthread_mutex_t m;
|
|
|
|
pthread_mutex_init (&m, pthread_mutexattr_default);],
|
2002-03-06 18:43:32 +01:00
|
|
|
have_threads=dce)
|
2000-02-13 08:18:23 +01:00
|
|
|
fi
|
2003-02-12 14:01:35 +01:00
|
|
|
# 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
|
2000-02-13 08:18:23 +01:00
|
|
|
CPPFLAGS="$glib_save_CPPFLAGS"
|
|
|
|
fi
|
2001-09-17 02:41:39 +02:00
|
|
|
if test "x$want_threads" = xyes || test "x$want_threads" = xwin32; then
|
|
|
|
case $host in
|
2001-10-26 07:38:32 +02:00
|
|
|
*-*-mingw*)
|
2001-09-17 02:41:39 +02:00
|
|
|
have_threads=win32
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
fi
|
2001-10-31 16:40:52 +01:00
|
|
|
if test "x$want_threads" = xnone; then
|
|
|
|
have_threads=none
|
|
|
|
fi
|
2000-02-13 08:18:23 +01:00
|
|
|
|
|
|
|
AC_MSG_CHECKING(for thread implementation)
|
|
|
|
|
2001-10-31 16:40:52 +01:00
|
|
|
if test "x$have_threads" = xno && test "x$want_threads" != xno; then
|
2000-02-13 08:18:23 +01:00
|
|
|
AC_MSG_RESULT(none available)
|
|
|
|
AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
|
|
|
|
else
|
|
|
|
AC_MSG_RESULT($have_threads)
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
2000-09-28 09:54:40 +02:00
|
|
|
dnl determination of G_THREAD_CFLAGS
|
|
|
|
dnl ********************************
|
2000-02-13 08:18:23 +01:00
|
|
|
|
|
|
|
G_THREAD_LIBS=
|
|
|
|
G_THREAD_LIBS_EXTRA=
|
|
|
|
G_THREAD_CFLAGS=
|
|
|
|
|
2002-12-11 21:28:46 +01:00
|
|
|
dnl
|
|
|
|
dnl Test program for basic POSIX threads functionality
|
|
|
|
dnl
|
|
|
|
m4_define([glib_thread_test],[
|
|
|
|
#include <pthread.h>
|
|
|
|
int check_me = 0;
|
2003-02-18 15:00:16 +01:00
|
|
|
void* func(void* data) {check_me = 42; return &check_me;}
|
|
|
|
int main()
|
2002-12-11 21:28:46 +01:00
|
|
|
{ pthread_t t;
|
|
|
|
void *ret;
|
2003-02-18 15:00:16 +01:00
|
|
|
pthread_create (&t, $1, func, 0);
|
2002-12-11 21:28:46 +01:00
|
|
|
pthread_join (t, &ret);
|
2006-08-28 05:54:28 +02:00
|
|
|
return (check_me != 42 || ret != &check_me);
|
2002-12-11 22:28:45 +01:00
|
|
|
}])
|
|
|
|
|
|
|
|
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;
|
|
|
|
}])
|
2002-12-11 21:28:46 +01:00
|
|
|
|
2001-10-31 16:40:52 +01:00
|
|
|
if test x"$have_threads" != xno; then
|
2000-09-28 09:54:40 +02:00
|
|
|
|
2002-07-03 18:43:22 +02:00
|
|
|
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.
|
2004-04-03 06:46:41 +02:00
|
|
|
case $host in
|
2006-03-06 08:53:24 +01:00
|
|
|
*-*-cygwin*|*-*-darwin*)
|
|
|
|
# skip cygwin and darwin -pthread or -pthreads test
|
2004-04-03 06:46:41 +02:00
|
|
|
;;
|
2006-12-16 04:52:27 +01:00
|
|
|
*-solaris*)
|
|
|
|
# These compiler/linker flags work with both Sun Studio and gcc
|
|
|
|
# Sun Studio expands -mt to -D_REENTRANT and -lthread
|
|
|
|
# gcc expands -pthreads to -D_REENTRANT -D_PTHREADS -lpthread
|
|
|
|
G_THREAD_CFLAGS="-D_REENTRANT -D_PTHREADS"
|
|
|
|
G_THREAD_LIBS="-lpthread -lthread"
|
|
|
|
;;
|
2004-04-03 06:46:41 +02:00
|
|
|
*)
|
2005-07-26 21:37:34 +02:00
|
|
|
for flag in pthread pthreads mt; do
|
2004-04-03 06:46:41 +02:00
|
|
|
glib_save_CFLAGS="$CFLAGS"
|
|
|
|
CFLAGS="$CFLAGS -$flag"
|
|
|
|
AC_TRY_RUN(glib_thread_test(0),
|
|
|
|
glib_flag_works=yes,
|
|
|
|
glib_flag_works=no,
|
2011-05-02 17:44:46 +02:00
|
|
|
[AC_LINK_IFELSE([AC_LANG_SOURCE(glib_thread_test(0))],
|
2004-04-03 06:46:41 +02:00
|
|
|
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
|
2006-08-28 05:54:28 +02:00
|
|
|
break;
|
2004-04-03 06:46:41 +02:00
|
|
|
fi
|
|
|
|
done
|
|
|
|
;;
|
|
|
|
esac
|
2002-07-03 18:43:22 +02:00
|
|
|
fi
|
|
|
|
|
|
|
|
if test x"$G_THREAD_CFLAGS" = x; then
|
|
|
|
|
|
|
|
# The canonical -pthread[s] does not work. Try something different.
|
2000-09-28 09:54:40 +02:00
|
|
|
|
|
|
|
case $host in
|
|
|
|
*-aix*)
|
|
|
|
if test x"$GCC" = xyes; then
|
2002-07-03 18:43:22 +02:00
|
|
|
# GCC 3.0 and above needs -pthread.
|
|
|
|
# Should be coverd by the case above.
|
2002-01-22 10:50:24 +01:00
|
|
|
# GCC 2.x and below needs -mthreads
|
2002-07-03 18:43:22 +02:00
|
|
|
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"
|
2000-09-28 09:54:40 +02:00
|
|
|
fi
|
|
|
|
;;
|
2000-11-15 18:48:43 +01:00
|
|
|
*-dg-dgux*) # DG/UX
|
2002-07-03 18:43:22 +02:00
|
|
|
G_THREAD_CFLAGS="-D_REENTRANT -D_POSIX4A_DRAFT10_SOURCE"
|
|
|
|
;;
|
|
|
|
*-osf*)
|
|
|
|
# So we are using dce threads. posix threads are already
|
|
|
|
# catched above.
|
|
|
|
G_THREAD_CFLAGS="-threads"
|
|
|
|
G_THREAD_LIBS=$G_THREAD_CFLAGS
|
|
|
|
;;
|
|
|
|
*-sysv5uw7*) # UnixWare 7
|
|
|
|
# We are not using gcc with -pthread. Catched above.
|
|
|
|
G_THREAD_CFLAGS="-Kthread"
|
|
|
|
G_THREAD_LIBS=$G_THREAD_CFLAGS
|
|
|
|
;;
|
2003-10-24 05:41:22 +02:00
|
|
|
*-mingw*)
|
|
|
|
# No flag needed when using MSVCRT.DLL
|
|
|
|
G_THREAD_CFLAGS=""
|
|
|
|
;;
|
2002-07-03 18:43:22 +02:00
|
|
|
*)
|
|
|
|
G_THREAD_CFLAGS="-D_REENTRANT" # good default guess otherwise
|
|
|
|
;;
|
2000-09-28 09:54:40 +02:00
|
|
|
esac
|
2002-07-03 18:43:22 +02:00
|
|
|
|
|
|
|
fi
|
2000-09-28 09:54:40 +02:00
|
|
|
|
2001-04-19 10:26:21 +02:00
|
|
|
# if we are not finding the localtime_r function, then we probably are
|
2000-09-28 09:54:40 +02:00
|
|
|
# not using the proper multithread flag
|
|
|
|
|
|
|
|
glib_save_CPPFLAGS="$CPPFLAGS"
|
|
|
|
CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
|
|
|
|
|
2001-04-19 10:26:21 +02:00
|
|
|
# First we test, whether localtime_r is declared in time.h
|
2001-04-20 19:08:57 +02:00
|
|
|
# directly. Then we test whether a macro localtime_r exists, in
|
2001-04-19 10:26:21 +02:00
|
|
|
# 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))])
|
2000-09-28 09:54:40 +02:00
|
|
|
|
|
|
|
CPPFLAGS="$glib_save_CPPFLAGS"
|
|
|
|
|
|
|
|
AC_MSG_CHECKING(thread related cflags)
|
|
|
|
AC_MSG_RESULT($G_THREAD_CFLAGS)
|
2002-11-26 13:57:16 +01:00
|
|
|
CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
|
2000-09-28 09:54:40 +02:00
|
|
|
fi
|
|
|
|
|
|
|
|
dnl determination of G_THREAD_LIBS
|
|
|
|
dnl ******************************
|
|
|
|
|
2000-02-13 08:18:23 +01:00
|
|
|
mutex_has_default=no
|
|
|
|
case $have_threads in
|
|
|
|
posix|dce)
|
2002-11-26 13:57:16 +01:00
|
|
|
glib_save_CPPFLAGS="$CPPFLAGS"
|
|
|
|
CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
|
2002-07-03 18:43:22 +02:00
|
|
|
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
|
2000-02-13 08:18:23 +01:00
|
|
|
if test x"$thread_lib" = x; then
|
|
|
|
add_thread_lib=""
|
|
|
|
IN=""
|
|
|
|
else
|
|
|
|
add_thread_lib="-l$thread_lib"
|
|
|
|
IN=" in -l$thread_lib"
|
|
|
|
fi
|
Added the missing POSIX_NO_YIELD and POSIX_NO_PRIORITIES warning messages.
2000-03-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in: Added the missing POSIX_NO_YIELD and
POSIX_NO_PRIORITIES warning messages.
* configure.in: Use AC_TRY_RUN instead of AC_TRY_LINK, to test for
real thread support. On solaris pthread_create can be linked to
even in -lc, but it doesn't work then.
* configure.in: Don't use priorities for threads, when the
minimal/maximal priorities couldn't be determined at configure
time.
* configure.in, gthread.c: Always define GSystemThread in
glibconfig.h to represent a system thread.
* configure.in: Do not use native recursive threads, when
possibe. We use some features, that they do not expose (namely the
depth counter).
* glib.h, gthread.c: Redefined GStaticRecMutex. The functions are
now implemented in a different way, which should be way
faster. Alsothere are now functions g_static_rec_mutex_unlock_full
and g_static_rec_mutex_lock_full to leave/enter a recursive mutex
completly.
* gthread.c (g_thread_self): Do not test the system_thread to be
non-zero to speed things up.
* gthread.c (g_mutex_init): Therefore set the system_thread of the
main thread here.
* tests/thread-test.c: Rerun all tests once again, but this time
we fool the system into thinking, that the available thread system
is not native, but userprovided.
* gthread/gthread-posix.c: Don't use priorities for threads,
when the minimal/maximal priorities couldn't be determined at
configure time.
* gthread/gthread-posix.c: Don't check for errors, when
setting the scope of a tread to system, as some posix
implementations can't do that and we don't want the thing to
fail because of that.
2000-03-17 15:49:59 +01:00
|
|
|
if test x"$have_threads" = xposix; then
|
2000-11-15 18:48:43 +01:00
|
|
|
defattr=0
|
Added the missing POSIX_NO_YIELD and POSIX_NO_PRIORITIES warning messages.
2000-03-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in: Added the missing POSIX_NO_YIELD and
POSIX_NO_PRIORITIES warning messages.
* configure.in: Use AC_TRY_RUN instead of AC_TRY_LINK, to test for
real thread support. On solaris pthread_create can be linked to
even in -lc, but it doesn't work then.
* configure.in: Don't use priorities for threads, when the
minimal/maximal priorities couldn't be determined at configure
time.
* configure.in, gthread.c: Always define GSystemThread in
glibconfig.h to represent a system thread.
* configure.in: Do not use native recursive threads, when
possibe. We use some features, that they do not expose (namely the
depth counter).
* glib.h, gthread.c: Redefined GStaticRecMutex. The functions are
now implemented in a different way, which should be way
faster. Alsothere are now functions g_static_rec_mutex_unlock_full
and g_static_rec_mutex_lock_full to leave/enter a recursive mutex
completly.
* gthread.c (g_thread_self): Do not test the system_thread to be
non-zero to speed things up.
* gthread.c (g_mutex_init): Therefore set the system_thread of the
main thread here.
* tests/thread-test.c: Rerun all tests once again, but this time
we fool the system into thinking, that the available thread system
is not native, but userprovided.
* gthread/gthread-posix.c: Don't use priorities for threads,
when the minimal/maximal priorities couldn't be determined at
configure time.
* gthread/gthread-posix.c: Don't check for errors, when
setting the scope of a tread to system, as some posix
implementations can't do that and we don't want the thing to
fail because of that.
2000-03-17 15:49:59 +01:00
|
|
|
else
|
|
|
|
defattr=pthread_attr_default
|
|
|
|
fi
|
2000-02-13 08:18:23 +01:00
|
|
|
|
2002-12-13 05:11:32 +01:00
|
|
|
LIBS="$add_thread_lib $glib_save_LIBS"
|
2000-02-13 08:18:23 +01:00
|
|
|
|
2000-04-26 15:03:49 +02:00
|
|
|
AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
|
2003-02-18 15:00:16 +01:00
|
|
|
AC_TRY_RUN(glib_thread_test($defattr),
|
2002-12-11 22:28:45 +01:00
|
|
|
glib_result=yes,
|
|
|
|
glib_result=no,
|
2011-05-02 17:44:46 +02:00
|
|
|
[AC_LINK_IFELSE([AC_LANG_SOURCE(glib_thread_test($defattr))],
|
2002-12-13 05:11:32 +01:00
|
|
|
glib_result=yes,
|
2002-12-11 22:28:45 +01:00
|
|
|
glib_result=no)])
|
|
|
|
AC_MSG_RESULT($glib_result)
|
|
|
|
|
|
|
|
if test "$glib_result" = "yes" ; then
|
|
|
|
G_THREAD_LIBS="$add_thread_lib"
|
|
|
|
break
|
|
|
|
fi
|
2000-02-13 08:18:23 +01:00
|
|
|
done
|
2002-07-03 18:43:22 +02:00
|
|
|
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"
|
2002-03-06 18:43:32 +01:00
|
|
|
;;
|
2002-07-03 18:43:22 +02:00
|
|
|
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
|
2002-12-13 05:11:32 +01:00
|
|
|
LIBS="$add_thread_lib $glib_save_LIBS"
|
2002-12-11 22:28:45 +01:00
|
|
|
|
2002-07-03 18:43:22 +02:00
|
|
|
AC_MSG_CHECKING(for sched_get_priority_min$IN)
|
2002-12-11 22:28:45 +01:00
|
|
|
AC_TRY_RUN(glib_sched_priority_test,
|
|
|
|
glib_result=yes,
|
|
|
|
glib_result=no,
|
2011-05-02 17:44:46 +02:00
|
|
|
[AC_LINK_IFELSE([AC_LANG_SOURCE(glib_sched_priority_test)],
|
2002-12-13 05:11:32 +01:00
|
|
|
glib_result=yes,
|
2002-12-11 22:28:45 +01:00
|
|
|
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
|
2002-07-03 18:43:22 +02:00
|
|
|
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"
|
|
|
|
;;
|
2001-09-17 02:41:39 +02:00
|
|
|
win32)
|
|
|
|
g_threads_impl="WIN32"
|
|
|
|
;;
|
2002-02-09 21:08:06 +01:00
|
|
|
none|no)
|
2000-09-28 09:54:40 +02:00
|
|
|
g_threads_impl="NONE"
|
|
|
|
;;
|
2000-02-13 08:18:23 +01:00
|
|
|
*)
|
2000-09-28 09:54:40 +02:00
|
|
|
g_threads_impl="NONE"
|
|
|
|
G_THREAD_LIBS=error
|
|
|
|
;;
|
2000-02-13 08:18:23 +01:00
|
|
|
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*)
|
2005-06-30 21:43:48 +02:00
|
|
|
G_THREAD_LIBS="-lbe -lroot -lglib-2.0 "
|
2000-02-13 08:18:23 +01:00
|
|
|
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 ************************************************************
|
|
|
|
|
2001-10-31 16:40:52 +01:00
|
|
|
if test x"$have_threads" != xno; then
|
2000-02-13 08:18:23 +01:00
|
|
|
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"
|
2008-02-03 11:54:13 +01:00
|
|
|
AC_CHECK_FUNCS(localtime_r gmtime_r)
|
2000-02-13 08:18:23 +01:00
|
|
|
if test "$ac_cv_header_pwd_h" = "yes"; then
|
2000-11-15 18:48:43 +01:00
|
|
|
AC_CACHE_CHECK([for posix getpwuid_r],
|
|
|
|
ac_cv_func_posix_getpwuid_r,
|
2002-12-05 21:49:26 +01:00
|
|
|
[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;
|
|
|
|
} ],
|
2000-11-15 18:48:43 +01:00
|
|
|
[ac_cv_func_posix_getpwuid_r=yes],
|
|
|
|
[ac_cv_func_posix_getpwuid_r=no])])
|
2002-12-11 23:21:32 +01:00
|
|
|
GLIB_ASSERT_SET(ac_cv_func_posix_getpwuid_r)
|
2000-11-15 18:48:43 +01:00
|
|
|
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,
|
2001-04-20 19:08:57 +02:00
|
|
|
[AC_TRY_LINK([#include <pwd.h>],
|
2000-11-15 18:48:43 +01:00
|
|
|
[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])])
|
2002-12-11 23:21:32 +01:00
|
|
|
GLIB_ASSERT_SET(ac_cv_func_nonposix_getpwuid_r)
|
2000-11-15 18:48:43 +01:00
|
|
|
if test "$ac_cv_func_nonposix_getpwuid_r" = yes; then
|
|
|
|
AC_DEFINE(HAVE_NONPOSIX_GETPWUID_R,1,
|
|
|
|
[Have non-POSIX function getpwuid_r])
|
|
|
|
fi
|
2000-02-13 08:18:23 +01:00
|
|
|
fi
|
|
|
|
fi
|
2007-11-26 17:13:05 +01:00
|
|
|
if test "$ac_cv_header_grp_h" = "yes"; then
|
|
|
|
AC_CACHE_CHECK([for posix getgrgid_r],
|
|
|
|
ac_cv_func_posix_getgrgid_r,
|
|
|
|
[AC_TRY_RUN([
|
|
|
|
#include <errno.h>
|
|
|
|
#include <grp.h>
|
|
|
|
int main () {
|
|
|
|
char buffer[10000];
|
|
|
|
struct group grp, *grpptr = &grp;
|
|
|
|
int error;
|
|
|
|
errno = 0;
|
|
|
|
error = getgrgid_r (0, &grp, buffer,
|
|
|
|
sizeof (buffer), &grpptr);
|
|
|
|
return (error < 0 && errno == ENOSYS)
|
|
|
|
|| error == ENOSYS;
|
|
|
|
} ],
|
|
|
|
[ac_cv_func_posix_getgrgid_r=yes],
|
|
|
|
[ac_cv_func_posix_getgrgid_r=no])])
|
|
|
|
GLIB_ASSERT_SET(ac_cv_func_posix_getgrgid_r)
|
|
|
|
if test "$ac_cv_func_posix_getgrgid_r" = yes; then
|
|
|
|
AC_DEFINE(HAVE_POSIX_GETGRGID_R,1,
|
|
|
|
[Have POSIX function getgrgid_r])
|
|
|
|
else
|
|
|
|
AC_CACHE_CHECK([for nonposix getgrgid_r],
|
|
|
|
ac_cv_func_nonposix_getgrgid_r,
|
|
|
|
[AC_TRY_LINK([#include <grp.h>],
|
|
|
|
[char buffer[10000];
|
|
|
|
struct group grp;
|
|
|
|
getgrgid_r (0, &grp, buffer,
|
|
|
|
sizeof (buffer));],
|
|
|
|
[ac_cv_func_nonposix_getgrgid_r=yes],
|
|
|
|
[ac_cv_func_nonposix_getgrgid_r=no])])
|
|
|
|
GLIB_ASSERT_SET(ac_cv_func_nonposix_getgrgid_r)
|
|
|
|
if test "$ac_cv_func_nonposix_getgrgid_r" = yes; then
|
|
|
|
AC_DEFINE(HAVE_NONPOSIX_GETGRGID_R,1,
|
|
|
|
[Have non-POSIX function getgrgid_r])
|
|
|
|
fi
|
|
|
|
fi
|
|
|
|
fi
|
2002-12-13 05:11:32 +01:00
|
|
|
LIBS="$G_THREAD_LIBS $LIBS"
|
2000-02-13 08:18:23 +01:00
|
|
|
if test x"$have_threads" = xposix; then
|
Added the missing POSIX_NO_YIELD and POSIX_NO_PRIORITIES warning messages.
2000-03-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in: Added the missing POSIX_NO_YIELD and
POSIX_NO_PRIORITIES warning messages.
* configure.in: Use AC_TRY_RUN instead of AC_TRY_LINK, to test for
real thread support. On solaris pthread_create can be linked to
even in -lc, but it doesn't work then.
* configure.in: Don't use priorities for threads, when the
minimal/maximal priorities couldn't be determined at configure
time.
* configure.in, gthread.c: Always define GSystemThread in
glibconfig.h to represent a system thread.
* configure.in: Do not use native recursive threads, when
possibe. We use some features, that they do not expose (namely the
depth counter).
* glib.h, gthread.c: Redefined GStaticRecMutex. The functions are
now implemented in a different way, which should be way
faster. Alsothere are now functions g_static_rec_mutex_unlock_full
and g_static_rec_mutex_lock_full to leave/enter a recursive mutex
completly.
* gthread.c (g_thread_self): Do not test the system_thread to be
non-zero to speed things up.
* gthread.c (g_mutex_init): Therefore set the system_thread of the
main thread here.
* tests/thread-test.c: Rerun all tests once again, but this time
we fool the system into thinking, that the available thread system
is not native, but userprovided.
* gthread/gthread-posix.c: Don't use priorities for threads,
when the minimal/maximal priorities couldn't be determined at
configure time.
* gthread/gthread-posix.c: Don't check for errors, when
setting the scope of a tread to system, as some posix
implementations can't do that and we don't want the thing to
fail because of that.
2000-03-17 15:49:59 +01:00
|
|
|
glib_save_CPPFLAGS="$CPPFLAGS"
|
|
|
|
CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
|
2000-12-29 16:11:03 +01:00
|
|
|
dnl we might grow sizeof(pthread_t) later on, so use a dummy name here
|
2001-02-15 17:43:02 +01:00
|
|
|
GLIB_SIZEOF([#include <pthread.h>], pthread_t, system_thread)
|
2000-02-13 08:18:23 +01:00
|
|
|
# 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)
|
2000-10-16 03:02:19 +02:00
|
|
|
AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE,1,
|
|
|
|
[Have function pthread_attr_setstacksize])],
|
2000-02-13 08:18:23 +01:00
|
|
|
[AC_MSG_RESULT(no)])
|
|
|
|
AC_MSG_CHECKING(for minimal/maximal thread priority)
|
2002-07-03 17:30:46 +02:00
|
|
|
if test x"$posix_priority_min" = x; then
|
2000-02-13 08:18:23 +01:00
|
|
|
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
|
2002-07-03 17:30:46 +02:00
|
|
|
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
|
2002-11-22 18:40:03 +01:00
|
|
|
posix_priority_max=PTHREAD_PRIO_MAX])
|
2002-07-03 17:30:46 +02:00
|
|
|
fi
|
|
|
|
if test x"$posix_priority_min" = x; then
|
2000-02-13 08:18:23 +01:00
|
|
|
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
|
2000-03-23 17:23:50 +01:00
|
|
|
if test x"$posix_priority_min" = x; then
|
2000-02-13 08:18:23 +01:00
|
|
|
AC_MSG_RESULT(none found)
|
|
|
|
AC_MSG_WARN($POSIX_NO_PRIORITIES)
|
Added the missing POSIX_NO_YIELD and POSIX_NO_PRIORITIES warning messages.
2000-03-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in: Added the missing POSIX_NO_YIELD and
POSIX_NO_PRIORITIES warning messages.
* configure.in: Use AC_TRY_RUN instead of AC_TRY_LINK, to test for
real thread support. On solaris pthread_create can be linked to
even in -lc, but it doesn't work then.
* configure.in: Don't use priorities for threads, when the
minimal/maximal priorities couldn't be determined at configure
time.
* configure.in, gthread.c: Always define GSystemThread in
glibconfig.h to represent a system thread.
* configure.in: Do not use native recursive threads, when
possibe. We use some features, that they do not expose (namely the
depth counter).
* glib.h, gthread.c: Redefined GStaticRecMutex. The functions are
now implemented in a different way, which should be way
faster. Alsothere are now functions g_static_rec_mutex_unlock_full
and g_static_rec_mutex_lock_full to leave/enter a recursive mutex
completly.
* gthread.c (g_thread_self): Do not test the system_thread to be
non-zero to speed things up.
* gthread.c (g_mutex_init): Therefore set the system_thread of the
main thread here.
* tests/thread-test.c: Rerun all tests once again, but this time
we fool the system into thinking, that the available thread system
is not native, but userprovided.
* gthread/gthread-posix.c: Don't use priorities for threads,
when the minimal/maximal priorities couldn't be determined at
configure time.
* gthread/gthread-posix.c: Don't check for errors, when
setting the scope of a tread to system, as some posix
implementations can't do that and we don't want the thing to
fail because of that.
2000-03-17 15:49:59 +01:00
|
|
|
posix_priority_min=-1
|
|
|
|
posix_priority_max=-1
|
2000-02-13 08:18:23 +01:00
|
|
|
else
|
|
|
|
AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
|
2003-06-03 14:35:00 +02:00
|
|
|
AC_MSG_CHECKING(for pthread_setschedparam)
|
|
|
|
AC_TRY_LINK([#include <pthread.h>],
|
2003-06-11 15:34:40 +02:00
|
|
|
[pthread_t t; pthread_setschedparam(t, 0, NULL)],
|
2003-06-03 14:35:00 +02:00
|
|
|
[AC_MSG_RESULT(yes)
|
2000-10-16 03:02:19 +02:00
|
|
|
AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
|
2003-06-03 14:35:00 +02:00
|
|
|
AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])],
|
|
|
|
[AC_MSG_RESULT(no)
|
|
|
|
AC_MSG_WARN($POSIX_NO_PRIORITIES)])
|
2000-02-13 08:18:23 +01:00
|
|
|
fi
|
|
|
|
posix_yield_func=none
|
|
|
|
AC_MSG_CHECKING(for posix yield function)
|
2000-03-22 11:04:29 +01:00
|
|
|
for yield_func in sched_yield pthread_yield_np pthread_yield \
|
2000-02-13 08:18:23 +01:00
|
|
|
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)
|
2000-03-22 11:04:29 +01:00
|
|
|
posix_yield_func="g_usleep(1000)"
|
2000-02-13 08:18:23 +01:00
|
|
|
else
|
|
|
|
AC_MSG_RESULT($posix_yield_func)
|
|
|
|
posix_yield_func="$posix_yield_func()"
|
|
|
|
fi
|
2000-10-16 03:02:19 +02:00
|
|
|
AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func,[The POSIX RT yield function])
|
Added the missing POSIX_NO_YIELD and POSIX_NO_PRIORITIES warning messages.
2000-03-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in: Added the missing POSIX_NO_YIELD and
POSIX_NO_PRIORITIES warning messages.
* configure.in: Use AC_TRY_RUN instead of AC_TRY_LINK, to test for
real thread support. On solaris pthread_create can be linked to
even in -lc, but it doesn't work then.
* configure.in: Don't use priorities for threads, when the
minimal/maximal priorities couldn't be determined at configure
time.
* configure.in, gthread.c: Always define GSystemThread in
glibconfig.h to represent a system thread.
* configure.in: Do not use native recursive threads, when
possibe. We use some features, that they do not expose (namely the
depth counter).
* glib.h, gthread.c: Redefined GStaticRecMutex. The functions are
now implemented in a different way, which should be way
faster. Alsothere are now functions g_static_rec_mutex_unlock_full
and g_static_rec_mutex_lock_full to leave/enter a recursive mutex
completly.
* gthread.c (g_thread_self): Do not test the system_thread to be
non-zero to speed things up.
* gthread.c (g_mutex_init): Therefore set the system_thread of the
main thread here.
* tests/thread-test.c: Rerun all tests once again, but this time
we fool the system into thinking, that the available thread system
is not native, but userprovided.
* gthread/gthread-posix.c: Don't use priorities for threads,
when the minimal/maximal priorities couldn't be determined at
configure time.
* gthread/gthread-posix.c: Don't check for errors, when
setting the scope of a tread to system, as some posix
implementations can't do that and we don't want the thing to
fail because of that.
2000-03-17 15:49:59 +01:00
|
|
|
CPPFLAGS="$glib_save_CPPFLAGS"
|
2002-12-11 22:28:45 +01:00
|
|
|
|
2001-09-17 02:41:39 +02:00
|
|
|
elif test x"$have_threads" = xwin32; then
|
|
|
|
# It's a pointer to a private struct
|
|
|
|
GLIB_SIZEOF(,struct _GThreadData *, system_thread)
|
2000-02-13 08:18:23 +01:00
|
|
|
fi
|
|
|
|
|
|
|
|
LIBS="$glib_save_LIBS"
|
|
|
|
|
|
|
|
# now spit out all the warnings.
|
2000-11-15 18:48:43 +01:00
|
|
|
if test "$ac_cv_func_posix_getpwuid_r" != "yes" &&
|
|
|
|
test "$ac_cv_func_nonposix_getpwuid_r" != "yes"; then
|
2000-02-13 08:18:23 +01:00
|
|
|
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
|
Added the missing POSIX_NO_YIELD and POSIX_NO_PRIORITIES warning messages.
2000-03-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in: Added the missing POSIX_NO_YIELD and
POSIX_NO_PRIORITIES warning messages.
* configure.in: Use AC_TRY_RUN instead of AC_TRY_LINK, to test for
real thread support. On solaris pthread_create can be linked to
even in -lc, but it doesn't work then.
* configure.in: Don't use priorities for threads, when the
minimal/maximal priorities couldn't be determined at configure
time.
* configure.in, gthread.c: Always define GSystemThread in
glibconfig.h to represent a system thread.
* configure.in: Do not use native recursive threads, when
possibe. We use some features, that they do not expose (namely the
depth counter).
* glib.h, gthread.c: Redefined GStaticRecMutex. The functions are
now implemented in a different way, which should be way
faster. Alsothere are now functions g_static_rec_mutex_unlock_full
and g_static_rec_mutex_lock_full to leave/enter a recursive mutex
completly.
* gthread.c (g_thread_self): Do not test the system_thread to be
non-zero to speed things up.
* gthread.c (g_mutex_init): Therefore set the system_thread of the
main thread here.
* tests/thread-test.c: Rerun all tests once again, but this time
we fool the system into thinking, that the available thread system
is not native, but userprovided.
* gthread/gthread-posix.c: Don't use priorities for threads,
when the minimal/maximal priorities couldn't be determined at
configure time.
* gthread/gthread-posix.c: Don't check for errors, when
setting the scope of a tread to system, as some posix
implementations can't do that and we don't want the thing to
fail because of that.
2000-03-17 15:49:59 +01:00
|
|
|
fi
|
2000-02-13 08:18:23 +01:00
|
|
|
|
2001-11-28 17:47:26 +01:00
|
|
|
if test x"$glib_cv_sizeof_system_thread" = x; then
|
|
|
|
# use a pointer as a fallback.
|
|
|
|
GLIB_SIZEOF(,void *, system_thread)
|
|
|
|
fi
|
|
|
|
|
2002-12-16 23:14:40 +01:00
|
|
|
#
|
|
|
|
# Hack to deal with:
|
|
|
|
#
|
|
|
|
# a) GCC < 3.3 for Linux doesn't include -lpthread when
|
|
|
|
# building shared libraries with linux.
|
2007-09-16 18:15:34 +02:00
|
|
|
# b) FreeBSD doesn't do this either.
|
2002-12-16 23:14:40 +01:00
|
|
|
#
|
|
|
|
case $host in
|
2007-09-16 18:15:34 +02:00
|
|
|
*-*-freebsd*|*-*-linux*)
|
2002-12-16 23:14:40 +01:00
|
|
|
G_THREAD_LIBS_FOR_GTHREAD="`echo $G_THREAD_LIBS | sed s/-pthread/-lpthread/`"
|
|
|
|
;;
|
2005-02-24 05:24:16 +01:00
|
|
|
*)
|
|
|
|
G_THREAD_LIBS_FOR_GTHREAD="$G_THREAD_LIBS"
|
|
|
|
;;
|
2002-12-16 23:14:40 +01:00
|
|
|
esac
|
|
|
|
|
2010-01-12 21:28:23 +01:00
|
|
|
AM_CONDITIONAL(HAVE_THREADS, [test "$have_threads" != "none"])
|
2000-10-16 03:02:19 +02:00
|
|
|
AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
|
|
|
|
[Source file containing theread implementation])
|
2000-02-13 08:18:23 +01:00
|
|
|
AC_SUBST(G_THREAD_CFLAGS)
|
|
|
|
AC_SUBST(G_THREAD_LIBS)
|
2002-12-16 23:14:40 +01:00
|
|
|
AC_SUBST(G_THREAD_LIBS_FOR_GTHREAD)
|
2000-02-13 08:18:23 +01:00
|
|
|
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
|
2002-12-05 21:33:26 +01:00
|
|
|
if test $mutex_has_default = yes ; then
|
Added the missing POSIX_NO_YIELD and POSIX_NO_PRIORITIES warning messages.
2000-03-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in: Added the missing POSIX_NO_YIELD and
POSIX_NO_PRIORITIES warning messages.
* configure.in: Use AC_TRY_RUN instead of AC_TRY_LINK, to test for
real thread support. On solaris pthread_create can be linked to
even in -lc, but it doesn't work then.
* configure.in: Don't use priorities for threads, when the
minimal/maximal priorities couldn't be determined at configure
time.
* configure.in, gthread.c: Always define GSystemThread in
glibconfig.h to represent a system thread.
* configure.in: Do not use native recursive threads, when
possibe. We use some features, that they do not expose (namely the
depth counter).
* glib.h, gthread.c: Redefined GStaticRecMutex. The functions are
now implemented in a different way, which should be way
faster. Alsothere are now functions g_static_rec_mutex_unlock_full
and g_static_rec_mutex_lock_full to leave/enter a recursive mutex
completly.
* gthread.c (g_thread_self): Do not test the system_thread to be
non-zero to speed things up.
* gthread.c (g_mutex_init): Therefore set the system_thread of the
main thread here.
* tests/thread-test.c: Rerun all tests once again, but this time
we fool the system into thinking, that the available thread system
is not native, but userprovided.
* gthread/gthread-posix.c: Don't use priorities for threads,
when the minimal/maximal priorities couldn't be determined at
configure time.
* gthread/gthread-posix.c: Don't check for errors, when
setting the scope of a tread to system, as some posix
implementations can't do that and we don't want the thing to
fail because of that.
2000-03-17 15:49:59 +01:00
|
|
|
glib_save_CPPFLAGS="$CPPFLAGS"
|
|
|
|
glib_save_LIBS="$LIBS"
|
2002-12-13 05:11:32 +01:00
|
|
|
LIBS="$G_THREAD_LIBS $LIBS"
|
Added the missing POSIX_NO_YIELD and POSIX_NO_PRIORITIES warning messages.
2000-03-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in: Added the missing POSIX_NO_YIELD and
POSIX_NO_PRIORITIES warning messages.
* configure.in: Use AC_TRY_RUN instead of AC_TRY_LINK, to test for
real thread support. On solaris pthread_create can be linked to
even in -lc, but it doesn't work then.
* configure.in: Don't use priorities for threads, when the
minimal/maximal priorities couldn't be determined at configure
time.
* configure.in, gthread.c: Always define GSystemThread in
glibconfig.h to represent a system thread.
* configure.in: Do not use native recursive threads, when
possibe. We use some features, that they do not expose (namely the
depth counter).
* glib.h, gthread.c: Redefined GStaticRecMutex. The functions are
now implemented in a different way, which should be way
faster. Alsothere are now functions g_static_rec_mutex_unlock_full
and g_static_rec_mutex_lock_full to leave/enter a recursive mutex
completly.
* gthread.c (g_thread_self): Do not test the system_thread to be
non-zero to speed things up.
* gthread.c (g_mutex_init): Therefore set the system_thread of the
main thread here.
* tests/thread-test.c: Rerun all tests once again, but this time
we fool the system into thinking, that the available thread system
is not native, but userprovided.
* gthread/gthread-posix.c: Don't use priorities for threads,
when the minimal/maximal priorities couldn't be determined at
configure time.
* gthread/gthread-posix.c: Don't check for errors, when
setting the scope of a tread to system, as some posix
implementations can't do that and we don't want the thing to
fail because of that.
2000-03-17 15:49:59 +01:00
|
|
|
CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
|
2000-02-13 08:18:23 +01:00
|
|
|
GLIB_SIZEOF([#include <$mutex_header_file>],
|
|
|
|
$mutex_default_type,
|
2002-12-05 21:33:26 +01:00
|
|
|
gmutex)
|
2000-02-13 08:18:23 +01:00
|
|
|
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
|
Added the missing POSIX_NO_YIELD and POSIX_NO_PRIORITIES warning messages.
2000-03-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in: Added the missing POSIX_NO_YIELD and
POSIX_NO_PRIORITIES warning messages.
* configure.in: Use AC_TRY_RUN instead of AC_TRY_LINK, to test for
real thread support. On solaris pthread_create can be linked to
even in -lc, but it doesn't work then.
* configure.in: Don't use priorities for threads, when the
minimal/maximal priorities couldn't be determined at configure
time.
* configure.in, gthread.c: Always define GSystemThread in
glibconfig.h to represent a system thread.
* configure.in: Do not use native recursive threads, when
possibe. We use some features, that they do not expose (namely the
depth counter).
* glib.h, gthread.c: Redefined GStaticRecMutex. The functions are
now implemented in a different way, which should be way
faster. Alsothere are now functions g_static_rec_mutex_unlock_full
and g_static_rec_mutex_lock_full to leave/enter a recursive mutex
completly.
* gthread.c (g_thread_self): Do not test the system_thread to be
non-zero to speed things up.
* gthread.c (g_mutex_init): Therefore set the system_thread of the
main thread here.
* tests/thread-test.c: Rerun all tests once again, but this time
we fool the system into thinking, that the available thread system
is not native, but userprovided.
* gthread/gthread-posix.c: Don't use priorities for threads,
when the minimal/maximal priorities couldn't be determined at
configure time.
* gthread/gthread-posix.c: Don't check for errors, when
setting the scope of a tread to system, as some posix
implementations can't do that and we don't want the thing to
fail because of that.
2000-03-17 15:49:59 +01:00
|
|
|
CPPFLAGS="$glib_save_CPPFLAGS"
|
|
|
|
LIBS="$glib_save_LIBS"
|
2002-12-05 21:33:26 +01:00
|
|
|
fi
|
2000-02-13 08:18:23 +01:00
|
|
|
|
2006-12-17 19:39:10 +01:00
|
|
|
AC_CHECK_FUNCS(clock_gettime, [], [
|
|
|
|
AC_CHECK_LIB(rt, clock_gettime, [
|
|
|
|
AC_DEFINE(HAVE_CLOCK_GETTIME, 1)
|
2007-01-08 06:13:15 +01:00
|
|
|
G_THREAD_LIBS="$G_THREAD_LIBS -lrt"
|
2007-01-10 14:52:04 +01:00
|
|
|
G_THREAD_LIBS_FOR_GTHREAD="$G_THREAD_LIBS_FOR_GTHREAD -lrt"
|
2010-10-22 17:16:47 +02:00
|
|
|
GLIB_RT_LIBS="-lrt"
|
2006-12-17 19:39:10 +01:00
|
|
|
])
|
|
|
|
])
|
2010-10-22 17:16:47 +02:00
|
|
|
AC_SUBST(GLIB_RT_LIBS)
|
2006-12-17 19:39:10 +01:00
|
|
|
|
|
|
|
AC_CACHE_CHECK(for monotonic clocks,
|
2006-12-18 02:16:03 +01:00
|
|
|
glib_cv_monotonic_clock,AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
|
2006-12-17 19:39:10 +01:00
|
|
|
#include <time.h>
|
|
|
|
#include <unistd.h>
|
2006-12-18 02:16:03 +01:00
|
|
|
int main() {
|
2006-12-17 19:39:10 +01:00
|
|
|
#if !(defined(_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK >= 0 && defined(CLOCK_MONOTONIC))
|
|
|
|
#error No monotonic clock
|
|
|
|
#endif
|
2006-12-18 02:16:03 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
]])],glib_cv_monotonic_clock=yes,glib_cv_monotonic_clock=no))
|
2006-12-17 19:39:10 +01:00
|
|
|
if test "$glib_cv_monotonic_clock" = "yes"; then
|
|
|
|
AC_DEFINE(HAVE_MONOTONIC_CLOCK,1,[Have a monotonic clock])
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
2004-02-26 15:44:42 +01:00
|
|
|
dnl ********************************
|
|
|
|
dnl *** g_atomic_* tests for gcc ***
|
|
|
|
dnl ********************************
|
2004-02-26 15:30:35 +01:00
|
|
|
|
2004-02-29 17:47:48 +01:00
|
|
|
AC_MSG_CHECKING([whether to use assembler code for atomic operations])
|
2004-02-26 15:30:35 +01:00
|
|
|
|
2010-01-07 11:33:39 +01:00
|
|
|
glib_cv_gcc_has_builtin_atomic_operations=no
|
2004-02-26 15:30:35 +01:00
|
|
|
if test x"$GCC" = xyes; then
|
2010-01-07 11:33:39 +01:00
|
|
|
AC_MSG_CHECKING([whether GCC supports build-in atomic intrinsics])
|
|
|
|
AC_TRY_LINK([],
|
|
|
|
[int i;
|
|
|
|
__sync_synchronize ();
|
|
|
|
__sync_bool_compare_and_swap (&i, 0, 1);
|
|
|
|
__sync_fetch_and_add (&i, 1);
|
|
|
|
],
|
|
|
|
[glib_cv_gcc_has_builtin_atomic_operations=yes],
|
|
|
|
[glib_cv_gcc_has_builtin_atomic_operations=no])
|
|
|
|
|
|
|
|
AC_MSG_RESULT($glib_cv_gcc_has_builtin_atomic_operations)
|
|
|
|
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."
|
|
|
|
|
2011-05-02 17:44:46 +02:00
|
|
|
AC_LINK_IFELSE([AC_LANG_SOURCE([[
|
2010-01-07 11:33:39 +01:00
|
|
|
main ()
|
|
|
|
{
|
|
|
|
int tmp1, tmp2, tmp3;
|
|
|
|
__asm__ __volatile__("casx [%2], %0, %1"
|
|
|
|
: "=&r" (tmp1), "=&r" (tmp2) : "r" (&tmp3));
|
2011-05-02 17:44:46 +02:00
|
|
|
}]])],
|
2010-01-07 11:33:39 +01:00
|
|
|
AC_MSG_RESULT([sparcv9])
|
|
|
|
AC_DEFINE_UNQUOTED(G_ATOMIC_SPARCV9, 1,
|
|
|
|
[sparcv9 atomic implementation]),
|
|
|
|
AC_MSG_RESULT([no])
|
|
|
|
AC_MSG_WARN([[$SPARCV9_WARNING]]))
|
|
|
|
glib_memory_barrier_needed=yes
|
|
|
|
;;
|
|
|
|
alpha*)
|
|
|
|
AC_MSG_RESULT([alpha])
|
|
|
|
AC_DEFINE_UNQUOTED(G_ATOMIC_ALPHA, 1,
|
|
|
|
[alpha atomic implementation])
|
|
|
|
glib_memory_barrier_needed=yes
|
|
|
|
;;
|
|
|
|
x86_64)
|
|
|
|
AC_MSG_RESULT([x86_64])
|
|
|
|
AC_DEFINE_UNQUOTED(G_ATOMIC_X86_64, 1,
|
|
|
|
[x86_64 atomic implementation])
|
|
|
|
glib_memory_barrier_needed=no
|
|
|
|
;;
|
|
|
|
powerpc*)
|
|
|
|
AC_MSG_RESULT([powerpc])
|
|
|
|
AC_DEFINE_UNQUOTED(G_ATOMIC_POWERPC, 1,
|
|
|
|
[powerpc atomic implementation])
|
|
|
|
glib_memory_barrier_needed=yes
|
|
|
|
AC_MSG_CHECKING([whether asm supports numbered local labels])
|
|
|
|
AC_TRY_COMPILE(
|
|
|
|
,[
|
|
|
|
__asm__ __volatile__ ("1: nop\n"
|
|
|
|
" bne- 1b")
|
|
|
|
],[
|
|
|
|
AC_DEFINE_UNQUOTED(ASM_NUMERIC_LABELS, 1, [define if asm blocks can use numeric local labels])
|
|
|
|
AC_MSG_RESULT([yes])
|
|
|
|
],[
|
|
|
|
AC_MSG_RESULT([no])
|
|
|
|
])
|
|
|
|
;;
|
|
|
|
ia64)
|
|
|
|
AC_MSG_RESULT([ia64])
|
|
|
|
AC_DEFINE_UNQUOTED(G_ATOMIC_IA64, 1,
|
|
|
|
[ia64 atomic implementation])
|
|
|
|
glib_memory_barrier_needed=yes
|
|
|
|
;;
|
|
|
|
s390|s390x)
|
|
|
|
AC_MSG_RESULT([s390])
|
|
|
|
AC_DEFINE_UNQUOTED(G_ATOMIC_S390, 1,
|
|
|
|
[s390 atomic implementation])
|
|
|
|
glib_memory_barrier_needed=no
|
|
|
|
;;
|
|
|
|
arm*)
|
|
|
|
AC_MSG_RESULT([arm])
|
|
|
|
AC_DEFINE_UNQUOTED(G_ATOMIC_ARM, 1,
|
|
|
|
[arm atomic implementation])
|
|
|
|
glib_memory_barrier_needed=no
|
|
|
|
;;
|
|
|
|
crisv32*|etraxfs*)
|
|
|
|
AC_MSG_RESULT([crisv32])
|
|
|
|
AC_DEFINE_UNQUOTED(G_ATOMIC_CRISV32, 1,
|
|
|
|
[crisv32 atomic implementation])
|
|
|
|
glib_memory_barrier_needed=no
|
|
|
|
;;
|
|
|
|
cris*|etrax*)
|
|
|
|
AC_MSG_RESULT([cris])
|
|
|
|
AC_DEFINE_UNQUOTED(G_ATOMIC_CRIS, 1,
|
|
|
|
[cris atomic implementation])
|
|
|
|
glib_memory_barrier_needed=no
|
|
|
|
;;
|
|
|
|
*)
|
|
|
|
AC_MSG_RESULT([none])
|
|
|
|
glib_memory_barrier_needed=yes
|
|
|
|
;;
|
|
|
|
esac
|
2008-05-20 10:03:03 +02:00
|
|
|
else
|
|
|
|
if test $glib_native_win32 = yes; then
|
|
|
|
# For Windows but not using gcc. No barriers needed then either.
|
|
|
|
glib_memory_barrier_needed=no
|
|
|
|
fi
|
2004-02-26 15:30:35 +01:00
|
|
|
fi
|
|
|
|
|
2010-01-07 11:33:39 +01:00
|
|
|
AM_CONDITIONAL(HAVE_GCC_BUILTINS_FOR_ATOMIC_OPERATIONS,
|
|
|
|
[test $glib_cv_gcc_has_builtin_atomic_operations = yes])
|
|
|
|
|
2010-01-28 17:32:07 +01:00
|
|
|
dnl ************************
|
|
|
|
dnl ** Check for futex(2) **
|
|
|
|
dnl ************************
|
2011-06-22 05:24:07 +02:00
|
|
|
AC_CACHE_CHECK(for futex(2) system call,
|
|
|
|
glib_cv_futex,AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
|
2010-01-28 17:32:07 +01:00
|
|
|
#include <linux/futex.h>
|
2011-05-28 23:27:12 +02:00
|
|
|
#include <sys/syscall.h>
|
2010-01-28 17:32:07 +01:00
|
|
|
#include <unistd.h>
|
2011-05-02 17:44:46 +02:00
|
|
|
],[
|
2010-01-28 17:32:07 +01:00
|
|
|
int
|
|
|
|
main (void)
|
|
|
|
{
|
2011-05-22 22:31:43 +02:00
|
|
|
/* it is not like this actually runs or anything... */
|
2011-05-28 23:27:12 +02:00
|
|
|
syscall (__NR_futex, NULL, FUTEX_WAKE, FUTEX_WAIT);
|
2010-01-28 17:32:07 +01:00
|
|
|
return 0;
|
|
|
|
}
|
2011-06-22 05:24:07 +02:00
|
|
|
])],glib_cv_futex=yes,glib_cv_futex=no))
|
|
|
|
if test x"$glib_cv_futex" = xyes; then
|
2011-05-28 23:27:12 +02:00
|
|
|
AC_DEFINE(HAVE_FUTEX, 1, [we have the futex(2) system call])
|
2011-06-22 05:24:07 +02:00
|
|
|
fi
|
2010-01-28 17:32:07 +01:00
|
|
|
|
2011-06-22 05:24:07 +02:00
|
|
|
AC_CACHE_CHECK(for eventfd(2) system call,
|
|
|
|
glib_cv_eventfd,AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
|
2011-06-22 01:01:10 +02:00
|
|
|
#include <sys/eventfd.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
],[
|
|
|
|
int
|
|
|
|
main (void)
|
|
|
|
{
|
|
|
|
eventfd (0, EFD_CLOEXEC);
|
|
|
|
return 0;
|
|
|
|
}
|
2011-06-22 05:24:07 +02:00
|
|
|
])],glib_cv_eventfd=yes,glib_cv_eventfd=no))
|
|
|
|
if test x"$glib_cv_eventfd" = x"yes"; then
|
2011-06-22 01:01:10 +02:00
|
|
|
AC_DEFINE(HAVE_EVENTFD, 1, [we have the eventfd(2) system call])
|
2011-06-22 05:24:07 +02:00
|
|
|
fi
|
2011-06-22 01:01:10 +02:00
|
|
|
|
2000-02-13 08:18:23 +01:00
|
|
|
dnl ****************************************
|
|
|
|
dnl *** GLib POLL* compatibility defines ***
|
|
|
|
dnl ****************************************
|
2002-12-05 21:33:26 +01:00
|
|
|
|
|
|
|
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
|
2000-02-13 08:18:23 +01:00
|
|
|
|
2006-12-19 16:28:17 +01:00
|
|
|
AC_MSG_CHECKING([for broken poll])
|
|
|
|
AC_RUN_IFELSE([AC_LANG_SOURCE([[
|
2006-12-12 21:04:45 +01:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <poll.h>
|
2006-12-19 16:28:17 +01:00
|
|
|
#ifdef HAVE_SYS_POLL_H
|
|
|
|
#include <sys/poll.h>
|
|
|
|
#endif
|
2006-12-12 21:04:45 +01:00
|
|
|
int main(void) {
|
|
|
|
struct pollfd fds[1];
|
|
|
|
int fd;
|
|
|
|
fd = open("/dev/null", 1);
|
|
|
|
fds[0].fd = fd;
|
|
|
|
fds[0].events = POLLIN;
|
|
|
|
fds[0].revents = 0;
|
|
|
|
if (poll(fds, 1, 0) < 0 || (fds[0].revents & POLLNVAL) != 0) {
|
|
|
|
exit(1); /* Does not work for devices -- fail */
|
|
|
|
}
|
|
|
|
exit(0);
|
2006-12-19 16:28:17 +01:00
|
|
|
}]])],
|
|
|
|
[broken_poll=no],
|
|
|
|
[broken_poll=yes
|
|
|
|
AC_DEFINE(BROKEN_POLL,1,[poll doesn't work on devices])],
|
|
|
|
[broken_poll="no (cross compiling)"])
|
|
|
|
AC_MSG_RESULT($broken_poll)
|
2006-12-12 21:04:45 +01:00
|
|
|
|
2007-03-15 14:01:31 +01:00
|
|
|
dnl *********************
|
|
|
|
dnl *** GRegex checks ***
|
|
|
|
dnl *********************
|
2011-01-22 16:36:13 +01:00
|
|
|
PCRE_REQUIRED_VERSION=8.11
|
2007-03-15 14:01:31 +01:00
|
|
|
|
|
|
|
# Check if we should compile GRegex
|
|
|
|
AC_ARG_ENABLE(regex, AC_HELP_STRING([--disable-regex],
|
|
|
|
[disable the compilation of GRegex]),
|
|
|
|
[case "${enableval}" in
|
|
|
|
yes) enable_regex=true ;;
|
|
|
|
no) enable_regex=false ;;
|
|
|
|
*) AC_MSG_ERROR(bad value ${enableval} for --enable-regex) ;;
|
|
|
|
esac],
|
|
|
|
[enable_regex=true])
|
|
|
|
|
|
|
|
AM_CONDITIONAL(ENABLE_REGEX, $enable_regex)
|
|
|
|
|
|
|
|
if test x$enable_regex = xtrue; then
|
2009-01-18 07:53:44 +01:00
|
|
|
AC_DEFINE(ENABLE_REGEX, [], [include GRegex])
|
2007-03-15 14:01:31 +01:00
|
|
|
# Check if we should use the internal or the system-supplied pcre
|
|
|
|
AC_ARG_WITH(pcre,
|
|
|
|
[AC_HELP_STRING([--with-pcre=@<:@internal/system@:>@],
|
|
|
|
[specify whether to use the internal or the
|
|
|
|
system-supplied PCRE library])])
|
|
|
|
|
|
|
|
AM_CONDITIONAL(USE_SYSTEM_PCRE, [test "x$with_pcre" = xsystem])
|
|
|
|
|
|
|
|
if test "x$with_pcre" = xsystem; then
|
|
|
|
PKG_CHECK_MODULES(PCRE,
|
|
|
|
libpcre >= $PCRE_REQUIRED_VERSION)
|
|
|
|
AC_CACHE_CHECK([for Unicode support in PCRE],glib_cv_pcre_has_unicode,[
|
2007-09-11 22:10:31 +02:00
|
|
|
glib_save_CFLAGS="$CFLAGS"
|
2008-01-27 23:49:25 +01:00
|
|
|
glib_save_LIBS="$LIBS"
|
|
|
|
CFLAGS="$CFLAGS $PCRE_CFLAGS" LIBS="$PCRE_LIBS"
|
2007-03-15 14:01:31 +01:00
|
|
|
AC_TRY_RUN([#include <pcre.h>
|
|
|
|
int main () {
|
|
|
|
int support;
|
|
|
|
pcre_config (PCRE_CONFIG_UTF8, &support);
|
|
|
|
if (!support)
|
|
|
|
return 1;
|
|
|
|
pcre_config (PCRE_CONFIG_UNICODE_PROPERTIES, &support);
|
|
|
|
if (!support)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}],
|
|
|
|
glib_cv_pcre_has_unicode=yes,
|
|
|
|
glib_cv_pcre_has_unicode=no,
|
2007-09-11 22:10:31 +02:00
|
|
|
glib_cv_pcre_has_unicode=yes)
|
2007-09-11 22:22:18 +02:00
|
|
|
CFLAGS="$glib_save_CFLAGS"
|
2008-01-27 23:49:25 +01:00
|
|
|
LIBS="$glib_save_LIBS"
|
2007-09-11 22:10:31 +02:00
|
|
|
])
|
2007-03-15 14:01:31 +01:00
|
|
|
if test "$glib_cv_pcre_has_unicode" = "no"; then
|
|
|
|
AC_MSG_ERROR([*** The system-supplied PCRE does not support Unicode properties or UTF-8.])
|
|
|
|
fi
|
|
|
|
AC_SUBST(PCRE_CFLAGS)
|
|
|
|
AC_SUBST(PCRE_LIBS)
|
|
|
|
AC_DEFINE(USE_SYSTEM_PCRE, [], [using the system-supplied PCRE library])
|
2007-09-16 17:48:11 +02:00
|
|
|
PCRE_REQUIRES=libpcre
|
|
|
|
AC_SUBST(PCRE_REQUIRES)
|
2007-03-15 14:01:31 +01:00
|
|
|
else
|
|
|
|
# If using gcc 4 pass -Wno-pointer-sign when compiling the internal PCRE
|
|
|
|
if test x"$GCC" = xyes; then
|
2007-05-30 04:45:22 +02:00
|
|
|
AC_MSG_CHECKING([whether compiler understands -Wno-pointer-sign])
|
|
|
|
save_CFLAGS="$CFLAGS"
|
|
|
|
CFLAGS="$CFLAGS -Wno-pointer-sign"
|
|
|
|
AC_TRY_COMPILE([],[],[PCRE_WARN_CFLAGS="$PCRE_WARN_CFLAGS -Wno-pointer-sign"
|
|
|
|
AC_MSG_RESULT(yes)],[AC_MSG_RESULT(no)])
|
|
|
|
CFLAGS="$save_CFLAGS"
|
2007-03-15 14:01:31 +01:00
|
|
|
fi
|
|
|
|
fi
|
|
|
|
AC_SUBST(PCRE_WARN_CFLAGS)
|
|
|
|
else
|
|
|
|
AM_CONDITIONAL(USE_SYSTEM_PCRE, false])
|
|
|
|
fi
|
|
|
|
|
2001-03-09 22:18:33 +01:00
|
|
|
dnl **********************
|
|
|
|
dnl *** Win32 API libs ***
|
|
|
|
dnl **********************
|
|
|
|
|
|
|
|
case $host in
|
|
|
|
*-*-cygwin*)
|
2002-08-26 21:39:28 +02:00
|
|
|
G_LIBS_EXTRA="-luser32 -lkernel32"
|
2001-03-09 22:18:33 +01:00
|
|
|
;;
|
|
|
|
*-*-mingw*)
|
2005-02-05 23:39:40 +01:00
|
|
|
G_LIBS_EXTRA="-lws2_32 -lole32"
|
2001-03-09 22:18:33 +01:00
|
|
|
;;
|
|
|
|
*)
|
|
|
|
G_LIBS_EXTRA=""
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
AC_SUBST(G_LIBS_EXTRA)
|
|
|
|
|
2000-11-13 00:44:28 +01:00
|
|
|
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)
|
|
|
|
|
2002-05-07 17:41:24 +02:00
|
|
|
dnl ******************************************************************
|
2010-06-15 06:38:35 +02:00
|
|
|
dnl *** If we are cross-compiling, look for glib-genmarshal and ***
|
|
|
|
dnl *** glib-compile-schemas in PATH ***
|
2002-05-07 17:41:24 +02:00
|
|
|
dnl ******************************************************************
|
|
|
|
|
2002-05-08 17:19:45 +02:00
|
|
|
AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
|
2002-05-07 17:41:24 +02:00
|
|
|
|
2002-05-08 17:19:45 +02:00
|
|
|
if test $cross_compiling = yes; then
|
2002-05-07 17:41:24 +02:00
|
|
|
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
|
2010-06-15 06:38:35 +02:00
|
|
|
|
2010-06-19 04:59:43 +02:00
|
|
|
AC_PATH_PROG(GLIB_COMPILE_SCHEMAS, glib-compile-schemas, no)
|
2010-06-15 06:38:35 +02:00
|
|
|
if test x$GLIB_COMPILE_SCHEMAS = xno; then
|
|
|
|
AC_MSG_ERROR(Could not find a glib-compile-schemas in your PATH)
|
|
|
|
fi
|
2002-05-07 17:41:24 +02:00
|
|
|
fi
|
|
|
|
|
2000-09-06 02:17:41 +02:00
|
|
|
dnl **************************
|
|
|
|
dnl *** Checks for gtk-doc ***
|
|
|
|
dnl **************************
|
|
|
|
|
2010-07-12 21:30:26 +02:00
|
|
|
GTK_DOC_CHECK([1.15])
|
2000-02-13 08:18:23 +01:00
|
|
|
|
2003-06-18 01:08:37 +02:00
|
|
|
AC_ARG_ENABLE(man,
|
|
|
|
[AC_HELP_STRING([--enable-man],
|
|
|
|
[regenerate man pages from Docbook [default=no]])],enable_man=yes,
|
|
|
|
enable_man=no)
|
2004-02-14 02:04:47 +01:00
|
|
|
|
|
|
|
if test "${enable_man}" != no; then
|
2003-06-18 01:08:37 +02:00
|
|
|
dnl
|
|
|
|
dnl Check for xsltproc
|
|
|
|
dnl
|
|
|
|
AC_PATH_PROG([XSLTPROC], [xsltproc])
|
2004-02-14 02:04:47 +01:00
|
|
|
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)
|
2003-06-18 01:08:37 +02:00
|
|
|
fi
|
|
|
|
|
|
|
|
AM_CONDITIONAL(ENABLE_MAN, test x$enable_man != xno)
|
|
|
|
|
2009-12-18 21:25:47 +01:00
|
|
|
dnl
|
|
|
|
dnl Tracing
|
|
|
|
dnl
|
|
|
|
|
|
|
|
AC_ARG_ENABLE([dtrace],
|
|
|
|
[AS_HELP_STRING([--enable-dtrace],
|
|
|
|
[Enable inclusion of dtrace trace support])])
|
|
|
|
have_dtrace=no
|
|
|
|
AC_MSG_CHECKING([whether to include dtrace tracing support])
|
|
|
|
if test "x$enable_dtrace" != xno; then
|
2010-06-25 15:37:06 +02:00
|
|
|
if test x$glib_have_carbon = xyes; then
|
|
|
|
AC_MSG_RESULT([no (not yet compatible with MacOS dtrace)])
|
|
|
|
else
|
|
|
|
AC_MSG_RESULT([yes])
|
|
|
|
AC_CHECK_PROGS(DTRACE, dtrace)
|
|
|
|
if test -z "$DTRACE"; then
|
|
|
|
if test "x$enable_dtrace" = xyes; then
|
|
|
|
AC_MSG_ERROR([dtrace not found])
|
|
|
|
fi
|
2010-09-28 11:53:03 +02:00
|
|
|
else
|
|
|
|
AC_CHECK_HEADER([sys/sdt.h],have_dtrace=yes,
|
|
|
|
[if test "x$enable_dtrace" = xyes; then
|
|
|
|
AC_MSG_ERROR([dtrace support needs sys/sdt.h header])
|
|
|
|
fi])
|
2009-12-18 21:25:47 +01:00
|
|
|
fi
|
|
|
|
fi
|
|
|
|
else
|
|
|
|
AC_MSG_RESULT([no])
|
|
|
|
fi
|
|
|
|
if test "x$have_dtrace" = xyes; then
|
|
|
|
AC_DEFINE([HAVE_DTRACE], [1], [Define to 1 if using dtrace probes.])
|
|
|
|
fi
|
|
|
|
AM_CONDITIONAL([ENABLE_DTRACE], [test x$have_dtrace = xyes ])
|
|
|
|
|
|
|
|
AC_MSG_CHECKING([whether to include systemtap tracing support])
|
|
|
|
AC_ARG_ENABLE([systemtap],
|
|
|
|
[AS_HELP_STRING([--enable-systemtap],
|
|
|
|
[Enable inclusion of systemtap trace support])])
|
|
|
|
have_systemtap=no
|
|
|
|
if test "x$enable_systemtap" != xno -a "x$have_dtrace" = xyes; then
|
|
|
|
have_systemtap=yes
|
|
|
|
fi
|
|
|
|
AC_MSG_RESULT(${have_systemtap})
|
|
|
|
|
|
|
|
AM_CONDITIONAL([ENABLE_SYSTEMTAP], [test x$have_systemtap = xyes])
|
|
|
|
|
|
|
|
AC_ARG_WITH([tapset-install-dir],
|
|
|
|
[AS_HELP_STRING([--with-tapset-install-dir],
|
|
|
|
[The absolute path where the systemtap tapsets will be installed])],
|
|
|
|
[if test "x${withval}" = x; then
|
|
|
|
ABS_TAPSET_DIR="\$(datadir)/systemtap/tapset"
|
|
|
|
else
|
|
|
|
ABS_TAPSET_DIR="${withval}"
|
|
|
|
fi],
|
|
|
|
[ABS_TAPSET_DIR="\$(datadir)/systemtap/tapset"])
|
|
|
|
AC_SUBST(ABS_TAPSET_DIR)
|
|
|
|
|
2010-06-21 04:46:47 +02:00
|
|
|
dnl ************************************
|
|
|
|
dnl *** Enable lcov coverage reports ***
|
|
|
|
dnl ************************************
|
|
|
|
|
|
|
|
AC_ARG_ENABLE(gcov,
|
|
|
|
AS_HELP_STRING([--enable-gcov],
|
|
|
|
[Enable gcov]),
|
|
|
|
[use_gcov=$enableval], [use_gcov=no])
|
|
|
|
|
|
|
|
if test "x$use_gcov" = "xyes"; then
|
|
|
|
dnl we need gcc:
|
|
|
|
if test "$GCC" != "yes"; then
|
|
|
|
AC_MSG_ERROR([GCC is required for --enable-gcov])
|
|
|
|
fi
|
|
|
|
|
|
|
|
dnl Check if ccache is being used
|
|
|
|
AC_CHECK_PROG(SHTOOL, shtool, shtool)
|
|
|
|
case `$SHTOOL path $CC` in
|
|
|
|
*ccache*[)] gcc_ccache=yes;;
|
|
|
|
*[)] gcc_ccache=no;;
|
|
|
|
esac
|
|
|
|
|
|
|
|
if test "$gcc_ccache" = "yes" && (test -z "$CCACHE_DISABLE" || test "$CCACHE_DISABLE" != "1"); then
|
|
|
|
AC_MSG_ERROR([ccache must be disabled when --enable-gcov option is used. You can disable ccache by setting environment variable CCACHE_DISABLE=1.])
|
|
|
|
fi
|
|
|
|
|
|
|
|
ltp_version_list="1.6 1.7 1.8"
|
|
|
|
AC_CHECK_PROG(LTP, lcov, lcov)
|
|
|
|
AC_CHECK_PROG(LTP_GENHTML, genhtml, genhtml)
|
|
|
|
|
|
|
|
if test "$LTP"; then
|
|
|
|
AC_CACHE_CHECK([for ltp version], glib_cv_ltp_version, [
|
|
|
|
glib_cv_ltp_version=invalid
|
|
|
|
ltp_version=`$LTP -v 2>/dev/null | $SED -e 's/^.* //'`
|
|
|
|
for ltp_check_version in $ltp_version_list; do
|
|
|
|
if test "$ltp_version" = "$ltp_check_version"; then
|
|
|
|
glib_cv_ltp_version="$ltp_check_version (ok)"
|
|
|
|
fi
|
|
|
|
done
|
|
|
|
])
|
|
|
|
else
|
|
|
|
ltp_msg="To enable code coverage reporting you must have one of the following LTP versions installed: $ltp_version_list"
|
|
|
|
AC_MSG_ERROR([$ltp_msg])
|
|
|
|
fi
|
|
|
|
|
|
|
|
case $glib_cv_ltp_version in
|
|
|
|
""|invalid[)]
|
|
|
|
ltp_msg="You must have one of the following versions of LTP: $ltp_version_list (found: $ltp_version)."
|
|
|
|
AC_MSG_ERROR([$ltp_msg])
|
|
|
|
LTP="exit 0;"
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
|
|
|
|
if test -z "$LTP_GENHTML"; then
|
|
|
|
AC_MSG_ERROR([Could not find genhtml from the LTP package])
|
|
|
|
fi
|
|
|
|
|
|
|
|
AC_DEFINE(HAVE_GCOV, 1, [Whether you have gcov])
|
|
|
|
|
|
|
|
dnl Remove all optimization flags from CFLAGS
|
|
|
|
changequote({,})
|
|
|
|
CFLAGS=`echo "$CFLAGS" | $SED -e 's/-O[0-9]*//g'`
|
|
|
|
changequote([,])
|
|
|
|
|
|
|
|
dnl Add the special gcc flags
|
|
|
|
CFLAGS="$CFLAGS -O0 -fprofile-arcs -ftest-coverage"
|
|
|
|
LDFLAGS="$LDFLAGS -lgcov"
|
|
|
|
fi
|
|
|
|
|
2000-02-13 08:18:23 +01:00
|
|
|
dnl ******************************
|
|
|
|
dnl *** output the whole stuff ***
|
|
|
|
dnl ******************************
|
|
|
|
|
2003-03-04 11:10:48 +01:00
|
|
|
dnl this section will only be run if config.status is invoked with no
|
2010-07-12 03:08:42 +02:00
|
|
|
dnl arguments, or with "glib/glibconfig.h" as an argument.
|
|
|
|
AC_CONFIG_COMMANDS([glib/glibconfig.h],
|
2003-03-04 11:10:48 +01:00
|
|
|
[
|
2010-07-12 03:08:42 +02:00
|
|
|
outfile=glib/glibconfig.h-tmp
|
2000-02-13 08:18:23 +01:00
|
|
|
cat > $outfile <<\_______EOF
|
|
|
|
/* glibconfig.h
|
|
|
|
*
|
2010-07-13 17:59:16 +02:00
|
|
|
* This is a generated file. Please modify 'configure.ac'
|
2000-02-13 08:18:23 +01:00
|
|
|
*/
|
|
|
|
|
Split glib.h into many header files mostly according to the resp.
2000-10-12 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* glib.h, galloca.h, garray.h, gasyncqueue.h, gbacktrace.h,
gcache.h, gcompletion.h, gconvert.h, gdataset.h, gdate.h, ghash.h,
ghook.h, giochannel.h, glist.h , gmacros.h, gmain.h, gmem.h,
gmessages.h, gnode.h, gprimes.h, gquark.h, gqueue.h, grand.h,
grel.h, gscanner.h, gslist.h, gstrfuncs.h, gstring.h, gthread.h,
gthreadpool.h, gtimer.h, gtree.h, gtypes.h, gutils.h: Split glib.h
into many header files mostly according to the resp. *.c-files.
* gmacros.h: Added G_BEGIN_DECLS and G_END_DECLS to mean: 'in case
of C++: extern "C" { ... }' analogous to glibc __BEGIN_DECLS and
__END_DECLS.
* configure.in, gerror.h, gfileutils.h, gshell.h, gspawn.h,
gunicode.h, : Changed guard-macro names to something more
consistent.
* configure.in, *.h: Use G_BEGIN_DECLS and G_END_DECLS.
2000-10-12 13:52:07 +02:00
|
|
|
#ifndef __G_LIBCONFIG_H__
|
|
|
|
#define __G_LIBCONFIG_H__
|
|
|
|
|
2001-06-26 18:01:21 +02:00
|
|
|
#include <glib/gmacros.h>
|
2000-02-13 08:18:23 +01:00
|
|
|
|
|
|
|
_______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
|
2000-09-18 00:18:48 +02:00
|
|
|
if test "$glib_header_alloca_h" = "yes"; then
|
2000-10-12 10:06:16 +02:00
|
|
|
echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
|
2000-09-18 00:18:48 +02:00
|
|
|
fi
|
2000-02-13 08:18:23 +01:00
|
|
|
if test x$glib_sys_poll_h = xyes; then
|
|
|
|
echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
|
|
|
|
fi
|
2008-07-24 02:29:56 +02:00
|
|
|
if test x$glib_included_printf != xyes; then
|
2008-06-26 17:03:05 +02:00
|
|
|
echo "
|
|
|
|
/* Specifies that GLib's g_print*() functions wrap the
|
|
|
|
* system printf functions. This is useful to know, for example,
|
|
|
|
* when using glibc's register_printf_function().
|
|
|
|
*/" >> $outfile
|
|
|
|
echo '#define GLIB_USING_SYSTEM_PRINTF' >> $outfile
|
|
|
|
fi
|
2000-02-13 08:18:23 +01:00
|
|
|
|
|
|
|
cat >> $outfile <<_______EOF
|
|
|
|
|
Split glib.h into many header files mostly according to the resp.
2000-10-12 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* glib.h, galloca.h, garray.h, gasyncqueue.h, gbacktrace.h,
gcache.h, gcompletion.h, gconvert.h, gdataset.h, gdate.h, ghash.h,
ghook.h, giochannel.h, glist.h , gmacros.h, gmain.h, gmem.h,
gmessages.h, gnode.h, gprimes.h, gquark.h, gqueue.h, grand.h,
grel.h, gscanner.h, gslist.h, gstrfuncs.h, gstring.h, gthread.h,
gthreadpool.h, gtimer.h, gtree.h, gtypes.h, gutils.h: Split glib.h
into many header files mostly according to the resp. *.c-files.
* gmacros.h: Added G_BEGIN_DECLS and G_END_DECLS to mean: 'in case
of C++: extern "C" { ... }' analogous to glibc __BEGIN_DECLS and
__END_DECLS.
* configure.in, gerror.h, gfileutils.h, gshell.h, gspawn.h,
gunicode.h, : Changed guard-macro names to something more
consistent.
* configure.in, *.h: Use G_BEGIN_DECLS and G_END_DECLS.
2000-10-12 13:52:07 +02:00
|
|
|
G_BEGIN_DECLS
|
2000-07-19 16:01:22 +02:00
|
|
|
|
2000-02-13 08:18:23 +01:00
|
|
|
#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;
|
2003-07-29 01:00:05 +02:00
|
|
|
#define G_GINT16_MODIFIER $gint16_modifier
|
2000-02-13 08:18:23 +01:00
|
|
|
#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;
|
2003-07-29 01:00:05 +02:00
|
|
|
#define G_GINT32_MODIFIER $gint32_modifier
|
2000-02-13 08:18:23 +01:00
|
|
|
#define G_GINT32_FORMAT $gint32_format
|
|
|
|
#define G_GUINT32_FORMAT $guint32_format
|
|
|
|
_______EOF
|
|
|
|
fi
|
|
|
|
|
2001-10-11 04:43:40 +02:00
|
|
|
cat >>$outfile <<_______EOF
|
|
|
|
#define G_HAVE_GINT64 1 /* deprecated, always true */
|
2000-02-13 08:18:23 +01:00
|
|
|
|
|
|
|
${glib_extension}typedef signed $gint64 gint64;
|
|
|
|
${glib_extension}typedef unsigned $gint64 guint64;
|
|
|
|
|
2000-09-28 09:45:04 +02:00
|
|
|
#define G_GINT64_CONSTANT(val) $gint64_constant
|
2005-12-02 22:25:45 +01:00
|
|
|
#define G_GUINT64_CONSTANT(val) $guint64_constant
|
2002-02-09 05:59:54 +01:00
|
|
|
_______EOF
|
2001-10-11 04:43:40 +02:00
|
|
|
|
2002-02-09 05:59:54 +01:00
|
|
|
if test x$gint64_format != x ; then
|
|
|
|
cat >>$outfile <<_______EOF
|
2003-07-29 01:00:05 +02:00
|
|
|
#define G_GINT64_MODIFIER $gint64_modifier
|
2000-02-13 08:18:23 +01:00
|
|
|
#define G_GINT64_FORMAT $gint64_format
|
|
|
|
#define G_GUINT64_FORMAT $guint64_format
|
|
|
|
_______EOF
|
2002-02-09 05:59:54 +01:00
|
|
|
else
|
|
|
|
cat >>$outfile <<_______EOF
|
2003-07-29 01:00:05 +02:00
|
|
|
#undef G_GINT64_MODIFIER
|
2002-02-09 05:59:54 +01:00
|
|
|
#undef G_GINT64_FORMAT
|
|
|
|
#undef G_GUINT64_FORMAT
|
|
|
|
_______EOF
|
|
|
|
fi
|
2000-02-13 08:18:23 +01:00
|
|
|
|
2000-12-29 03:16:51 +01:00
|
|
|
cat >>$outfile <<_______EOF
|
|
|
|
|
|
|
|
#define GLIB_SIZEOF_VOID_P $glib_void_p
|
|
|
|
#define GLIB_SIZEOF_LONG $glib_long
|
2001-11-26 10:19:17 +01:00
|
|
|
#define GLIB_SIZEOF_SIZE_T $glib_size_t
|
2000-12-29 03:16:51 +01:00
|
|
|
|
|
|
|
_______EOF
|
|
|
|
|
2003-11-21 00:12:05 +01:00
|
|
|
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
|
2004-01-12 01:16:18 +01:00
|
|
|
|
|
|
|
#define G_MAXSIZE G_MAXU$glib_msize_type
|
2007-07-20 18:41:47 +02:00
|
|
|
#define G_MINSSIZE G_MIN$glib_msize_type
|
|
|
|
#define G_MAXSSIZE G_MAX$glib_msize_type
|
|
|
|
|
|
|
|
typedef gint64 goffset;
|
|
|
|
#define G_MINOFFSET G_MININT64
|
|
|
|
#define G_MAXOFFSET G_MAXINT64
|
|
|
|
|
2009-01-28 15:09:18 +01:00
|
|
|
#define G_GOFFSET_MODIFIER G_GINT64_MODIFIER
|
|
|
|
#define G_GOFFSET_FORMAT G_GINT64_FORMAT
|
|
|
|
#define G_GOFFSET_CONSTANT(val) G_GINT64_CONSTANT(val)
|
|
|
|
|
2003-11-21 00:12:05 +01:00
|
|
|
_______EOF
|
2000-02-13 08:18:23 +01:00
|
|
|
|
|
|
|
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))
|
2008-07-30 17:30:26 +02:00
|
|
|
|
|
|
|
typedef signed $glib_intptr_type_define gintptr;
|
|
|
|
typedef unsigned $glib_intptr_type_define guintptr;
|
2009-01-27 20:39:37 +01:00
|
|
|
|
|
|
|
#define G_GINTPTR_MODIFIER $gintptr_modifier
|
|
|
|
#define G_GINTPTR_FORMAT $gintptr_format
|
|
|
|
#define G_GUINTPTR_FORMAT $guintptr_format
|
2000-02-13 08:18:23 +01:00
|
|
|
_______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
|
2008-04-04 00:03:32 +02:00
|
|
|
$glib_static_compilation
|
2000-02-13 08:18:23 +01:00
|
|
|
|
|
|
|
$glib_vacopy
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
|
#define G_HAVE_INLINE 1
|
|
|
|
#else /* !__cplusplus */
|
|
|
|
$glib_inline
|
|
|
|
#endif /* !__cplusplus */
|
2001-05-31 10:10:17 +02:00
|
|
|
|
2005-01-04 06:31:44 +01:00
|
|
|
#ifdef __cplusplus
|
|
|
|
#define G_CAN_INLINE 1
|
|
|
|
_______EOF
|
|
|
|
|
|
|
|
if test x$g_can_inline = xyes ; then
|
|
|
|
cat >>$outfile <<_______EOF
|
|
|
|
#else /* !__cplusplus */
|
|
|
|
#define G_CAN_INLINE 1
|
|
|
|
_______EOF
|
|
|
|
fi
|
|
|
|
|
|
|
|
cat >>$outfile <<_______EOF
|
|
|
|
#endif
|
|
|
|
|
2000-02-13 08:18:23 +01:00
|
|
|
_______EOF
|
|
|
|
|
2001-05-28 17:41:24 +02:00
|
|
|
if test x$g_have_iso_c_varargs = xyes ; then
|
2001-05-18 18:00:54 +02:00
|
|
|
cat >>$outfile <<_______EOF
|
2001-05-31 10:10:17 +02:00
|
|
|
#ifndef __cplusplus
|
|
|
|
# define G_HAVE_ISO_VARARGS 1
|
|
|
|
#endif
|
2001-05-18 18:00:54 +02:00
|
|
|
_______EOF
|
|
|
|
fi
|
2001-05-28 17:41:24 +02:00
|
|
|
if test x$g_have_iso_cxx_varargs = xyes ; then
|
|
|
|
cat >>$outfile <<_______EOF
|
2001-05-31 10:10:17 +02:00
|
|
|
#ifdef __cplusplus
|
2001-05-29 15:47:05 +02:00
|
|
|
# define G_HAVE_ISO_VARARGS 1
|
|
|
|
#endif
|
2001-05-28 17:41:24 +02:00
|
|
|
_______EOF
|
2001-05-31 10:10:17 +02:00
|
|
|
fi
|
2001-05-20 16:49:44 +02:00
|
|
|
if test x$g_have_gnuc_varargs = xyes ; then
|
2001-05-18 18:00:54 +02:00
|
|
|
cat >>$outfile <<_______EOF
|
|
|
|
|
2002-02-18 18:48:44 +01:00
|
|
|
/* 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
|
|
|
|
|
2001-05-20 16:49:44 +02:00
|
|
|
#define G_HAVE_GNUC_VARARGS 1
|
2001-05-18 18:00:54 +02:00
|
|
|
_______EOF
|
|
|
|
fi
|
|
|
|
|
2001-12-18 21:39:53 +01:00
|
|
|
case x$g_stack_grows in
|
|
|
|
xyes) echo "#define G_HAVE_GROWING_STACK 1" >>$outfile ;;
|
|
|
|
*) echo "#define G_HAVE_GROWING_STACK 0" >>$outfile ;;
|
|
|
|
esac
|
|
|
|
|
|
|
|
|
2000-11-13 00:44:28 +01:00
|
|
|
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
|
|
|
|
|
2007-05-18 16:04:27 +02:00
|
|
|
if test x$g_have_gnuc_visibility = xyes; then
|
|
|
|
cat >>$outfile <<_______EOF
|
|
|
|
#define G_HAVE_GNUC_VISIBILITY 1
|
|
|
|
_______EOF
|
|
|
|
fi
|
2004-08-10 20:52:30 +02:00
|
|
|
cat >>$outfile <<_______EOF
|
2009-01-03 02:00:38 +01:00
|
|
|
#if defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
|
|
|
|
#define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
|
|
|
|
#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
|
2007-01-27 04:34:48 +01:00
|
|
|
#define G_GNUC_INTERNAL __hidden
|
2007-05-18 16:56:32 +02:00
|
|
|
#elif defined (__GNUC__) && defined (G_HAVE_GNUC_VISIBILITY)
|
|
|
|
#define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
|
2007-05-18 06:22:46 +02:00
|
|
|
#else
|
2004-08-10 20:52:30 +02:00
|
|
|
#define G_GNUC_INTERNAL
|
2009-01-03 02:00:38 +01:00
|
|
|
#endif
|
2004-08-10 20:52:30 +02:00
|
|
|
_______EOF
|
|
|
|
|
|
|
|
|
2000-02-13 08:18:23 +01:00
|
|
|
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;
|
2001-01-30 15:16:56 +01:00
|
|
|
union {
|
2003-03-04 11:10:48 +01:00
|
|
|
char pad[[$g_mutex_sizeof]];
|
2001-01-30 15:16:56 +01:00
|
|
|
double dummy_double;
|
|
|
|
void *dummy_pointer;
|
|
|
|
long dummy_long;
|
2000-09-29 15:10:41 +02:00
|
|
|
} static_mutex;
|
2000-02-13 08:18:23 +01:00
|
|
|
};
|
2001-01-30 15:16:56 +01:00
|
|
|
#define G_STATIC_MUTEX_INIT { NULL, { { $g_mutex_contents} } }
|
2003-07-09 01:43:48 +02:00
|
|
|
#define g_static_mutex_get_mutex(mutex) \\
|
2008-10-13 14:54:13 +02:00
|
|
|
(g_thread_use_default_impl ? ((GMutex*)(gpointer) ((mutex)->static_mutex.pad)) : \\
|
2003-07-09 01:43:48 +02:00
|
|
|
g_static_mutex_get_mutex_impl_shortcut (&((mutex)->runtime_mutex)))
|
2000-02-13 08:18:23 +01:00
|
|
|
_______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
|
2003-07-09 01:43:48 +02:00
|
|
|
#define g_static_mutex_get_mutex(mutex) \\
|
|
|
|
(g_static_mutex_get_mutex_impl_shortcut (mutex))
|
2000-02-13 08:18:23 +01:00
|
|
|
_______EOF
|
|
|
|
fi
|
Added the missing POSIX_NO_YIELD and POSIX_NO_PRIORITIES warning messages.
2000-03-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in: Added the missing POSIX_NO_YIELD and
POSIX_NO_PRIORITIES warning messages.
* configure.in: Use AC_TRY_RUN instead of AC_TRY_LINK, to test for
real thread support. On solaris pthread_create can be linked to
even in -lc, but it doesn't work then.
* configure.in: Don't use priorities for threads, when the
minimal/maximal priorities couldn't be determined at configure
time.
* configure.in, gthread.c: Always define GSystemThread in
glibconfig.h to represent a system thread.
* configure.in: Do not use native recursive threads, when
possibe. We use some features, that they do not expose (namely the
depth counter).
* glib.h, gthread.c: Redefined GStaticRecMutex. The functions are
now implemented in a different way, which should be way
faster. Alsothere are now functions g_static_rec_mutex_unlock_full
and g_static_rec_mutex_lock_full to leave/enter a recursive mutex
completly.
* gthread.c (g_thread_self): Do not test the system_thread to be
non-zero to speed things up.
* gthread.c (g_mutex_init): Therefore set the system_thread of the
main thread here.
* tests/thread-test.c: Rerun all tests once again, but this time
we fool the system into thinking, that the available thread system
is not native, but userprovided.
* gthread/gthread-posix.c: Don't use priorities for threads,
when the minimal/maximal priorities couldn't be determined at
configure time.
* gthread/gthread-posix.c: Don't check for errors, when
setting the scope of a tread to system, as some posix
implementations can't do that and we don't want the thing to
fail because of that.
2000-03-17 15:49:59 +01:00
|
|
|
|
|
|
|
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
|
2000-02-13 08:18:23 +01:00
|
|
|
{
|
2003-03-04 11:10:48 +01:00
|
|
|
char data[[$g_system_thread_sizeof]];
|
Added the missing POSIX_NO_YIELD and POSIX_NO_PRIORITIES warning messages.
2000-03-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in: Added the missing POSIX_NO_YIELD and
POSIX_NO_PRIORITIES warning messages.
* configure.in: Use AC_TRY_RUN instead of AC_TRY_LINK, to test for
real thread support. On solaris pthread_create can be linked to
even in -lc, but it doesn't work then.
* configure.in: Don't use priorities for threads, when the
minimal/maximal priorities couldn't be determined at configure
time.
* configure.in, gthread.c: Always define GSystemThread in
glibconfig.h to represent a system thread.
* configure.in: Do not use native recursive threads, when
possibe. We use some features, that they do not expose (namely the
depth counter).
* glib.h, gthread.c: Redefined GStaticRecMutex. The functions are
now implemented in a different way, which should be way
faster. Alsothere are now functions g_static_rec_mutex_unlock_full
and g_static_rec_mutex_lock_full to leave/enter a recursive mutex
completly.
* gthread.c (g_thread_self): Do not test the system_thread to be
non-zero to speed things up.
* gthread.c (g_mutex_init): Therefore set the system_thread of the
main thread here.
* tests/thread-test.c: Rerun all tests once again, but this time
we fool the system into thinking, that the available thread system
is not native, but userprovided.
* gthread/gthread-posix.c: Don't use priorities for threads,
when the minimal/maximal priorities couldn't be determined at
configure time.
* gthread/gthread-posix.c: Don't check for errors, when
setting the scope of a tread to system, as some posix
implementations can't do that and we don't want the thing to
fail because of that.
2000-03-17 15:49:59 +01:00
|
|
|
double dummy_double;
|
|
|
|
void *dummy_pointer;
|
|
|
|
long dummy_long;
|
2000-02-13 08:18:23 +01:00
|
|
|
};
|
|
|
|
_______EOF
|
2004-02-29 17:47:48 +01:00
|
|
|
if test x"$g_memory_barrier_needed" != xno; then
|
2004-02-26 15:30:35 +01:00
|
|
|
echo >>$outfile
|
2004-02-29 17:47:48 +01:00
|
|
|
echo "#define G_ATOMIC_OP_MEMORY_BARRIER_NEEDED 1" >>$outfile
|
2004-02-26 15:30:35 +01:00
|
|
|
fi
|
2011-05-22 22:31:43 +02:00
|
|
|
if test x"$g_gcc_atomic_ops" != xno; then
|
|
|
|
echo >>$outfile
|
|
|
|
echo "#define G_ATOMIC_OP_USE_GCC_BUILTINS 1" >>$outfile
|
|
|
|
fi
|
2000-02-13 08:18:23 +01:00
|
|
|
echo >>$outfile
|
2001-10-11 04:43:40 +02:00
|
|
|
g_bit_sizes="16 32 64"
|
2000-02-13 08:18:23 +01:00
|
|
|
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))
|
2009-12-01 01:50:21 +01:00
|
|
|
#define GSIZE_TO_LE(val) ((gsize) GUINT${gsizebits}_TO_LE (val))
|
|
|
|
#define GSSIZE_TO_LE(val) ((gssize) GINT${gsizebits}_TO_LE (val))
|
|
|
|
#define GSIZE_TO_BE(val) ((gsize) GUINT${gsizebits}_TO_BE (val))
|
|
|
|
#define GSSIZE_TO_BE(val) ((gssize) GINT${gsizebits}_TO_BE (val))
|
2000-02-13 08:18:23 +01:00
|
|
|
#define G_BYTE_ORDER $g_byte_order
|
|
|
|
|
2002-12-05 21:33:26 +01:00
|
|
|
#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
|
2000-02-13 08:18:23 +01:00
|
|
|
|
Determine the suffix of the shared librarries for this system. This is
2000-12-22 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in: Determine the suffix of the shared librarries for
this system. This is done analogous to
ltconfig.sh. G_MODULE_SUFFIX in glibconfig.h is set to either
"sl", "dll", or (most often) "so".
* tests/Makefile.am, tests/module-test.c,
tests/libmoduletestplugin_a.c, tests/libmoduletestplugin_b.c:
Added new testcase for gmodule. This is mostly copied from
gmodule/testgmodule.c, but unlike that is is quiet. (Why BTW are
some tests that verbose, not to say loquacious...)
* gmodule.c: Make g_module_open more tolerant wrt to the module
name. First it tries to open the module as named, if that fails,
it checks, whether it is a libtool archive and parses it, if that
fails it appends the systems shared library suffix
(i.e. ".so") (if not already found) and tries again and if that
fails it tries to append the ".la" libtool suffix (if not already
found) and parses it.
* gmodule.c: Lock recursive mutex during most module functions for
safety.
* gmodule-dl.c: Return an error from _g_module_symbol only, if
dlerror says so. All other functions return an error as well, if
dlerror returns NULL.
* testgmodule.c: Thanks to the above change the #ifdefs have
vanished.
* glib/glib-sections.txt: Added G_MODULE_SUFFIX.
* glib/tmpl/modules.sgml: Updated.
2000-12-22 14:44:25 +01:00
|
|
|
#define G_MODULE_SUFFIX "$g_module_suffix"
|
|
|
|
|
2008-08-08 06:56:22 +02:00
|
|
|
/* A GPid is an abstraction for a process "handle". It is *not* an
|
|
|
|
* abstraction for a process identifier in general. GPid is used in
|
|
|
|
* GLib only for descendant processes spawned with the g_spawn*
|
|
|
|
* functions. On POSIX there is no "process handle" concept as such,
|
|
|
|
* but on Windows a GPid is a handle to a process, a kind of pointer,
|
|
|
|
* not a process identifier.
|
2008-08-07 17:40:03 +02:00
|
|
|
*/
|
2004-02-14 01:23:36 +01:00
|
|
|
typedef $g_pid_type GPid;
|
|
|
|
|
2008-12-12 19:13:55 +01:00
|
|
|
#define GLIB_SYSDEF_AF_UNIX $g_af_unix
|
|
|
|
#define GLIB_SYSDEF_AF_INET $g_af_inet
|
|
|
|
#define GLIB_SYSDEF_AF_INET6 $g_af_inet6
|
|
|
|
|
2009-05-14 15:26:37 +02:00
|
|
|
#define GLIB_SYSDEF_MSG_OOB $g_msg_oob
|
|
|
|
#define GLIB_SYSDEF_MSG_PEEK $g_msg_peek
|
|
|
|
#define GLIB_SYSDEF_MSG_DONTROUTE $g_msg_dontroute
|
|
|
|
|
Split glib.h into many header files mostly according to the resp.
2000-10-12 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* glib.h, galloca.h, garray.h, gasyncqueue.h, gbacktrace.h,
gcache.h, gcompletion.h, gconvert.h, gdataset.h, gdate.h, ghash.h,
ghook.h, giochannel.h, glist.h , gmacros.h, gmain.h, gmem.h,
gmessages.h, gnode.h, gprimes.h, gquark.h, gqueue.h, grand.h,
grel.h, gscanner.h, gslist.h, gstrfuncs.h, gstring.h, gthread.h,
gthreadpool.h, gtimer.h, gtree.h, gtypes.h, gutils.h: Split glib.h
into many header files mostly according to the resp. *.c-files.
* gmacros.h: Added G_BEGIN_DECLS and G_END_DECLS to mean: 'in case
of C++: extern "C" { ... }' analogous to glibc __BEGIN_DECLS and
__END_DECLS.
* configure.in, gerror.h, gfileutils.h, gshell.h, gspawn.h,
gunicode.h, : Changed guard-macro names to something more
consistent.
* configure.in, *.h: Use G_BEGIN_DECLS and G_END_DECLS.
2000-10-12 13:52:07 +02:00
|
|
|
G_END_DECLS
|
2000-02-13 08:18:23 +01:00
|
|
|
|
|
|
|
#endif /* GLIBCONFIG_H */
|
|
|
|
_______EOF
|
|
|
|
|
|
|
|
|
2010-07-12 03:08:42 +02:00
|
|
|
if cmp -s $outfile glib/glibconfig.h; then
|
|
|
|
AC_MSG_NOTICE([glib/glibconfig.h is unchanged])
|
2000-02-13 08:18:23 +01:00
|
|
|
rm -f $outfile
|
|
|
|
else
|
2010-07-12 03:08:42 +02:00
|
|
|
mv $outfile glib/glibconfig.h
|
2003-03-04 11:10:48 +01:00
|
|
|
fi
|
2000-02-13 08:18:23 +01:00
|
|
|
],[
|
|
|
|
|
|
|
|
# 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.
|
|
|
|
|
2001-09-19 00:28:32 +02:00
|
|
|
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
|
2000-09-18 00:18:48 +02:00
|
|
|
|
2000-02-13 08:18:23 +01:00
|
|
|
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
|
|
|
|
|
2008-07-24 02:29:56 +02:00
|
|
|
if test x$enable_included_printf = xyes ; then
|
|
|
|
glib_included_printf=yes
|
|
|
|
fi
|
|
|
|
|
2000-02-13 08:18:23 +01:00
|
|
|
case 2 in
|
|
|
|
$ac_cv_sizeof_short)
|
|
|
|
gint16=short
|
2003-07-29 01:00:05 +02:00
|
|
|
gint16_modifier='"h"'
|
2000-02-13 08:18:23 +01:00
|
|
|
gint16_format='"hi"'
|
|
|
|
guint16_format='"hu"'
|
|
|
|
;;
|
|
|
|
$ac_cv_sizeof_int)
|
|
|
|
gint16=int
|
2003-07-29 01:00:05 +02:00
|
|
|
gint16_modifier='""'
|
2000-02-13 08:18:23 +01:00
|
|
|
gint16_format='"i"'
|
|
|
|
guint16_format='"u"'
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
case 4 in
|
|
|
|
$ac_cv_sizeof_short)
|
|
|
|
gint32=short
|
2003-07-29 01:00:05 +02:00
|
|
|
gint32_modifier='"h"'
|
2000-02-13 08:18:23 +01:00
|
|
|
gint32_format='"hi"'
|
|
|
|
guint32_format='"hu"'
|
|
|
|
;;
|
|
|
|
$ac_cv_sizeof_int)
|
|
|
|
gint32=int
|
2003-07-29 01:00:05 +02:00
|
|
|
gint32_modifier='""'
|
2000-02-13 08:18:23 +01:00
|
|
|
gint32_format='"i"'
|
|
|
|
guint32_format='"u"'
|
|
|
|
;;
|
|
|
|
$ac_cv_sizeof_long)
|
|
|
|
gint32=long
|
2003-07-29 01:00:05 +02:00
|
|
|
gint32_modifier='"l"'
|
2000-02-13 08:18:23 +01:00
|
|
|
gint32_format='"li"'
|
|
|
|
guint32_format='"lu"'
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
case 8 in
|
|
|
|
$ac_cv_sizeof_int)
|
|
|
|
gint64=int
|
2003-07-29 01:00:05 +02:00
|
|
|
gint64_modifier='""'
|
2000-02-13 08:18:23 +01:00
|
|
|
gint64_format='"i"'
|
|
|
|
guint64_format='"u"'
|
|
|
|
glib_extension=
|
|
|
|
gint64_constant='(val)'
|
2005-12-02 22:25:45 +01:00
|
|
|
guint64_constant='(val)'
|
2000-02-13 08:18:23 +01:00
|
|
|
;;
|
|
|
|
$ac_cv_sizeof_long)
|
|
|
|
gint64=long
|
2003-07-29 01:00:05 +02:00
|
|
|
gint64_modifier='"l"'
|
2000-02-13 08:18:23 +01:00
|
|
|
gint64_format='"li"'
|
|
|
|
guint64_format='"lu"'
|
|
|
|
glib_extension=
|
|
|
|
gint64_constant='(val##L)'
|
2005-12-02 22:25:45 +01:00
|
|
|
guint64_constant='(val##UL)'
|
2000-02-13 08:18:23 +01:00
|
|
|
;;
|
|
|
|
$ac_cv_sizeof_long_long)
|
|
|
|
gint64='long long'
|
2000-09-28 09:45:04 +02:00
|
|
|
if test -n "$glib_cv_long_long_format"; then
|
2003-07-29 01:00:05 +02:00
|
|
|
gint64_modifier='"'$glib_cv_long_long_format'"'
|
2000-09-28 09:54:40 +02:00
|
|
|
gint64_format='"'$glib_cv_long_long_format'i"'
|
|
|
|
guint64_format='"'$glib_cv_long_long_format'u"'
|
2000-09-28 09:45:04 +02:00
|
|
|
fi
|
2000-02-13 08:18:23 +01:00
|
|
|
glib_extension='G_GNUC_EXTENSION '
|
|
|
|
gint64_constant='(G_GNUC_EXTENSION (val##LL))'
|
2005-12-02 22:25:45 +01:00
|
|
|
guint64_constant='(G_GNUC_EXTENSION (val##ULL))'
|
2000-02-13 08:18:23 +01:00
|
|
|
;;
|
2001-09-27 08:11:48 +02:00
|
|
|
$ac_cv_sizeof___int64)
|
|
|
|
gint64='__int64'
|
|
|
|
if test -n "$glib_cv_long_long_format"; then
|
2003-07-29 01:00:05 +02:00
|
|
|
gint64_modifier='"'$glib_cv_long_long_format'"'
|
2001-09-27 08:11:48 +02:00
|
|
|
gint64_format='"'$glib_cv_long_long_format'i"'
|
|
|
|
guint64_format='"'$glib_cv_long_long_format'u"'
|
|
|
|
fi
|
|
|
|
glib_extension=
|
|
|
|
gint64_constant='(val##i64)'
|
2005-12-02 22:25:45 +01:00
|
|
|
guint64_constant='(val##ui64)'
|
2001-09-27 08:11:48 +02:00
|
|
|
;;
|
2000-02-13 08:18:23 +01:00
|
|
|
esac
|
2002-12-05 21:33:26 +01:00
|
|
|
glib_size_t=$ac_cv_sizeof_size_t
|
2008-07-24 02:29:56 +02:00
|
|
|
glib_size_type_define="$glib_size_type"
|
|
|
|
glib_void_p=$ac_cv_sizeof_void_p
|
|
|
|
glib_long=$ac_cv_sizeof_long
|
2000-02-13 08:18:23 +01:00
|
|
|
|
2008-07-24 02:29:56 +02:00
|
|
|
case "$glib_size_type" in
|
2003-11-21 00:12:05 +01:00
|
|
|
short)
|
|
|
|
gsize_modifier='"h"'
|
|
|
|
gsize_format='"hu"'
|
|
|
|
gssize_format='"hi"'
|
2004-01-12 01:16:18 +01:00
|
|
|
glib_msize_type='SHRT'
|
2003-11-21 00:12:05 +01:00
|
|
|
;;
|
|
|
|
int)
|
|
|
|
gsize_modifier='""'
|
|
|
|
gsize_format='"u"'
|
|
|
|
gssize_format='"i"'
|
2004-01-12 01:16:18 +01:00
|
|
|
glib_msize_type='INT'
|
2003-11-21 00:12:05 +01:00
|
|
|
;;
|
|
|
|
long)
|
|
|
|
gsize_modifier='"l"'
|
|
|
|
gsize_format='"lu"'
|
|
|
|
gssize_format='"li"'
|
2004-01-12 01:16:18 +01:00
|
|
|
glib_msize_type='LONG'
|
2003-11-21 00:12:05 +01:00
|
|
|
;;
|
2008-07-24 02:29:56 +02:00
|
|
|
"long long"|__int64)
|
|
|
|
gsize_modifier='"I64"'
|
|
|
|
gsize_format='"I64u"'
|
|
|
|
gssize_format='"I64i"'
|
|
|
|
glib_msize_type='INT64'
|
|
|
|
;;
|
2003-11-21 00:12:05 +01:00
|
|
|
esac
|
|
|
|
|
2000-02-13 08:18:23 +01:00
|
|
|
gintbits=`expr $ac_cv_sizeof_int \* 8`
|
|
|
|
glongbits=`expr $ac_cv_sizeof_long \* 8`
|
2009-12-01 01:50:21 +01:00
|
|
|
gsizebits=`expr $ac_cv_sizeof_size_t \* 8`
|
2000-02-13 08:18:23 +01:00
|
|
|
|
|
|
|
case $ac_cv_sizeof_void_p in
|
2008-07-30 17:30:26 +02:00
|
|
|
$ac_cv_sizeof_int)
|
|
|
|
glib_intptr_type_define=int
|
2009-01-27 20:39:37 +01:00
|
|
|
gintptr_modifier='""'
|
|
|
|
gintptr_format='"i"'
|
|
|
|
guintptr_format='"u"'
|
2008-07-30 17:30:26 +02:00
|
|
|
glib_gpi_cast=''
|
|
|
|
glib_gpui_cast=''
|
|
|
|
;;
|
|
|
|
$ac_cv_sizeof_long)
|
|
|
|
glib_intptr_type_define=long
|
2009-01-27 20:39:37 +01:00
|
|
|
gintptr_modifier='"l"'
|
|
|
|
gintptr_format='"li"'
|
|
|
|
guintptr_format='"lu"'
|
2008-07-30 17:30:26 +02:00
|
|
|
glib_gpi_cast='(glong)'
|
|
|
|
glib_gpui_cast='(gulong)'
|
|
|
|
;;
|
|
|
|
$ac_cv_sizeof_long_long)
|
|
|
|
glib_intptr_type_define='long long'
|
2009-01-27 20:39:37 +01:00
|
|
|
gintptr_modifier='"I64"'
|
|
|
|
gintptr_format='"I64i"'
|
|
|
|
guintptr_format='"I64u"'
|
2008-07-30 17:30:26 +02:00
|
|
|
glib_gpi_cast='(gint64)'
|
|
|
|
glib_gpui_cast='(guint64)'
|
|
|
|
;;
|
|
|
|
$ac_cv_sizeof___int64)
|
|
|
|
glib_intptr_type_define=__int64
|
2009-01-27 20:39:37 +01:00
|
|
|
gintptr_modifier='"I64"'
|
|
|
|
gintptr_format='"I64i"'
|
|
|
|
guintptr_format='"I64u"'
|
2008-07-30 17:30:26 +02:00
|
|
|
glib_gpi_cast='(gint64)'
|
|
|
|
glib_gpui_cast='(guint64)'
|
|
|
|
;;
|
|
|
|
*)
|
|
|
|
glib_unknown_void_p=yes
|
|
|
|
;;
|
2000-02-13 08:18:23 +01:00
|
|
|
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='
|
2005-02-02 07:07:14 +01:00
|
|
|
#define g_memmove(dest,src,len) G_STMT_START { memmove ((dest), (src), (len)); } G_STMT_END'
|
2000-02-13 08:18:23 +01:00
|
|
|
;;
|
|
|
|
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
|
|
|
|
|
2001-05-18 18:00:54 +02:00
|
|
|
g_have_gnuc_varargs=$g_have_gnuc_varargs
|
2001-05-28 17:41:24 +02:00
|
|
|
g_have_iso_c_varargs=$g_have_iso_c_varargs
|
|
|
|
g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
|
2001-05-18 18:00:54 +02:00
|
|
|
|
2005-01-04 06:31:44 +01:00
|
|
|
g_can_inline=$g_can_inline
|
2004-08-10 20:52:30 +02:00
|
|
|
g_have_gnuc_visibility=$g_have_gnuc_visibility
|
2007-01-27 04:34:48 +01:00
|
|
|
g_have_sunstudio_visibility=$g_have_sunstudio_visibility
|
2004-08-10 20:52:30 +02:00
|
|
|
|
2008-07-02 17:56:27 +02:00
|
|
|
if test x$ac_cv_c_bigendian = xyes; then
|
2000-02-13 08:18:23 +01:00
|
|
|
g_byte_order=G_BIG_ENDIAN
|
|
|
|
g_bs_native=BE
|
2008-07-02 21:11:08 +02:00
|
|
|
g_bs_alien=LE
|
2008-07-02 17:56:27 +02:00
|
|
|
else
|
2008-07-02 21:11:08 +02:00
|
|
|
g_byte_order=G_LITTLE_ENDIAN
|
|
|
|
g_bs_native=LE
|
|
|
|
g_bs_alien=BE
|
2008-07-02 17:56:27 +02:00
|
|
|
fi
|
2000-02-13 08:18:23 +01:00
|
|
|
|
2002-12-05 21:33:26 +01:00
|
|
|
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
|
|
|
|
|
2008-12-12 19:13:55 +01:00
|
|
|
g_af_unix=$glib_cv_value_AF_UNIX
|
|
|
|
g_af_inet=$glib_cv_value_AF_INET
|
|
|
|
g_af_inet6=$glib_cv_value_AF_INET6
|
|
|
|
|
2009-05-14 15:26:37 +02:00
|
|
|
g_msg_peek=$glib_cv_value_MSG_PEEK
|
|
|
|
g_msg_oob=$glib_cv_value_MSG_OOB
|
|
|
|
g_msg_dontroute=$glib_cv_value_MSG_DONTROUTE
|
|
|
|
|
2001-12-18 21:39:53 +01:00
|
|
|
g_stack_grows=$glib_cv_stack_grows
|
|
|
|
|
2000-11-13 00:44:28 +01:00
|
|
|
g_have_eilseq=$have_eilseq
|
|
|
|
|
2000-09-28 09:54:40 +02:00
|
|
|
case x$have_threads in
|
2001-10-31 16:40:52 +01:00
|
|
|
xno) g_enable_threads_def="#undef";;
|
2000-09-28 09:54:40 +02:00
|
|
|
*) g_enable_threads_def="#define";;
|
2000-02-13 08:18:23 +01:00
|
|
|
esac
|
|
|
|
|
|
|
|
g_threads_impl_def=$g_threads_impl
|
|
|
|
|
|
|
|
g_mutex_has_default="$mutex_has_default"
|
|
|
|
g_mutex_sizeof="$glib_cv_sizeof_gmutex"
|
2001-11-28 17:47:26 +01:00
|
|
|
g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
|
2000-02-13 08:18:23 +01:00
|
|
|
g_mutex_contents="$glib_cv_byte_contents_gmutex"
|
|
|
|
|
2004-02-29 17:47:48 +01:00
|
|
|
g_memory_barrier_needed="$glib_memory_barrier_needed"
|
2011-05-22 22:31:43 +02:00
|
|
|
g_gcc_atomic_ops="$glib_cv_gcc_has_builtin_atomic_operations"
|
2004-02-26 15:30:35 +01:00
|
|
|
|
Determine the suffix of the shared librarries for this system. This is
2000-12-22 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in: Determine the suffix of the shared librarries for
this system. This is done analogous to
ltconfig.sh. G_MODULE_SUFFIX in glibconfig.h is set to either
"sl", "dll", or (most often) "so".
* tests/Makefile.am, tests/module-test.c,
tests/libmoduletestplugin_a.c, tests/libmoduletestplugin_b.c:
Added new testcase for gmodule. This is mostly copied from
gmodule/testgmodule.c, but unlike that is is quiet. (Why BTW are
some tests that verbose, not to say loquacious...)
* gmodule.c: Make g_module_open more tolerant wrt to the module
name. First it tries to open the module as named, if that fails,
it checks, whether it is a libtool archive and parses it, if that
fails it appends the systems shared library suffix
(i.e. ".so") (if not already found) and tries again and if that
fails it tries to append the ".la" libtool suffix (if not already
found) and parses it.
* gmodule.c: Lock recursive mutex during most module functions for
safety.
* gmodule-dl.c: Return an error from _g_module_symbol only, if
dlerror says so. All other functions return an error as well, if
dlerror returns NULL.
* testgmodule.c: Thanks to the above change the #ifdefs have
vanished.
* glib/glib-sections.txt: Added G_MODULE_SUFFIX.
* glib/tmpl/modules.sgml: Updated.
2000-12-22 14:44:25 +01:00
|
|
|
g_module_suffix="$glib_gmodule_suffix"
|
|
|
|
|
2004-02-14 01:23:36 +01:00
|
|
|
g_pid_type="$glib_pid_type"
|
2000-02-13 08:18:23 +01:00
|
|
|
case $host in
|
|
|
|
*-*-beos*)
|
|
|
|
glib_os="#define G_OS_BEOS"
|
|
|
|
;;
|
|
|
|
*-*-cygwin*)
|
|
|
|
glib_os="#define G_OS_UNIX
|
2001-03-09 22:18:33 +01:00
|
|
|
#define G_PLATFORM_WIN32
|
2000-02-13 08:18:23 +01:00
|
|
|
#define G_WITH_CYGWIN"
|
2001-01-05 20:30:13 +01:00
|
|
|
;;
|
|
|
|
*-*-mingw*)
|
2001-03-09 22:18:33 +01:00
|
|
|
glib_os="#define G_OS_WIN32
|
|
|
|
#define G_PLATFORM_WIN32"
|
2001-01-05 20:30:13 +01:00
|
|
|
;;
|
2000-02-13 08:18:23 +01:00
|
|
|
*)
|
|
|
|
glib_os="#define G_OS_UNIX"
|
|
|
|
;;
|
|
|
|
esac
|
2008-04-04 00:03:32 +02:00
|
|
|
glib_static_compilation=""
|
|
|
|
if test x$glib_win32_static_compilation = xyes; then
|
2008-04-21 10:38:36 +02:00
|
|
|
glib_static_compilation="#define GLIB_STATIC_COMPILATION 1
|
|
|
|
#define GOBJECT_STATIC_COMPILATION 1"
|
2008-04-04 00:03:32 +02:00
|
|
|
fi
|
2000-02-13 08:18:23 +01:00
|
|
|
])
|
|
|
|
|
2010-05-06 20:13:59 +02:00
|
|
|
# Check for libdbus1 - Optional - is only used in the GDBus test cases
|
|
|
|
#
|
2010-06-19 20:23:35 +02:00
|
|
|
# 1.2.14 required for dbus_message_set_serial
|
2010-05-06 20:13:59 +02:00
|
|
|
PKG_CHECK_MODULES(DBUS1,
|
2010-06-19 20:23:35 +02:00
|
|
|
dbus-1 >= 1.2.14,
|
2010-05-06 20:13:59 +02:00
|
|
|
[AC_DEFINE(HAVE_DBUS1, 1, [Define if dbus-1 is available]) have_dbus1=yes],
|
|
|
|
have_dbus1=no)
|
|
|
|
AC_SUBST(DBUS1_CFLAGS)
|
|
|
|
AC_SUBST(DBUS1_LIBS)
|
|
|
|
AM_CONDITIONAL(HAVE_DBUS1, [test "x$have_dbus1" = "xyes"])
|
|
|
|
|
2010-06-21 19:25:44 +02:00
|
|
|
dnl
|
|
|
|
dnl Check for -Bsymbolic-functions linker flag used to avoid
|
|
|
|
dnl intra-library PLT jumps, if available.
|
|
|
|
dnl
|
2010-07-05 19:10:28 +02:00
|
|
|
|
|
|
|
AC_ARG_ENABLE(Bsymbolic,
|
|
|
|
[AC_HELP_STRING([--disable-Bsymbolic],
|
|
|
|
[avoid linking with -Bsymbolic])],,
|
|
|
|
[SAVED_LDFLAGS="${LDFLAGS}"
|
|
|
|
AC_MSG_CHECKING([for -Bsymbolic-functions linker flag])
|
|
|
|
LDFLAGS=-Wl,-Bsymbolic-functions
|
|
|
|
AC_TRY_LINK([], [int main (void) { return 0; }],
|
|
|
|
AC_MSG_RESULT(yes)
|
|
|
|
enable_Bsymbolic=yes,
|
|
|
|
AC_MSG_RESULT(no)
|
|
|
|
enable_Bsymbolic=no)
|
|
|
|
LDFLAGS="${SAVED_LDFLAGS}"])
|
|
|
|
|
|
|
|
if test "x${enable_Bsymbolic}" == "xyes"; then
|
|
|
|
GLIB_LINK_FLAGS=-Wl,-Bsymbolic-functions
|
|
|
|
fi
|
|
|
|
|
2010-06-21 19:25:44 +02:00
|
|
|
AC_SUBST(GLIB_LINK_FLAGS)
|
|
|
|
|
2010-08-06 19:07:31 +02:00
|
|
|
#
|
|
|
|
# Define variables corresponding to the correct include paths to use for
|
|
|
|
# in-tree building.
|
|
|
|
#
|
|
|
|
|
|
|
|
# for config.h:
|
|
|
|
config_h_INCLUDES='-I$(top_builddir)'
|
|
|
|
AC_SUBST(config_h_INCLUDES)
|
|
|
|
|
|
|
|
# glib:
|
|
|
|
# config.h
|
|
|
|
# $(top_builddir)/glib: for glibconfig.h
|
|
|
|
# $(top_srcdir)/glib: for glib.h
|
|
|
|
# $(top_srcdir): for everything
|
|
|
|
glib_INCLUDES='$(config_h_INCLUDES) -I$(top_builddir)/glib -I$(top_srcdir)/glib -I$(top_srcdir)'
|
|
|
|
AC_SUBST(glib_INCLUDES)
|
|
|
|
|
|
|
|
# gthread:
|
|
|
|
# same as glib
|
|
|
|
gthread_INCLUDES='$(glib_INCLUDES)'
|
|
|
|
AC_SUBST(gthread_INCLUDES)
|
|
|
|
|
|
|
|
# gobject:
|
|
|
|
# same as gthread
|
|
|
|
gobject_INCLUDES='$(gthread_INCLUDES)'
|
|
|
|
AC_SUBST(gobject_INCLUDES)
|
|
|
|
|
|
|
|
# gmodule:
|
|
|
|
# glib includes
|
|
|
|
# $(top_srcdir)/gmodule: for gmodule.h
|
|
|
|
gmodule_INCLUDES='$(glib_INCLUDES) -I$(top_srcdir)/gmodule'
|
|
|
|
AC_SUBST(gmodule_INCLUDES)
|
|
|
|
|
|
|
|
# gio:
|
|
|
|
# same as gmodule
|
|
|
|
gio_INCLUDES='$(gmodule_INCLUDES)'
|
|
|
|
AC_SUBST(gio_INCLUDES)
|
|
|
|
|
|
|
|
|
2003-03-04 11:10:48 +01:00
|
|
|
AC_CONFIG_FILES([
|
2000-07-31 19:10:33 +02:00
|
|
|
glib-2.0.pc
|
2001-06-07 18:39:54 +02:00
|
|
|
glib-2.0-uninstalled.pc
|
2000-07-31 19:10:33 +02:00
|
|
|
gmodule-2.0.pc
|
2005-01-11 21:39:00 +01:00
|
|
|
gmodule-export-2.0.pc
|
2004-11-17 04:33:05 +01:00
|
|
|
gmodule-no-export-2.0.pc
|
2001-06-07 18:39:54 +02:00
|
|
|
gmodule-2.0-uninstalled.pc
|
2005-05-06 23:54:52 +02:00
|
|
|
gmodule-no-export-2.0-uninstalled.pc
|
2000-07-31 19:10:33 +02:00
|
|
|
gthread-2.0.pc
|
2001-06-07 18:39:54 +02:00
|
|
|
gthread-2.0-uninstalled.pc
|
2000-07-31 19:10:33 +02:00
|
|
|
gobject-2.0.pc
|
2001-06-07 18:39:54 +02:00
|
|
|
gobject-2.0-uninstalled.pc
|
2007-11-26 17:13:05 +01:00
|
|
|
gio-2.0.pc
|
|
|
|
gio-unix-2.0.pc
|
2010-04-19 10:32:05 +02:00
|
|
|
gio-windows-2.0.pc
|
2007-11-26 17:13:05 +01:00
|
|
|
gio-2.0-uninstalled.pc
|
|
|
|
gio-unix-2.0-uninstalled.pc
|
2001-10-29 23:33:34 +01:00
|
|
|
glib-zip
|
2001-10-28 17:34:24 +01:00
|
|
|
glib-gettextize
|
2000-02-13 08:18:23 +01:00
|
|
|
Makefile
|
2007-04-15 13:44:41 +02:00
|
|
|
build/Makefile
|
|
|
|
build/win32/Makefile
|
|
|
|
build/win32/dirent/Makefile
|
2008-11-02 20:43:52 +01:00
|
|
|
build/win32/vs9/Makefile
|
2011-02-22 12:58:18 +01:00
|
|
|
build/win32/vs10/Makefile
|
2001-06-26 18:01:21 +02:00
|
|
|
glib/Makefile
|
2009-12-18 21:25:47 +01:00
|
|
|
glib/glib.stp
|
2001-09-27 04:49:05 +02:00
|
|
|
glib/libcharset/Makefile
|
2003-07-29 01:00:05 +02:00
|
|
|
glib/gnulib/Makefile
|
2007-03-15 14:01:31 +01:00
|
|
|
glib/pcre/Makefile
|
|
|
|
glib/update-pcre/Makefile
|
2007-11-20 16:00:19 +01:00
|
|
|
glib/tests/Makefile
|
2000-02-13 08:18:23 +01:00
|
|
|
gmodule/Makefile
|
2003-03-04 11:10:48 +01:00
|
|
|
gmodule/gmoduleconf.h
|
2000-05-12 17:23:16 +02:00
|
|
|
gobject/Makefile
|
2010-01-01 21:39:52 +01:00
|
|
|
gobject/gobject.stp
|
2001-10-29 17:13:36 +01:00
|
|
|
gobject/glib-mkenums
|
2008-02-05 18:43:09 +01:00
|
|
|
gobject/tests/Makefile
|
2000-02-13 08:18:23 +01:00
|
|
|
gthread/Makefile
|
2010-01-29 00:41:19 +01:00
|
|
|
gthread/tests/Makefile
|
2007-11-26 17:13:05 +01:00
|
|
|
gio/Makefile
|
2011-04-08 22:57:31 +02:00
|
|
|
gio/gdbus-codegen/Makefile
|
|
|
|
gio/gdbus-codegen/config.py
|
2007-11-26 17:13:05 +01:00
|
|
|
gio/xdgmime/Makefile
|
|
|
|
gio/inotify/Makefile
|
2008-12-29 18:53:47 +01:00
|
|
|
gio/libasyncns/Makefile
|
2008-03-14 09:58:24 +01:00
|
|
|
gio/fen/Makefile
|
2007-11-26 17:13:05 +01:00
|
|
|
gio/fam/Makefile
|
2008-03-12 20:09:11 +01:00
|
|
|
gio/win32/Makefile
|
2009-07-06 04:49:24 +02:00
|
|
|
gio/tests/Makefile
|
2011-06-03 19:22:31 +02:00
|
|
|
gio/tests/gdbus-object-manager-example/Makefile
|
2001-01-16 03:24:24 +01:00
|
|
|
po/Makefile.in
|
2000-02-13 08:18:23 +01:00
|
|
|
docs/Makefile
|
2000-09-06 02:17:41 +02:00
|
|
|
docs/reference/Makefile
|
2000-09-06 17:01:07 +02:00
|
|
|
docs/reference/glib/Makefile
|
2002-11-23 02:37:17 +01:00
|
|
|
docs/reference/glib/version.xml
|
2000-09-06 17:01:07 +02:00
|
|
|
docs/reference/gobject/Makefile
|
2002-11-23 02:37:17 +01:00
|
|
|
docs/reference/gobject/version.xml
|
2007-11-26 17:13:05 +01:00
|
|
|
docs/reference/gio/Makefile
|
2011-06-03 19:22:31 +02:00
|
|
|
docs/reference/gio/gdbus-object-manager-example/Makefile
|
2007-11-26 17:13:05 +01:00
|
|
|
docs/reference/gio/version.xml
|
2000-02-13 08:18:23 +01:00
|
|
|
tests/Makefile
|
2003-09-12 22:37:09 +02:00
|
|
|
tests/gobject/Makefile
|
Make refcounting threadsafe by using atomic operations. (#166020, Wim
2005-07-15 Matthias Clasen <mclasen@redhat.com>
Make refcounting threadsafe by using atomic
operations. (#166020, Wim Taymans)
* gobject.c: Use a recursive lock to protect the
notify queue.
(g_object_unref): Get rid of g_object_last_unref and
do the last unref handling in g_object_unref.
(g_object_ref, g_object_unref): Use atomic operations.
* gsignal.c (struct _HandlerMatch): Use a full integer
for the ref_count field.
(handler_ref, handler_unref_R): Use atomic operations.
* gparam.c (g_param_spec_ref, g_param_spec_unref):
Use atomic operations instead of a lock to make the
refcounting threadsafe.
* gclosure.c (g_closure_ref, g_closure_unref): Use atomic
operations. This is more complicated here, since the
refcount is stored in a bitfield, so we also have
to access all other bitfield members atomically.
* gsignal.c (handlers_find): Read the meta_marshal flag
of the closure atomically.
* tests/Makefile.am (SUBDIRS): Add tests/refcount
* configure.in: Add tests/refcount
* tests/refcount/properties.c: Test property changes
from multiple threads.
* tests/refcount/signals.c: Test signal emission from
multiple threads.
* tests/refcount/objects.c: Test refcounting from
multiple threads.
* tests/refcount/objects2.c:
* tests/refcount/properties2.c: Tests to measure the
overhead of threadsafe refcounting.
* glib/giochannel.c (g_io_channel_ref, g_io_channel_unref):
Use atomic operations to make refcounting
threadsafe. (#166020, Wim Taymans)
2005-07-15 18:51:10 +02:00
|
|
|
tests/refcount/Makefile
|
2001-05-16 00:07:21 +02:00
|
|
|
m4macros/Makefile
|
2000-02-13 08:18:23 +01:00
|
|
|
])
|
2003-03-04 11:10:48 +01:00
|
|
|
|
|
|
|
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
|
2010-07-12 03:08:42 +02:00
|
|
|
glib/glibconfig.h.win32
|
2003-03-04 11:10:48 +01:00
|
|
|
glib/makefile.msc
|
|
|
|
glib/glib.rc
|
|
|
|
gmodule/makefile.msc
|
|
|
|
gmodule/gmodule.rc
|
|
|
|
gobject/makefile.msc
|
|
|
|
gobject/gobject.rc
|
|
|
|
gthread/makefile.msc
|
|
|
|
gthread/gthread.rc
|
2010-02-03 23:37:13 +01:00
|
|
|
gio/gio.rc
|
2003-03-04 11:10:48 +01:00
|
|
|
tests/makefile.msc
|
|
|
|
])
|
|
|
|
fi
|
|
|
|
|
|
|
|
AC_OUTPUT
|