| blob | f8ca929856cd6e71abbb76e6e3fc7db54d08aedf |
1 # Process this file with autoconf to produce a configure script.
2 # require autoconf 2.54
3 AC_PREREQ(2.54)
5 dnl ***********************************
6 dnl *** include special GLib macros ***
7 dnl ***********************************
9 m4_define(glib_configure_in)
11 #
12 # The following version number definitions apply to GLib, GModule, GObject
13 # and GThread as a whole, so if changes occoured in any of them, they are all
14 # treated with the same interface and binary age.
15 #
16 # Making releases:
17 # glib_micro_version += 1;
18 # glib_interface_age += 1;
19 # glib_binary_age += 1;
20 # if any functions have been added, set glib_interface_age to 0.
21 # if backwards compatibility has been broken,
22 # set glib_binary_age _and_ glib_interface_age to 0.
23 #
24 m4_define([glib_major_version], [2])
25 m4_define([glib_minor_version], [17])
26 m4_define([glib_micro_version], [3])
27 m4_define([glib_interface_age], [0])
28 m4_define([glib_binary_age],
29 [m4_eval(100 * glib_minor_version + glib_micro_version)])
30 m4_define([glib_version],
31 [glib_major_version.glib_minor_version.glib_micro_version])
33 # libtool version related macros
34 m4_define([glib_lt_release], [glib_major_version.glib_minor_version])
35 m4_define([glib_lt_current],
36 [m4_eval(100 * glib_minor_version + glib_micro_version - glib_interface_age)])
37 m4_define([glib_lt_revision], [glib_interface_age])
38 m4_define([glib_lt_age], [m4_eval(glib_binary_age - glib_interface_age)])
39 m4_define([glib_lt_current_minus_age],
40 [m4_eval(glib_lt_current - glib_lt_age)])
42 # if the minor version number is odd, then we want debugging. Otherwise
43 # we only want minimal debugging support.
44 m4_define([glib_debug_default],
45 [m4_if(m4_eval(glib_minor_version % 2), [1], [yes], [minimum])])dnl
48 AC_INIT(glib, [glib_version],
49 [http://bugzilla.gnome.org/enter_bug.cgi?product=glib])
51 AC_CONFIG_SRCDIR([glib/glib.h])
53 # Save this value here, since automake will set cflags later
54 cflags_set=${CFLAGS+set}
56 AM_INIT_AUTOMAKE([no-define])
58 # Specify a configuration file
59 AM_CONFIG_HEADER([config.h])
62 GLIB_MAJOR_VERSION=glib_major_version
63 GLIB_MINOR_VERSION=glib_minor_version
64 GLIB_MICRO_VERSION=glib_micro_version
65 GLIB_INTERFACE_AGE=glib_interface_age
66 GLIB_BINARY_AGE=glib_binary_age
67 GLIB_VERSION=glib_version
69 AC_SUBST(GLIB_MAJOR_VERSION)
70 AC_SUBST(GLIB_MINOR_VERSION)
71 AC_SUBST(GLIB_MICRO_VERSION)
72 AC_SUBST(GLIB_VERSION)
73 AC_SUBST(GLIB_INTERFACE_AGE)
74 AC_SUBST(GLIB_BINARY_AGE)
76 AC_DEFINE(GLIB_MAJOR_VERSION, [glib_major_version],
77 [Define to the GLIB major version])
78 AC_DEFINE(GLIB_MINOR_VERSION, [glib_minor_version],
79 [Define to the GLIB minor version])
80 AC_DEFINE(GLIB_MICRO_VERSION, [glib_micro_version],
81 [Define to the GLIB micro version])
82 AC_DEFINE(GLIB_INTERFACE_AGE, [glib_interface_age],
83 [Define to the GLIB interface age])
84 AC_DEFINE(GLIB_BINARY_AGE, [glib_binary_age],
85 [Define to the GLIB binary age])
87 # libtool versioning
88 LT_RELEASE=glib_lt_release
89 LT_CURRENT=glib_lt_current
90 LT_REVISION=glib_lt_revision
91 LT_AGE=glib_lt_age
92 LT_CURRENT_MINUS_AGE=glib_lt_current_minus_age
93 AC_SUBST(LT_RELEASE)
94 AC_SUBST(LT_CURRENT)
95 AC_SUBST(LT_REVISION)
96 AC_SUBST(LT_AGE)
97 AC_SUBST(LT_CURRENT_MINUS_AGE)
99 dnl Initialize maintainer mode
100 AM_MAINTAINER_MODE
102 AC_CANONICAL_HOST
104 AC_MSG_CHECKING([for the BeOS])
105 case $host in
106 *-*-beos*)
107 glib_native_beos="yes"
108 ;;
109 *)
110 glib_native_beos="no"
111 ;;
112 esac
113 AC_MSG_RESULT([$glib_native_beos])
115 dnl
117 AC_MSG_CHECKING([for Win32])
118 case "$host" in
119 *-*-mingw*)
120 glib_native_win32=yes
121 glib_pid_type='void *'
122 # Unfortunately the mingw implementations of C99-style snprintf and vsnprintf
123 # don't seem to be quite good enough, at least not in mingw-runtime-3.14.
124 # (Sorry, I don't know exactly what is the problem, but it is related to
125 # floating point formatting and decimal point vs. comma.)
126 # The simple tests in AC_FUNC_VSNPRINTF_C99 and AC_FUNC_SNPRINTF_C99 aren't
127 # rigorous enough to notice, though.
128 # So preset the autoconf cache variables.
129 ac_cv_func_vsnprintf_c99=no
130 ac_cv_func_snprintf_c99=no
131 ;;
132 *)
133 glib_native_win32=no
134 glib_pid_type=int
135 ;;
136 esac
137 case $host in
138 *-*-linux*)
139 glib_os_linux=yes
140 ;;
141 esac
143 AC_MSG_RESULT([$glib_native_win32])
145 glib_have_carbon=no
146 AC_MSG_CHECKING([for Mac OS X Carbon support])
147 AC_TRY_CPP([
148 #include <Carbon/Carbon.h>
149 #include <CoreServices/CoreServices.h>
150 ], glib_have_carbon=yes)
152 AC_MSG_RESULT([$glib_have_carbon])
154 AM_CONDITIONAL(OS_WIN32, [test "$glib_native_win32" = "yes"])
155 AM_CONDITIONAL(OS_UNIX, [test "$glib_native_win32" != "yes"])
156 AM_CONDITIONAL(OS_LINUX, [test "$glib_os_linux" = "yes"])
157 AM_CONDITIONAL(OS_CARBON, [test "$glib_have_carbon" = "yes"])
159 if test "$glib_native_win32" = "yes"; then
160 AC_CHECK_TOOL(WINDRES, windres, no)
161 if test "$WINDRES" = no; then
162 AC_MSG_ERROR([*** Could not find an implementation of windres in your PATH.])
163 fi
164 AC_CHECK_TOOL(NM, nm, no)
165 if test "$NM" = no; then
166 AC_MSG_ERROR([*** Could not find an implementation of nm in your PATH.])
167 fi
168 AC_CHECK_TOOL(RANLIB, ranlib, :)
169 AC_CHECK_PROG(ms_librarian, [lib.exe], [yes], [no])
170 fi
171 AM_CONDITIONAL(MS_LIB_AVAILABLE, [test x$ms_librarian = xyes])
173 if test "$glib_native_win32" != yes; then
174 # libtool option to control which symbols are exported
175 # right now, symbols starting with _ are not exported
176 LIBTOOL_EXPORT_OPTIONS='-export-symbols-regex "^g.*"'
177 else
178 # We currently use .def files on Windows
179 LIBTOOL_EXPORT_OPTIONS=
180 fi
181 AC_SUBST(LIBTOOL_EXPORT_OPTIONS)
183 if test "x$glib_have_carbon" = "xyes"; then
184 AC_DEFINE(HAVE_CARBON, 1, [define to 1 if Carbon is available])
185 LDFLAGS="$LDFLAGS -framework Carbon"
186 fi
189 dnl declare --enable-* args and collect ac_help strings
190 AC_ARG_ENABLE(debug,
191 AC_HELP_STRING([--enable-debug=@<:@no/minimum/yes@:>@],
192 [turn on debugging @<:@default=glib_debug_default@:>@]),,
193 enable_debug=glib_debug_default)
195 AC_ARG_ENABLE(gc_friendly,
196 [AC_HELP_STRING([--enable-gc-friendly],
197 [turn on garbage collector friendliness [default=no]])],,
198 [enable_gc_friendly=no])
199 AC_ARG_ENABLE(mem_pools,
200 [AC_HELP_STRING([--disable-mem-pools],
201 [disable all glib memory pools])],,
202 [disable_mem_pools=no])
203 AC_ARG_ENABLE(threads,
204 [AC_HELP_STRING([--enable-threads],
205 [turn on basic thread support [default=yes]
206 ([=no] will override --with-threads)])],,
207 [enable_threads=yes])
208 AC_ARG_ENABLE(rebuilds,
209 [AC_HELP_STRING([--disable-rebuilds],
210 [disable all source autogeneration rules])],,
211 [enable_rebuilds=yes])
212 AC_ARG_ENABLE(visibility,
213 [AC_HELP_STRING([--disable-visibility],
214 [don't use ELF visibility attributes])],,
215 [enable_visibility=yes])
217 if test "x$enable_threads" != "xyes"; then
218 enable_threads=no
219 fi
221 AC_MSG_CHECKING([whether to enable garbage collector friendliness])
222 if test "x$enable_gc_friendly" = "xyes"; then
223 AC_DEFINE(ENABLE_GC_FRIENDLY_DEFAULT, 1, [Whether to enable GC friendliness by default])
224 AC_MSG_RESULT([yes])
225 else
226 AC_MSG_RESULT([no])
227 fi
229 AC_MSG_CHECKING([whether to disable memory pools])
230 if test "x$disable_mem_pools" = "xno"; then
231 AC_MSG_RESULT([no])
232 else
233 AC_DEFINE(DISABLE_MEM_POOLS, [1], [Whether to disable memory pools])
234 AC_SUBST(DISABLE_MEM_POOLS)
235 AC_MSG_RESULT([yes])
236 fi
238 dnl Checks for programs.
239 AC_PROG_CC
241 dnl Check for a working C++ compiler, but do not bail out, if none is found.
242 AC_CHECK_PROGS(CXX, [$CCC c++ g++ gcc CC cxx cc++ cl], [gcc])
243 AC_LANG_SAVE
244 AC_LANG_CPLUSPLUS
245 AC_TRY_COMPILE(,[class a { int b; } c;], ,CXX=)
246 AM_CONDITIONAL(HAVE_CXX, [test "$CXX" != ""])
247 AC_LANG_RESTORE
249 AM_PROG_CC_STDC
250 AM_PROG_CC_C_O
251 AC_PROG_INSTALL
253 AC_SYS_LARGEFILE
255 #
256 # Find pkg-config
257 #
258 AC_PATH_PROG(PKG_CONFIG, [pkg-config], [no])
259 if test x$PKG_CONFIG = xno ; then
260 AC_MSG_ERROR([*** pkg-config not found. See http://www.freedesktop.org/software/pkgconfig/])
261 fi
263 if $PKG_CONFIG --atleast-pkgconfig-version 0.16 ; then
264 :
265 else
266 AC_MSG_ERROR([*** pkg-config too old; version 0.16 or better required.])
267 fi
269 if test "x$enable_debug" = "xyes"; then
270 if test x$cflags_set != xset ; then
271 case " $CFLAGS " in
272 *[[\ \ ]]-g[[\ \ ]]*) ;;
273 *) CFLAGS="$CFLAGS -g" ;;
274 esac
275 fi
277 GLIB_DEBUG_FLAGS="-DG_ENABLE_DEBUG"
278 else
279 GLIB_DEBUG_FLAGS="-DG_DISABLE_CAST_CHECKS"
281 if test "x$enable_debug" = "xno"; then
282 GLIB_DEBUG_FLAGS="$GLIB_DEBUG_FLAGS -DG_DISABLE_ASSERT -DG_DISABLE_CHECKS"
283 fi
284 fi
286 if test "x$enable_visibility" = "xno"; then
287 GLIB_DEBUG_FLAGS="$GLIB_DEBUG_FLAGS -DDISABLE_VISIBILITY"
288 fi
290 # Ensure MSVC-compatible struct packing convention is used when
291 # compiling for Win32 with gcc.
292 # What flag to depends on gcc version: gcc3 uses "-mms-bitfields", while
293 # gcc2 uses "-fnative-struct".
294 if test x"$glib_native_win32" = xyes; then
295 if test x"$GCC" = xyes; then
296 msnative_struct=''
297 AC_MSG_CHECKING([how to get MSVC-compatible struct packing])
298 if test -z "$ac_cv_prog_CC"; then
299 our_gcc="$CC"
300 else
301 our_gcc="$ac_cv_prog_CC"
302 fi
303 case `$our_gcc --version | sed -e 's,\..*,.,' -e q` in
304 2.)
305 if $our_gcc -v --help 2>/dev/null | grep fnative-struct >/dev/null; then
306 msnative_struct='-fnative-struct'
307 fi
308 ;;
309 *)
310 if $our_gcc -v --help 2>/dev/null | grep ms-bitfields >/dev/null; then
311 msnative_struct='-mms-bitfields'
312 fi
313 ;;
314 esac
315 if test x"$msnative_struct" = x ; then
316 AC_MSG_RESULT([no way])
317 AC_MSG_WARN([produced libraries might be incompatible with MSVC-compiled code])
318 else
319 CFLAGS="$CFLAGS $msnative_struct"
320 AC_MSG_RESULT([${msnative_struct}])
321 fi
322 fi
323 fi
324 GLIB_EXTRA_CFLAGS="${msnative_struct}"
325 AC_SUBST(GLIB_EXTRA_CFLAGS)
327 AC_EXEEXT
329 # define a MAINT-like variable REBUILD which is set if Perl
330 # and awk are found, so autogenerated sources can be rebuilt
331 AC_PROG_AWK
332 AC_CHECK_PROGS(PERL, [perl5 perl])
333 # We would like indent, but don't require it.
334 AC_CHECK_PROG(INDENT, indent, indent)
335 REBUILD=\#
336 if test "x$enable_rebuilds" = "xyes" && \
337 test -n "$PERL" && \
338 $PERL -e 'exit !($] >= 5.002)' > /dev/null 2>&1 && \
339 test -n "$AWK" ; then
340 REBUILD=
341 fi
342 AC_SUBST(REBUILD)
344 # Need full path to Perl for glib-mkenums
345 #
346 if test "x$PERL" != x ; then
347 AC_PATH_PROG(PERL_PATH, [$PERL])
348 fi
349 if test "x$PERL_PATH" = x ; then
350 PERL_PATH="/usr/bin/env perl"
351 fi
352 AC_SUBST(PERL_PATH)
354 # Need suitable python path for greport
355 AM_PATH_PYTHON(2.4,,PYTHON="/usr/bin/env python2.4")
358 dnl ***********************
359 dnl *** Tests for iconv ***
360 dnl ***********************
361 dnl
362 dnl We do this before the gettext checks, to avoid distortion
364 dnl On Windows we use a native implementation
366 if test x"$glib_native_win32" = xyes; then
367 with_libiconv=native
368 else
369 AC_ARG_WITH(libiconv,
370 [AC_HELP_STRING([--with-libiconv=@<:@no/gnu/native@:>@],
371 [use the libiconv library])],,
372 [with_libiconv=maybe])
374 found_iconv=no
375 case $with_libiconv in
376 maybe)
377 # Check in the C library first
378 AC_CHECK_FUNC(iconv_open, [with_libiconv=no; found_iconv=yes])
379 # Check if we have GNU libiconv
380 if test $found_iconv = "no"; then
381 AC_CHECK_LIB(iconv, libiconv_open, [with_libiconv=gnu; found_iconv=yes])
382 fi
383 # Check if we have a iconv in -liconv, possibly from vendor
384 if test $found_iconv = "no"; then
385 AC_CHECK_LIB(iconv, iconv_open, [with_libiconv=native; found_iconv=yes])
386 fi
387 ;;
388 no)
389 AC_CHECK_FUNC(iconv_open, [with_libiconv=no; found_iconv=yes])
390 ;;
391 gnu|yes)
392 AC_CHECK_LIB(iconv, libiconv_open, [with_libiconv=gnu; found_iconv=yes])
393 ;;
394 native)
395 AC_CHECK_LIB(iconv, iconv_open, [with_libiconv=native; found_iconv=yes])
396 ;;
397 esac
399 if test "x$found_iconv" = "xno" ; then
400 AC_MSG_ERROR([*** No iconv() implementation found in C library or libiconv])
401 fi
402 fi
404 gl_GLIBC21
405 AC_ARG_ENABLE(iconv-cache,
406 [AC_HELP_STRING([--enable-iconv-cache=@<:@yes/no/auto@:>@],
407 [cache iconv descriptors [default=auto]])],,
408 [enable_iconv_cache=auto])
410 AC_MSG_CHECKING([Whether to cache iconv descriptors])
411 case $enable_iconv_cache in
412 auto)
413 if test $ac_cv_gnu_library_2_1 = yes; then
414 enable_iconv_cache=no
415 else
416 enable_iconv_cache=yes
417 fi
418 ;;
419 yes|no)
420 ;;
421 *) AC_MSG_ERROR([Value given to --enable-iconv-cache must be one of yes, no or auto])
422 ;;
423 esac
425 if test $enable_iconv_cache = yes; then
426 AC_DEFINE(NEED_ICONV_CACHE,1,[Do we cache iconv descriptors])
427 fi
429 AC_MSG_RESULT($enable_iconv_cache)
432 dnl
433 dnl gettext support
434 dnl
436 ALL_LINGUAS="`grep -v '^#' "$srcdir/po/LINGUAS" | tr '\n' ' '`"
437 AC_SUBST([CONFIG_STATUS_DEPENDENCIES],['$(top_srcdir)/po/LINGUAS'])
438 GLIB_GNU_GETTEXT
440 if test "$gt_cv_have_gettext" != "yes" ; then
441 AC_MSG_ERROR([
442 *** You must have either have gettext support in your C library, or use the
443 *** GNU gettext library. (http://www.gnu.org/software/gettext/gettext.html
444 ])
445 fi
447 LIBS="$INTLLIBS $LIBS"
449 GETTEXT_PACKAGE=glib20
450 AC_SUBST(GETTEXT_PACKAGE)
451 AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE, ["$GETTEXT_PACKAGE"],
452 [Define the gettext package to be used])
454 GLIB_DEFINE_LOCALEDIR(GLIB_LOCALE_DIR)
456 dnl
457 dnl Now we are done with gettext checks, figure out ICONV_LIBS
458 dnl
460 if test x"$glib_native_win32" != xyes; then
461 if test x$with_libiconv != xno ; then
462 case " $INTLLIBS " in
463 *[[\ \ ]]-liconv[[\ \ ]]*) ;;
464 *) ICONV_LIBS="-liconv" ;;
465 esac
466 fi
467 fi
468 AC_SUBST(ICONV_LIBS)
470 case $with_libiconv in
471 gnu)
472 AC_DEFINE(USE_LIBICONV_GNU, 1, [Using GNU libiconv])
473 ;;
474 native)
475 AC_DEFINE(USE_LIBICONV_NATIVE, 1, [Using a native implementation of iconv in a separate library])
476 ;;
477 esac
479 dnl Initialize libtool
480 AM_DISABLE_STATIC
481 AC_LIBTOOL_WIN32_DLL
482 AM_PROG_LIBTOOL
484 if test "x$GCC" = "xyes"; then
485 case " $CFLAGS " in
486 *[[\ \ ]]-Wall[[\ \ ]]*) ;;
487 *) CFLAGS="$CFLAGS -Wall" ;;
488 esac
489 fi
491 CPPFLAGS="$CPPFLAGS -DG_DISABLE_SINGLE_INCLUDES"
493 if test "$glib_native_win32" = "yes"; then
494 if test x$enable_static = xyes -a x$enable_shared = xyes; then
495 AC_MSG_ERROR([Can not build both shared and static at the same time on Windows.])
496 fi
497 if test x$enable_static = xyes; then
498 glib_win32_static_compilation=yes
499 GLIB_WIN32_STATIC_COMPILATION_DEFINE="#define GLIB_STATIC_COMPILATION 1
500 #define GOBJECT_STATIC_COMPILATION 1"
501 AC_SUBST(GLIB_WIN32_STATIC_COMPILATION_DEFINE)
502 fi
503 fi
504 AM_CONDITIONAL(OS_WIN32_AND_DLL_COMPILATION, [test x$glib_native_win32 = xyes -a x$glib_win32_static_compilation != xyes])
506 dnl
507 dnl DU4 native cc currently needs -std1 for ANSI mode (instead of K&R)
508 dnl
509 if test $cross_compiling != yes ; then
510 AC_MSG_CHECKING([for extra flags to get ANSI library prototypes])
511 glib_save_LIBS=$LIBS
512 LIBS="$LIBS -lm"
513 AC_TRY_RUN([#include <math.h>
514 int main (void) { return (log(1) != log(1.)); }],
515 AC_MSG_RESULT(none needed),
516 glib_save_CFLAGS=$CFLAGS
517 CFLAGS="$CFLAGS -std1"
518 AC_TRY_RUN([#include <math.h>
519 int main (void) { return (log(1) != log(1.)); }],
520 AC_MSG_RESULT(-std1),
521 AC_MSG_RESULT()
522 CFLAGS=$glib_save_CFLAGS
523 AC_MSG_WARN(
524 [No ANSI prototypes found in library. (-std1 didn't work.)])
525 )
526 )
527 LIBS=$glib_save_LIBS
528 fi
530 dnl NeXTStep cc seems to need this
531 AC_MSG_CHECKING([for extra flags for POSIX compliance])
532 AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
533 AC_MSG_RESULT(none needed),
534 glib_save_CFLAGS=$CFLAGS
535 CFLAGS="$CFLAGS -posix"
536 AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
537 AC_MSG_RESULT(-posix),
538 AC_MSG_RESULT()
539 CFLAGS=$glib_save_CFLAGS
540 AC_MSG_WARN([Could not determine POSIX flag. (-posix didn't work.)])))
542 # Checks for header files.
543 AC_HEADER_STDC
545 # Checks for library functions.
546 AC_FUNC_VPRINTF
547 AC_FUNC_MMAP
548 AC_FUNC_ALLOCA
549 AC_CHECK_FUNCS(posix_memalign)
550 AC_CHECK_FUNCS(memalign)
551 AC_CHECK_FUNCS(valloc)
553 AC_CHECK_FUNCS(atexit on_exit)
555 AC_CHECK_FUNCS(timegm gmtime_r)
557 AC_CHECK_SIZEOF(char)
558 AC_CHECK_SIZEOF(short)
559 AC_CHECK_SIZEOF(long)
560 AC_CHECK_SIZEOF(int)
561 AC_CHECK_SIZEOF(void *)
562 AC_CHECK_SIZEOF(long long)
563 AC_CHECK_SIZEOF(__int64)
565 if test x$ac_cv_sizeof_long = x8 || test x$ac_cv_sizeof_long_long = x8 || test x$ac_cv_sizeof___int64 = x8 ; then
566 :
567 else
568 AC_MSG_ERROR([
569 *** GLib requires a 64 bit type. You might want to consider
570 *** using the GNU C compiler.
571 ])
572 fi
574 if test x$glib_native_win32 != xyes && test x$ac_cv_sizeof_long_long = x8; then
575 # long long is a 64 bit integer.
576 AC_MSG_CHECKING(for format to printf and scanf a guint64)
577 AC_CACHE_VAL(glib_cv_long_long_format,[
578 for format in ll q I64; do
579 AC_TRY_RUN([#include <stdio.h>
580 int main()
581 {
582 long long b, a = -0x3AFAFAFAFAFAFAFALL;
583 char buffer[1000];
584 sprintf (buffer, "%${format}u", a);
585 sscanf (buffer, "%${format}u", &b);
586 exit (b!=a);
587 }
588 ],
589 [glib_cv_long_long_format=${format}
590 break],
591 [],[:])
592 done])
593 if test -n "$glib_cv_long_long_format"; then
594 AC_MSG_RESULT(%${glib_cv_long_long_format}u)
595 AC_DEFINE(HAVE_LONG_LONG_FORMAT,1,[define if system printf can print long long])
596 if test x"$glib_cv_long_long_format" = xI64; then
597 AC_DEFINE(HAVE_INT64_AND_I64,1,[define to support printing 64-bit integers with format I64])
598 fi
599 else
600 AC_MSG_RESULT(none)
601 fi
602 elif test x$ac_cv_sizeof___int64 = x8; then
603 # __int64 is a 64 bit integer.
604 AC_MSG_CHECKING(for format to printf and scanf a guint64)
605 # We know this is MSVCRT.DLL, and what the formats are
606 glib_cv_long_long_format=I64
607 AC_MSG_RESULT(%${glib_cv_long_long_format}u)
608 AC_DEFINE(HAVE_LONG_LONG_FORMAT,1,[define if system printf can print long long])
609 AC_DEFINE(HAVE_INT64_AND_I64,1,[define to support printing 64-bit integers with format I64])
610 fi
612 dnl long doubles were not used, and a portability problem
613 dnl AC_C_LONG_DOUBLE
614 AC_C_CONST
616 dnl ok, here we try to check whether the systems prototypes for
617 dnl malloc and friends actually match the prototypes provided
618 dnl by gmem.h (keep in sync). i currently only know how to check
619 dnl this reliably with gcc (-Werror), improvements for other
620 dnl compilers are apprechiated.
621 SANE_MALLOC_PROTOS=no
622 AC_MSG_CHECKING([if malloc() and friends prototypes are gmem.h compatible])
623 glib_save_CFLAGS=$CFLAGS
624 if test "x$GCC" = "xyes"; then
625 CFLAGS="$CFLAGS -Werror"
626 AC_TRY_COMPILE([#include <stdlib.h>], [
627 void* (*my_calloc_p) (size_t, size_t) = calloc;
628 void* (*my_malloc_p) (size_t) = malloc;
629 void (*my_free_p) (void*) = free;
630 void* (*my_realloc_p) (void*, size_t) = realloc;
631 my_calloc_p = 0;
632 my_malloc_p = 0;
633 my_free_p = 0;
634 my_realloc_p = 0;
635 ],
636 AC_DEFINE(SANE_MALLOC_PROTOS, 1,
637 [Define if you have correct malloc prototypes])
638 SANE_MALLOC_PROTOS=yes)
639 fi
640 AC_MSG_RESULT($SANE_MALLOC_PROTOS)
641 CFLAGS=$glib_save_CFLAGS
643 dnl
644 dnl check in which direction the stack grows
645 dnl
646 AC_CACHE_CHECK([for growing stack pointer],glib_cv_stack_grows,[
647 AC_TRY_RUN([
648 volatile int *a = 0, *b = 0;
649 void foo (void);
650 int main () { volatile int y = 7; a = &y; foo (); return b > a; }
651 void foo (void) { volatile int x = 5; b = &x; }
652 ],
653 glib_cv_stack_grows=no
654 ,
655 glib_cv_stack_grows=yes
656 ,)
657 ])
659 dnl AC_C_INLINE is useless to us since it bails out too early, we need to
660 dnl truely know which ones of `inline', `__inline' and `__inline__' are
661 dnl actually supported.
662 AC_CACHE_CHECK([for __inline],glib_cv_has__inline,[
663 AC_COMPILE_IFELSE([
664 __inline int foo () { return 0; }
665 int main () { return foo (); }
666 ],
667 glib_cv_has__inline=yes
668 ,
669 glib_cv_has__inline=no
670 ,)
671 ])
672 case x$glib_cv_has__inline in
673 xyes) AC_DEFINE(G_HAVE___INLINE,1,[Have __inline keyword])
674 esac
675 AC_CACHE_CHECK([for __inline__],glib_cv_has__inline__,[
676 AC_COMPILE_IFELSE([
677 __inline__ int foo () { return 0; }
678 int main () { return foo (); }
679 ],
680 glib_cv_has__inline__=yes
681 ,
682 glib_cv_has__inline__=no
683 ,)
684 ])
685 case x$glib_cv_has__inline__ in
686 xyes) AC_DEFINE(G_HAVE___INLINE__,1,[Have __inline__ keyword])
687 esac
688 AC_CACHE_CHECK([for inline], glib_cv_hasinline,[
689 AC_COMPILE_IFELSE([
690 #undef inline
691 inline int foo () { return 0; }
692 int main () { return foo (); }
693 ],
694 glib_cv_hasinline=yes
695 ,
696 glib_cv_hasinline=no
697 ,)
698 ])
699 case x$glib_cv_hasinline in
700 xyes) AC_DEFINE(G_HAVE_INLINE,1,[Have inline keyword])
701 esac
703 # if we can use inline functions in headers
704 AC_MSG_CHECKING(if inline functions in headers work)
705 AC_LINK_IFELSE([
706 #if defined (G_HAVE_INLINE) && defined (__GNUC__) && defined (__STRICT_ANSI__)
707 # undef inline
708 # define inline __inline__
709 #elif !defined (G_HAVE_INLINE)
710 # undef inline
711 # if defined (G_HAVE___INLINE__)
712 # define inline __inline__
713 # elif defined (G_HAVE___INLINE)
714 # define inline __inline
715 # endif
716 #endif
718 int glib_test_func2 (int);
720 static inline int
721 glib_test_func1 (void) {
722 return glib_test_func2 (1);
723 }
725 int
726 main (void) {
727 int i = 1;
728 }],[g_can_inline=yes],[g_can_inline=no])
729 AC_MSG_RESULT($g_can_inline)
731 dnl *** check for working do while(0) macros ***
732 AC_CACHE_CHECK([for working do while(0) macros], g_cv_support_dowhile_macros, [
733 AC_TRY_COMPILE([],[
734 #define STMT_START do
735 #define STMT_END while(0)
736 #define STMT_TEST STMT_START { i = 0; } STMT_END
737 int main(void) { int i = 1; STMT_TEST; return i; }],
738 [g_cv_support_dowhile_macros=yes],
739 [g_cv_support_dowhile_macros=no],
740 [g_cv_support_dowhile_macros=yes])
741 ])
742 if test x$g_cv_support_dowhile_macros = xyes; then
743 AC_DEFINE(HAVE_DOWHILE_MACROS, 1, [define for working do while(0) macros])
744 fi
746 # check for flavours of varargs macros
747 AC_MSG_CHECKING(for ISO C99 varargs macros in C)
748 AC_TRY_COMPILE([],[
749 int a(int p1, int p2, int p3);
750 #define call_a(...) a(1,__VA_ARGS__)
751 call_a(2,3);
752 ],g_have_iso_c_varargs=yes,g_have_iso_c_varargs=no)
753 AC_MSG_RESULT($g_have_iso_c_varargs)
755 AC_MSG_CHECKING(for ISO C99 varargs macros in C++)
756 if test "$CXX" = ""; then
757 dnl No C++ compiler
758 g_have_iso_cxx_varargs=no
759 else
760 AC_LANG_CPLUSPLUS
761 AC_TRY_COMPILE([],[
762 int a(int p1, int p2, int p3);
763 #define call_a(...) a(1,__VA_ARGS__)
764 call_a(2,3);
765 ],g_have_iso_cxx_varargs=yes,g_have_iso_cxx_varargs=no)
766 AC_LANG_C
767 fi
768 AC_MSG_RESULT($g_have_iso_cxx_varargs)
770 AC_MSG_CHECKING(for GNUC varargs macros)
771 AC_TRY_COMPILE([],[
772 int a(int p1, int p2, int p3);
773 #define call_a(params...) a(1,params)
774 call_a(2,3);
775 ],g_have_gnuc_varargs=yes,g_have_gnuc_varargs=no)
776 AC_MSG_RESULT($g_have_gnuc_varargs)
778 # check for GNUC visibility support
779 AC_MSG_CHECKING(for GNUC visibility attribute)
780 GLIB_CHECK_COMPILE_WARNINGS([
781 void
782 __attribute__ ((visibility ("hidden")))
783 f_hidden (void)
784 {
785 }
786 void
787 __attribute__ ((visibility ("internal")))
788 f_internal (void)
789 {
790 }
791 void
792 __attribute__ ((visibility ("protected")))
793 f_protected (void)
794 {
795 }
796 void
797 __attribute__ ((visibility ("default")))
798 f_default (void)
799 {
800 }
801 int main (int argc, char **argv)
802 {
803 f_hidden();
804 f_internal();
805 f_protected();
806 f_default();
807 return 0;
808 }
809 ],g_have_gnuc_visibility=yes,g_have_gnuc_visibility=no)
810 AC_MSG_RESULT($g_have_gnuc_visibility)
811 AM_CONDITIONAL(HAVE_GNUC_VISIBILITY, [test x$g_have_gnuc_visibility = xyes])
813 AC_MSG_CHECKING([whether using Sun Studio C compiler])
814 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#if defined(__SUNPRO_C) || (__SUNPRO_C >= 0x550)
815 #else
816 # include "error: this is not Sun Studio."
817 #endif
818 ]], [[]])], [ g_have_sunstudio_visibility=yes ], [ g_have_sunstudio_visibility=no ])
819 AC_MSG_RESULT($g_have_sunstudio_visibility)
820 AM_CONDITIONAL(HAVE_SUNSTUDIO_VISIBILITY, [test x$g_have_sunstudio_visibility = xyes])
822 # check for bytesex stuff
823 AC_C_BIGENDIAN
824 if test x$ac_cv_c_bigendian = xuniversal ; then
825 AC_TRY_COMPILE([#include <endian.h>], [#if __BYTE_ORDER == __BIG_ENDIAN
826 #else
827 #error Not a big endian.
828 #endif],
829 ac_cv_c_bigendian=yes
830 ,AC_TRY_COMPILE([#include <endian.h>], [#if __BYTE_ORDER == __LITTLE_ENDIAN
831 #else
832 #error Not a little endian.
833 #endif],
834 ac_cv_c_bigendian=no
835 ,AC_MSG_WARN([Could not determine endianness.])))
836 fi
839 # check for header files
840 AC_CHECK_HEADERS([dirent.h float.h limits.h pwd.h grp.h sys/param.h sys/poll.h sys/resource.h])
841 AC_CHECK_HEADERS([sys/time.h sys/times.h sys/wait.h unistd.h values.h])
842 AC_CHECK_HEADERS([sys/select.h sys/types.h stdint.h sched.h malloc.h])
843 AC_CHECK_HEADERS([sys/vfs.h sys/mount.h sys/vmount.h sys/statfs.h sys/statvfs.h])
844 AC_CHECK_HEADERS([mntent.h sys/mnttab.h sys/vfstab.h sys/mntctl.h sys/sysctl.h fstab.h])
846 # check for structure fields
847 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])
848 AC_CHECK_MEMBERS([struct stat.st_blksize, struct stat.st_blocks, struct statfs.f_fstypename, struct statfs.f_bavail],,, [#include <sys/types.h>
849 #include <sys/stat.h>
850 #include <unistd.h>
851 #ifdef HAVE_SYS_PARAM_H
852 #include <sys/param.h>
853 #endif
854 #ifdef HAVE_SYS_MOUNT_H
855 #include <sys/mount.h>
856 #endif])
857 # struct statvfs.f_basetype is available on Solaris but not for Linux.
858 AC_CHECK_MEMBERS([struct statvfs.f_basetype],,, [#include <sys/statvfs.h>])
860 # Checks for libcharset
861 AM_LANGINFO_CODESET
862 gl_GLIBC21
863 AC_CHECK_HEADERS([stddef.h stdlib.h string.h])
864 AC_CHECK_FUNCS(setlocale)
866 # check additional type sizes
867 AC_CHECK_SIZEOF(size_t)
869 dnl Try to figure out whether gsize, gssize should be long or int
870 AC_MSG_CHECKING([for the appropriate definition for size_t])
872 case $ac_cv_sizeof_size_t in
873 $ac_cv_sizeof_short)
874 glib_size_type=short
875 ;;
876 $ac_cv_sizeof_int)
877 glib_size_type=int
878 ;;
879 $ac_cv_sizeof_long)
880 glib_size_type=long
881 ;;
882 *) AC_MSG_ERROR([No type matching size_t in size])
883 ;;
884 esac
886 dnl If int/long are the same size, we see which one produces
887 dnl warnings when used in the location as size_t. (This matters
888 dnl on AIX with xlc)
889 dnl
890 if test $ac_cv_sizeof_size_t = $ac_cv_sizeof_int &&
891 test $ac_cv_sizeof_size_t = $ac_cv_sizeof_long ; then
892 GLIB_CHECK_COMPILE_WARNINGS([
893 #if defined(_AIX) && !defined(__GNUC__)
894 #pragma options langlvl=stdc89
895 #endif
896 #include <stddef.h>
897 int main ()
898 {
899 size_t s = 1;
900 unsigned int *size_int = &s;
901 return (int)*size_int;
902 }
903 ],glib_size_type=int,
904 [GLIB_CHECK_COMPILE_WARNINGS([
905 #if defined(_AIX) && !defined(__GNUC__)
906 #pragma options langlvl=stdc89
907 #endif
908 #include <stddef.h>
909 int main ()
910 {
911 size_t s = 1;
912 unsigned long *size_long = &s;
913 return (int)*size_long;
914 }
915 ],glib_size_type=long)])
916 fi
918 AC_MSG_RESULT(unsigned $glib_size_type)
920 # Check for some functions
921 AC_CHECK_FUNCS(lstat strerror strsignal memmove vsnprintf stpcpy strcasecmp strncasecmp poll getcwd vasprintf setenv unsetenv getc_unlocked readlink symlink fdwalk)
922 AC_CHECK_FUNCS(chown lchown fchmod fchown link statvfs statfs utimes getgrgid getpwuid)
923 AC_CHECK_FUNCS(getmntent_r setmntent endmntent hasmntopt getmntinfo)
924 # Check for high-resolution sleep functions
925 AC_CHECK_FUNCS(nanosleep nsleep)
927 AC_CHECK_HEADERS(crt_externs.h)
928 AC_CHECK_FUNCS(_NSGetEnviron)
930 AC_FUNC_VSNPRINTF_C99
931 AC_FUNC_PRINTF_UNIX98
933 dnl
934 dnl if statfs() takes 2 arguments (Posix) or 4 (Solaris)
935 dnl
936 if test "$ac_cv_func_statfs" = yes ; then
937 AC_MSG_CHECKING([number of arguments to statfs()])
938 AC_TRY_COMPILE([#include <unistd.h>
939 #ifdef HAVE_SYS_PARAM_H
940 #include <sys/param.h>
941 #endif
942 #ifdef HAVE_SYS_VFS_H
943 #include <sys/vfs.h>
944 #endif
945 #ifdef HAVE_SYS_MOUNT_H
946 #include <sys/mount.h>
947 #endif
948 #ifdef HAVE_SYS_STATFS_H
949 #include <sys/statfs.h>
950 #endif], [struct statfs st;
951 statfs(NULL, &st);],[
952 AC_MSG_RESULT([2])
953 AC_DEFINE(STATFS_ARGS, 2, [Number of arguments to statfs()])],[
954 AC_TRY_COMPILE([#include <unistd.h>
955 #ifdef HAVE_SYS_PARAM_H
956 #include <sys/param.h>
957 #endif
958 #ifdef HAVE_SYS_VFS_H
959 #include <sys/vfs.h>
960 #endif
961 #ifdef HAVE_SYS_MOUNT_H
962 #include <sys/mount.h>
963 #endif
964 #ifdef HAVE_SYS_STATFS_H
965 #include <sys/statfs.h>
966 #endif], [struct statfs st;
967 statfs(NULL, &st, sizeof (st), 0);],[
968 AC_MSG_RESULT([4])
969 AC_DEFINE(STATFS_ARGS, 4, [Number of arguments to statfs()])],[
970 AC_MSG_RESULT(unknown)
971 AC_MSG_ERROR([unable to determine number of arguments to statfs()])])])
972 fi
974 #
975 # Check whether to use an included printf
976 #
978 AC_ARG_ENABLE(included-printf,
979 [AC_HELP_STRING([--enable-included-printf],
980 [use included printf [default=auto]])],
981 enable_included_printf="$enableval")
983 need_included_printf=no
984 if test "x$enable_included_printf" = "xyes" ; then
985 need_included_printf=yes
986 fi
987 if test "$ac_cv_func_vsnprintf_c99" != "yes" ; then
988 need_included_printf=yes
989 fi
990 if test "$ac_cv_func_printf_unix98" != "yes" ; then
991 need_included_printf=yes
992 fi
993 if test "x$ac_cv_sizeof_long_long" = "x8" &&
994 test -z "$glib_cv_long_long_format" ; then
995 need_included_printf=yes
996 fi
998 if test "x$enable_included_printf" = "xno" &&
999 test "x$need_included_printf" = "xyes" ; then
1000 AC_MSG_ERROR([
1001 *** Your C library's printf doesn't appear to have the features that
1002 *** GLib needs, but you specified --enable-included-printf=no.])
1003 fi
1005 enable_included_printf=$need_included_printf
1007 AM_CONDITIONAL(HAVE_GOOD_PRINTF, test "$enable_included_printf" != "yes")
1008 if test "$enable_included_printf" != "yes" ; then
1009 AC_DEFINE(HAVE_GOOD_PRINTF,1,[define to use system printf])
1010 else
1011 if test -z "$glib_cv_long_long_format" ; then
1012 glib_cv_long_long_format="ll"
1013 fi
1014 AC_DEFINE(HAVE_VASPRINTF,1)
1015 fi
1017 # Checks needed for gnulib vasnprintf
1018 bh_C_SIGNED
1019 jm_AC_TYPE_LONG_LONG
1020 gt_TYPE_LONGDOUBLE
1021 gt_TYPE_WCHAR_T
1022 gt_TYPE_WINT_T
1023 AC_TYPE_SIZE_T
1024 AC_CHECK_TYPES(ptrdiff_t)
1025 jm_AC_TYPE_INTMAX_T
1026 AC_CHECK_FUNCS([snprintf wcslen])
1027 AC_FUNC_SNPRINTF_C99
1029 # Check if bcopy can be used for overlapping copies, if memmove isn't found.
1030 # The check is borrowed from the PERL Configure script.
1031 if test "$ac_cv_func_memmove" != "yes"; then
1032 AC_CACHE_CHECK(whether bcopy can handle overlapping copies,
1033 glib_cv_working_bcopy,[AC_TRY_RUN([
1034 int main() {
1035 char buf[128], abc[128], *b;
1036 int len, off, align;
1037 bcopy("abcdefghijklmnopqrstuvwxyz0123456789", abc, 36);
1038 for (align = 7; align >= 0; align--) {
1039 for (len = 36; len; len--) {
1040 b = buf+align; bcopy(abc, b, len);
1041 for (off = 1; off <= len; off++) {
1042 bcopy(b, b+off, len); bcopy(b+off, b, len);
1043 if (bcmp(b, abc, len)) return(1);
1044 }
1045 }
1046 }
1047 return(0);
1048 }],glib_cv_working_bcopy=yes,glib_cv_working_bcopy=no)])
1050 GLIB_ASSERT_SET(glib_cv_working_bcopy)
1051 if test "$glib_cv_working_bcopy" = "yes"; then
1052 AC_DEFINE(HAVE_WORKING_BCOPY,1,[Have a working bcopy])
1053 fi
1054 fi
1056 # Check for sys_errlist
1057 AC_MSG_CHECKING(for sys_errlist)
1058 AC_TRY_LINK(, [
1059 extern char *sys_errlist[];
1060 extern int sys_nerr;
1061 sys_errlist[sys_nerr-1][0] = 0;
1062 ], glib_ok=yes, glib_ok=no)
1063 AC_MSG_RESULT($glib_ok)
1064 if test "$glib_ok" = "no"; then
1065 AC_DEFINE(NO_SYS_ERRLIST,1,[global 'sys_errlist' not found])
1066 fi
1068 # Check for sys_siglist
1069 AC_MSG_CHECKING(for sys_siglist)
1070 AC_TRY_LINK(, [
1071 extern char *sys_siglist[];
1072 exit (sys_siglist[0]);
1073 ], glib_ok=yes, glib_ok=no)
1074 AC_MSG_RESULT($glib_ok)
1075 if test "$glib_ok" = "no"; then
1076 AC_DEFINE(NO_SYS_SIGLIST,1,[global 'sys_siglist' not found])
1077 fi
1079 # Check for sys_siglist decl (see Tue Jan 19 00:44:24 1999 in changelog)
1080 AC_MSG_CHECKING(for sys_siglist declaration)
1081 AC_TRY_COMPILE([#include <signal.h>], [
1082 strlen (sys_siglist[0]);
1083 ], glib_ok=yes, glib_ok=no)
1084 AC_MSG_RESULT($glib_ok)
1085 if test "$glib_ok" = "no"; then
1086 AC_DEFINE(NO_SYS_SIGLIST_DECL,1,[global 'sys_siglist' not declared])
1087 fi
1089 # Check if <sys/select.h> needs to be included for fd_set
1090 AC_MSG_CHECKING([for fd_set])
1091 AC_TRY_COMPILE([#include <sys/types.h>],
1092 [fd_set readMask, writeMask;], gtk_ok=yes, gtk_ok=no)
1093 if test "$gtk_ok" = "yes"; then
1094 AC_MSG_RESULT([yes, found in sys/types.h])
1095 else
1096 AC_EGREP_HEADER(fd_set, sys/select.h, gtk_ok=yes)
1097 if test "$gtk_ok" = "yes"; then
1098 # *** FIXME: give it a different name
1099 AC_DEFINE(HAVE_SYS_SELECT_H,1,[found fd_set in sys/select.h])
1100 AC_MSG_RESULT([yes, found in sys/select.h])
1101 else
1102 AC_DEFINE(NO_FD_SET,1,[didn't find fd_set])
1103 AC_MSG_RESULT(no)
1104 fi
1105 fi
1107 dnl *** check for sane realloc() ***
1108 AC_CACHE_CHECK([whether realloc (NULL,) will work],glib_cv_sane_realloc,[
1109 AC_TRY_RUN([#include <stdlib.h>
1110 int main() {
1111 return realloc (0, sizeof (int)) == 0;
1112 }],
1113 [glib_cv_sane_realloc=yes],
1114 [glib_cv_sane_realloc=no],
1115 [glib_cv_sane_realloc=yes])
1116 ])
1117 if test x$glib_cv_sane_realloc = xyes; then
1118 AC_DEFINE(REALLOC_0_WORKS,1,[whether realloc (NULL,) works])
1119 fi
1121 dnl Check for nl_langinfo and CODESET
1122 AC_CACHE_CHECK([for nl_langinfo (CODESET)],glib_cv_langinfo_codeset,[
1123 AC_TRY_COMPILE([#include <langinfo.h>],
1124 [char *codeset = nl_langinfo (CODESET);],
1125 [glib_cv_langinfo_codeset=yes],
1126 [glib_cv_langinfo_codeset=no])])
1127 if test x$glib_cv_langinfo_codeset = xyes; then
1128 AC_DEFINE(HAVE_CODESET,1,[Have nl_langinfo (CODESET)])
1129 fi
1131 dnl ****************************************
1132 dnl *** posix_memalign ***
1133 dnl ****************************************
1134 AC_MSG_CHECKING(for a compliant posix_memalign() implementation)
1135 AC_CACHE_VAL(glib_cv_compliant_posix_memalign,[
1136 glib_cv_compliant_posix_memalign=0
1137 if test "$ac_cv_func_posix_memalign" = "yes" ; then
1138 AC_TRY_RUN([
1139 #define _XOPEN_SOURCE 600
1140 #include <stdlib.h> /* posix_memalign() should be defined here */
1141 /* some systems break if #include <malloc.h> used */
1142 static void test_memalign (size_t boundary, size_t size) {
1143 void *mem = 0;
1144 if (posix_memalign (&mem, boundary, size) != 0 || !mem)
1145 exit (1);
1146 else
1147 free (mem);
1148 }
1149 int main() {
1150 test_memalign ( 128, 128 - 2 * sizeof (void*));
1151 test_memalign ( 256, 256 - 2 * sizeof (void*));
1152 test_memalign ( 512, 512 - 2 * sizeof (void*));
1153 test_memalign ( 1024, 1024 - 2 * sizeof (void*));
1154 test_memalign ( 2048, 2048 - 2 * sizeof (void*));
1155 test_memalign ( 4096, 4096 - 2 * sizeof (void*));
1156 test_memalign ( 8192, 8192 - 2 * sizeof (void*));
1157 test_memalign (16384, 16384 - 2 * sizeof (void*));
1158 test_memalign (32768, 32768 - 2 * sizeof (void*));
1159 exit (0); /* success */
1160 }
1161 ],
1162 [glib_cv_compliant_posix_memalign=1], [], [:])
1163 :
1164 fi
1165 ])
1166 if test "$glib_cv_compliant_posix_memalign" = "1"; then
1167 AC_MSG_RESULT(yes)
1168 AC_DEFINE(POSIX_MEMALIGN_WITH_COMPLIANT_ALLOCS, 1, [define if posix_memalign() can allocate any size])
1169 else
1170 AC_MSG_RESULT(no)
1171 fi
1174 dnl ****************************************
1175 dnl *** strlcpy/strlcat ***
1176 dnl ****************************************
1177 # Check for strlcpy
1178 AC_CACHE_CHECK([for OpenBSD strlcpy/strlcat],glib_cv_have_strlcpy,[
1179 AC_TRY_RUN([#include <stdlib.h>
1180 #include <string.h>
1181 int main() {
1182 char p[10];
1183 (void) strlcpy (p, "hi", 10);
1184 if (strlcat (p, "bye", 0) != 3)
1185 return 1;
1186 return 0;
1187 }], glib_cv_have_strlcpy=yes,
1188 glib_cv_have_strlcpy=no,
1189 glib_cv_have_strlcpy=no)])
1190 if test "$glib_cv_have_strlcpy" = "yes"; then
1191 AC_DEFINE(HAVE_STRLCPY,1,[Have functions strlcpy and strlcat])
1192 fi
1195 dnl **********************
1196 dnl *** va_copy checks ***
1197 dnl **********************
1198 dnl we currently check for all three va_copy possibilities, so we get
1199 dnl all results in config.log for bug reports.
1200 AC_CACHE_CHECK([for an implementation of va_copy()],glib_cv_va_copy,[
1201 AC_LINK_IFELSE([#include <stdarg.h>
1202 #include <stdlib.h>
1203 void f (int i, ...) {
1204 va_list args1, args2;
1205 va_start (args1, i);
1206 va_copy (args2, args1);
1207 if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
1208 exit (1);
1209 va_end (args1); va_end (args2);
1210 }
1211 int main() {
1212 f (0, 42);
1213 return 0;
1214 }],
1215 [glib_cv_va_copy=yes],
1216 [glib_cv_va_copy=no])
1217 ])
1218 AC_CACHE_CHECK([for an implementation of __va_copy()],glib_cv___va_copy,[
1219 AC_LINK_IFELSE([#include <stdarg.h>
1220 #include <stdlib.h>
1221 void f (int i, ...) {
1222 va_list args1, args2;
1223 va_start (args1, i);
1224 __va_copy (args2, args1);
1225 if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
1226 exit (1);
1227 va_end (args1); va_end (args2);
1228 }
1229 int main() {
1230 f (0, 42);
1231 return 0;
1232 }],
1233 [glib_cv___va_copy=yes],
1234 [glib_cv___va_copy=no])
1235 ])
1237 if test "x$glib_cv_va_copy" = "xyes"; then
1238 g_va_copy_func=va_copy
1239 else if test "x$glib_cv___va_copy" = "xyes"; then
1240 g_va_copy_func=__va_copy
1241 fi
1242 fi
1244 if test -n "$g_va_copy_func"; then
1245 AC_DEFINE_UNQUOTED(G_VA_COPY,$g_va_copy_func,[A 'va_copy' style function])
1246 fi
1248 AC_CACHE_CHECK([whether va_lists can be copied by value],glib_cv_va_val_copy,[
1249 AC_TRY_RUN([#include <stdarg.h>
1250 #include <stdlib.h>
1251 void f (int i, ...) {
1252 va_list args1, args2;
1253 va_start (args1, i);
1254 args2 = args1;
1255 if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
1256 exit (1);
1257 va_end (args1); va_end (args2);
1258 }
1259 int main() {
1260 f (0, 42);
1261 return 0;
1262 }],
1263 [glib_cv_va_val_copy=yes],
1264 [glib_cv_va_val_copy=no],
1265 [glib_cv_va_val_copy=yes])
1266 ])
1268 if test "x$glib_cv_va_val_copy" = "xno"; then
1269 AC_DEFINE(G_VA_COPY_AS_ARRAY,1, ['va_lists' cannot be copies as values])
1270 fi
1272 dnl ***********************
1273 dnl *** g_module checks ***
1274 dnl ***********************
1275 G_MODULE_LIBS=
1276 G_MODULE_LIBS_EXTRA=
1277 G_MODULE_PLUGIN_LIBS=
1278 if test x"$glib_native_win32" = xyes; then
1279 dnl No use for this on Win32
1280 G_MODULE_LDFLAGS=
1281 else
1282 export SED
1283 G_MODULE_LDFLAGS=`(./libtool --config; echo eval echo \\$export_dynamic_flag_spec) | sh`
1284 fi
1285 dnl G_MODULE_IMPL= don't reset, so cmd-line can override
1286 G_MODULE_NEED_USCORE=0
1287 G_MODULE_BROKEN_RTLD_GLOBAL=0
1288 G_MODULE_HAVE_DLERROR=0
1289 dnl *** force native WIN32 shared lib loader
1290 if test -z "$G_MODULE_IMPL"; then
1291 case "$host" in
1292 *-*-mingw*|*-*-cygwin*) G_MODULE_IMPL=G_MODULE_IMPL_WIN32 ;;
1293 esac
1294 fi
1295 dnl *** force native AIX library loader
1296 dnl *** dlopen() filepath must be of the form /path/libname.a(libname.so)
1297 if test -z "$G_MODULE_IMPL"; then
1298 case "$host" in
1299 *-*-aix*) G_MODULE_IMPL=G_MODULE_IMPL_AR ;;
1300 esac
1301 fi
1302 dnl *** dlopen() and dlsym() in system libraries
1303 if test -z "$G_MODULE_IMPL"; then
1304 AC_CHECK_FUNC(dlopen,
1305 [AC_CHECK_FUNC(dlsym,
1306 [G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
1307 [])
1308 fi
1309 dnl *** load_image (BeOS)
1310 if test -z "$G_MODULE_IMPL" && test "x$glib_native_beos" = "xyes"; then
1311 AC_CHECK_LIB(root, load_image,
1312 [G_MODULE_LIBS="-lbe -lroot -lglib-2.0 "
1313 G_MODULE_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
1314 G_MODULE_PLUGIN_LIBS="-L\$(top_builddir_full)/gmodule/.libs -lgmodule"
1315 G_MODULE_IMPL=G_MODULE_IMPL_BEOS],
1316 [])
1317 fi
1318 dnl *** NSLinkModule (dyld) in system libraries (Darwin)
1319 if test -z "$G_MODULE_IMPL"; then
1320 AC_CHECK_FUNC(NSLinkModule,
1321 [G_MODULE_IMPL=G_MODULE_IMPL_DYLD
1322 G_MODULE_NEED_USCORE=1],
1323 [])
1324 fi
1325 dnl *** dlopen() and dlsym() in libdl
1326 if test -z "$G_MODULE_IMPL"; then
1327 AC_CHECK_LIB(dl, dlopen,
1328 [AC_CHECK_LIB(dl, dlsym,
1329 [G_MODULE_LIBS=-ldl
1330 G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
1331 [])
1332 fi
1333 dnl *** shl_load() in libdld (HP-UX)
1334 if test -z "$G_MODULE_IMPL"; then
1335 AC_CHECK_LIB(dld, shl_load,
1336 [G_MODULE_LIBS=-ldld
1337 G_MODULE_IMPL=G_MODULE_IMPL_DLD],
1338 [])
1339 fi
1340 dnl *** additional checks for G_MODULE_IMPL_DL
1341 if test "$G_MODULE_IMPL" = "G_MODULE_IMPL_DL"; then
1342 LIBS_orig="$LIBS"
1343 LDFLAGS_orig="$LDFLAGS"
1344 LIBS="$G_MODULE_LIBS $LIBS"
1345 LDFLAGS="$LDFLAGS $G_MODULE_LDFLAGS"
1346 dnl *** check for OSF1/5.0 RTLD_GLOBAL brokenness
1347 echo "void glib_plugin_test(void) { }" > plugin.c
1348 ${SHELL} ./libtool --mode=compile ${CC} -shared \
1349 -export-dynamic -o plugin.o plugin.c 2>&1 >/dev/null
1350 AC_CACHE_CHECK([for RTLD_GLOBAL brokenness],
1351 glib_cv_rtldglobal_broken,[
1352 AC_TRY_RUN([
1353 #include <dlfcn.h>
1354 #ifndef RTLD_GLOBAL
1355 # define RTLD_GLOBAL 0
1356 #endif
1357 #ifndef RTLD_LAZY
1358 # define RTLD_LAZY 0
1359 #endif
1360 int glib_plugin_test;
1361 int main () {
1362 void *handle, *global, *local;
1363 global = &glib_plugin_test;
1364 handle = dlopen ("./.libs/plugin.o", RTLD_GLOBAL | RTLD_LAZY);
1365 if (!handle) return 0;
1366 local = dlsym (handle, "glib_plugin_test");
1367 return global == local;
1368 } ],
1369 [glib_cv_rtldglobal_broken=no],
1370 [glib_cv_rtldglobal_broken=yes],
1371 [glib_cv_rtldglobal_broken=no])
1372 rm -f plugin.c plugin.o plugin.lo .libs/plugin.o
1373 rmdir .libs 2>/dev/null
1374 ])
1375 if test "x$glib_cv_rtldglobal_broken" = "xyes"; then
1376 G_MODULE_BROKEN_RTLD_GLOBAL=1
1377 else
1378 G_MODULE_BROKEN_RTLD_GLOBAL=0
1379 fi
1380 dnl *** check whether we need preceeding underscores
1381 AC_CACHE_CHECK([for preceeding underscore in symbols],
1382 glib_cv_uscore,[
1383 AC_TRY_RUN([#include <dlfcn.h>
1384 int glib_underscore_test (void) { return 42; }
1385 int main() {
1386 void *f1 = (void*)0, *f2 = (void*)0, *handle;
1387 handle = dlopen ((void*)0, 0);
1388 if (handle) {
1389 f1 = dlsym (handle, "glib_underscore_test");
1390 f2 = dlsym (handle, "_glib_underscore_test");
1391 } return (!f2 || f1);
1392 }],
1393 [glib_cv_uscore=yes],
1394 [glib_cv_uscore=no],
1395 [])
1396 rm -f plugin.c plugin.$ac_objext plugin.lo
1397 ])
1398 GLIB_ASSERT_SET(glib_cv_uscore)
1399 if test "x$glib_cv_uscore" = "xyes"; then
1400 G_MODULE_NEED_USCORE=1
1401 else
1402 G_MODULE_NEED_USCORE=0
1403 fi
1405 LDFLAGS="$LDFLAGS_orig"
1406 dnl *** check for having dlerror()
1407 AC_CHECK_FUNC(dlerror,
1408 [G_MODULE_HAVE_DLERROR=1],
1409 [G_MODULE_HAVE_DLERROR=0])
1410 LIBS="$LIBS_orig"
1411 fi
1412 dnl *** done, have we got an implementation?
1413 if test -z "$G_MODULE_IMPL"; then
1414 G_MODULE_IMPL=0
1415 G_MODULE_SUPPORTED=false
1416 else
1417 G_MODULE_SUPPORTED=true
1418 fi
1420 AC_MSG_CHECKING(for the suffix of shared libraries)
1421 export SED
1422 shrext_cmds=`./libtool --config | grep '^shrext_cmds='`
1423 eval $shrext_cmds
1424 module=yes eval std_shrext=$shrext_cmds
1425 # chop the initial dot
1426 glib_gmodule_suffix=`echo $std_shrext | sed 's/^\.//'`
1427 AC_MSG_RESULT(.$glib_gmodule_suffix)
1428 # any reason it may fail?
1429 if test "x$glib_gmodule_suffix" = x; then
1430 AC_MSG_ERROR(Cannot determine shared library suffix from libtool)
1431 fi
1433 AC_SUBST(G_MODULE_SUPPORTED)
1434 AC_SUBST(G_MODULE_IMPL)
1435 AC_SUBST(G_MODULE_LIBS)
1436 AC_SUBST(G_MODULE_LIBS_EXTRA)
1437 AC_SUBST(G_MODULE_PLUGIN_LIBS)
1438 AC_SUBST(G_MODULE_LDFLAGS)
1439 AC_SUBST(G_MODULE_HAVE_DLERROR)
1440 AC_SUBST(G_MODULE_BROKEN_RTLD_GLOBAL)
1441 AC_SUBST(G_MODULE_NEED_USCORE)
1442 AC_SUBST(GLIB_DEBUG_FLAGS)
1444 dnl **********************
1445 dnl *** g_spawn checks ***
1446 dnl **********************
1448 AC_MSG_CHECKING(for gspawn implementation)
1449 case "$host" in
1450 *-*-mingw*)
1451 GSPAWN=gspawn-win32.lo
1452 ;;
1453 *)
1454 GSPAWN=gspawn.lo
1455 ;;
1456 esac
1457 AC_MSG_RESULT($GSPAWN)
1458 AC_SUBST(GSPAWN)
1460 dnl *************************
1461 dnl *** GIOChannel checks ***
1462 dnl *************************
1464 AC_MSG_CHECKING(for GIOChannel implementation)
1465 case "$host" in
1466 *-*-mingw*)
1467 GIO=giowin32.lo
1468 ;;
1469 *)
1470 GIO=giounix.lo
1471 ;;
1472 esac
1473 AC_MSG_RESULT($GIO)
1474 AC_SUBST(GIO)
1476 dnl *********************************
1477 dnl *** Directory for GIO modules ***
1478 dnl *********************************
1480 AC_ARG_WITH(gio-module-dir,
1481 [AC_HELP_STRING([--with-gio-module-dir=PATH],
1482 [Load gio modules from this directory [LIBDIR/gio/modules]])],
1483 [],
1484 [with_gio_module_dir='${libdir}/gio/modules'])
1485 GIO_MODULE_DIR=$with_gio_module_dir
1486 AC_SUBST(GIO_MODULE_DIR)
1488 dnl **********************************
1489 dnl *** Check for libselinux (GIO) ***
1490 dnl **********************************
1491 AC_ARG_ENABLE(selinux, [ --disable-selinux build without selinux support])
1492 msg_selinux=no
1493 SELINUX_LIBS=
1494 if test "x$enable_selinux" != "xno"; then
1496 AC_CHECK_LIB(selinux, is_selinux_enabled,
1497 [AC_CHECK_HEADERS(selinux/selinux.h,
1498 [AC_SEARCH_LIBS(lgetfilecon_raw, selinux,
1499 [AC_DEFINE(HAVE_SELINUX, 1, [Define to 1 if libselinux is available])
1500 SELINUX_LIBS="-lselinux"
1501 msg_selinux=yes])
1502 ])
1503 ])
1504 fi
1505 AC_SUBST(SELINUX_LIBS)
1507 dnl *****************************
1508 dnl ** Check for inotify (GIO) **
1509 dnl *****************************
1510 inotify_support=no
1511 AC_CHECK_HEADERS([sys/inotify.h],
1512 [
1513 inotify_support=yes
1514 ])
1516 AM_CONDITIONAL(HAVE_INOTIFY, [test "$inotify_support" = "yes"])
1518 dnl *********************************
1519 dnl ** Check for Solaris FEN (GIO) **
1520 dnl *********************************
1521 fen_support=no
1522 AC_COMPILE_IFELSE([
1523 #include <port.h>
1524 #ifndef PORT_SOURCE_FILE
1525 #error "Please upgrade to Nevada 72 or above to suppoert FEN"
1526 #endif
1527 int main() { return 0; } ],
1528 [
1529 fen_support=yes
1530 ],)
1532 AM_CONDITIONAL(HAVE_FEN, [test "$fen_support" = "yes"])
1534 dnl ****************************
1535 dnl *** Checks for FAM (GIO) ***
1536 dnl ****************************
1538 should_disable_fam=no
1540 AC_ARG_ENABLE(fam, [ --disable-fam build without enabling fam for file system monitoring],
1541 [
1542 if test "x$enable_fam" = "xno"; then
1543 should_disable_fam=yes
1544 echo "Not building FAM support"
1545 fi
1546 ]
1547 )
1548 fam_support=no
1549 FAM_LIBS=
1550 if test "x$should_disable_fam" = "xno"; then
1551 AC_CHECK_LIB(fam, FAMOpen,
1552 [AC_CHECK_HEADERS(fam.h,
1553 [AC_DEFINE(HAVE_FAM, [], [Define if we have FAM])
1554 AC_CHECK_LIB(fam, FAMNoExists,
1555 AC_DEFINE(HAVE_FAM_NO_EXISTS, [], [Define if we have FAMNoExists in fam]))
1556 FAM_LIBS="-lfam"]
1557 fam_support=yes,
1558 AC_MSG_WARN(*** FAM support will not be built (header files not found) ***))],
1559 AC_MSG_WARN(*** FAM support will not be built (FAM library not found) ***))
1560 AC_SUBST(FAM_LIBS)
1561 fi
1562 AM_CONDITIONAL(HAVE_FAM, [test "$fam_support" = "yes"])
1565 dnl *****************************
1566 dnl *** Check for xattr (GIO) ***
1567 dnl *****************************
1568 AC_ARG_ENABLE(xattr, [ --disable-xattr build without xattr support])
1569 msg_xattr=no
1570 XATTR_LIBS=
1571 if test "x$enable_xattr" != "xno"; then
1573 dnl either glibc or libattr can provide xattr support
1575 dnl for both of them, we check for getxattr being in
1576 dnl the library and a valid xattr header.
1578 dnl try glibc
1579 AC_CHECK_LIB(c, getxattr,
1580 [AC_CHECK_HEADERS(sys/xattr.h,
1581 [AC_DEFINE(HAVE_XATTR, 1, [Define to 1 if xattr is available])
1582 msg_xattr=yes])
1583 ])
1585 if test "x$msg_xattr" != "xyes"; then
1586 dnl failure. try libattr
1587 AC_CHECK_LIB(attr, getxattr,
1588 [AC_CHECK_HEADERS(attr/xattr.h,
1589 [AC_DEFINE(HAVE_XATTR, 1, [Define to 1 if xattr is available])
1590 XATTR_LIBS="-lattr"
1591 msg_xattr=yes])
1592 ])
1593 fi
1595 if test "x$msg_xattr" = "xyes"; then
1596 AC_MSG_CHECKING([for XATTR_NOFOLLOW])
1597 AC_TRY_COMPILE([
1598 #include <stdio.h>
1599 #ifdef HAVE_SYS_TYPES_H
1600 #include <sys/types.h>
1601 #endif
1602 #ifdef HAVE_SYS_XATTR_H
1603 #include <sys/xattr.h>
1604 #elif HAVE_ATTR_XATTR_H
1605 #include <attr/xattr.h>
1606 #endif
1607 ],
1608 [ssize_t len = getxattr("", "", NULL, 0, 0, XATTR_NOFOLLOW);],
1609 [
1610 AC_DEFINE([HAVE_XATTR_NOFOLLOW], [1], [Define to 1 if xattr API uses XATTR_NOFOLLOW])
1611 AC_MSG_RESULT([yes])
1612 ],
1613 [AC_MSG_RESULT([no])]
1614 )
1615 fi
1617 fi
1618 AC_SUBST(XATTR_LIBS)
1620 dnl ****************************************
1621 dnl *** platform dependent source checks ***
1622 dnl ****************************************
1624 AC_MSG_CHECKING(for platform-dependent source)
1625 case "$host" in
1626 *-*-cygwin*|*-*-mingw*)
1627 PLATFORMDEP=gwin32.lo
1628 ;;
1629 *)
1630 PLATFORMDEP=
1631 ;;
1632 esac
1633 AC_MSG_RESULT($PLATFORMDEP)
1634 AC_SUBST(PLATFORMDEP)
1636 AC_MSG_CHECKING([whether to compile timeloop])
1637 case "$host" in
1638 *-*-cygwin*|*-*-mingw*|*-*-minix)
1639 enable_timeloop=no
1640 ;;
1641 *)
1642 enable_timeloop=yes
1643 ;;
1644 esac
1645 AC_MSG_RESULT($enable_timeloop)
1646 AM_CONDITIONAL(ENABLE_TIMELOOP, test x$enable_timeloop = xyes)
1648 AC_MSG_CHECKING([if building for some Win32 platform])
1649 case "$host" in
1650 *-*-mingw*|*-*-cygwin*)
1651 platform_win32=yes
1652 ;;
1653 *)
1654 platform_win32=no
1655 ;;
1656 esac
1657 AC_MSG_RESULT($platform_win32)
1658 AM_CONDITIONAL(PLATFORM_WIN32, test x$platform_win32 = xyes)
1660 dnl ***********************
1661 dnl *** g_thread checks ***
1662 dnl ***********************
1664 AC_ARG_WITH(threads,
1665 [AC_HELP_STRING([--with-threads=@<:@none/posix/dce/win32@:>@],
1666 [specify a thread implementation to use])],
1667 [if test "x$with_threads" = x; then
1668 want_threads=yes
1669 else
1670 want_threads=$with_threads
1671 fi],
1672 [want_threads=yes])
1673 if test "x$enable_threads" = "xno"; then
1674 want_threads=no
1675 fi
1677 dnl error and warning message
1678 dnl *************************
1680 THREAD_NO_IMPLEMENTATION="You do not have any known thread system on your
1681 computer. GLib will not have a default thread implementation."
1683 FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your
1684 platform (normally it's "_REENTRANT"). I'll not use any flag on
1685 compilation now, but then your programs might not work.
1686 Please provide information on how it is done on your system."
1688 LIBS_NOT_FOUND_1="I can't find the libraries for the thread implementation
1689 "
1691 LIBS_NOT_FOUND_2=". Please choose another thread implementation or
1692 provide information on your thread implementation.
1693 You can also run 'configure --disable-threads'
1694 to compile without thread support."
1696 FUNC_NO_GETPWUID_R="the 'g_get_(user_name|real_name|home_dir|tmp_dir)'
1697 functions will not be MT-safe during their first call because
1698 there is no working 'getpwuid_r' on your system."
1700 FUNC_NO_LOCALTIME_R="the 'g_date_set_time' function will not be MT-safe
1701 because there is no 'localtime_r' on your system."
1703 POSIX_NO_YIELD="I can not find a yield functions for your platform. A rather
1704 crude surrogate will be used. If you happen to know a
1705 yield function for your system, please inform the GLib
1706 developers."
1708 POSIX_NO_PRIORITIES="I can not find the minimal and maximal priorities for
1709 threads on your system. Thus threads can only have the default
1710 priority. If you happen to know these main/max
1711 priorities, please inform the GLib developers."
1713 AIX_COMPILE_INFO="AIX's C compiler needs to be called by a different name, when
1714 linking threaded applications. As GLib cannot do that
1715 automatically, you will get an linkg error everytime you are
1716 not using the right compiler. In that case you have to relink
1717 with the right compiler. Ususally just '_r' is appended
1718 to the compiler name."
1720 dnl determination of thread implementation
1721 dnl ***************************************
1723 # have_threads=no means no thread support
1724 # have_threads=none means no default thread implementation
1726 have_threads=no
1727 if test "x$want_threads" = xyes || test "x$want_threads" = xposix \
1728 || test "x$want_threads" = xdce; then
1729 # -D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE is for DG/UX
1730 # -U_OSF_SOURCE is for Digital UNIX 4.0d
1731 GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE"
1732 glib_save_CPPFLAGS="$CPPFLAGS"
1733 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1734 if test "x$have_threads" = xno; then
1735 AC_TRY_COMPILE([#include <pthread.h>],
1736 [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1737 have_threads=posix)
1738 fi
1739 if test "x$have_threads" = xno; then
1740 AC_TRY_COMPILE([#include <pthread.h>],
1741 [pthread_mutex_t m;
1742 pthread_mutex_init (&m, pthread_mutexattr_default);],
1743 have_threads=dce)
1744 fi
1745 # Tru64Unix requires -pthread to find pthread.h. See #103020
1746 CPPFLAGS="$CPPFLAGS -pthread"
1747 if test "x$have_threads" = xno; then
1748 AC_TRY_COMPILE([#include <pthread.h>],
1749 [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1750 have_threads=posix)
1751 fi
1752 CPPFLAGS="$glib_save_CPPFLAGS"
1753 fi
1754 if test "x$want_threads" = xyes || test "x$want_threads" = xwin32; then
1755 case $host in
1756 *-*-mingw*)
1757 have_threads=win32
1758 ;;
1759 esac
1760 fi
1761 if test "x$want_threads" = xnone; then
1762 have_threads=none
1763 fi
1765 AC_MSG_CHECKING(for thread implementation)
1767 if test "x$have_threads" = xno && test "x$want_threads" != xno; then
1768 AC_MSG_RESULT(none available)
1769 AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
1770 else
1771 AC_MSG_RESULT($have_threads)
1772 fi
1775 dnl determination of G_THREAD_CFLAGS
1776 dnl ********************************
1778 G_THREAD_LIBS=
1779 G_THREAD_LIBS_EXTRA=
1780 G_THREAD_CFLAGS=
1782 dnl
1783 dnl Test program for basic POSIX threads functionality
1784 dnl
1785 m4_define([glib_thread_test],[
1786 #include <pthread.h>
1787 int check_me = 0;
1788 void* func(void* data) {check_me = 42; return &check_me;}
1789 int main()
1790 { pthread_t t;
1791 void *ret;
1792 pthread_create (&t, $1, func, 0);
1793 pthread_join (t, &ret);
1794 return (check_me != 42 || ret != &check_me);
1795 }])
1797 dnl
1798 dnl Test program for sched_get_priority_min()
1799 dnl
1800 m4_define([glib_sched_priority_test],[
1801 #include <sched.h>
1802 #include <errno.h>
1803 int main() {
1804 errno = 0;
1805 return sched_get_priority_min(SCHED_OTHER)==-1
1806 && errno != 0;
1807 }])
1809 if test x"$have_threads" != xno; then
1811 if test x"$have_threads" = xposix; then
1812 # First we test for posix, whether -pthread or -pthreads do the trick as
1813 # both CPPFLAG and LIBS.
1814 # One of them does for most gcc versions and some other platforms/compilers
1815 # too and could be considered as the canonical way to go.
1816 case $host in
1817 *-*-cygwin*|*-*-darwin*)
1818 # skip cygwin and darwin -pthread or -pthreads test
1819 ;;
1820 *-solaris*)
1821 # These compiler/linker flags work with both Sun Studio and gcc
1822 # Sun Studio expands -mt to -D_REENTRANT and -lthread
1823 # gcc expands -pthreads to -D_REENTRANT -D_PTHREADS -lpthread
1824 G_THREAD_CFLAGS="-D_REENTRANT -D_PTHREADS"
1825 G_THREAD_LIBS="-lpthread -lthread"
1826 ;;
1827 *)
1828 for flag in pthread pthreads mt; do
1829 glib_save_CFLAGS="$CFLAGS"
1830 CFLAGS="$CFLAGS -$flag"
1831 AC_TRY_RUN(glib_thread_test(0),
1832 glib_flag_works=yes,
1833 glib_flag_works=no,
1834 [AC_LINK_IFELSE(glib_thread_test(0),
1835 glib_flag_works=yes,
1836 glib_flag_works=no)])
1837 CFLAGS="$glib_save_CFLAGS"
1838 if test $glib_flag_works = yes ; then
1839 G_THREAD_CFLAGS=-$flag
1840 G_THREAD_LIBS=-$flag
1841 break;
1842 fi
1843 done
1844 ;;
1845 esac
1846 fi
1848 if test x"$G_THREAD_CFLAGS" = x; then
1850 # The canonical -pthread[s] does not work. Try something different.
1852 case $host in
1853 *-aix*)
1854 if test x"$GCC" = xyes; then
1855 # GCC 3.0 and above needs -pthread.
1856 # Should be coverd by the case above.
1857 # GCC 2.x and below needs -mthreads
1858 G_THREAD_CFLAGS="-mthreads"
1859 G_THREAD_LIBS=$G_THREAD_CFLAGS
1860 else
1861 # We are probably using the aix compiler. Normaly a
1862 # program would have to be compiled with the _r variant
1863 # of the corresponding compiler, but we as GLib cannot
1864 # do that: but the good news is that for compiling the
1865 # only difference is the added -D_THREAD_SAFE compile
1866 # option. This is according to the "C for AIX User's
1867 # Guide".
1868 G_THREAD_CFLAGS="-D_THREAD_SAFE"
1869 fi
1870 ;;
1871 *-dg-dgux*) # DG/UX
1872 G_THREAD_CFLAGS="-D_REENTRANT -D_POSIX4A_DRAFT10_SOURCE"
1873 ;;
1874 *-osf*)
1875 # So we are using dce threads. posix threads are already
1876 # catched above.
1877 G_THREAD_CFLAGS="-threads"
1878 G_THREAD_LIBS=$G_THREAD_CFLAGS
1879 ;;
1880 *-sysv5uw7*) # UnixWare 7
1881 # We are not using gcc with -pthread. Catched above.
1882 G_THREAD_CFLAGS="-Kthread"
1883 G_THREAD_LIBS=$G_THREAD_CFLAGS
1884 ;;
1885 *-mingw*)
1886 # No flag needed when using MSVCRT.DLL
1887 G_THREAD_CFLAGS=""
1888 ;;
1889 *)
1890 G_THREAD_CFLAGS="-D_REENTRANT" # good default guess otherwise
1891 ;;
1892 esac
1894 fi
1896 # if we are not finding the localtime_r function, then we probably are
1897 # not using the proper multithread flag
1899 glib_save_CPPFLAGS="$CPPFLAGS"
1900 CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1902 # First we test, whether localtime_r is declared in time.h
1903 # directly. Then we test whether a macro localtime_r exists, in
1904 # which case localtime_r in the test program is replaced and thus
1905 # if we still find localtime_r in the output, it is not defined as
1906 # a macro.
1908 AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>], ,
1909 [AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>
1910 localtime_r(a,b)],
1911 AC_MSG_WARN($FLAG_DOES_NOT_WORK))])
1913 CPPFLAGS="$glib_save_CPPFLAGS"
1915 AC_MSG_CHECKING(thread related cflags)
1916 AC_MSG_RESULT($G_THREAD_CFLAGS)
1917 CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1918 fi
1920 dnl determination of G_THREAD_LIBS
1921 dnl ******************************
1923 mutex_has_default=no
1924 case $have_threads in
1925 posix|dce)
1926 glib_save_CPPFLAGS="$CPPFLAGS"
1927 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1928 if test x"$G_THREAD_LIBS" = x; then
1929 case $host in
1930 *-aix*)
1931 # We are not using gcc (would have set G_THREAD_LIBS) and thus
1932 # probably using the aix compiler.
1933 AC_MSG_WARN($AIX_COMPILE_INFO)
1934 ;;
1935 *)
1936 G_THREAD_LIBS=error
1937 glib_save_LIBS="$LIBS"
1938 for thread_lib in "" pthread pthread32 pthreads thread dce; do
1939 if test x"$thread_lib" = x; then
1940 add_thread_lib=""
1941 IN=""
1942 else
1943 add_thread_lib="-l$thread_lib"
1944 IN=" in -l$thread_lib"
1945 fi
1946 if test x"$have_threads" = xposix; then
1947 defattr=0
1948 else
1949 defattr=pthread_attr_default
1950 fi
1952 LIBS="$add_thread_lib $glib_save_LIBS"
1954 AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
1955 AC_TRY_RUN(glib_thread_test($defattr),
1956 glib_result=yes,
1957 glib_result=no,
1958 [AC_LINK_IFELSE(glib_thread_test($defattr),
1959 glib_result=yes,
1960 glib_result=no)])
1961 AC_MSG_RESULT($glib_result)
1963 if test "$glib_result" = "yes" ; then
1964 G_THREAD_LIBS="$add_thread_lib"
1965 break
1966 fi
1967 done
1968 if test "x$G_THREAD_LIBS" = xerror; then
1969 AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1970 fi
1971 LIBS="$glib_save_LIBS"
1972 ;;
1973 esac
1974 fi
1976 glib_save_LIBS="$LIBS"
1977 for thread_lib in "" rt rte; do
1978 if test x"$thread_lib" = x; then
1979 add_thread_lib=""
1980 IN=""
1981 else
1982 add_thread_lib="-l$thread_lib"
1983 IN=" in -l$thread_lib"
1984 fi
1985 LIBS="$add_thread_lib $glib_save_LIBS"
1987 AC_MSG_CHECKING(for sched_get_priority_min$IN)
1988 AC_TRY_RUN(glib_sched_priority_test,
1989 glib_result=yes,
1990 glib_result=no,
1991 [AC_LINK_IFELSE(glib_sched_priority_test,
1992 glib_result=yes,
1993 glib_result=no)])
1994 AC_MSG_RESULT($glib_result)
1996 if test "$glib_result" = "yes" ; then
1997 G_THREAD_LIBS="$G_THREAD_LIBS $add_thread_lib"
1998 posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
1999 posix_priority_max="sched_get_priority_max(SCHED_OTHER)"
2000 break
2001 fi
2002 done
2003 LIBS="$glib_save_LIBS"
2004 mutex_has_default=yes
2005 mutex_default_type='pthread_mutex_t'
2006 mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
2007 mutex_header_file='pthread.h'
2008 if test "x$have_threads" = "xposix"; then
2009 g_threads_impl="POSIX"
2010 else
2011 g_threads_impl="DCE"
2012 have_threads="posix"
2013 fi
2014 AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
2015 CPPFLAGS="$glib_save_CPPFLAGS"
2016 ;;
2017 win32)
2018 g_threads_impl="WIN32"
2019 ;;
2020 none|no)
2021 g_threads_impl="NONE"
2022 ;;
2023 *)
2024 g_threads_impl="NONE"
2025 G_THREAD_LIBS=error
2026 ;;
2027 esac
2029 if test "x$G_THREAD_LIBS" = xerror; then
2030 AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
2031 fi
2033 case $host in
2034 *-*-beos*)
2035 G_THREAD_LIBS="-lbe -lroot -lglib-2.0 "
2036 G_THREAD_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
2037 ;;
2038 *)
2039 ;;
2040 esac
2042 AC_MSG_CHECKING(thread related libraries)
2043 AC_MSG_RESULT($G_THREAD_LIBS)
2045 dnl check for mt safe function variants and some posix functions
2046 dnl ************************************************************
2048 if test x"$have_threads" != xno; then
2049 glib_save_LIBS="$LIBS"
2050 # we are not doing the following for now, as this might require glib
2051 # to always be linked with the thread libs on some platforms.
2052 # LIBS="$LIBS $G_THREAD_LIBS"
2053 AC_CHECK_FUNCS(localtime_r gmtime_r)
2054 if test "$ac_cv_header_pwd_h" = "yes"; then
2055 AC_CACHE_CHECK([for posix getpwuid_r],
2056 ac_cv_func_posix_getpwuid_r,
2057 [AC_TRY_RUN([
2058 #include <errno.h>
2059 #include <pwd.h>
2060 int main () {
2061 char buffer[10000];
2062 struct passwd pwd, *pwptr = &pwd;
2063 int error;
2064 errno = 0;
2065 error = getpwuid_r (0, &pwd, buffer,
2066 sizeof (buffer), &pwptr);
2067 return (error < 0 && errno == ENOSYS)
2068 || error == ENOSYS;
2069 } ],
2070 [ac_cv_func_posix_getpwuid_r=yes],
2071 [ac_cv_func_posix_getpwuid_r=no])])
2072 GLIB_ASSERT_SET(ac_cv_func_posix_getpwuid_r)
2073 if test "$ac_cv_func_posix_getpwuid_r" = yes; then
2074 AC_DEFINE(HAVE_POSIX_GETPWUID_R,1,
2075 [Have POSIX function getpwuid_r])
2076 else
2077 AC_CACHE_CHECK([for nonposix getpwuid_r],
2078 ac_cv_func_nonposix_getpwuid_r,
2079 [AC_TRY_LINK([#include <pwd.h>],
2080 [char buffer[10000];
2081 struct passwd pwd;
2082 getpwuid_r (0, &pwd, buffer,
2083 sizeof (buffer));],
2084 [ac_cv_func_nonposix_getpwuid_r=yes],
2085 [ac_cv_func_nonposix_getpwuid_r=no])])
2086 GLIB_ASSERT_SET(ac_cv_func_nonposix_getpwuid_r)
2087 if test "$ac_cv_func_nonposix_getpwuid_r" = yes; then
2088 AC_DEFINE(HAVE_NONPOSIX_GETPWUID_R,1,
2089 [Have non-POSIX function getpwuid_r])
2090 fi
2091 fi
2092 fi
2093 if test "$ac_cv_header_grp_h" = "yes"; then
2094 AC_CACHE_CHECK([for posix getgrgid_r],
2095 ac_cv_func_posix_getgrgid_r,
2096 [AC_TRY_RUN([
2097 #include <errno.h>
2098 #include <grp.h>
2099 int main () {
2100 char buffer[10000];
2101 struct group grp, *grpptr = &grp;
2102 int error;
2103 errno = 0;
2104 error = getgrgid_r (0, &grp, buffer,
2105 sizeof (buffer), &grpptr);
2106 return (error < 0 && errno == ENOSYS)
2107 || error == ENOSYS;
2108 } ],
2109 [ac_cv_func_posix_getgrgid_r=yes],
2110 [ac_cv_func_posix_getgrgid_r=no])])
2111 GLIB_ASSERT_SET(ac_cv_func_posix_getgrgid_r)
2112 if test "$ac_cv_func_posix_getgrgid_r" = yes; then
2113 AC_DEFINE(HAVE_POSIX_GETGRGID_R,1,
2114 [Have POSIX function getgrgid_r])
2115 else
2116 AC_CACHE_CHECK([for nonposix getgrgid_r],
2117 ac_cv_func_nonposix_getgrgid_r,
2118 [AC_TRY_LINK([#include <grp.h>],
2119 [char buffer[10000];
2120 struct group grp;
2121 getgrgid_r (0, &grp, buffer,
2122 sizeof (buffer));],
2123 [ac_cv_func_nonposix_getgrgid_r=yes],
2124 [ac_cv_func_nonposix_getgrgid_r=no])])
2125 GLIB_ASSERT_SET(ac_cv_func_nonposix_getgrgid_r)
2126 if test "$ac_cv_func_nonposix_getgrgid_r" = yes; then
2127 AC_DEFINE(HAVE_NONPOSIX_GETGRGID_R,1,
2128 [Have non-POSIX function getgrgid_r])
2129 fi
2130 fi
2131 fi
2132 LIBS="$G_THREAD_LIBS $LIBS"
2133 if test x"$have_threads" = xposix; then
2134 glib_save_CPPFLAGS="$CPPFLAGS"
2135 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
2136 dnl we might grow sizeof(pthread_t) later on, so use a dummy name here
2137 GLIB_SIZEOF([#include <pthread.h>], pthread_t, system_thread)
2138 # This is not AC_CHECK_FUNC to also work with function
2139 # name mangling in header files.
2140 AC_MSG_CHECKING(for pthread_attr_setstacksize)
2141 AC_TRY_LINK([#include <pthread.h>],
2142 [pthread_attr_t t; pthread_attr_setstacksize(&t,0)],
2143 [AC_MSG_RESULT(yes)
2144 AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE,1,
2145 [Have function pthread_attr_setstacksize])],
2146 [AC_MSG_RESULT(no)])
2147 AC_MSG_CHECKING(for minimal/maximal thread priority)
2148 if test x"$posix_priority_min" = x; then
2149 AC_EGREP_CPP(PX_PRIO_MIN,[#include <pthread.h>
2150 PX_PRIO_MIN],,[
2151 posix_priority_min=PX_PRIO_MIN
2152 posix_priority_max=PX_PRIO_MAX])
2153 fi
2154 if test x"$posix_priority_min" = x; then
2155 # AIX
2156 AC_EGREP_CPP(PTHREAD_PRIO_MIN,[#include <pthread.h>
2157 PTHREAD_PRIO_MIN],,[
2158 posix_priority_min=PTHREAD_PRIO_MIN
2159 posix_priority_max=PTHREAD_PRIO_MAX])
2160 fi
2161 if test x"$posix_priority_min" = x; then
2162 AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
2163 PRI_OTHER_MIN],,[
2164 posix_priority_min=PRI_OTHER_MIN
2165 posix_priority_max=PRI_OTHER_MAX])
2166 fi
2167 if test x"$posix_priority_min" = x; then
2168 AC_MSG_RESULT(none found)
2169 AC_MSG_WARN($POSIX_NO_PRIORITIES)
2170 posix_priority_min=-1
2171 posix_priority_max=-1
2172 else
2173 AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
2174 AC_MSG_CHECKING(for pthread_setschedparam)
2175 AC_TRY_LINK([#include <pthread.h>],
2176 [pthread_t t; pthread_setschedparam(t, 0, NULL)],
2177 [AC_MSG_RESULT(yes)
2178 AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
2179 AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])],
2180 [AC_MSG_RESULT(no)
2181 AC_MSG_WARN($POSIX_NO_PRIORITIES)])
2182 fi
2183 posix_yield_func=none
2184 AC_MSG_CHECKING(for posix yield function)
2185 for yield_func in sched_yield pthread_yield_np pthread_yield \
2186 thr_yield; do
2187 AC_TRY_LINK([#include <pthread.h>],
2188 [$yield_func()],
2189 [posix_yield_func="$yield_func"
2190 break])
2191 done
2192 if test x"$posix_yield_func" = xnone; then
2193 AC_MSG_RESULT(none found)
2194 AC_MSG_WARN($POSIX_NO_YIELD)
2195 posix_yield_func="g_usleep(1000)"
2196 else
2197 AC_MSG_RESULT($posix_yield_func)
2198 posix_yield_func="$posix_yield_func()"
2199 fi
2200 AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func,[The POSIX RT yield function])
2201 CPPFLAGS="$glib_save_CPPFLAGS"
2203 elif test x"$have_threads" = xwin32; then
2204 # It's a pointer to a private struct
2205 GLIB_SIZEOF(,struct _GThreadData *, system_thread)
2206 fi
2208 LIBS="$glib_save_LIBS"
2210 # now spit out all the warnings.
2211 if test "$ac_cv_func_posix_getpwuid_r" != "yes" &&
2212 test "$ac_cv_func_nonposix_getpwuid_r" != "yes"; then
2213 AC_MSG_WARN($FUNC_NO_GETPWUID_R)
2214 fi
2215 if test "$ac_cv_func_localtime_r" != "yes"; then
2216 AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
2217 fi
2218 fi
2220 if test x"$glib_cv_sizeof_system_thread" = x; then
2221 # use a pointer as a fallback.
2222 GLIB_SIZEOF(,void *, system_thread)
2223 fi
2225 #
2226 # Hack to deal with:
2227 #
2228 # a) GCC < 3.3 for Linux doesn't include -lpthread when
2229 # building shared libraries with linux.
2230 # b) FreeBSD doesn't do this either.
2231 #
2232 case $host in
2233 *-*-freebsd*|*-*-linux*)
2234 G_THREAD_LIBS_FOR_GTHREAD="`echo $G_THREAD_LIBS | sed s/-pthread/-lpthread/`"
2235 ;;
2236 *)
2237 G_THREAD_LIBS_FOR_GTHREAD="$G_THREAD_LIBS"
2238 ;;
2239 esac
2241 AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
2242 [Source file containing theread implementation])
2243 AC_SUBST(G_THREAD_CFLAGS)
2244 AC_SUBST(G_THREAD_LIBS)
2245 AC_SUBST(G_THREAD_LIBS_FOR_GTHREAD)
2246 AC_SUBST(G_THREAD_LIBS_EXTRA)
2248 dnl **********************************************
2249 dnl *** GDefaultMutex setup and initialization ***
2250 dnl **********************************************
2251 dnl
2252 dnl if mutex_has_default = yes, we also got
2253 dnl mutex_default_type, mutex_default_init and mutex_header_file
2254 if test $mutex_has_default = yes ; then
2255 glib_save_CPPFLAGS="$CPPFLAGS"
2256 glib_save_LIBS="$LIBS"
2257 LIBS="$G_THREAD_LIBS $LIBS"
2258 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
2259 GLIB_SIZEOF([#include <$mutex_header_file>],
2260 $mutex_default_type,
2261 gmutex)
2262 GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
2263 $mutex_default_type,
2264 gmutex,
2265 $glib_cv_sizeof_gmutex,
2266 $mutex_default_init)
2267 if test x"$glib_cv_byte_contents_gmutex" = xno; then
2268 mutex_has_default=no
2269 fi
2270 CPPFLAGS="$glib_save_CPPFLAGS"
2271 LIBS="$glib_save_LIBS"
2272 fi
2274 AC_CHECK_FUNCS(clock_gettime, [], [
2275 AC_CHECK_LIB(rt, clock_gettime, [
2276 AC_DEFINE(HAVE_CLOCK_GETTIME, 1)
2277 G_THREAD_LIBS="$G_THREAD_LIBS -lrt"
2278 G_THREAD_LIBS_FOR_GTHREAD="$G_THREAD_LIBS_FOR_GTHREAD -lrt"
2279 ])
2280 ])
2282 AC_CACHE_CHECK(for monotonic clocks,
2283 glib_cv_monotonic_clock,AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
2284 #include <time.h>
2285 #include <unistd.h>
2286 int main() {
2287 #if !(defined(_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK >= 0 && defined(CLOCK_MONOTONIC))
2288 #error No monotonic clock
2289 #endif
2290 return 0;
2291 }
2292 ]])],glib_cv_monotonic_clock=yes,glib_cv_monotonic_clock=no))
2293 if test "$glib_cv_monotonic_clock" = "yes"; then
2294 AC_DEFINE(HAVE_MONOTONIC_CLOCK,1,[Have a monotonic clock])
2295 fi
2298 dnl ********************************
2299 dnl *** g_atomic_* tests for gcc ***
2300 dnl ********************************
2302 AC_MSG_CHECKING([whether to use assembler code for atomic operations])
2304 if test x"$GCC" = xyes; then
2305 case $host_cpu in
2306 i386)
2307 AC_MSG_RESULT([none])
2308 glib_memory_barrier_needed=no
2309 ;;
2310 i?86)
2311 AC_MSG_RESULT([i486])
2312 AC_DEFINE_UNQUOTED(G_ATOMIC_I486, 1,
2313 [i486 atomic implementation])
2314 glib_memory_barrier_needed=no
2315 ;;
2316 sparc*)
2317 SPARCV9_WARNING="Try to rerun configure with CFLAGS='-mcpu=v9',
2318 when you are using a sparc with v9 instruction set (most
2319 sparcs nowadays). This will make the code for atomic
2320 operations much faster. The resulting code will not run
2321 on very old sparcs though."
2323 AC_LINK_IFELSE([[
2324 main ()
2325 {
2326 int tmp1, tmp2, tmp3;
2327 __asm__ __volatile__("casx [%2], %0, %1"
2328 : "=&r" (tmp1), "=&r" (tmp2) : "r" (&tmp3));
2329 }]],
2330 AC_MSG_RESULT([sparcv9])
2331 AC_DEFINE_UNQUOTED(G_ATOMIC_SPARCV9, 1,
2332 [sparcv9 atomic implementation]),
2333 AC_MSG_RESULT([no])
2334 AC_MSG_WARN([[$SPARCV9_WARNING]]))
2335 glib_memory_barrier_needed=yes
2336 ;;
2337 alpha*)
2338 AC_MSG_RESULT([alpha])
2339 AC_DEFINE_UNQUOTED(G_ATOMIC_ALPHA, 1,
2340 [alpha atomic implementation])
2341 glib_memory_barrier_needed=yes
2342 ;;
2343 x86_64)
2344 AC_MSG_RESULT([x86_64])
2345 AC_DEFINE_UNQUOTED(G_ATOMIC_X86_64, 1,
2346 [x86_64 atomic implementation])
2347 glib_memory_barrier_needed=no
2348 ;;
2349 powerpc*)
2350 AC_MSG_RESULT([powerpc])
2351 AC_DEFINE_UNQUOTED(G_ATOMIC_POWERPC, 1,
2352 [powerpc atomic implementation])
2353 glib_memory_barrier_needed=yes
2354 AC_MSG_CHECKING([whether asm supports numbered local labels])
2355 AC_TRY_COMPILE(
2356 ,[
2357 __asm__ __volatile__ ("1: nop\n"
2358 " bne- 1b")
2359 ],[
2360 AC_DEFINE_UNQUOTED(ASM_NUMERIC_LABELS, 1, [define if asm blocks can use numeric local labels])
2361 AC_MSG_RESULT([yes])
2362 ],[
2363 AC_MSG_RESULT([no])
2364 ])
2365 ;;
2366 ia64)
2367 AC_MSG_RESULT([ia64])
2368 AC_DEFINE_UNQUOTED(G_ATOMIC_IA64, 1,
2369 [ia64 atomic implementation])
2370 glib_memory_barrier_needed=yes
2371 ;;
2372 s390|s390x)
2373 AC_MSG_RESULT([s390])
2374 AC_DEFINE_UNQUOTED(G_ATOMIC_S390, 1,
2375 [s390 atomic implementation])
2376 glib_memory_barrier_needed=no
2377 ;;
2378 arm*)
2379 AC_MSG_RESULT([arm])
2380 AC_DEFINE_UNQUOTED(G_ATOMIC_ARM, 1,
2381 [arm atomic implementation])
2382 glib_memory_barrier_needed=no
2383 ;;
2384 *)
2385 AC_MSG_RESULT([none])
2386 glib_memory_barrier_needed=yes
2387 ;;
2388 esac
2389 else
2390 if test $glib_native_win32 = yes; then
2391 # For Windows but not using gcc. No barriers needed then either.
2392 glib_memory_barrier_needed=no
2393 fi
2394 fi
2396 dnl ****************************************
2397 dnl *** GLib POLL* compatibility defines ***
2398 dnl ****************************************
2400 glib_poll_includes=["
2401 #include <sys/types.h>
2402 #include <sys/poll.h>
2403 "]
2405 if test $ac_cv_header_sys_types_h = yes &&
2406 test $ac_cv_header_sys_poll_h = yes ; then
2407 glib_failed=false
2408 GLIB_CHECK_VALUE(POLLIN, $glib_poll_includes, glib_failed=true)
2409 GLIB_CHECK_VALUE(POLLOUT, $glib_poll_includes, glib_failed=true)
2410 GLIB_CHECK_VALUE(POLLPRI, $glib_poll_includes, glib_failed=true)
2411 GLIB_CHECK_VALUE(POLLERR, $glib_poll_includes, glib_failed=true)
2412 GLIB_CHECK_VALUE(POLLHUP, $glib_poll_includes, glib_failed=true)
2413 GLIB_CHECK_VALUE(POLLNVAL, $glib_poll_includes, glib_failed=true)
2414 if $glib_failed ; then
2415 AC_MSG_ERROR([Could not determine values for POLL* constants])
2416 fi
2417 else
2418 glib_cv_value_POLLIN=1
2419 glib_cv_value_POLLOUT=4
2420 glib_cv_value_POLLPRI=2
2421 glib_cv_value_POLLERR=8
2422 glib_cv_value_POLLHUP=16
2423 glib_cv_value_POLLNVAL=32
2424 fi
2426 AC_MSG_CHECKING([for broken poll])
2427 AC_RUN_IFELSE([AC_LANG_SOURCE([[
2428 #include <stdlib.h>
2429 #include <fcntl.h>
2430 #include <poll.h>
2431 #ifdef HAVE_SYS_POLL_H
2432 #include <sys/poll.h>
2433 #endif
2434 int main(void) {
2435 struct pollfd fds[1];
2436 int fd;
2437 fd = open("/dev/null", 1);
2438 fds[0].fd = fd;
2439 fds[0].events = POLLIN;
2440 fds[0].revents = 0;
2441 if (poll(fds, 1, 0) < 0 || (fds[0].revents & POLLNVAL) != 0) {
2442 exit(1); /* Does not work for devices -- fail */
2443 }
2444 exit(0);
2445 }]])],
2446 [broken_poll=no],
2447 [broken_poll=yes
2448 AC_DEFINE(BROKEN_POLL,1,[poll doesn't work on devices])],
2449 [broken_poll="no (cross compiling)"])
2450 AC_MSG_RESULT($broken_poll)
2452 dnl *********************
2453 dnl *** GRegex checks ***
2454 dnl *********************
2455 PCRE_REQUIRED_VERSION=7.2
2457 # Check if we should compile GRegex
2458 AC_ARG_ENABLE(regex, AC_HELP_STRING([--disable-regex],
2459 [disable the compilation of GRegex]),
2460 [case "${enableval}" in
2461 yes) enable_regex=true ;;
2462 no) enable_regex=false ;;
2463 *) AC_MSG_ERROR(bad value ${enableval} for --enable-regex) ;;
2464 esac],
2465 [enable_regex=true])
2467 AM_CONDITIONAL(ENABLE_REGEX, $enable_regex)
2469 if test x$enable_regex = xtrue; then
2470 # Check if we should use the internal or the system-supplied pcre
2471 AC_ARG_WITH(pcre,
2472 [AC_HELP_STRING([--with-pcre=@<:@internal/system@:>@],
2473 [specify whether to use the internal or the
2474 system-supplied PCRE library])])
2476 AM_CONDITIONAL(USE_SYSTEM_PCRE, [test "x$with_pcre" = xsystem])
2478 if test "x$with_pcre" = xsystem; then
2479 PKG_CHECK_MODULES(PCRE,
2480 libpcre >= $PCRE_REQUIRED_VERSION)
2481 AC_CACHE_CHECK([for Unicode support in PCRE],glib_cv_pcre_has_unicode,[
2482 glib_save_CFLAGS="$CFLAGS"
2483 glib_save_LIBS="$LIBS"
2484 CFLAGS="$CFLAGS $PCRE_CFLAGS" LIBS="$PCRE_LIBS"
2485 AC_TRY_RUN([#include <pcre.h>
2486 int main () {
2487 int support;
2488 pcre_config (PCRE_CONFIG_UTF8, &support);
2489 if (!support)
2490 return 1;
2491 pcre_config (PCRE_CONFIG_UNICODE_PROPERTIES, &support);
2492 if (!support)
2493 return 1;
2494 return 0;
2495 }],
2496 glib_cv_pcre_has_unicode=yes,
2497 glib_cv_pcre_has_unicode=no,
2498 glib_cv_pcre_has_unicode=yes)
2499 CFLAGS="$glib_save_CFLAGS"
2500 LIBS="$glib_save_LIBS"
2501 ])
2502 if test "$glib_cv_pcre_has_unicode" = "no"; then
2503 AC_MSG_ERROR([*** The system-supplied PCRE does not support Unicode properties or UTF-8.])
2504 fi
2505 AC_SUBST(PCRE_CFLAGS)
2506 AC_SUBST(PCRE_LIBS)
2507 AC_DEFINE(USE_SYSTEM_PCRE, [], [using the system-supplied PCRE library])
2508 PCRE_REQUIRES=libpcre
2509 AC_SUBST(PCRE_REQUIRES)
2510 else
2511 # If using gcc 4 pass -Wno-pointer-sign when compiling the internal PCRE
2512 if test x"$GCC" = xyes; then
2513 AC_MSG_CHECKING([whether compiler understands -Wno-pointer-sign])
2514 save_CFLAGS="$CFLAGS"
2515 CFLAGS="$CFLAGS -Wno-pointer-sign"
2516 AC_TRY_COMPILE([],[],[PCRE_WARN_CFLAGS="$PCRE_WARN_CFLAGS -Wno-pointer-sign"
2517 AC_MSG_RESULT(yes)],[AC_MSG_RESULT(no)])
2518 CFLAGS="$save_CFLAGS"
2519 fi
2520 fi
2521 AC_SUBST(PCRE_WARN_CFLAGS)
2522 else
2523 AM_CONDITIONAL(USE_SYSTEM_PCRE, false])
2524 fi
2526 dnl **********************
2527 dnl *** Win32 API libs ***
2528 dnl **********************
2530 case $host in
2531 *-*-cygwin*)
2532 G_LIBS_EXTRA="-luser32 -lkernel32"
2533 ;;
2534 *-*-mingw*)
2535 G_LIBS_EXTRA="-lws2_32 -lole32"
2536 ;;
2537 *)
2538 G_LIBS_EXTRA=""
2539 ;;
2540 esac
2541 AC_SUBST(G_LIBS_EXTRA)
2543 dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
2544 dnl since we need it for g_iconv()
2546 AC_MSG_CHECKING([for EILSEQ])
2547 AC_TRY_COMPILE([
2548 #include <errno.h>
2549 ],
2550 [
2551 int error = EILSEQ;
2552 ], have_eilseq=yes, have_eilseq=no);
2553 AC_MSG_RESULT($have_eilseq)
2555 dnl ******************************************************************
2556 dnl *** Look for glib-genmarshal in PATH if we are cross-compiling ***
2557 dnl ******************************************************************
2559 AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
2561 if test $cross_compiling = yes; then
2562 AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal, no)
2563 if test x$GLIB_GENMARSHAL = xno; then
2564 AC_MSG_ERROR(Could not find a glib-genmarshal in your PATH)
2565 fi
2566 fi
2568 dnl **************************
2569 dnl *** Checks for gtk-doc ***
2570 dnl **************************
2572 GTK_DOC_CHECK([1.8])
2574 AC_ARG_ENABLE(man,
2575 [AC_HELP_STRING([--enable-man],
2576 [regenerate man pages from Docbook [default=no]])],enable_man=yes,
2577 enable_man=no)
2579 if test "${enable_man}" != no; then
2580 dnl
2581 dnl Check for xsltproc
2582 dnl
2583 AC_PATH_PROG([XSLTPROC], [xsltproc])
2584 if test -z "$XSLTPROC"; then
2585 enable_man=no
2586 fi
2588 dnl check for DocBook DTD and stylesheets in the local catalog.
2589 JH_CHECK_XML_CATALOG([-//OASIS//DTD DocBook XML V4.1.2//EN],
2590 [DocBook XML DTD V4.1.2],,enable_man=no)
2591 JH_CHECK_XML_CATALOG([http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl],
2592 [DocBook XSL Stylesheets],,enable_man=no)
2593 fi
2595 AM_CONDITIONAL(ENABLE_MAN, test x$enable_man != xno)
2597 dnl ******************************
2598 dnl *** output the whole stuff ***
2599 dnl ******************************
2601 dnl this section will only be run if config.status is invoked with no
2602 dnl arguments, or with "glibconfig.h" as an argument.
2603 AC_CONFIG_COMMANDS([glibconfig.h],
2604 [
2605 outfile=glibconfig.h-tmp
2606 cat > $outfile <<\_______EOF
2607 /* glibconfig.h
2608 *
2609 * This is a generated file. Please modify 'configure.in'
2610 */
2612 #ifndef __G_LIBCONFIG_H__
2613 #define __G_LIBCONFIG_H__
2615 #include <glib/gmacros.h>
2617 _______EOF
2619 if test x$glib_limits_h = xyes; then
2620 echo '#include <limits.h>' >> $outfile
2621 fi
2622 if test x$glib_float_h = xyes; then
2623 echo '#include <float.h>' >> $outfile
2624 fi
2625 if test x$glib_values_h = xyes; then
2626 echo '#include <values.h>' >> $outfile
2627 fi
2628 if test "$glib_header_alloca_h" = "yes"; then
2629 echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
2630 fi
2631 if test x$glib_sys_poll_h = xyes; then
2632 echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
2633 fi
2634 if test x$enable_included_printf != xyes; then
2635 echo "
2636 /* Specifies that GLib's g_print*() functions wrap the
2637 * system printf functions. This is useful to know, for example,
2638 * when using glibc's register_printf_function().
2639 */" >> $outfile
2640 echo '#define GLIB_USING_SYSTEM_PRINTF' >> $outfile
2641 fi
2643 cat >> $outfile <<_______EOF
2645 G_BEGIN_DECLS
2647 #define G_MINFLOAT $glib_mf
2648 #define G_MAXFLOAT $glib_Mf
2649 #define G_MINDOUBLE $glib_md
2650 #define G_MAXDOUBLE $glib_Md
2651 #define G_MINSHORT $glib_ms
2652 #define G_MAXSHORT $glib_Ms
2653 #define G_MAXUSHORT $glib_Mus
2654 #define G_MININT $glib_mi
2655 #define G_MAXINT $glib_Mi
2656 #define G_MAXUINT $glib_Mui
2657 #define G_MINLONG $glib_ml
2658 #define G_MAXLONG $glib_Ml
2659 #define G_MAXULONG $glib_Mul
2661 _______EOF
2664 ### this should always be true in a modern C/C++ compiler
2665 cat >>$outfile <<_______EOF
2666 typedef signed char gint8;
2667 typedef unsigned char guint8;
2668 _______EOF
2671 if test -n "$gint16"; then
2672 cat >>$outfile <<_______EOF
2673 typedef signed $gint16 gint16;
2674 typedef unsigned $gint16 guint16;
2675 #define G_GINT16_MODIFIER $gint16_modifier
2676 #define G_GINT16_FORMAT $gint16_format
2677 #define G_GUINT16_FORMAT $guint16_format
2678 _______EOF
2679 fi
2682 if test -n "$gint32"; then
2683 cat >>$outfile <<_______EOF
2684 typedef signed $gint32 gint32;
2685 typedef unsigned $gint32 guint32;
2686 #define G_GINT32_MODIFIER $gint32_modifier
2687 #define G_GINT32_FORMAT $gint32_format
2688 #define G_GUINT32_FORMAT $guint32_format
2689 _______EOF
2690 fi
2692 cat >>$outfile <<_______EOF
2693 #define G_HAVE_GINT64 1 /* deprecated, always true */
2695 ${glib_extension}typedef signed $gint64 gint64;
2696 ${glib_extension}typedef unsigned $gint64 guint64;
2698 #define G_GINT64_CONSTANT(val) $gint64_constant
2699 #define G_GUINT64_CONSTANT(val) $guint64_constant
2700 _______EOF
2702 if test x$gint64_format != x ; then
2703 cat >>$outfile <<_______EOF
2704 #define G_GINT64_MODIFIER $gint64_modifier
2705 #define G_GINT64_FORMAT $gint64_format
2706 #define G_GUINT64_FORMAT $guint64_format
2707 _______EOF
2708 else
2709 cat >>$outfile <<_______EOF
2710 #undef G_GINT64_MODIFIER
2711 #undef G_GINT64_FORMAT
2712 #undef G_GUINT64_FORMAT
2713 _______EOF
2714 fi
2716 cat >>$outfile <<_______EOF
2718 #define GLIB_SIZEOF_VOID_P $glib_void_p
2719 #define GLIB_SIZEOF_LONG $glib_long
2720 #define GLIB_SIZEOF_SIZE_T $glib_size_t
2722 _______EOF
2724 cat >>$outfile <<_______EOF
2725 typedef signed $glib_size_type_define gssize;
2726 typedef unsigned $glib_size_type_define gsize;
2727 #define G_GSIZE_MODIFIER $gsize_modifier
2728 #define G_GSSIZE_FORMAT $gssize_format
2729 #define G_GSIZE_FORMAT $gsize_format
2731 #define G_MAXSIZE G_MAXU$glib_msize_type
2732 #define G_MINSSIZE G_MIN$glib_msize_type
2733 #define G_MAXSSIZE G_MAX$glib_msize_type
2735 typedef gint64 goffset;
2736 #define G_MINOFFSET G_MININT64
2737 #define G_MAXOFFSET G_MAXINT64
2739 _______EOF
2741 if test -z "$glib_unknown_void_p"; then
2742 cat >>$outfile <<_______EOF
2744 #define GPOINTER_TO_INT(p) ((gint) ${glib_gpi_cast} (p))
2745 #define GPOINTER_TO_UINT(p) ((guint) ${glib_gpui_cast} (p))
2747 #define GINT_TO_POINTER(i) ((gpointer) ${glib_gpi_cast} (i))
2748 #define GUINT_TO_POINTER(u) ((gpointer) ${glib_gpui_cast} (u))
2749 _______EOF
2750 else
2751 echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
2752 fi
2756 cat >>$outfile <<_______EOF
2757 $glib_atexit
2758 $glib_memmove
2759 $glib_defines
2760 $glib_os
2761 $glib_static_compilation
2763 $glib_vacopy
2765 #ifdef __cplusplus
2766 #define G_HAVE_INLINE 1
2767 #else /* !__cplusplus */
2768 $glib_inline
2769 #endif /* !__cplusplus */
2771 #ifdef __cplusplus
2772 #define G_CAN_INLINE 1
2773 _______EOF
2775 if test x$g_can_inline = xyes ; then
2776 cat >>$outfile <<_______EOF
2777 #else /* !__cplusplus */
2778 #define G_CAN_INLINE 1
2779 _______EOF
2780 fi
2782 cat >>$outfile <<_______EOF
2783 #endif
2785 _______EOF
2787 if test x$g_have_iso_c_varargs = xyes ; then
2788 cat >>$outfile <<_______EOF
2789 #ifndef __cplusplus
2790 # define G_HAVE_ISO_VARARGS 1
2791 #endif
2792 _______EOF
2793 fi
2794 if test x$g_have_iso_cxx_varargs = xyes ; then
2795 cat >>$outfile <<_______EOF
2796 #ifdef __cplusplus
2797 # define G_HAVE_ISO_VARARGS 1
2798 #endif
2799 _______EOF
2800 fi
2801 if test x$g_have_gnuc_varargs = xyes ; then
2802 cat >>$outfile <<_______EOF
2804 /* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
2805 * is passed ISO vararg support is turned off, and there is no work
2806 * around to turn it on, so we unconditionally turn it off.
2807 */
2808 #if __GNUC__ == 2 && __GNUC_MINOR__ == 95
2809 # undef G_HAVE_ISO_VARARGS
2810 #endif
2812 #define G_HAVE_GNUC_VARARGS 1
2813 _______EOF
2814 fi
2816 case x$g_stack_grows in
2817 xyes) echo "#define G_HAVE_GROWING_STACK 1" >>$outfile ;;
2818 *) echo "#define G_HAVE_GROWING_STACK 0" >>$outfile ;;
2819 esac
2822 echo >>$outfile
2823 if test x$g_have_eilseq = xno; then
2824 cat >>$outfile <<_______EOF
2825 #ifndef EILSEQ
2826 /* On some systems, like SunOS and NetBSD, EILSEQ is not defined.
2827 * The correspondence between this and the corresponding definition
2828 * in libiconv is essential.
2829 */
2830 # define EILSEQ ENOENT
2831 #endif
2832 _______EOF
2834 fi
2836 if test x$g_have_gnuc_visibility = xyes; then
2837 cat >>$outfile <<_______EOF
2838 #define G_HAVE_GNUC_VISIBILITY 1
2839 _______EOF
2840 fi
2841 cat >>$outfile <<_______EOF
2842 #if defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
2843 #define G_GNUC_INTERNAL __hidden
2844 #elif defined (__GNUC__) && defined (G_HAVE_GNUC_VISIBILITY)
2845 #define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
2846 #else
2847 #define G_GNUC_INTERNAL
2848 #endif
2849 _______EOF
2852 echo >>$outfile
2853 if test x$g_mutex_has_default = xyes; then
2854 cat >>$outfile <<_______EOF
2855 $g_enable_threads_def G_THREADS_ENABLED
2856 #define G_THREADS_IMPL_$g_threads_impl_def
2857 typedef struct _GStaticMutex GStaticMutex;
2858 struct _GStaticMutex
2859 {
2860 struct _GMutex *runtime_mutex;
2861 union {
2862 char pad[[$g_mutex_sizeof]];
2863 double dummy_double;
2864 void *dummy_pointer;
2865 long dummy_long;
2866 } static_mutex;
2867 };
2868 #define G_STATIC_MUTEX_INIT { NULL, { { $g_mutex_contents} } }
2869 #define g_static_mutex_get_mutex(mutex) \\
2870 (g_thread_use_default_impl ? ((GMutex*) ((mutex)->static_mutex.pad)) : \\
2871 g_static_mutex_get_mutex_impl_shortcut (&((mutex)->runtime_mutex)))
2872 _______EOF
2873 else
2874 cat >>$outfile <<_______EOF
2875 $g_enable_threads_def G_THREADS_ENABLED
2876 #define G_THREADS_IMPL_$g_threads_impl_def
2877 typedef struct _GMutex* GStaticMutex;
2878 #define G_STATIC_MUTEX_INIT NULL
2879 #define g_static_mutex_get_mutex(mutex) \\
2880 (g_static_mutex_get_mutex_impl_shortcut (mutex))
2881 _______EOF
2882 fi
2884 cat >>$outfile <<_______EOF
2885 /* This represents a system thread as used by the implementation. An
2886 * alien implementaion, as loaded by g_thread_init can only count on
2887 * "sizeof (gpointer)" bytes to store their info. We however need more
2888 * for some of our native implementations. */
2889 typedef union _GSystemThread GSystemThread;
2890 union _GSystemThread
2891 {
2892 char data[[$g_system_thread_sizeof]];
2893 double dummy_double;
2894 void *dummy_pointer;
2895 long dummy_long;
2896 };
2897 _______EOF
2898 if test x"$g_memory_barrier_needed" != xno; then
2899 echo >>$outfile
2900 echo "#define G_ATOMIC_OP_MEMORY_BARRIER_NEEDED 1" >>$outfile
2901 fi
2903 echo >>$outfile
2904 g_bit_sizes="16 32 64"
2905 for bits in $g_bit_sizes; do
2906 cat >>$outfile <<_______EOF
2907 #define GINT${bits}_TO_${g_bs_native}(val) ((gint${bits}) (val))
2908 #define GUINT${bits}_TO_${g_bs_native}(val) ((guint${bits}) (val))
2909 #define GINT${bits}_TO_${g_bs_alien}(val) ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
2910 #define GUINT${bits}_TO_${g_bs_alien}(val) (GUINT${bits}_SWAP_LE_BE (val))
2911 _______EOF
2912 done
2914 cat >>$outfile <<_______EOF
2915 #define GLONG_TO_LE(val) ((glong) GINT${glongbits}_TO_LE (val))
2916 #define GULONG_TO_LE(val) ((gulong) GUINT${glongbits}_TO_LE (val))
2917 #define GLONG_TO_BE(val) ((glong) GINT${glongbits}_TO_BE (val))
2918 #define GULONG_TO_BE(val) ((gulong) GUINT${glongbits}_TO_BE (val))
2919 #define GINT_TO_LE(val) ((gint) GINT${gintbits}_TO_LE (val))
2920 #define GUINT_TO_LE(val) ((guint) GUINT${gintbits}_TO_LE (val))
2921 #define GINT_TO_BE(val) ((gint) GINT${gintbits}_TO_BE (val))
2922 #define GUINT_TO_BE(val) ((guint) GUINT${gintbits}_TO_BE (val))
2923 #define G_BYTE_ORDER $g_byte_order
2925 #define GLIB_SYSDEF_POLLIN =$g_pollin
2926 #define GLIB_SYSDEF_POLLOUT =$g_pollout
2927 #define GLIB_SYSDEF_POLLPRI =$g_pollpri
2928 #define GLIB_SYSDEF_POLLHUP =$g_pollhup
2929 #define GLIB_SYSDEF_POLLERR =$g_pollerr
2930 #define GLIB_SYSDEF_POLLNVAL =$g_pollnval
2932 #define G_MODULE_SUFFIX "$g_module_suffix"
2934 typedef $g_pid_type GPid;
2936 G_END_DECLS
2938 #endif /* GLIBCONFIG_H */
2939 _______EOF
2942 if cmp -s $outfile glibconfig.h; then
2943 AC_MSG_NOTICE([glibconfig.h is unchanged])
2944 rm -f $outfile
2945 else
2946 mv $outfile glibconfig.h
2947 fi
2948 ],[
2950 # Note that if two cases are the same, case goes with the first one.
2951 # Note also that this is inside an AC_OUTPUT_COMMAND. We do not depend
2952 # on variable expansion in case labels. Look at the generated config.status
2953 # for a hint.
2955 if test "x${ac_cv_working_alloca_h+set}" = xset ; then
2956 glib_header_alloca_h="$ac_cv_working_alloca_h"
2957 else
2958 glib_header_alloca_h="$ac_cv_header_alloca_h"
2959 fi
2961 case xyes in
2962 x$ac_cv_header_float_h)
2963 glib_float_h=yes
2964 glib_mf=FLT_MIN glib_Mf=FLT_MAX
2965 glib_md=DBL_MIN glib_Md=DBL_MAX
2966 ;;
2967 x$ac_cv_header_values_h)
2968 glib_values_h=yes
2969 glib_mf=MINFLOAT glib_Mf=MAXFLOAT
2970 glib_md=MINDOUBLE glib_Md=MAXDOUBLE
2971 ;;
2972 esac
2974 case xyes in
2975 x$ac_cv_header_limits_h)
2976 glib_limits_h=yes
2977 glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
2978 glib_mi=INT_MIN glib_Mi=INT_MAX glib_Mui=UINT_MAX
2979 glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
2980 ;;
2981 x$ac_cv_header_values_h)
2982 glib_values_h=yes
2983 glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
2984 glib_mi=MININT glib_Mi=MAXINT glib_Mui="(((guint)G_MAXINT)*2+1)"
2985 glib_ml=MINLONG glib_Ml=MAXLONG glib_Mul="(((gulong)G_MAXLONG)*2+1)"
2986 ;;
2987 esac
2989 if test x$ac_cv_header_sys_poll_h = xyes ; then
2990 glib_sys_poll_h=yes
2991 fi
2993 case 2 in
2994 $ac_cv_sizeof_short)
2995 gint16=short
2996 gint16_modifier='"h"'
2997 gint16_format='"hi"'
2998 guint16_format='"hu"'
2999 ;;
3000 $ac_cv_sizeof_int)
3001 gint16=int
3002 gint16_modifier='""'
3003 gint16_format='"i"'
3004 guint16_format='"u"'
3005 ;;
3006 esac
3007 case 4 in
3008 $ac_cv_sizeof_short)
3009 gint32=short
3010 gint32_modifier='"h"'
3011 gint32_format='"hi"'
3012 guint32_format='"hu"'
3013 ;;
3014 $ac_cv_sizeof_int)
3015 gint32=int
3016 gint32_modifier='""'
3017 gint32_format='"i"'
3018 guint32_format='"u"'
3019 ;;
3020 $ac_cv_sizeof_long)
3021 gint32=long
3022 gint32_modifier='"l"'
3023 gint32_format='"li"'
3024 guint32_format='"lu"'
3025 ;;
3026 esac
3027 case 8 in
3028 $ac_cv_sizeof_int)
3029 gint64=int
3030 gint64_modifier='""'
3031 gint64_format='"i"'
3032 guint64_format='"u"'
3033 glib_extension=
3034 gint64_constant='(val)'
3035 guint64_constant='(val)'
3036 ;;
3037 $ac_cv_sizeof_long)
3038 gint64=long
3039 gint64_modifier='"l"'
3040 gint64_format='"li"'
3041 guint64_format='"lu"'
3042 glib_extension=
3043 gint64_constant='(val##L)'
3044 guint64_constant='(val##UL)'
3045 ;;
3046 $ac_cv_sizeof_long_long)
3047 gint64='long long'
3048 if test -n "$glib_cv_long_long_format"; then
3049 gint64_modifier='"'$glib_cv_long_long_format'"'
3050 gint64_format='"'$glib_cv_long_long_format'i"'
3051 guint64_format='"'$glib_cv_long_long_format'u"'
3052 fi
3053 glib_extension='G_GNUC_EXTENSION '
3054 gint64_constant='(G_GNUC_EXTENSION (val##LL))'
3055 guint64_constant='(G_GNUC_EXTENSION (val##ULL))'
3056 ;;
3057 $ac_cv_sizeof___int64)
3058 gint64='__int64'
3059 if test -n "$glib_cv_long_long_format"; then
3060 gint64_modifier='"'$glib_cv_long_long_format'"'
3061 gint64_format='"'$glib_cv_long_long_format'i"'
3062 guint64_format='"'$glib_cv_long_long_format'u"'
3063 fi
3064 glib_extension=
3065 gint64_constant='(val##i64)'
3066 guint64_constant='(val##ui64)'
3067 ;;
3068 esac
3069 glib_size_t=$ac_cv_sizeof_size_t
3070 glib_size_type_define=$glib_size_type
3071 glib_void_p=$ac_cv_sizeof_long
3072 glib_long=$ac_cv_sizeof_void_p
3074 case $glib_size_type in
3075 short)
3076 gsize_modifier='"h"'
3077 gsize_format='"hu"'
3078 gssize_format='"hi"'
3079 glib_msize_type='SHRT'
3080 ;;
3081 int)
3082 gsize_modifier='""'
3083 gsize_format='"u"'
3084 gssize_format='"i"'
3085 glib_msize_type='INT'
3086 ;;
3087 long)
3088 gsize_modifier='"l"'
3089 gsize_format='"lu"'
3090 gssize_format='"li"'
3091 glib_msize_type='LONG'
3092 ;;
3093 esac
3095 gintbits=`expr $ac_cv_sizeof_int \* 8`
3096 glongbits=`expr $ac_cv_sizeof_long \* 8`
3099 case $ac_cv_sizeof_void_p in
3100 $ac_cv_sizeof_int) glib_gpi_cast='' glib_gpui_cast='' ;;
3101 $ac_cv_sizeof_long) glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
3102 *) glib_unknown_void_p=yes ;;
3103 esac
3106 case xyes in
3107 x$ac_cv_func_atexit)
3108 glib_atexit="
3109 #ifdef NeXT /* @#%@! NeXTStep */
3110 # define g_ATEXIT(proc) (!atexit (proc))
3111 #else
3112 # define g_ATEXIT(proc) (atexit (proc))
3113 #endif"
3114 ;;
3115 x$ac_cv_func_on_exit)
3116 glib_atexit="
3117 #define g_ATEXIT(proc) (on_exit ((void (*)(int, void*))(proc), NULL))"
3118 ;;
3119 esac
3121 case xyes in
3122 x$ac_cv_func_memmove)
3123 glib_memmove='
3124 #define g_memmove(dest,src,len) G_STMT_START { memmove ((dest), (src), (len)); } G_STMT_END'
3125 ;;
3126 x$glib_cv_working_bcopy)
3127 glib_memmove="
3128 /* memmove isn't available, but bcopy can copy overlapping memory regions */
3129 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
3130 ;;
3131 *)
3132 glib_memmove="
3133 /* memmove isn't found and bcopy can't copy overlapping memory regions,
3134 * so we have to roll our own copy routine. */
3135 void g_memmove (void* dest, const void * src, unsigned long len);"
3136 ;;
3137 esac
3139 glib_defines="
3140 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
3141 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
3142 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
3143 "
3145 case xyes in
3146 x$glib_cv_va_copy) glib_vacopy='#define G_VA_COPY va_copy' ;;
3147 x$glib_cv___va_copy) glib_vacopy='#define G_VA_COPY __va_copy' ;;
3148 *) glib_vacopy=''
3149 esac
3151 if test x$glib_cv_va_val_copy = xno; then
3152 glib_vacopy="\$glib_vacopy
3153 #define G_VA_COPY_AS_ARRAY 1"
3154 fi
3156 if test x$glib_cv_hasinline = xyes; then
3157 glib_inline='#define G_HAVE_INLINE 1'
3158 fi
3159 if test x$glib_cv_has__inline = xyes; then
3160 glib_inline="\$glib_inline
3161 #define G_HAVE___INLINE 1"
3162 fi
3163 if test x$glib_cv_has__inline__ = xyes; then
3164 glib_inline="\$glib_inline
3165 #define G_HAVE___INLINE__ 1"
3166 fi
3168 g_have_gnuc_varargs=$g_have_gnuc_varargs
3169 g_have_iso_c_varargs=$g_have_iso_c_varargs
3170 g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
3172 g_can_inline=$g_can_inline
3173 g_have_gnuc_visibility=$g_have_gnuc_visibility
3174 g_have_sunstudio_visibility=$g_have_sunstudio_visibility
3176 if test x$ac_cv_c_bigendian = xyes; then
3177 g_byte_order=G_BIG_ENDIAN
3178 g_bs_native=BE
3179 g_bs_alien=LE
3180 else
3181 g_byte_order=G_LITTLE_ENDIAN
3182 g_bs_native=LE
3183 g_bs_alien=BE
3184 fi
3186 g_pollin=$glib_cv_value_POLLIN
3187 g_pollout=$glib_cv_value_POLLOUT
3188 g_pollpri=$glib_cv_value_POLLPRI
3189 g_pollhup=$glib_cv_value_POLLHUP
3190 g_pollerr=$glib_cv_value_POLLERR
3191 g_pollnval=$glib_cv_value_POLLNVAL
3193 g_stack_grows=$glib_cv_stack_grows
3195 g_have_eilseq=$have_eilseq
3197 case x$have_threads in
3198 xno) g_enable_threads_def="#undef";;
3199 *) g_enable_threads_def="#define";;
3200 esac
3202 g_threads_impl_def=$g_threads_impl
3204 g_mutex_has_default="$mutex_has_default"
3205 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
3206 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
3207 g_mutex_contents="$glib_cv_byte_contents_gmutex"
3209 g_memory_barrier_needed="$glib_memory_barrier_needed"
3211 g_module_suffix="$glib_gmodule_suffix"
3213 g_pid_type="$glib_pid_type"
3214 case $host in
3215 *-*-beos*)
3216 glib_os="#define G_OS_BEOS"
3217 ;;
3218 *-*-cygwin*)
3219 glib_os="#define G_OS_UNIX
3220 #define G_PLATFORM_WIN32
3221 #define G_WITH_CYGWIN"
3222 ;;
3223 *-*-mingw*)
3224 glib_os="#define G_OS_WIN32
3225 #define G_PLATFORM_WIN32"
3226 ;;
3227 *)
3228 glib_os="#define G_OS_UNIX"
3229 ;;
3230 esac
3231 glib_static_compilation=""
3232 if test x$glib_win32_static_compilation = xyes; then
3233 glib_static_compilation="#define GLIB_STATIC_COMPILATION 1
3234 #define GOBJECT_STATIC_COMPILATION 1"
3235 fi
3236 ])
3238 AC_CONFIG_FILES([
3239 glib-2.0.pc
3240 glib-2.0-uninstalled.pc
3241 gmodule-2.0.pc
3242 gmodule-export-2.0.pc
3243 gmodule-no-export-2.0.pc
3244 gmodule-2.0-uninstalled.pc
3245 gmodule-no-export-2.0-uninstalled.pc
3246 gthread-2.0.pc
3247 gthread-2.0-uninstalled.pc
3248 gobject-2.0.pc
3249 gobject-2.0-uninstalled.pc
3250 gio-2.0.pc
3251 gio-unix-2.0.pc
3252 gio-2.0-uninstalled.pc
3253 gio-unix-2.0-uninstalled.pc
3254 glib-zip
3255 glib-gettextize
3256 Makefile
3257 build/Makefile
3258 build/win32/Makefile
3259 build/win32/dirent/Makefile
3260 build/win32/vs8/Makefile
3261 glib/Makefile
3262 glib/libcharset/Makefile
3263 glib/gnulib/Makefile
3264 glib/pcre/Makefile
3265 glib/update-pcre/Makefile
3266 glib/tests/Makefile
3267 gmodule/Makefile
3268 gmodule/gmoduleconf.h
3269 gobject/Makefile
3270 gobject/glib-mkenums
3271 gobject/tests/Makefile
3272 gthread/Makefile
3273 gio/Makefile
3274 gio/xdgmime/Makefile
3275 gio/inotify/Makefile
3276 gio/fen/Makefile
3277 gio/fam/Makefile
3278 gio/win32/Makefile
3279 gio/tests/Makefile
3280 po/Makefile.in
3281 docs/Makefile
3282 docs/reference/Makefile
3283 docs/reference/glib/Makefile
3284 docs/reference/glib/version.xml
3285 docs/reference/gobject/Makefile
3286 docs/reference/gobject/version.xml
3287 docs/reference/gio/Makefile
3288 docs/reference/gio/version.xml
3289 tests/Makefile
3290 tests/gobject/Makefile
3291 tests/refcount/Makefile
3292 m4macros/Makefile
3293 ])
3295 AC_CONFIG_COMMANDS([chmod-scripts],
3296 [chmod 0755 glib-zip
3297 chmod 0755 glib-gettextize
3298 chmod 0755 gobject/glib-mkenums])
3300 # we want to invoke this macro solely so that the config.status script
3301 # and automake generated makefiles know about these generated files.
3302 # They are only needed to distcheck the package
3303 if false; then
3304 AC_CONFIG_FILES([
3305 INSTALL
3306 README
3307 config.h.win32
3308 glibconfig.h.win32
3309 glib/makefile.msc
3310 glib/glib.rc
3311 gmodule/makefile.msc
3312 gmodule/gmodule.rc
3313 gobject/makefile.msc
3314 gobject/gobject.rc
3315 gthread/makefile.msc
3316 gthread/gthread.rc
3317 tests/makefile.msc
3318 ])
3319 fi
3321 AC_OUTPUT