Bump version
[platform/upstream/glib.git] / configure.in
1 # Process this file with autoconf to produce a configure script.
2 # require autoconf 2.54
3 AC_PREREQ(2.54)
4
5 dnl ***********************************
6 dnl *** include special GLib macros ***
7 dnl ***********************************
8
9 m4_define(glib_configure_in)
10 m4_include(acglib.m4)dnl
11 m4_include(glib/libcharset/codeset.m4)dnl
12 m4_include(glib/libcharset/glibc21.m4)dnl
13 m4_include(m4macros/glib-gettext.m4)dnl
14
15 #
16 # The following version number definitions apply to GLib, GModule, GObject 
17 # and GThread as a whole, so if changes occoured in any of them, they are all
18 # treated with the same interface and binary age.
19 #
20 # Making releases:
21 #   glib_micro_version += 1;
22 #   glib_interface_age += 1;
23 #   glib_binary_age += 1;
24 # if any functions have been added, set glib_interface_age to 0.
25 # if backwards compatibility has been broken,
26 # set glib_binary_age _and_ glib_interface_age to 0.
27 #
28 m4_define([glib_major_version], [2])
29 m4_define([glib_minor_version], [5])
30 m4_define([glib_micro_version], [4])
31 m4_define([glib_interface_age], [0])
32 m4_define([glib_binary_age],
33           [m4_eval(100 * glib_minor_version + glib_micro_version)])
34 m4_define([glib_version],
35           [glib_major_version.glib_minor_version.glib_micro_version])
36
37 # libtool version related macros
38 m4_define([glib_lt_release], [glib_major_version.glib_minor_version])
39 m4_define([glib_lt_current],
40           [m4_eval(100 * glib_minor_version + glib_micro_version - glib_interface_age)])
41 m4_define([glib_lt_revision], [glib_interface_age])
42 m4_define([glib_lt_age], [m4_eval(glib_binary_age - glib_interface_age)])
43 m4_define([glib_lt_current_minus_age],
44           [m4_eval(glib_lt_current - glib_lt_age)])
45
46 # if the minor version number is odd, then we want debugging.  Otherwise
47 # we only want minimal debugging support.
48 m4_define([glib_debug_default],
49           [m4_if(m4_eval(glib_minor_version % 2), [1], [yes], [minimum])])dnl
50
51
52 AC_INIT(glib, [glib_version],
53         [http://bugzilla.gnome.org/enter_bug.cgi?product=glib])
54
55 AC_CONFIG_SRCDIR([glib/glib.h])
56
57 # Save this value here, since automake will set cflags later
58 cflags_set=${CFLAGS+set}
59
60 AM_INIT_AUTOMAKE([no-define])
61
62 # Specify a configuration file
63 AM_CONFIG_HEADER([config.h])
64
65
66 GLIB_MAJOR_VERSION=glib_major_version
67 GLIB_MINOR_VERSION=glib_minor_version
68 GLIB_MICRO_VERSION=glib_micro_version
69 GLIB_INTERFACE_AGE=glib_interface_age
70 GLIB_BINARY_AGE=glib_binary_age
71 GLIB_VERSION=glib_version
72
73 AC_SUBST(GLIB_MAJOR_VERSION)
74 AC_SUBST(GLIB_MINOR_VERSION)
75 AC_SUBST(GLIB_MICRO_VERSION)
76 AC_SUBST(GLIB_VERSION)
77 AC_SUBST(GLIB_INTERFACE_AGE)
78 AC_SUBST(GLIB_BINARY_AGE)
79
80 AC_DEFINE(GLIB_MAJOR_VERSION, [glib_major_version],
81           [Define to the GLIB major version])
82 AC_DEFINE(GLIB_MINOR_VERSION, [glib_minor_version],
83           [Define to the GLIB minor version])
84 AC_DEFINE(GLIB_MICRO_VERSION, [glib_micro_version],
85           [Define to the GLIB micro version])
86 AC_DEFINE(GLIB_INTERFACE_AGE, [glib_interface_age],
87           [Define to the GLIB interface age])
88 AC_DEFINE(GLIB_BINARY_AGE, [glib_binary_age],
89           [Define to the GLIB binary age])
90
91 # libtool versioning
92 LT_RELEASE=glib_lt_release
93 LT_CURRENT=glib_lt_current
94 LT_REVISION=glib_lt_revision
95 LT_AGE=glib_lt_age
96 LT_CURRENT_MINUS_AGE=glib_lt_current_minus_age
97 AC_SUBST(LT_RELEASE)
98 AC_SUBST(LT_CURRENT)
99 AC_SUBST(LT_REVISION)
100 AC_SUBST(LT_AGE)
101 AC_SUBST(LT_CURRENT_MINUS_AGE)
102
103 dnl Initialize maintainer mode
104 AM_MAINTAINER_MODE
105
106 AC_CANONICAL_HOST
107
108 AC_MSG_CHECKING([for the BeOS])
109 case $host in
110   *-*-beos*)
111     glib_native_beos="yes"
112     ;;
113   *)
114     glib_native_beos="no"
115     ;;
116 esac
117 AC_MSG_RESULT([$glib_native_beos])
118
119 dnl
120
121 AC_MSG_CHECKING([for Win32])
122 case "$host" in
123   *-*-mingw*)
124     glib_native_win32=yes
125     G_LIB_WIN32_RESOURCE=glib-win32res.lo
126     G_MODULE_WIN32_RESOURCE=gmodule-win32res.lo
127     G_OBJECT_WIN32_RESOURCE=gobject-win32res.lo
128     G_THREAD_WIN32_RESOURCE=gthread-win32res.lo
129     GLIB_DEF=glib.def
130     GMODULE_DEF=gmodule.def
131     GOBJECT_DEF=gobject.def
132     GTHREAD_DEF=gthread.def
133     TESTGMODULE_EXP=testgmodule.exp
134     glib_pid_type='void *'
135     ;;
136   *)
137     glib_native_win32=no
138     G_LIB_WIN32_RESOURCE=
139     G_MODULE_WIN32_RESOURCE=
140     G_OBJECT_WIN32_RESOURCE=
141     G_THREAD_WIN32_RESOURCE=
142     GLIB_DEF=
143     GMODULE_DEF=
144     GOBJECT_DEF=
145     GTHREAD_DEF=
146     TESTGMODULE_EXP=
147     glib_pid_type=int
148     ;;
149 esac
150 AC_MSG_RESULT([$glib_native_win32])
151 AM_CONDITIONAL(OS_WIN32, [test "$glib_native_win32" = "yes"])
152 AM_CONDITIONAL(OS_UNIX, [test "$glib_native_win32" != "yes"])
153 AC_SUBST(G_LIB_WIN32_RESOURCE)
154 AC_SUBST(G_MODULE_WIN32_RESOURCE)
155 AC_SUBST(G_OBJECT_WIN32_RESOURCE)
156 AC_SUBST(G_THREAD_WIN32_RESOURCE)
157 AC_SUBST(GLIB_DEF)
158 AC_SUBST(GMODULE_DEF)
159 AC_SUBST(GOBJECT_DEF)
160 AC_SUBST(GTHREAD_DEF)
161 AC_SUBST(TESTGMODULE_EXP)
162
163 if test "$glib_native_win32" = "yes"; then
164   AC_CHECK_PROG(ms_librarian, [lib.exe], [yes], [no])
165 fi
166 AM_CONDITIONAL(MS_LIB_AVAILABLE, [test x$ms_librarian = xyes])
167
168 if test "$glib_native_win32" != yes; then
169     # libtool option to control which symbols are exported
170     # right now, symbols starting with _ are not exported
171     LIBTOOL_EXPORT_OPTIONS='-export-symbols-regex "^[[^_]].*"'
172 else
173     # We currently use .def files on Windows
174     LIBTOOL_EXPORT_OPTIONS=
175 fi
176 AC_SUBST(LIBTOOL_EXPORT_OPTIONS)
177
178 dnl declare --enable-* args and collect ac_help strings
179 AC_ARG_ENABLE(debug,
180               AC_HELP_STRING([--enable-debug=@<:@no/minimum/yes@:>@],
181                              [turn on debugging @<:@default=glib_debug_default@:>@]),,
182               enable_debug=glib_debug_default)
183
184 AC_ARG_ENABLE(gc_friendly,
185               [AC_HELP_STRING([--enable-gc-friendly],
186                               [turn on garbage collector friendliness [default=no]])],,
187               [enable_gc_friendly=no])
188 AC_ARG_ENABLE(mem_pools,
189               [AC_HELP_STRING([--disable-mem-pools],
190                               [disable all glib memory pools])],,
191               [disable_mem_pools=no])
192 AC_ARG_ENABLE(ansi,
193               [AC_HELP_STRING([--enable-ansi],
194                               [turn on strict ansi [default=no]])],,
195               [enable_ansi=no])
196 AC_ARG_ENABLE(threads,
197               [AC_HELP_STRING([--enable-threads],
198                               [turn on basic thread support [default=yes]
199 ([=no] will override --with-threads)])],,
200               [enable_threads=yes])
201 AC_ARG_ENABLE(rebuilds,
202               [AC_HELP_STRING([--disable-rebuilds],
203                               [disable all source autogeneration rules])],,
204               [enable_rebuilds=yes])
205 AC_ARG_ENABLE(visibility,
206               [AC_HELP_STRING([--disable-visibility],
207                               [don't use ELF visibility attributes])],,
208               [enable_visibility=yes])
209
210 if test "x$enable_threads" != "xyes"; then
211   enable_threads=no
212 fi
213
214 AC_DEFINE_UNQUOTED(G_COMPILED_WITH_DEBUGGING, ["${enable_debug}"],
215         [Whether glib was compiled with debugging enabled])
216
217 AC_MSG_CHECKING([whether to enable garbage collector friendliness])
218 if test "x$enable_gc_friendly" = "xyes"; then
219   AC_DEFINE(ENABLE_GC_FRIENDLY, 1, [Whether to enable GC friendliness])
220   AC_SUBST(ENABLE_GC_FRIENDLY)
221   AC_MSG_RESULT([yes])
222 else
223   AC_MSG_RESULT([no])
224 fi
225
226 AC_MSG_CHECKING([whether to disable memory pools])
227 if test "x$disable_mem_pools" = "xno"; then
228   AC_MSG_RESULT([no])
229 else
230   AC_DEFINE(DISABLE_MEM_POOLS, [1], [Whether to disable memory pools])
231   AC_SUBST(DISABLE_MEM_POOLS)
232   AC_MSG_RESULT([yes])
233 fi
234
235 if test "$glib_native_win32" = "yes"; then
236   if test x$enable_static = xyes -o x$enable_static = x; then
237     AC_MSG_WARN([Disabling static library build, must build as DLL on Windows.])
238     enable_static=no
239   fi
240   if test x$enable_shared = xno; then
241     AC_MSG_WARN([Enabling shared library build, must build as DLL on Windows.])
242   fi
243   enable_shared=yes
244 fi
245
246 dnl Checks for programs.
247 AC_PROG_CC
248
249 dnl Check for a working C++ compiler, but do not bail out, if none is found.
250 AC_CHECK_PROGS(CXX, [$CCC c++ g++ gcc CC cxx cc++ cl], [gcc])
251 AC_LANG_SAVE
252 AC_LANG_CPLUSPLUS
253 AC_TRY_COMPILE(,[class a { int b; } c;], ,CXX=)
254 AM_CONDITIONAL(HAVE_CXX, [test "$CXX" != ""])
255 AC_LANG_RESTORE
256
257 AM_PROG_CC_STDC
258 AC_PROG_INSTALL
259
260 AC_SYS_LARGEFILE
261
262 #
263 # Find pkg-config
264 #
265 AC_PATH_PROG(PKG_CONFIG, [pkg-config], [no])
266 if test x$PKG_CONFIG = xno ; then
267   AC_MSG_ERROR([*** pkg-config not found. See http://www.freedesktop.org/software/pkgconfig/])
268 fi
269
270 if $PKG_CONFIG --atleast-pkgconfig-version 0.14 ; then
271   :
272 else
273   AC_MSG_ERROR([*** pkg-config too old; version 0.14 or better required.])
274 fi
275
276 if test "x$enable_debug" = "xyes"; then
277   if test x$cflags_set != xset ; then
278       case " $CFLAGS " in
279       *[[\ \    ]]-g[[\ \       ]]*) ;;
280       *) CFLAGS="$CFLAGS -g" ;;
281       esac
282   fi
283         
284   GLIB_DEBUG_FLAGS="-DG_ENABLE_DEBUG"
285 else
286   GLIB_DEBUG_FLAGS="-DG_DISABLE_CAST_CHECKS"
287
288   if test "x$enable_debug" = "xno"; then
289     GLIB_DEBUG_FLAGS="$GLIB_DEBUG_FLAGS -DG_DISABLE_ASSERT -DG_DISABLE_CHECKS"
290   fi
291 fi
292
293 if test "x$enable_visibility" = "xno"; then
294   GLIB_DEBUG_FLAGS="$GLIB_DEBUG_FLAGS -DDISABLE_VISIBILITY"
295 fi
296
297 # Ensure MSVC-compatible struct packing convention is used when
298 # compiling for Win32 with gcc.
299 # What flag to depends on gcc version: gcc3 uses "-mms-bitfields", while
300 # gcc2 uses "-fnative-struct".
301 if test x"$glib_native_win32" = xyes; then
302   if test x"$GCC" = xyes; then
303     msnative_struct=''
304     AC_MSG_CHECKING([how to get MSVC-compatible struct packing])
305     if test -z "$ac_cv_prog_CC"; then
306       our_gcc="$CC"
307     else
308       our_gcc="$ac_cv_prog_CC"
309     fi
310     case `$our_gcc --version | sed -e 's,\..*,.,' -e q` in
311       2.)
312         if $our_gcc -v --help 2>/dev/null | grep fnative-struct >/dev/null; then
313           msnative_struct='-fnative-struct'
314         fi
315         ;;
316       *)
317         if $our_gcc -v --help 2>/dev/null | grep ms-bitfields >/dev/null; then
318           msnative_struct='-mms-bitfields'
319         fi
320         ;;
321     esac
322     if test x"$msnative_struct" = x ; then
323       AC_MSG_RESULT([no way])
324       AC_MSG_WARN([produced libraries might be incompatible with MSVC-compiled code])
325     else
326       CFLAGS="$CFLAGS $msnative_struct"
327       AC_MSG_RESULT([${msnative_struct}])
328     fi
329   fi
330 fi
331
332 AC_EXEEXT
333
334 # define a MAINT-like variable REBUILD which is set if Perl
335 # and awk are found, so autogenerated sources can be rebuilt
336 AC_PROG_AWK
337 AC_CHECK_PROGS(PERL, [perl5 perl])
338 # We would like indent, but don't require it.
339 AC_CHECK_PROG(INDENT, indent, indent)
340 REBUILD=\#
341 if test "x$enable_rebuilds" = "xyes" && \
342      test -n "$PERL" && \
343      $PERL -e 'exit !($] >= 5.002)' > /dev/null 2>&1 && \
344      test -n "$AWK" ; then
345   REBUILD=
346 fi
347 AC_SUBST(REBUILD)
348
349 # Need full path to Perl for glib-mkenums
350 #
351 if test "x$PERL" != x ; then
352   AC_PATH_PROG(PERL_PATH, [$PERL])
353 else
354   PERL_PATH="/usr/bin/env perl"
355 fi
356 AC_SUBST(PERL_PATH)
357
358 dnl ***********************
359 dnl *** Tests for iconv ***
360 dnl ***********************
361 dnl
362 dnl We do this before the gettext checks, to avoid distortion
363
364 AC_ARG_WITH(libiconv,
365             [AC_HELP_STRING([--with-libiconv=@<:@no/gnu/native@:>@],
366                             [use the libiconv library])],,
367             [with_libiconv=maybe])
368
369 found_iconv=no
370 case $with_libiconv in
371   maybe)
372     # Check in the C library first
373     AC_CHECK_FUNC(iconv_open, [with_libiconv=no; found_iconv=yes])
374     # Check if we have GNU libiconv
375     if test $found_iconv = "no"; then
376       AC_CHECK_LIB(iconv, libiconv_open, [with_libiconv=gnu; found_iconv=yes])
377     fi
378     # Check if we have a iconv in -liconv, possibly from vendor
379     if test $found_iconv = "no"; then
380       AC_CHECK_LIB(iconv, iconv_open, [with_libiconv=native; found_iconv=yes])
381     fi
382     ;;
383   no)
384     AC_CHECK_FUNC(iconv_open, [with_libiconv=no; found_iconv=yes])
385     ;;
386   gnu|yes)
387     AC_CHECK_LIB(iconv, libiconv_open, [with_libiconv=gnu; found_iconv=yes])
388     ;;
389   native)
390     AC_CHECK_LIB(iconv, iconv_open, [with_libiconv=native; found_iconv=yes])
391     ;;
392 esac
393
394 if test "x$found_iconv" = "xno" ; then
395    AC_MSG_ERROR([*** No iconv() implementation found in C library or libiconv])
396 fi
397
398 dnl
399 dnl gettext support
400 dnl
401
402 ALL_LINGUAS="am ar az be bg bn bs ca cs cy da de el en_CA en_GB eo es et eu fa fi fr ga gl gu he hi hr id is it ja ko lt lv mk mn ms ne nl nn no pa pl pt pt_BR ro ru sk sl sq sr sr@ije sr@Latn sv ta tr uk vi wa yi zh_CN zh_TW"
403 GLIB_GNU_GETTEXT
404
405 if test "$gt_cv_have_gettext" != "yes" ; then
406   AC_MSG_ERROR([
407 *** You must have either have gettext support in your C library, or use the 
408 *** GNU gettext library. (http://www.gnu.org/software/gettext/gettext.html
409 ])
410 fi
411
412 LIBS="$INTLLIBS $LIBS"
413
414 GETTEXT_PACKAGE=glib20
415 AC_SUBST(GETTEXT_PACKAGE)
416 AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE, ["$GETTEXT_PACKAGE"], 
417   [Define the gettext package to be used])
418
419 GLIB_DEFINE_LOCALEDIR(GLIB_LOCALE_DIR)
420
421 dnl
422 dnl Now we are done with gettext checks, figure out ICONV_LIBS
423 dnl
424
425 if test x$with_libiconv != xno ; then
426   case " $INTLLIBS " in
427   *[[\ \        ]]-liconv[[\ \  ]]*) ;;
428   *) ICONV_LIBS="-liconv" ;;
429   esac
430 fi
431 AC_SUBST(ICONV_LIBS)
432
433 case $with_libiconv in
434   gnu)
435     AC_DEFINE(USE_LIBICONV_GNU, 1, [Using GNU libiconv])
436     ;;
437   native)
438     AC_DEFINE(USE_LIBICONV_NATIVE, 1, [Using a native implementation of iconv in a separate library])
439     ;;
440 esac
441
442 dnl Initialize libtool
443 AM_DISABLE_STATIC
444 AM_PROG_LIBTOOL
445
446 if test "x$GCC" = "xyes"; then
447   case " $CFLAGS " in
448   *[[\ \        ]]-Wall[[\ \    ]]*) ;;
449   *) CFLAGS="$CFLAGS -Wall" ;;
450   esac
451
452   if test "x$enable_ansi" = "xyes"; then
453     case " $CFLAGS " in
454     *[[\ \      ]]-ansi[[\ \    ]]*) ;;
455     *) CFLAGS="$CFLAGS -ansi" ;;
456     esac
457
458     case " $CFLAGS " in
459     *[[\ \      ]]-pedantic[[\ \        ]]*) ;;
460     *) CFLAGS="$CFLAGS -pedantic" ;;
461     esac
462   fi
463 fi
464
465 dnl
466 dnl DU4 native cc currently needs -std1 for ANSI mode (instead of K&R)
467 dnl
468 if test $cross_compiling != yes ; then
469     AC_MSG_CHECKING([for extra flags to get ANSI library prototypes])
470     glib_save_LIBS=$LIBS
471     LIBS="$LIBS -lm"
472     AC_TRY_RUN([#include <math.h>
473                  int main (void) { return (log(1) != log(1.)); }],
474          AC_MSG_RESULT(none needed),
475          glib_save_CFLAGS=$CFLAGS
476          CFLAGS="$CFLAGS -std1"
477          AC_TRY_RUN([#include <math.h>
478                      int main (void) { return (log(1) != log(1.)); }],
479              AC_MSG_RESULT(-std1),
480              AC_MSG_RESULT()
481              CFLAGS=$glib_save_CFLAGS
482              AC_MSG_WARN(
483                     [No ANSI prototypes found in library. (-std1 didn't work.)])
484          )
485     )
486     LIBS=$glib_save_LIBS
487 fi
488
489 dnl NeXTStep cc seems to need this
490 AC_MSG_CHECKING([for extra flags for POSIX compliance])
491 AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
492   AC_MSG_RESULT(none needed),
493   glib_save_CFLAGS=$CFLAGS
494   CFLAGS="$CFLAGS -posix"
495   AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
496     AC_MSG_RESULT(-posix),
497     AC_MSG_RESULT()
498     CFLAGS=$glib_save_CFLAGS
499     AC_MSG_WARN([Could not determine POSIX flag. (-posix didn't work.)])))
500
501 # Checks for header files.
502 AC_HEADER_STDC
503
504 # Checks for library functions.
505 AC_FUNC_VPRINTF
506
507 AC_FUNC_ALLOCA
508
509 AC_CHECK_FUNCS(atexit on_exit)
510
511 AC_CHECK_SIZEOF(char)
512 AC_CHECK_SIZEOF(short)
513 AC_CHECK_SIZEOF(long)
514 AC_CHECK_SIZEOF(int)
515 AC_CHECK_SIZEOF(void *)
516 AC_CHECK_SIZEOF(long long)
517 AC_CHECK_SIZEOF(__int64)
518
519 if test x$ac_cv_sizeof_long = x8 || test x$ac_cv_sizeof_long_long = x8 || test x$ac_cv_sizeof___int64 = x8 ; then
520   :
521 else
522   AC_MSG_ERROR([
523 *** GLib requires a 64 bit type. You might want to consider
524 *** using the GNU C compiler.
525 ])
526 fi
527
528 if test x$ac_cv_sizeof_long_long = x8; then
529         # long long is a 64 bit integer.
530         AC_MSG_CHECKING(for format to printf and scanf a guint64)
531         AC_CACHE_VAL(glib_cv_long_long_format,[
532                 for format in ll q I64; do
533                   AC_TRY_RUN([#include <stdio.h>  
534                         int main()
535                         {
536                           long long b, a = -0x3AFAFAFAFAFAFAFALL;
537                           char buffer[1000];
538                           sprintf (buffer, "%${format}u", a);
539                           sscanf (buffer, "%${format}u", &b);
540                           exit (b!=a);
541                         }
542                         ],
543                         [glib_cv_long_long_format=${format}
544                         break],
545                         [],[:])
546                 done])
547         if test -n "$glib_cv_long_long_format"; then
548           AC_MSG_RESULT(%${glib_cv_long_long_format}u)
549           AC_DEFINE(HAVE_LONG_LONG_FORMAT,1,[define if system printf can print long long])
550           if test x"$glib_cv_long_long_format" = xI64; then
551             AC_DEFINE(HAVE_INT64_AND_I64,1,[define to support printing 64-bit integers with format I64])
552           fi
553         else
554           AC_MSG_RESULT(none)
555         fi
556 elif test x$ac_cv_sizeof___int64 = x8; then
557         # __int64 is a 64 bit integer.
558         AC_MSG_CHECKING(for format to printf and scanf a guint64)
559         # We know this is MSVC, and what the formats are
560         glib_cv_long_long_format=I64
561         AC_MSG_RESULT(%${glib_cv_long_long_format}u)
562         AC_DEFINE(HAVE_LONG_LONG_FORMAT,1,[define if system printf can print long long])
563         AC_DEFINE(HAVE_INT64_AND_I64,1,[define to support printing 64-bit integers with format I64])
564 fi
565
566 dnl long doubles were not used, and a portability problem
567 dnl AC_C_LONG_DOUBLE
568 AC_C_CONST
569
570 dnl ok, here we try to check whether the systems prototypes for
571 dnl malloc and friends actually match the prototypes provided
572 dnl by gmem.h (keep in sync). i currently only know how to check
573 dnl this reliably with gcc (-Werror), improvements for other
574 dnl compilers are apprechiated.
575 SANE_MALLOC_PROTOS=no
576 AC_MSG_CHECKING([if malloc() and friends prototypes are gmem.h compatible])
577 glib_save_CFLAGS=$CFLAGS
578 if test "x$GCC" = "xyes"; then
579   CFLAGS="$CFLAGS -Werror"
580   AC_TRY_COMPILE([#include <stdlib.h>], [
581     void* (*my_calloc_p)  (size_t, size_t) = calloc;
582     void* (*my_malloc_p)  (size_t)         = malloc;
583     void  (*my_free_p)    (void*)          = free;
584     void* (*my_realloc_p) (void*, size_t)  = realloc;
585     my_calloc_p = 0;
586     my_malloc_p = 0;
587     my_free_p = 0;
588     my_realloc_p = 0;
589   ],
590     AC_DEFINE(SANE_MALLOC_PROTOS, 1, 
591       [Define if you have correct malloc prototypes])
592     SANE_MALLOC_PROTOS=yes)
593 fi
594 AC_MSG_RESULT($SANE_MALLOC_PROTOS)
595 CFLAGS=$glib_save_CFLAGS
596
597 dnl
598 dnl check in which direction the stack grows
599 dnl
600 AC_CACHE_CHECK([for growing stack pointer],glib_cv_stack_grows,[
601         AC_TRY_RUN([
602         volatile int *a = 0, *b = 0;
603         void foo (void);
604         int main () { volatile int y = 7; a = &y; foo (); return b > a; }
605         void foo (void) { volatile int x = 5; b = &x; }
606         ],
607         glib_cv_stack_grows=no
608         ,
609         glib_cv_stack_grows=yes
610         ,)
611 ])
612
613 dnl AC_C_INLINE is useless to us since it bails out too early, we need to
614 dnl truely know which ones of `inline', `__inline' and `__inline__' are
615 dnl actually supported.
616 AC_CACHE_CHECK([for __inline],glib_cv_has__inline,[
617         AC_COMPILE_IFELSE([
618         __inline int foo () { return 0; }
619         int main () { return foo (); }
620         ],
621         glib_cv_has__inline=yes
622         ,
623         glib_cv_has__inline=no
624         ,)
625 ])
626 case x$glib_cv_has__inline in
627 xyes) AC_DEFINE(G_HAVE___INLINE,1,[Have __inline keyword])
628 esac
629 AC_CACHE_CHECK([for __inline__],glib_cv_has__inline__,[
630         AC_COMPILE_IFELSE([
631         __inline__ int foo () { return 0; }
632         int main () { return foo (); }
633         ],
634         glib_cv_has__inline__=yes
635         ,
636         glib_cv_has__inline__=no
637         ,)
638 ])
639 case x$glib_cv_has__inline__ in
640 xyes) AC_DEFINE(G_HAVE___INLINE__,1,[Have __inline__ keyword])
641 esac
642 AC_CACHE_CHECK([for inline], glib_cv_hasinline,[
643         AC_COMPILE_IFELSE([
644         #undef inline
645         inline int foo () { return 0; }
646         int main () { return foo (); }
647         ],
648         glib_cv_hasinline=yes
649         ,
650         glib_cv_hasinline=no
651         ,)
652 ])
653 case x$glib_cv_hasinline in
654 xyes) AC_DEFINE(G_HAVE_INLINE,1,[Have inline keyword])
655 esac
656
657 # check for flavours of varargs macros
658 AC_MSG_CHECKING(for ISO C99 varargs macros in C)
659 AC_TRY_COMPILE([],[
660 int a(int p1, int p2, int p3);
661 #define call_a(...) a(1,__VA_ARGS__)
662 call_a(2,3);
663 ],g_have_iso_c_varargs=yes,g_have_iso_c_varargs=no)
664 AC_MSG_RESULT($g_have_iso_c_varargs)
665
666 AC_MSG_CHECKING(for ISO C99 varargs macros in C++)
667 if test "$CXX" = ""; then
668 dnl No C++ compiler
669   g_have_iso_cxx_varargs=no
670 else
671   AC_LANG_CPLUSPLUS
672   AC_TRY_COMPILE([],[
673 int a(int p1, int p2, int p3);
674 #define call_a(...) a(1,__VA_ARGS__)
675 call_a(2,3);
676 ],g_have_iso_cxx_varargs=yes,g_have_iso_cxx_varargs=no)
677   AC_LANG_C
678 fi
679 AC_MSG_RESULT($g_have_iso_cxx_varargs)
680
681 AC_MSG_CHECKING(for GNUC varargs macros)
682 AC_TRY_COMPILE([],[
683 int a(int p1, int p2, int p3);
684 #define call_a(params...) a(1,params)
685 call_a(2,3);
686 ],g_have_gnuc_varargs=yes,g_have_gnuc_varargs=no)
687 AC_MSG_RESULT($g_have_gnuc_varargs)
688
689 # check for GNUC visibility support
690 AC_MSG_CHECKING(for GNUC visibility attribute)
691 GLIB_CHECK_COMPILE_WARNINGS([
692 void
693 __attribute__ ((visibility ("hidden")))
694      f_hidden (void)
695 {
696 }
697 void
698 __attribute__ ((visibility ("internal")))
699      f_internal (void)
700 {
701 }
702 void
703 __attribute__ ((visibility ("protected")))
704      f_protected (void)
705 {
706 }
707 void
708 __attribute__ ((visibility ("default")))
709      f_default (void)
710 {
711 }
712 int main (int argc, char **argv)
713 {
714         f_hidden();
715         f_internal();
716         f_protected();
717         f_default();
718         return 0;
719 }
720 ],g_have_gnuc_visibility=yes,g_have_gnuc_visibility=no)
721 AC_MSG_RESULT($g_have_gnuc_visibility)
722
723 # check for bytesex stuff
724 AC_C_BIGENDIAN
725
726 # check for header files
727 AC_CHECK_HEADERS([dirent.h float.h limits.h pwd.h sys/param.h sys/poll.h sys/select.h sys/types.h])
728 AC_CHECK_HEADERS([sys/time.h sys/times.h unistd.h values.h stdint.h sched.h])
729
730 # Checks for libcharset
731 jm_LANGINFO_CODESET
732 jm_GLIBC21
733 AC_CHECK_HEADERS([stddef.h stdlib.h string.h])
734 AC_CHECK_FUNCS(setlocale)
735
736 # check additional type sizes
737 AC_CHECK_SIZEOF(size_t)
738
739 dnl Try to figure out whether gsize, gssize should be long or int
740 AC_MSG_CHECKING([for the appropriate definition for size_t])
741
742 case $ac_cv_sizeof_size_t in
743   $ac_cv_sizeof_short) 
744       glib_size_type=short
745       ;;
746   $ac_cv_sizeof_int) 
747       glib_size_type=int
748       ;;
749   $ac_cv_sizeof_long) 
750       glib_size_type=long
751       ;;
752   *)  AC_MSG_ERROR([No type matching size_t in size])
753       ;;
754 esac
755
756 dnl If int/long are the same size, we see which one produces
757 dnl warnings when used in the location as size_t. (This matters
758 dnl on AIX with xlc)
759 dnl
760 if test $ac_cv_sizeof_size_t = $ac_cv_sizeof_int &&
761    test $ac_cv_sizeof_size_t = $ac_cv_sizeof_long ; then
762   GLIB_CHECK_COMPILE_WARNINGS([
763 #include <stddef.h> 
764 int main ()
765 {
766   size_t s = 1;
767   unsigned int *size_int = &s;
768   return (int)*size_int;
769 }
770     ],glib_size_type=int,
771       [GLIB_CHECK_COMPILE_WARNINGS([
772 #include <stddef.h> 
773 int main ()
774 {
775    size_t s = 1;
776    unsigned long *size_long = &s;
777    return (int)*size_long;
778 }
779         ],glib_size_type=long)])
780 fi
781
782 AC_MSG_RESULT(unsigned $glib_size_type)
783
784 # Check for some functions
785 AC_CHECK_FUNCS(lstat strerror strsignal memmove mkstemp vsnprintf stpcpy strcasecmp strncasecmp poll getcwd nanosleep vasprintf setenv unsetenv getc_unlocked readlink symlink)
786
787 AC_FUNC_VSNPRINTF_C99
788 AC_FUNC_PRINTF_UNIX98
789
790 #
791 # Check whether to use an included printf
792 #
793
794 AC_ARG_ENABLE(included-printf,
795               [AC_HELP_STRING([--enable-included-printf],
796                               [use included printf [default=auto]])],
797               enable_included_printf="$enableval")
798
799 need_included_printf=no
800 if test "x$enable_included_printf" = "xyes" ; then
801   need_included_printf=yes
802 fi
803 if test "$ac_cv_func_vsnprintf_c99" != "yes" ; then
804   need_included_printf=yes
805 fi
806 if test "$ac_cv_func_printf_unix98" != "yes" ; then
807   need_included_printf=yes
808 fi
809 if test "x$ac_cv_sizeof_long_long" = "x8" &&
810    test -z "$glib_cv_long_long_format" ; then
811   need_included_printf=yes
812 fi
813
814 if test "x$enable_included_printf" = "xno" && 
815    test "x$need_included_printf" = "xyes" ; then
816   AC_MSG_ERROR([
817 *** Your C library's printf doesn't appear to have the features that
818 *** GLib needs, but you specified --enable-included-printf=no.])
819 fi
820
821 enable_included_printf=$need_included_printf
822
823 AM_CONDITIONAL(HAVE_GOOD_PRINTF, test "$enable_included_printf" != "yes")
824 if test "$enable_included_printf" != "yes" ; then 
825   AC_DEFINE(HAVE_GOOD_PRINTF,1,[define to use system printf])
826 else
827   if test -z "$glib_cv_long_long_format" ; then
828     glib_cv_long_long_format="ll"
829   fi
830   AC_DEFINE(HAVE_VASPRINTF,1)
831 fi
832
833 # Checks needed for gnulib vasnprintf
834 bh_C_SIGNED
835 jm_AC_TYPE_LONG_LONG
836 gt_TYPE_LONGDOUBLE
837 gt_TYPE_WCHAR_T
838 gt_TYPE_WINT_T
839 AC_TYPE_SIZE_T
840 AC_CHECK_TYPES(ptrdiff_t)
841 jm_AC_TYPE_INTMAX_T
842 AC_CHECK_FUNCS(snprintf)
843 AC_FUNC_SNPRINTF_C99
844
845 # Check if bcopy can be used for overlapping copies, if memmove isn't found.
846 # The check is borrowed from the PERL Configure script.
847 if test "$ac_cv_func_memmove" != "yes"; then
848   AC_CACHE_CHECK(whether bcopy can handle overlapping copies,
849     glib_cv_working_bcopy,[AC_TRY_RUN([
850       int main() {
851         char buf[128], abc[128], *b;
852         int len, off, align;
853         bcopy("abcdefghijklmnopqrstuvwxyz0123456789", abc, 36);
854         for (align = 7; align >= 0; align--) {
855           for (len = 36; len; len--) {
856             b = buf+align; bcopy(abc, b, len);
857             for (off = 1; off <= len; off++) {
858               bcopy(b, b+off, len); bcopy(b+off, b, len);
859                 if (bcmp(b, abc, len)) return(1);
860             }
861           }
862         }
863         return(0);
864       }],glib_cv_working_bcopy=yes,glib_cv_working_bcopy=no)])
865
866   GLIB_ASSERT_SET(glib_cv_working_bcopy)
867   if test "$glib_cv_working_bcopy" = "yes"; then
868     AC_DEFINE(HAVE_WORKING_BCOPY,1,[Have a working bcopy])
869   fi
870 fi
871
872 # Check for sys_errlist
873 AC_MSG_CHECKING(for sys_errlist)
874 AC_TRY_LINK(, [
875 extern char *sys_errlist[];
876 extern int sys_nerr;
877 sys_errlist[sys_nerr-1][0] = 0;
878 ], glib_ok=yes, glib_ok=no)
879 AC_MSG_RESULT($glib_ok)
880 if test "$glib_ok" = "no"; then
881     AC_DEFINE(NO_SYS_ERRLIST,1,[global 'sys_errlist' not found])
882 fi
883
884 # Check for sys_siglist
885 AC_MSG_CHECKING(for sys_siglist)
886 AC_TRY_LINK(, [
887 extern char *sys_siglist[];
888 exit (sys_siglist[0]);
889 ], glib_ok=yes, glib_ok=no)
890 AC_MSG_RESULT($glib_ok)
891 if test "$glib_ok" = "no"; then
892     AC_DEFINE(NO_SYS_SIGLIST,1,[global 'sys_siglist' not found])
893 fi
894
895 # Check for sys_siglist decl (see Tue Jan 19 00:44:24 1999 in changelog)
896 AC_MSG_CHECKING(for sys_siglist declaration)
897 AC_TRY_COMPILE([#include <signal.h>], [
898 strlen (sys_siglist[0]);
899 ], glib_ok=yes, glib_ok=no)
900 AC_MSG_RESULT($glib_ok)
901 if test "$glib_ok" = "no"; then
902     AC_DEFINE(NO_SYS_SIGLIST_DECL,1,[global 'sys_siglist' not declared])
903 fi
904
905 # Check if <sys/select.h> needs to be included for fd_set
906 AC_MSG_CHECKING([for fd_set])
907 AC_TRY_COMPILE([#include <sys/types.h>],
908         [fd_set readMask, writeMask;], gtk_ok=yes, gtk_ok=no)
909 if test "$gtk_ok" = "yes"; then
910     AC_MSG_RESULT([yes, found in sys/types.h])
911 else
912     AC_EGREP_HEADER(fd_set, sys/select.h, gtk_ok=yes)
913     if test "$gtk_ok" = "yes"; then
914         # *** FIXME: give it a different name
915         AC_DEFINE(HAVE_SYS_SELECT_H,1,[found fd_set in sys/select.h])
916         AC_MSG_RESULT([yes, found in sys/select.h])
917     else
918         AC_DEFINE(NO_FD_SET,1,[didn't find fd_set])
919         AC_MSG_RESULT(no)
920     fi
921 fi
922
923 dnl *** check for sane realloc() ***
924 AC_CACHE_CHECK([whether realloc (NULL,) will work],glib_cv_sane_realloc,[
925         AC_TRY_RUN([#include <stdlib.h>
926         int main() {
927           return realloc (0, sizeof (int)) == 0;
928         }],
929         [glib_cv_sane_realloc=yes],
930         [glib_cv_sane_realloc=no],
931         [glib_cv_sane_realloc=yes])
932 ])
933 if test x$glib_cv_sane_realloc = xyes; then
934   AC_DEFINE(REALLOC_0_WORKS,1,[whether realloc (NULL,) works])
935 fi
936
937 dnl Check for nl_langinfo and CODESET
938
939 AC_MSG_CHECKING([for nl_langinfo (CODESET)])
940 AC_TRY_COMPILE([#include <langinfo.h>],
941         [char *codeset = nl_langinfo (CODESET);],
942    AC_DEFINE(HAVE_CODESET,1,[Have nl_langinfo (CODESET)])
943    have_codeset=yes,
944    have_codeset=no)
945 AC_MSG_RESULT($have_codeset)
946
947
948 dnl ****************************************
949 dnl *** strlcpy/strlcat                  ***
950 dnl ****************************************
951 # Check for strlcpy
952 AC_CACHE_CHECK([for OpenBSD strlcpy/strlcat],glib_cv_have_strlcpy,[
953 AC_TRY_RUN([#include <stdlib.h>
954 #include <string.h>
955 int main() {
956   char p[10];
957   (void) strlcpy (p, "hi", 10);
958   if (strlcat (p, "bye", 0) != 3) 
959     return 1;
960   return 0;
961 }], glib_cv_have_strlcpy=yes, 
962     glib_cv_have_strlcpy=no,
963     glib_cv_have_strlcpy=no)])
964 if test "$glib_cv_have_strlcpy" = "yes"; then
965     AC_DEFINE(HAVE_STRLCPY,1,[Have functions strlcpy and strlcat])
966 fi
967   
968
969 dnl **********************
970 dnl *** va_copy checks ***
971 dnl **********************
972 dnl we currently check for all three va_copy possibilities, so we get
973 dnl all results in config.log for bug reports.
974 AC_CACHE_CHECK([for an implementation of va_copy()],glib_cv_va_copy,[
975         AC_LINK_IFELSE([#include <stdarg.h>
976         void f (int i, ...) {
977         va_list args1, args2;
978         va_start (args1, i);
979         va_copy (args2, args1);
980         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
981           exit (1);
982         va_end (args1); va_end (args2);
983         }
984         int main() {
985           f (0, 42);
986           return 0;
987         }],
988         [glib_cv_va_copy=yes],
989         [glib_cv_va_copy=no])
990 ])
991 AC_CACHE_CHECK([for an implementation of __va_copy()],glib_cv___va_copy,[
992         AC_LINK_IFELSE([#include <stdarg.h>
993         void f (int i, ...) {
994         va_list args1, args2;
995         va_start (args1, i);
996         __va_copy (args2, args1);
997         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
998           exit (1);
999         va_end (args1); va_end (args2);
1000         }
1001         int main() {
1002           f (0, 42);
1003           return 0;
1004         }],
1005         [glib_cv___va_copy=yes],
1006         [glib_cv___va_copy=no])
1007 ])
1008
1009 if test "x$glib_cv_va_copy" = "xyes"; then
1010   g_va_copy_func=va_copy
1011 else if test "x$glib_cv___va_copy" = "xyes"; then
1012   g_va_copy_func=__va_copy
1013 fi
1014 fi
1015
1016 if test -n "$g_va_copy_func"; then
1017   AC_DEFINE_UNQUOTED(G_VA_COPY,$g_va_copy_func,[A 'va_copy' style function])
1018 fi
1019
1020 AC_CACHE_CHECK([whether va_lists can be copied by value],glib_cv_va_val_copy,[
1021         AC_TRY_RUN([#include <stdarg.h>
1022         void f (int i, ...) {
1023         va_list args1, args2;
1024         va_start (args1, i);
1025         args2 = args1;
1026         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
1027           exit (1);
1028         va_end (args1); va_end (args2);
1029         }
1030         int main() {
1031           f (0, 42);
1032           return 0;
1033         }],
1034         [glib_cv_va_val_copy=yes],
1035         [glib_cv_va_val_copy=no],
1036         [glib_cv_va_val_copy=yes])
1037 ])
1038
1039 if test "x$glib_cv_va_val_copy" = "xno"; then
1040   AC_DEFINE(G_VA_COPY_AS_ARRAY,1, ['va_lists' cannot be copies as values])
1041 fi
1042
1043 dnl ***********************
1044 dnl *** g_module checks ***
1045 dnl ***********************
1046 G_MODULE_LIBS=
1047 G_MODULE_LIBS_EXTRA=
1048 G_MODULE_PLUGIN_LIBS=
1049 if test x"$glib_native_win32" = xyes; then
1050   dnl No use for this on Win32
1051   G_MODULE_LDFLAGS=
1052 else
1053   G_MODULE_LDFLAGS=`(./libtool --config; echo eval echo \\$export_dynamic_flag_spec) | sh`
1054 fi
1055 dnl G_MODULE_IMPL= don't reset, so cmd-line can override
1056 G_MODULE_NEED_USCORE=0
1057 G_MODULE_BROKEN_RTLD_GLOBAL=0
1058 G_MODULE_HAVE_DLERROR=0
1059 dnl *** force native WIN32 shared lib loader 
1060 if test -z "$G_MODULE_IMPL"; then
1061   case "$host" in
1062   *-*-mingw*|*-*-cygwin*) G_MODULE_IMPL=G_MODULE_IMPL_WIN32 ;;
1063   esac
1064 fi
1065 dnl *** force native AIX library loader
1066 dnl *** dlopen() filepath must be of the form /path/libname.a(libname.so)
1067 if test -z "$G_MODULE_IMPL"; then
1068   case "$host" in
1069   *-*-aix*) G_MODULE_IMPL=G_MODULE_IMPL_AR ;;
1070   esac
1071 fi
1072 dnl *** dlopen() and dlsym() in system libraries
1073 if test -z "$G_MODULE_IMPL"; then
1074         AC_CHECK_FUNC(dlopen,
1075                       [AC_CHECK_FUNC(dlsym,
1076                                      [G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
1077                       [])
1078 fi
1079 dnl *** load_image (BeOS)
1080 if test -z "$G_MODULE_IMPL" && test "x$glib_native_beos" = "xyes"; then
1081   AC_CHECK_LIB(root, load_image,
1082       [G_MODULE_LIBS="-lbe -lroot -lglib"
1083       G_MODULE_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
1084       G_MODULE_PLUGIN_LIBS="-L\$(top_builddir_full)/gmodule/.libs -lgmodule"
1085       G_MODULE_IMPL=G_MODULE_IMPL_BEOS],
1086       [])
1087 fi   
1088 dnl *** NSLinkModule (dyld) in system libraries (Darwin)
1089 if test -z "$G_MODULE_IMPL"; then
1090         AC_CHECK_FUNC(NSLinkModule,
1091                       [G_MODULE_IMPL=G_MODULE_IMPL_DYLD
1092                        G_MODULE_NEED_USCORE=1],
1093                       [])
1094 fi
1095 dnl *** dlopen() and dlsym() in libdl
1096 if test -z "$G_MODULE_IMPL"; then
1097         AC_CHECK_LIB(dl, dlopen,
1098                      [AC_CHECK_LIB(dl, dlsym,
1099                                    [G_MODULE_LIBS=-ldl
1100                                    G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
1101                      [])
1102 fi
1103 dnl *** shl_load() in libdld (HP-UX)
1104 if test -z "$G_MODULE_IMPL"; then
1105         AC_CHECK_LIB(dld, shl_load,
1106                 [G_MODULE_LIBS=-ldld
1107                 G_MODULE_IMPL=G_MODULE_IMPL_DLD],
1108                 [])
1109 fi
1110 dnl *** additional checks for G_MODULE_IMPL_DL
1111 if test "$G_MODULE_IMPL" = "G_MODULE_IMPL_DL"; then
1112         LIBS_orig="$LIBS"
1113         LDFLAGS_orig="$LDFLAGS"
1114         LIBS="$G_MODULE_LIBS $LIBS"
1115         LDFLAGS="$LDFLAGS $G_MODULE_LDFLAGS"
1116 dnl *** check for OSF1/5.0 RTLD_GLOBAL brokenness
1117         echo "void glib_plugin_test(void) { }" > plugin.c
1118         ${SHELL} ./libtool --mode=compile ${CC} -shared \
1119                 -export-dynamic -o plugin.o plugin.c 2>&1 >/dev/null
1120         AC_CACHE_CHECK([for RTLD_GLOBAL brokenness],
1121                 glib_cv_rtldglobal_broken,[
1122                 AC_TRY_RUN([
1123 #include <dlfcn.h>
1124 #ifndef RTLD_GLOBAL
1125 #  define RTLD_GLOBAL 0
1126 #endif
1127 #ifndef RTLD_LAZY
1128 #  define RTLD_LAZY 0
1129 #endif
1130 int glib_plugin_test;
1131 int main () {
1132     void *handle, *global, *local;
1133     global = &glib_plugin_test;
1134     handle = dlopen ("./.libs/plugin.o", RTLD_GLOBAL | RTLD_LAZY);
1135     if (!handle) return 0;
1136     local = dlsym (handle, "glib_plugin_test");
1137     return global == local;
1138 }                       ],
1139                         [glib_cv_rtldglobal_broken=no],
1140                         [glib_cv_rtldglobal_broken=yes],
1141                         [glib_cv_rtldglobal_broken=no])
1142                 rm -f plugin.c plugin.o plugin.lo .libs/plugin.o
1143                 rmdir .libs 2>/dev/null
1144         ])
1145         if test "x$glib_cv_rtldglobal_broken" = "xyes"; then
1146                 G_MODULE_BROKEN_RTLD_GLOBAL=1
1147         else
1148                 G_MODULE_BROKEN_RTLD_GLOBAL=0
1149         fi
1150 dnl *** check whether we need preceeding underscores
1151         AC_CACHE_CHECK([for preceeding underscore in symbols],
1152                 glib_cv_uscore,[
1153                 AC_TRY_RUN([#include <dlfcn.h>
1154                 int glib_underscore_test (void) { return 42; }
1155                 int main() {
1156                   void *f1 = (void*)0, *f2 = (void*)0, *handle;
1157                   handle = dlopen ((void*)0, 0);
1158                   if (handle) {
1159                     f1 = dlsym (handle, "glib_underscore_test");
1160                     f2 = dlsym (handle, "_glib_underscore_test");
1161                   } return (!f2 || f1);
1162                 }],
1163                         [glib_cv_uscore=yes],
1164                         [glib_cv_uscore=no],
1165                         [])
1166                 rm -f plugin.c plugin.$ac_objext plugin.lo
1167         ])
1168         GLIB_ASSERT_SET(glib_cv_uscore)
1169         if test "x$glib_cv_uscore" = "xyes"; then
1170                 G_MODULE_NEED_USCORE=1
1171         else
1172                 G_MODULE_NEED_USCORE=0
1173         fi
1174
1175         LDFLAGS="$LDFLAGS_orig"
1176 dnl *** check for having dlerror()
1177         AC_CHECK_FUNC(dlerror,
1178                 [G_MODULE_HAVE_DLERROR=1],
1179                 [G_MODULE_HAVE_DLERROR=0])
1180         LIBS="$LIBS_orig"
1181 fi
1182 dnl *** done, have we got an implementation?
1183 if test -z "$G_MODULE_IMPL"; then
1184         G_MODULE_IMPL=0
1185         G_MODULE_SUPPORTED=false
1186 else
1187         G_MODULE_SUPPORTED=true
1188 fi
1189
1190 AC_MSG_CHECKING(for the suffix of shared libraries)
1191 case "$host_os" in
1192   hpux9* | hpux10* | hpux11*)  # taken from ltconfig
1193     glib_gmodule_suffix='sl'
1194     ;;
1195   cygwin* | mingw*)
1196     glib_gmodule_suffix='dll'
1197     ;;
1198   aix*)
1199     glib_gmodule_suffix='a'
1200     ;;
1201   *)
1202     glib_gmodule_suffix='so'    
1203     ;;
1204 esac
1205 AC_MSG_RESULT(.$glib_gmodule_suffix)
1206  
1207 AC_SUBST(G_MODULE_SUPPORTED)
1208 AC_SUBST(G_MODULE_IMPL)
1209 AC_SUBST(G_MODULE_LIBS)
1210 AC_SUBST(G_MODULE_LIBS_EXTRA)
1211 AC_SUBST(G_MODULE_PLUGIN_LIBS)
1212 AC_SUBST(G_MODULE_LDFLAGS)
1213 AC_SUBST(G_MODULE_HAVE_DLERROR)
1214 AC_SUBST(G_MODULE_BROKEN_RTLD_GLOBAL)
1215 AC_SUBST(G_MODULE_NEED_USCORE)
1216 AC_SUBST(GLIB_DEBUG_FLAGS)
1217
1218 dnl **********************
1219 dnl *** g_spawn checks ***
1220 dnl **********************
1221
1222 AC_MSG_CHECKING(for gspawn implementation)
1223 case "$host" in
1224   *-*-mingw*)
1225     GSPAWN=gspawn-win32.lo
1226     ;;
1227   *)
1228     GSPAWN=gspawn.lo
1229     ;;    
1230 esac
1231 AC_MSG_RESULT($GSPAWN)
1232 AC_SUBST(GSPAWN)
1233
1234 dnl *************************
1235 dnl *** GIOChannel checks ***
1236 dnl *************************
1237
1238 AC_MSG_CHECKING(for GIOChannel implementation)
1239 case "$host" in
1240   *-*-mingw*)
1241     GIO=giowin32.lo
1242     ;;
1243   *)
1244     GIO=giounix.lo
1245     ;;    
1246 esac
1247 AC_MSG_RESULT($GIO)
1248 AC_SUBST(GIO)
1249
1250 dnl ****************************************
1251 dnl *** platform dependent source checks ***
1252 dnl ****************************************
1253
1254 AC_MSG_CHECKING(for platform-dependent source)
1255 case "$host" in
1256   *-*-cygwin*|*-*-mingw*)
1257     PLATFORMDEP=gwin32.lo
1258     ;;
1259   *)
1260     PLATFORMDEP=
1261     ;;    
1262 esac
1263 AC_MSG_RESULT($PLATFORMDEP)
1264 AC_SUBST(PLATFORMDEP)
1265
1266 AC_MSG_CHECKING([whether to compile timeloop])
1267 case "$host" in
1268   *-*-cygwin*|*-*-mingw*)
1269     enable_timeloop=no
1270     ;;
1271   *)
1272     enable_timeloop=yes
1273     ;;    
1274 esac
1275 AC_MSG_RESULT($enable_timeloop)
1276 AM_CONDITIONAL(ENABLE_TIMELOOP, test x$enable_timeloop = xyes)
1277
1278 AC_MSG_CHECKING([if building for some Win32 platform])
1279 case "$host" in
1280   *-*-mingw*|*-*-cygwin*)
1281     platform_win32=yes
1282     ;;
1283   *)
1284     platform_win32=no
1285     ;;
1286 esac
1287 AC_MSG_RESULT($platform_win32)
1288 AM_CONDITIONAL(PLATFORM_WIN32, test x$platform_win32 = xyes)
1289
1290 dnl ***********************
1291 dnl *** g_thread checks ***
1292 dnl ***********************
1293
1294 AC_ARG_WITH(threads,
1295            [AC_HELP_STRING([--with-threads=@<:@none/posix/dce/solaris/win32@:>@],
1296                            [specify a thread implementation to use])],
1297            [if test "x$with_threads" = x; then
1298                 want_threads=yes
1299             else
1300                 want_threads=$with_threads
1301             fi],
1302            [want_threads=yes])
1303 if test "x$enable_threads" = "xno"; then
1304         want_threads=no
1305 fi
1306
1307 dnl error and warning message
1308 dnl *************************
1309
1310 THREAD_NO_IMPLEMENTATION="You do not have any known thread system on your
1311                 computer. GLib will not have a default thread implementation."
1312
1313 FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your
1314                 platform (normally it's "_REENTRANT"). I'll not use any flag on
1315                 compilation now, but then your programs might not work.
1316                 Please provide information on how it is done on your system."
1317
1318 LIBS_NOT_FOUND_1="I can't find the libraries for the thread implementation
1319                 "
1320
1321 LIBS_NOT_FOUND_2=". Please choose another thread implementation or
1322                 provide information on your thread implementation.
1323                 You can also run 'configure --disable-threads' 
1324                 to compile without thread support."
1325
1326 FUNC_NO_GETPWUID_R="the 'g_get_(user_name|real_name|home_dir|tmp_dir)'
1327                 functions will not be MT-safe during their first call because
1328                 there is no working 'getpwuid_r' on your system."
1329
1330 FUNC_NO_LOCALTIME_R="the 'g_date_set_time' function will not be MT-safe
1331                 because there is no 'localtime_r' on your system."
1332
1333 POSIX_NO_YIELD="I can not find a yield functions for your platform. A rather
1334                 crude surrogate will be used. If you happen to know a 
1335                 yield function for your system, please inform the GLib 
1336                 developers."
1337
1338 POSIX_NO_PRIORITIES="I can not find the minimal and maximal priorities for 
1339                 threads on your system. Thus threads can only have the default 
1340                 priority. If you happen to know these main/max
1341                 priorities, please inform the GLib developers."
1342
1343 AIX_COMPILE_INFO="AIX's C compiler needs to be called by a different name, when
1344                 linking threaded applications. As GLib cannot do that 
1345                 automatically, you will get an linkg error everytime you are 
1346                 not using the right compiler. In that case you have to relink 
1347                 with the right compiler. Ususally just '_r' is appended 
1348                 to the compiler name."
1349
1350 dnl determination of thread implementation
1351 dnl ***************************************
1352
1353 # have_threads=no   means no thread support
1354 # have_threads=none means no default thread implementation
1355
1356 have_threads=no
1357 if test "x$want_threads" = xyes || test "x$want_threads" = xsolaris; then
1358         case $host in
1359                 *-*-solaris*)
1360                 AC_CHECK_LIB(thread, cond_init, have_threads=solaris)
1361                 ;;
1362         esac
1363 fi
1364 if test "x$want_threads" = xyes || test "x$want_threads" = xposix \
1365                                 || test "x$want_threads" = xdce; then
1366         # -D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE is for DG/UX
1367         # -U_OSF_SOURCE is for Digital UNIX 4.0d
1368         GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE"
1369         glib_save_CPPFLAGS="$CPPFLAGS"
1370         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1371         if test "x$have_threads" = xno; then
1372                 AC_TRY_COMPILE([#include <pthread.h>],
1373                         [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1374                         have_threads=posix)
1375         fi
1376         if test "x$have_threads" = xno; then
1377                 AC_TRY_COMPILE([#include <pthread.h>],
1378                         [pthread_mutex_t m; 
1379                          pthread_mutex_init (&m, pthread_mutexattr_default);],
1380                         have_threads=dce)
1381         fi
1382         # Tru64Unix requires -pthread to find pthread.h. See #103020
1383         CPPFLAGS="$CPPFLAGS -pthread"
1384         if test "x$have_threads" = xno; then
1385         AC_TRY_COMPILE([#include <pthread.h>],
1386                        [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1387                        have_threads=posix)
1388         fi
1389         CPPFLAGS="$glib_save_CPPFLAGS"
1390 fi
1391 if test "x$want_threads" = xyes || test "x$want_threads" = xwin32; then
1392         case $host in
1393                 *-*-mingw*)
1394                 have_threads=win32
1395                 ;;
1396         esac
1397 fi
1398 if test "x$want_threads" = xnone; then
1399         have_threads=none
1400 fi
1401
1402 AC_MSG_CHECKING(for thread implementation)
1403
1404 if test "x$have_threads" = xno && test "x$want_threads" != xno; then
1405         AC_MSG_RESULT(none available)
1406         AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
1407 else
1408         AC_MSG_RESULT($have_threads)
1409 fi
1410
1411
1412 dnl determination of G_THREAD_CFLAGS
1413 dnl ********************************
1414
1415 G_THREAD_LIBS=
1416 G_THREAD_LIBS_EXTRA=
1417 G_THREAD_CFLAGS=
1418
1419 dnl
1420 dnl Test program for basic POSIX threads functionality
1421 dnl
1422 m4_define([glib_thread_test],[
1423 #include <pthread.h> 
1424 int check_me = 0;
1425 void* func(void* data) {check_me = 42; return &check_me;}
1426 int main()
1427  { pthread_t t; 
1428    void *ret;
1429    pthread_create (&t, $1, func, 0);
1430    pthread_join (t, &ret);
1431    exit (check_me != 42 || ret != &check_me);
1432 }])
1433
1434 dnl
1435 dnl Test program for sched_get_priority_min()
1436 dnl
1437 m4_define([glib_sched_priority_test],[
1438 #include <sched.h>
1439 #include <errno.h>
1440 int main() {
1441     errno = 0;
1442     return sched_get_priority_min(SCHED_OTHER)==-1
1443            && errno != 0;
1444 }])
1445
1446 if test x"$have_threads" != xno; then
1447
1448   if test x"$have_threads" = xposix; then
1449     # First we test for posix, whether -pthread or -pthreads do the trick as 
1450     # both CPPFLAG and LIBS. 
1451     # One of them does for most gcc versions and some other platforms/compilers
1452     # too and could be considered as the canonical way to go. 
1453     case $host in
1454       *-*-cygwin*)
1455          # skip cygwin -pthread or -pthreads test
1456          ;;
1457       *)
1458         for flag in pthread pthreads; do
1459           glib_save_CFLAGS="$CFLAGS"
1460           CFLAGS="$CFLAGS -$flag"
1461           AC_TRY_RUN(glib_thread_test(0),
1462                      glib_flag_works=yes,
1463                      glib_flag_works=no,
1464                      [AC_LINK_IFELSE(glib_thread_test(0),
1465                                      glib_flag_works=yes,
1466                                      glib_flag_works=no)])
1467           CFLAGS="$glib_save_CFLAGS"
1468           if test $glib_flag_works = yes ; then
1469              G_THREAD_CFLAGS=-$flag
1470              G_THREAD_LIBS=-$flag
1471           fi
1472         done
1473          ;;
1474     esac 
1475   fi
1476
1477   if test x"$G_THREAD_CFLAGS" = x; then
1478
1479     # The canonical -pthread[s] does not work. Try something different.
1480
1481     case $host in
1482         *-aix*)
1483                 if test x"$GCC" = xyes; then
1484                         # GCC 3.0 and above needs -pthread. 
1485                         # Should be coverd by the case above.
1486                         # GCC 2.x and below needs -mthreads
1487                         G_THREAD_CFLAGS="-mthreads"             
1488                         G_THREAD_LIBS=$G_THREAD_CFLAGS
1489                 else 
1490                         # We are probably using the aix compiler. Normaly a 
1491                         # program would have to be compiled with the _r variant
1492                         # of the corresponding compiler, but we as GLib cannot 
1493                         # do that: but the good news is that for compiling the
1494                         # only difference is the added -D_THREAD_SAFE compile 
1495                         # option. This is according to the "C for AIX User's 
1496                         # Guide".
1497                         G_THREAD_CFLAGS="-D_THREAD_SAFE"
1498                 fi
1499                 ;;
1500         *-dg-dgux*)  # DG/UX
1501                 G_THREAD_CFLAGS="-D_REENTRANT -D_POSIX4A_DRAFT10_SOURCE"
1502                 ;;
1503         *-osf*)
1504                 # So we are using dce threads. posix threads are already 
1505                 # catched above.
1506                 G_THREAD_CFLAGS="-threads"
1507                 G_THREAD_LIBS=$G_THREAD_CFLAGS
1508                 ;;
1509         *-solaris*)
1510                 if test x"$GCC" = xyes; then
1511                    # We are using solaris threads. posix threads are 
1512                    # already catched above.
1513                         G_THREAD_CFLAGS="-threads"
1514                 else
1515                         G_THREAD_CFLAGS="-mt"
1516                 fi
1517                 G_THREAD_LIBS=$G_THREAD_CFLAGS
1518                 ;;
1519         *-sysv5uw7*) # UnixWare 7 
1520                 # We are not using gcc with -pthread. Catched above.
1521                 G_THREAD_CFLAGS="-Kthread"
1522                 G_THREAD_LIBS=$G_THREAD_CFLAGS
1523                 ;;
1524         *-mingw*)
1525                 # No flag needed when using MSVCRT.DLL
1526                 G_THREAD_CFLAGS=""
1527                 ;;
1528         *)
1529                 G_THREAD_CFLAGS="-D_REENTRANT" # good default guess otherwise
1530                 ;;
1531     esac
1532  
1533   fi
1534
1535     # if we are not finding the localtime_r function, then we probably are
1536     # not using the proper multithread flag
1537
1538     glib_save_CPPFLAGS="$CPPFLAGS"
1539     CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1540
1541     # First we test, whether localtime_r is declared in time.h
1542     # directly. Then we test whether a macro localtime_r exists, in
1543     # which case localtime_r in the test program is replaced and thus
1544     # if we still find localtime_r in the output, it is not defined as 
1545     # a macro.
1546
1547     AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>], ,
1548       [AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h> 
1549                                                            localtime_r(a,b)],
1550                    AC_MSG_WARN($FLAG_DOES_NOT_WORK))])
1551
1552     CPPFLAGS="$glib_save_CPPFLAGS"
1553
1554     AC_MSG_CHECKING(thread related cflags)
1555     AC_MSG_RESULT($G_THREAD_CFLAGS)
1556     CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1557 fi
1558
1559 dnl determination of G_THREAD_LIBS
1560 dnl ******************************
1561
1562 mutex_has_default=no
1563 case $have_threads in
1564         posix|dce)
1565           glib_save_CPPFLAGS="$CPPFLAGS"
1566           CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1567           if test x"$G_THREAD_LIBS" = x; then
1568             case $host in
1569               *-aix*)
1570                 # We are not using gcc (would have set G_THREAD_LIBS) and thus 
1571                 # probably using the aix compiler.
1572                 AC_MSG_WARN($AIX_COMPILE_INFO)
1573                 ;;
1574               *)
1575                 G_THREAD_LIBS=error
1576                 glib_save_LIBS="$LIBS"
1577                 for thread_lib in "" pthread pthread32 pthreads thread dce; do
1578                         if test x"$thread_lib" = x; then
1579                                 add_thread_lib=""
1580                                 IN=""
1581                         else
1582                                 add_thread_lib="-l$thread_lib"
1583                                 IN=" in -l$thread_lib"
1584                         fi
1585                         if test x"$have_threads" = xposix; then
1586                                 defattr=0
1587                         else
1588                                 defattr=pthread_attr_default
1589                         fi
1590                         
1591                         LIBS="$add_thread_lib $glib_save_LIBS"
1592                         
1593                         AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
1594                         AC_TRY_RUN(glib_thread_test($defattr),
1595                                    glib_result=yes,
1596                                    glib_result=no,
1597                                    [AC_LINK_IFELSE(glib_thread_test($defattr),
1598                                                    glib_result=yes,
1599                                                    glib_result=no)])
1600                         AC_MSG_RESULT($glib_result)
1601                         
1602                         if test "$glib_result" = "yes" ; then
1603                           G_THREAD_LIBS="$add_thread_lib"
1604                           break
1605                         fi
1606                 done
1607                 if test "x$G_THREAD_LIBS" = xerror; then
1608                   AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1609                 fi 
1610                 LIBS="$glib_save_LIBS"
1611                 ;;
1612             esac
1613           fi
1614
1615           glib_save_LIBS="$LIBS"
1616           for thread_lib in "" rt rte; do
1617             if test x"$thread_lib" = x; then
1618               add_thread_lib=""
1619               IN=""
1620             else
1621               add_thread_lib="-l$thread_lib"
1622               IN=" in -l$thread_lib"
1623             fi
1624             LIBS="$add_thread_lib $glib_save_LIBS"
1625             
1626             AC_MSG_CHECKING(for sched_get_priority_min$IN)
1627             AC_TRY_RUN(glib_sched_priority_test,
1628                        glib_result=yes,
1629                        glib_result=no,
1630                        [AC_LINK_IFELSE(glib_sched_priority_test,
1631                                        glib_result=yes,
1632                                        glib_result=no)])
1633             AC_MSG_RESULT($glib_result)
1634
1635             if test "$glib_result" = "yes" ; then           
1636                G_THREAD_LIBS="$G_THREAD_LIBS $add_thread_lib"
1637                posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
1638                posix_priority_max="sched_get_priority_max(SCHED_OTHER)"
1639                break
1640             fi
1641           done
1642           LIBS="$glib_save_LIBS"
1643           mutex_has_default=yes
1644           mutex_default_type='pthread_mutex_t'
1645           mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
1646           mutex_header_file='pthread.h'
1647           if test "x$have_threads" = "xposix"; then
1648             g_threads_impl="POSIX"
1649           else
1650             g_threads_impl="DCE"
1651             have_threads="posix"
1652           fi
1653           AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
1654           CPPFLAGS="$glib_save_CPPFLAGS"
1655           ;;
1656         solaris)
1657            mutex_has_default=yes
1658            mutex_default_type='mutex_t'
1659            mutex_default_init="DEFAULTMUTEX"
1660            mutex_header_file='thread.h'
1661            g_threads_impl="SOLARIS"
1662            ;;
1663         win32)
1664            g_threads_impl="WIN32"
1665            ;;
1666         none|no)
1667            g_threads_impl="NONE"
1668            ;;
1669         *)
1670            g_threads_impl="NONE"
1671            G_THREAD_LIBS=error
1672            ;;
1673 esac
1674
1675 if test "x$G_THREAD_LIBS" = xerror; then
1676         AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1677 fi
1678
1679 case $host in
1680   *-*-beos*)
1681     G_THREAD_LIBS="-lbe -lroot -lglib "
1682     G_THREAD_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
1683     ;;
1684   *)
1685     ;;
1686 esac
1687
1688 AC_MSG_CHECKING(thread related libraries)
1689 AC_MSG_RESULT($G_THREAD_LIBS)
1690
1691 dnl check for mt safe function variants and some posix functions
1692 dnl ************************************************************
1693
1694 if test x"$have_threads" != xno; then
1695         glib_save_LIBS="$LIBS"
1696         # we are not doing the following for now, as this might require glib 
1697         # to always be linked with the thread libs on some platforms. 
1698         # LIBS="$LIBS $G_THREAD_LIBS"
1699         AC_CHECK_FUNCS(localtime_r)
1700         if test "$ac_cv_header_pwd_h" = "yes"; then
1701                 AC_CACHE_CHECK([for posix getpwuid_r],
1702                         ac_cv_func_posix_getpwuid_r,
1703                         [AC_TRY_RUN([
1704 #include <errno.h>
1705 #include <pwd.h>
1706 int main () { 
1707     char buffer[10000];
1708     struct passwd pwd, *pwptr = &pwd;
1709     int error;
1710     errno = 0;
1711     error = getpwuid_r (0, &pwd, buffer, 
1712                         sizeof (buffer), &pwptr);
1713    return (error < 0 && errno == ENOSYS) 
1714            || error == ENOSYS; 
1715 }                               ],
1716                                 [ac_cv_func_posix_getpwuid_r=yes],
1717                                 [ac_cv_func_posix_getpwuid_r=no])])
1718                 GLIB_ASSERT_SET(ac_cv_func_posix_getpwuid_r)
1719                 if test "$ac_cv_func_posix_getpwuid_r" = yes; then
1720                         AC_DEFINE(HAVE_POSIX_GETPWUID_R,1,
1721                                 [Have POSIX function getpwuid_r])
1722                 else
1723                         AC_CACHE_CHECK([for nonposix getpwuid_r],
1724                                 ac_cv_func_nonposix_getpwuid_r,
1725                                 [AC_TRY_LINK([#include <pwd.h>],
1726                                         [char buffer[10000];
1727                                         struct passwd pwd;
1728                                         getpwuid_r (0, &pwd, buffer, 
1729                                                         sizeof (buffer));],
1730                                         [ac_cv_func_nonposix_getpwuid_r=yes],
1731                                         [ac_cv_func_nonposix_getpwuid_r=no])])
1732                         GLIB_ASSERT_SET(ac_cv_func_nonposix_getpwuid_r)
1733                         if test "$ac_cv_func_nonposix_getpwuid_r" = yes; then
1734                                 AC_DEFINE(HAVE_NONPOSIX_GETPWUID_R,1,
1735                                         [Have non-POSIX function getpwuid_r])
1736                         fi
1737                 fi
1738         fi
1739         LIBS="$G_THREAD_LIBS $LIBS"
1740         if test x"$have_threads" = xposix; then
1741                 glib_save_CPPFLAGS="$CPPFLAGS"
1742                 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1743                 dnl we might grow sizeof(pthread_t) later on, so use a dummy name here
1744                 GLIB_SIZEOF([#include <pthread.h>], pthread_t, system_thread)
1745                 # This is not AC_CHECK_FUNC to also work with function
1746                 # name mangling in header files.
1747                 AC_MSG_CHECKING(for pthread_attr_setstacksize)
1748                 AC_TRY_LINK([#include <pthread.h>],
1749                         [pthread_attr_t t; pthread_attr_setstacksize(&t,0)],
1750                         [AC_MSG_RESULT(yes)
1751                         AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE,1,
1752                                   [Have function pthread_attr_setstacksize])],
1753                         [AC_MSG_RESULT(no)])
1754                 AC_MSG_CHECKING(for minimal/maximal thread priority)
1755                 if test x"$posix_priority_min" = x; then
1756                         AC_EGREP_CPP(PX_PRIO_MIN,[#include <pthread.h>
1757                                 PX_PRIO_MIN],,[
1758                                 posix_priority_min=PX_PRIO_MIN
1759                                 posix_priority_max=PX_PRIO_MAX])
1760                 fi
1761                 if test x"$posix_priority_min" = x; then
1762                         # AIX
1763                         AC_EGREP_CPP(PTHREAD_PRIO_MIN,[#include <pthread.h>
1764                                 PTHREAD_PRIO_MIN],,[
1765                                 posix_priority_min=PTHREAD_PRIO_MIN
1766                                 posix_priority_max=PTHREAD_PRIO_MAX])
1767                 fi
1768                 if test x"$posix_priority_min" = x; then
1769                         AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
1770                                 PRI_OTHER_MIN],,[
1771                                 posix_priority_min=PRI_OTHER_MIN        
1772                                 posix_priority_max=PRI_OTHER_MAX])
1773                 fi
1774                 if test x"$posix_priority_min" = x; then
1775                         AC_MSG_RESULT(none found)
1776                         AC_MSG_WARN($POSIX_NO_PRIORITIES)
1777                         posix_priority_min=-1
1778                         posix_priority_max=-1
1779                 else
1780                         AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
1781                         AC_MSG_CHECKING(for pthread_setschedparam)
1782                         AC_TRY_LINK([#include <pthread.h>],
1783                           [pthread_t t; pthread_setschedparam(t, 0, NULL)],
1784                           [AC_MSG_RESULT(yes)
1785                         AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
1786                            AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])],
1787                           [AC_MSG_RESULT(no)
1788                            AC_MSG_WARN($POSIX_NO_PRIORITIES)])
1789                 fi
1790                 posix_yield_func=none
1791                 AC_MSG_CHECKING(for posix yield function)
1792                 for yield_func in sched_yield pthread_yield_np pthread_yield \
1793                                                         thr_yield; do
1794                         AC_TRY_LINK([#include <pthread.h>],
1795                                 [$yield_func()],
1796                                 [posix_yield_func="$yield_func"
1797                                 break])
1798                 done            
1799                 if test x"$posix_yield_func" = xnone; then
1800                         AC_MSG_RESULT(none found)
1801                         AC_MSG_WARN($POSIX_NO_YIELD)
1802                         posix_yield_func="g_usleep(1000)"
1803                 else
1804                         AC_MSG_RESULT($posix_yield_func)
1805                         posix_yield_func="$posix_yield_func()"
1806                 fi
1807                 AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func,[The POSIX RT yield function])
1808                 CPPFLAGS="$glib_save_CPPFLAGS"
1809            
1810         elif test x"$have_threads" = xwin32; then
1811                 # It's a pointer to a private struct
1812                 GLIB_SIZEOF(,struct _GThreadData *, system_thread)
1813         elif test x"$have_threads" = xsolaris; then 
1814                 GLIB_SIZEOF([#include <thread.h>], thread_t, system_thread)
1815         fi
1816
1817         LIBS="$glib_save_LIBS"
1818
1819         # now spit out all the warnings.
1820         if test "$ac_cv_func_posix_getpwuid_r" != "yes" && 
1821            test "$ac_cv_func_nonposix_getpwuid_r" != "yes"; then
1822                 AC_MSG_WARN($FUNC_NO_GETPWUID_R)
1823         fi
1824         if test "$ac_cv_func_localtime_r" != "yes"; then
1825                 AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
1826         fi
1827 fi      
1828
1829 if test x"$glib_cv_sizeof_system_thread" = x; then
1830    # use a pointer as a fallback.
1831    GLIB_SIZEOF(,void *, system_thread)
1832 fi
1833
1834 #
1835 # Hack to deal with:
1836
1837 #  a) GCC < 3.3 for Linux doesn't include -lpthread when
1838 #     building shared libraries with linux.
1839 #  b) libtool doesn't recognize -pthread as a library dependency.
1840 #
1841 case $host in
1842   *-*-linux*)
1843     G_THREAD_LIBS_FOR_GTHREAD="`echo $G_THREAD_LIBS | sed s/-pthread/-lpthread/`"
1844     ;;
1845   *)
1846     G_THREAD_LIBS_FOR_GTHREAD="`echo $G_THREAD_LIBS | sed s/-pthread/-Wc,-pthread/`"
1847     ;;
1848 esac
1849
1850 AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
1851                    [Source file containing theread implementation])
1852 AC_SUBST(G_THREAD_CFLAGS)
1853 AC_SUBST(G_THREAD_LIBS)
1854 AC_SUBST(G_THREAD_LIBS_FOR_GTHREAD)
1855 AC_SUBST(G_THREAD_LIBS_EXTRA)
1856
1857 dnl **********************************************
1858 dnl *** GDefaultMutex setup and initialization ***
1859 dnl **********************************************
1860 dnl
1861 dnl if mutex_has_default = yes, we also got
1862 dnl mutex_default_type, mutex_default_init and mutex_header_file
1863 if test $mutex_has_default = yes ; then
1864         glib_save_CPPFLAGS="$CPPFLAGS"
1865         glib_save_LIBS="$LIBS"
1866         LIBS="$G_THREAD_LIBS $LIBS"
1867         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1868         GLIB_SIZEOF([#include <$mutex_header_file>],
1869                     $mutex_default_type,
1870                     gmutex)
1871         GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
1872                            $mutex_default_type,
1873                            gmutex,
1874                            $glib_cv_sizeof_gmutex,
1875                            $mutex_default_init)
1876         if test x"$glib_cv_byte_contents_gmutex" = xno; then
1877                 mutex_has_default=no
1878         fi
1879         CPPFLAGS="$glib_save_CPPFLAGS"
1880         LIBS="$glib_save_LIBS"
1881 fi
1882
1883 dnl ********************************
1884 dnl *** g_atomic_* tests for gcc ***
1885 dnl ********************************
1886
1887 AC_MSG_CHECKING([whether to use assembler code for atomic operations])
1888
1889 if test x"$GCC" = xyes; then
1890   case $host_cpu in
1891     i386)
1892       AC_MSG_RESULT([none])
1893       glib_memory_barrier_needed=no
1894       ;;
1895     i?86)
1896       AC_MSG_RESULT([i486])
1897       AC_DEFINE_UNQUOTED(G_ATOMIC_I486, 1,
1898                          [i486 atomic implementation])
1899       glib_memory_barrier_needed=no
1900       ;;
1901     sparc*)
1902       SPARCV9_WARNING="Try to rerun configure with CFLAGS='-mcpu=v9',
1903                 when you are using a sparc with v9 instruction set (most
1904                 sparcs nowadays). This will make the code for atomic
1905                 operations much faster. The resulting code will not run
1906                 on very old sparcs though."
1907
1908       AC_LINK_IFELSE([[
1909         main () 
1910         {
1911           int tmp1, tmp2, tmp3;
1912           __asm__ __volatile__("casx [%2], %0, %1" 
1913                                : "=&r" (tmp1), "=&r" (tmp2) : "r" (&tmp3));
1914         }]],
1915         AC_MSG_RESULT([sparcv9])
1916         AC_DEFINE_UNQUOTED(G_ATOMIC_SPARCV9, 1,
1917                            [sparcv9 atomic implementation]),
1918         AC_MSG_RESULT([no])
1919         AC_MSG_WARN([[$SPARCV9_WARNING]]))
1920       glib_memory_barrier_needed=yes
1921       ;;
1922     alpha*)
1923       AC_MSG_RESULT([alpha])
1924       AC_DEFINE_UNQUOTED(G_ATOMIC_ALPHA, 1,
1925                          [alpha atomic implementation])
1926       glib_memory_barrier_needed=yes
1927       ;;
1928     x86_64)
1929       AC_MSG_RESULT([x86_64])
1930       AC_DEFINE_UNQUOTED(G_ATOMIC_X86_64, 1,
1931                          [x86_64 atomic implementation])
1932       glib_memory_barrier_needed=no
1933      ;;
1934     powerpc*)
1935       AC_MSG_RESULT([powerpc])
1936       AC_DEFINE_UNQUOTED(G_ATOMIC_POWERPC, 1,
1937                          [powerpc atomic implementation])
1938       glib_memory_barrier_needed=yes
1939       ;;        
1940     ia64)
1941       AC_MSG_RESULT([ia64])
1942       AC_DEFINE_UNQUOTED(G_ATOMIC_IA64, 1,
1943                          [ia64 atomic implementation])
1944       glib_memory_barrier_needed=yes
1945       ;;        
1946     *)
1947       AC_MSG_RESULT([none])
1948       glib_memory_barrier_needed=yes
1949       ;;
1950   esac
1951 fi
1952
1953 dnl ****************************************
1954 dnl *** GLib POLL* compatibility defines ***
1955 dnl ****************************************
1956
1957 glib_poll_includes=["
1958 #include <sys/types.h>
1959 #include <sys/poll.h>
1960 "]
1961
1962 if test $ac_cv_header_sys_types_h = yes &&
1963    test $ac_cv_header_sys_poll_h = yes ; then
1964   glib_failed=false
1965   GLIB_CHECK_VALUE(POLLIN, $glib_poll_includes, glib_failed=true)
1966   GLIB_CHECK_VALUE(POLLOUT, $glib_poll_includes, glib_failed=true)
1967   GLIB_CHECK_VALUE(POLLPRI, $glib_poll_includes, glib_failed=true)
1968   GLIB_CHECK_VALUE(POLLERR, $glib_poll_includes, glib_failed=true)
1969   GLIB_CHECK_VALUE(POLLHUP, $glib_poll_includes, glib_failed=true)
1970   GLIB_CHECK_VALUE(POLLNVAL, $glib_poll_includes, glib_failed=true)
1971   if $glib_failed ; then
1972     AC_MSG_ERROR([Could not determine values for POLL* constants])
1973   fi
1974 else
1975   glib_cv_value_POLLIN=1
1976   glib_cv_value_POLLOUT=4
1977   glib_cv_value_POLLPRI=2
1978   glib_cv_value_POLLERR=8
1979   glib_cv_value_POLLHUP=16
1980   glib_cv_value_POLLNVAL=32
1981 fi
1982
1983 dnl **********************
1984 dnl *** Win32 API libs ***
1985 dnl **********************
1986
1987 case $host in
1988   *-*-cygwin*)
1989         G_LIBS_EXTRA="-luser32 -lkernel32"
1990     ;;
1991   *-*-mingw*)
1992         G_LIBS_EXTRA="-lwsock32 -lole32"
1993     ;;
1994   *)
1995         G_LIBS_EXTRA=""
1996     ;;
1997 esac
1998 AC_SUBST(G_LIBS_EXTRA)
1999
2000 dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
2001 dnl since we need it for g_iconv()
2002
2003 AC_MSG_CHECKING([for EILSEQ])
2004 AC_TRY_COMPILE([
2005 #include <errno.h>
2006 ],
2007 [
2008 int error = EILSEQ;
2009 ], have_eilseq=yes, have_eilseq=no);
2010 AC_MSG_RESULT($have_eilseq)
2011
2012 dnl ******************************************************************
2013 dnl *** Look for glib-genmarshal in PATH if we are cross-compiling ***
2014 dnl ******************************************************************
2015
2016 AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
2017
2018 if test $cross_compiling = yes; then
2019   AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal, no)
2020   if test x$GLIB_GENMARSHAL = xno; then
2021     AC_MSG_ERROR(Could not find a glib-genmarshal in your PATH)
2022   fi
2023 fi
2024
2025 dnl **************************
2026 dnl *** Checks for gtk-doc ***
2027 dnl **************************
2028
2029 GTK_DOC_CHECK([1.0])
2030
2031 AC_ARG_ENABLE(man,
2032               [AC_HELP_STRING([--enable-man],
2033                               [regenerate man pages from Docbook [default=no]])],enable_man=yes,
2034               enable_man=no)
2035
2036 if test "${enable_man}" != no; then
2037 dnl
2038 dnl Check for xsltproc
2039 dnl
2040 AC_PATH_PROG([XSLTPROC], [xsltproc])
2041   if test -z "$XSLTPROC"; then
2042     enable_man=no
2043   fi
2044
2045   dnl check for DocBook DTD and stylesheets in the local catalog.
2046   JH_CHECK_XML_CATALOG([-//OASIS//DTD DocBook XML V4.1.2//EN],
2047      [DocBook XML DTD V4.1.2],,enable_man=no)
2048   JH_CHECK_XML_CATALOG([http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl],
2049      [DocBook XSL Stylesheets],,enable_man=no)
2050 fi
2051
2052 AM_CONDITIONAL(ENABLE_MAN, test x$enable_man != xno)
2053
2054 dnl ******************************
2055 dnl *** output the whole stuff ***
2056 dnl ******************************
2057
2058 dnl this section will only be run if config.status is invoked with no
2059 dnl arguments, or with "glibconfig.h" as an argument.
2060 AC_CONFIG_COMMANDS([glibconfig.h],
2061 [
2062         outfile=glibconfig.h-tmp
2063         cat > $outfile <<\_______EOF
2064 /* glibconfig.h
2065  *
2066  * This is a generated file.  Please modify 'configure.in'
2067  */
2068
2069 #ifndef __G_LIBCONFIG_H__
2070 #define __G_LIBCONFIG_H__
2071
2072 #include <glib/gmacros.h>
2073
2074 _______EOF
2075
2076         if test x$glib_limits_h = xyes; then
2077           echo '#include <limits.h>' >> $outfile
2078         fi
2079         if test x$glib_float_h = xyes; then
2080           echo '#include <float.h>' >> $outfile
2081         fi
2082         if test x$glib_values_h = xyes; then
2083           echo '#include <values.h>' >> $outfile
2084         fi
2085         if test "$glib_header_alloca_h" = "yes"; then
2086           echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
2087         fi
2088         if test x$glib_sys_poll_h = xyes; then
2089           echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
2090         fi
2091
2092         cat >> $outfile <<_______EOF
2093
2094 G_BEGIN_DECLS
2095
2096 #define G_MINFLOAT      $glib_mf
2097 #define G_MAXFLOAT      $glib_Mf
2098 #define G_MINDOUBLE     $glib_md
2099 #define G_MAXDOUBLE     $glib_Md
2100 #define G_MINSHORT      $glib_ms
2101 #define G_MAXSHORT      $glib_Ms
2102 #define G_MAXUSHORT     $glib_Mus
2103 #define G_MININT        $glib_mi
2104 #define G_MAXINT        $glib_Mi
2105 #define G_MAXUINT       $glib_Mui
2106 #define G_MINLONG       $glib_ml
2107 #define G_MAXLONG       $glib_Ml
2108 #define G_MAXULONG      $glib_Mul
2109
2110 _______EOF
2111
2112
2113         ### this should always be true in a modern C/C++ compiler
2114         cat >>$outfile <<_______EOF
2115 typedef signed char gint8;
2116 typedef unsigned char guint8;
2117 _______EOF
2118
2119
2120         if test -n "$gint16"; then
2121           cat >>$outfile <<_______EOF
2122 typedef signed $gint16 gint16;
2123 typedef unsigned $gint16 guint16;
2124 #define G_GINT16_MODIFIER $gint16_modifier
2125 #define G_GINT16_FORMAT $gint16_format
2126 #define G_GUINT16_FORMAT $guint16_format
2127 _______EOF
2128         fi
2129
2130
2131         if test -n "$gint32"; then
2132           cat >>$outfile <<_______EOF
2133 typedef signed $gint32 gint32;
2134 typedef unsigned $gint32 guint32;
2135 #define G_GINT32_MODIFIER $gint32_modifier
2136 #define G_GINT32_FORMAT $gint32_format
2137 #define G_GUINT32_FORMAT $guint32_format
2138 _______EOF
2139         fi
2140
2141         cat >>$outfile <<_______EOF
2142 #define G_HAVE_GINT64 1          /* deprecated, always true */
2143
2144 ${glib_extension}typedef signed $gint64 gint64;
2145 ${glib_extension}typedef unsigned $gint64 guint64;
2146
2147 #define G_GINT64_CONSTANT(val)  $gint64_constant
2148 _______EOF
2149
2150         if test x$gint64_format != x ; then
2151           cat >>$outfile <<_______EOF
2152 #define G_GINT64_MODIFIER $gint64_modifier
2153 #define G_GINT64_FORMAT $gint64_format
2154 #define G_GUINT64_FORMAT $guint64_format
2155 _______EOF
2156         else
2157           cat >>$outfile <<_______EOF
2158 #undef G_GINT64_MODIFIER
2159 #undef G_GINT64_FORMAT
2160 #undef G_GUINT64_FORMAT
2161 _______EOF
2162         fi           
2163
2164         cat >>$outfile <<_______EOF
2165
2166 #define GLIB_SIZEOF_VOID_P $glib_void_p
2167 #define GLIB_SIZEOF_LONG   $glib_long
2168 #define GLIB_SIZEOF_SIZE_T $glib_size_t
2169
2170 _______EOF
2171
2172         cat >>$outfile <<_______EOF
2173 typedef signed $glib_size_type_define gssize;
2174 typedef unsigned $glib_size_type_define gsize;
2175 #define G_GSIZE_MODIFIER $gsize_modifier
2176 #define G_GSSIZE_FORMAT $gssize_format
2177 #define G_GSIZE_FORMAT $gsize_format
2178
2179 #define G_MAXSIZE       G_MAXU$glib_msize_type
2180 _______EOF
2181
2182         if test -z "$glib_unknown_void_p"; then
2183           cat >>$outfile <<_______EOF
2184
2185 #define GPOINTER_TO_INT(p)      ((gint)  ${glib_gpi_cast} (p))
2186 #define GPOINTER_TO_UINT(p)     ((guint) ${glib_gpui_cast} (p))
2187
2188 #define GINT_TO_POINTER(i)      ((gpointer) ${glib_gpi_cast} (i))
2189 #define GUINT_TO_POINTER(u)     ((gpointer) ${glib_gpui_cast} (u))
2190 _______EOF
2191         else
2192           echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
2193         fi
2194
2195
2196
2197         cat >>$outfile <<_______EOF
2198 $glib_atexit
2199 $glib_memmove
2200 $glib_defines
2201 $glib_os
2202
2203 $glib_vacopy
2204
2205 #ifdef  __cplusplus
2206 #define G_HAVE_INLINE   1
2207 #else   /* !__cplusplus */
2208 $glib_inline
2209 #endif  /* !__cplusplus */
2210
2211 _______EOF
2212
2213         if test x$g_have_iso_c_varargs = xyes ; then
2214                 cat >>$outfile <<_______EOF
2215 #ifndef __cplusplus
2216 # define G_HAVE_ISO_VARARGS 1
2217 #endif
2218 _______EOF
2219         fi
2220         if test x$g_have_iso_cxx_varargs = xyes ; then
2221                 cat >>$outfile <<_______EOF
2222 #ifdef __cplusplus
2223 # define G_HAVE_ISO_VARARGS 1
2224 #endif
2225 _______EOF
2226         fi
2227         if test x$g_have_gnuc_varargs = xyes ; then
2228                 cat >>$outfile <<_______EOF
2229
2230 /* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
2231  * is passed ISO vararg support is turned off, and there is no work
2232  * around to turn it on, so we unconditionally turn it off.
2233  */
2234 #if __GNUC__ == 2 && __GNUC_MINOR__ == 95
2235 #  undef G_HAVE_ISO_VARARGS
2236 #endif
2237
2238 #define G_HAVE_GNUC_VARARGS 1
2239 _______EOF
2240         fi
2241
2242         case x$g_stack_grows in
2243         xyes) echo "#define G_HAVE_GROWING_STACK 1" >>$outfile ;;
2244         *)    echo "#define G_HAVE_GROWING_STACK 0" >>$outfile ;;
2245         esac
2246
2247
2248         echo >>$outfile
2249         if test x$g_have_eilseq = xno; then
2250                 cat >>$outfile <<_______EOF
2251 #ifndef EILSEQ
2252 /* On some systems, like SunOS and NetBSD, EILSEQ is not defined.
2253  * The correspondence between this and the corresponding definition
2254  * in libiconv is essential.
2255  */
2256 #  define EILSEQ ENOENT
2257 #endif
2258 _______EOF
2259
2260         fi
2261
2262         if test x$g_have_gnuc_visibility = xyes ; then
2263                 cat >>$outfile <<_______EOF
2264 #define G_HAVE_GNUC_VISIBILITY 1
2265 #define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
2266 _______EOF
2267         else
2268                 cat >>$outfile <<_______EOF
2269 #define G_GNUC_INTERNAL
2270 _______EOF
2271         fi
2272
2273
2274         echo >>$outfile
2275         if test x$g_mutex_has_default = xyes; then
2276                 cat >>$outfile <<_______EOF
2277 $g_enable_threads_def G_THREADS_ENABLED
2278 #define G_THREADS_IMPL_$g_threads_impl_def
2279 typedef struct _GStaticMutex GStaticMutex;
2280 struct _GStaticMutex
2281 {
2282   struct _GMutex *runtime_mutex;
2283   union {
2284     char   pad[[$g_mutex_sizeof]];
2285     double dummy_double;
2286     void  *dummy_pointer;
2287     long   dummy_long;
2288   } static_mutex;
2289 };
2290 #define G_STATIC_MUTEX_INIT     { NULL, { { $g_mutex_contents} } }
2291 #define g_static_mutex_get_mutex(mutex) \\
2292   (g_thread_use_default_impl ? ((GMutex*) &((mutex)->static_mutex)) : \\
2293    g_static_mutex_get_mutex_impl_shortcut (&((mutex)->runtime_mutex)))
2294 _______EOF
2295         else
2296                 cat >>$outfile <<_______EOF
2297 $g_enable_threads_def G_THREADS_ENABLED
2298 #define G_THREADS_IMPL_$g_threads_impl_def
2299 typedef struct _GMutex* GStaticMutex;
2300 #define G_STATIC_MUTEX_INIT NULL
2301 #define g_static_mutex_get_mutex(mutex) \\
2302   (g_static_mutex_get_mutex_impl_shortcut (mutex))
2303 _______EOF
2304         fi
2305
2306         cat >>$outfile <<_______EOF
2307 /* This represents a system thread as used by the implementation. An
2308  * alien implementaion, as loaded by g_thread_init can only count on
2309  * "sizeof (gpointer)" bytes to store their info. We however need more
2310  * for some of our native implementations. */
2311 typedef union _GSystemThread GSystemThread;
2312 union _GSystemThread
2313 {
2314   char   data[[$g_system_thread_sizeof]];
2315   double dummy_double;
2316   void  *dummy_pointer;
2317   long   dummy_long;
2318 };
2319 _______EOF
2320         if test x"$g_memory_barrier_needed" != xno; then
2321           echo >>$outfile
2322           echo "#define G_ATOMIC_OP_MEMORY_BARRIER_NEEDED 1" >>$outfile
2323         fi
2324
2325         echo >>$outfile
2326         g_bit_sizes="16 32 64"
2327         for bits in $g_bit_sizes; do
2328           cat >>$outfile <<_______EOF
2329 #define GINT${bits}_TO_${g_bs_native}(val)      ((gint${bits}) (val))
2330 #define GUINT${bits}_TO_${g_bs_native}(val)     ((guint${bits}) (val))
2331 #define GINT${bits}_TO_${g_bs_alien}(val)       ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
2332 #define GUINT${bits}_TO_${g_bs_alien}(val)      (GUINT${bits}_SWAP_LE_BE (val))
2333 _______EOF
2334         done
2335
2336         cat >>$outfile <<_______EOF
2337 #define GLONG_TO_LE(val)        ((glong) GINT${glongbits}_TO_LE (val))
2338 #define GULONG_TO_LE(val)       ((gulong) GUINT${glongbits}_TO_LE (val))
2339 #define GLONG_TO_BE(val)        ((glong) GINT${glongbits}_TO_BE (val))
2340 #define GULONG_TO_BE(val)       ((gulong) GUINT${glongbits}_TO_BE (val))
2341 #define GINT_TO_LE(val)         ((gint) GINT${gintbits}_TO_LE (val))
2342 #define GUINT_TO_LE(val)        ((guint) GUINT${gintbits}_TO_LE (val))
2343 #define GINT_TO_BE(val)         ((gint) GINT${gintbits}_TO_BE (val))
2344 #define GUINT_TO_BE(val)        ((guint) GUINT${gintbits}_TO_BE (val))
2345 #define G_BYTE_ORDER $g_byte_order
2346
2347 #define GLIB_SYSDEF_POLLIN =$g_pollin
2348 #define GLIB_SYSDEF_POLLOUT =$g_pollout
2349 #define GLIB_SYSDEF_POLLPRI =$g_pollpri
2350 #define GLIB_SYSDEF_POLLHUP =$g_pollhup
2351 #define GLIB_SYSDEF_POLLERR =$g_pollerr
2352 #define GLIB_SYSDEF_POLLNVAL =$g_pollnval
2353
2354 #define G_MODULE_SUFFIX "$g_module_suffix"
2355
2356 typedef $g_pid_type GPid;
2357
2358 G_END_DECLS
2359
2360 #endif /* GLIBCONFIG_H */
2361 _______EOF
2362
2363
2364         if cmp -s $outfile glibconfig.h; then
2365           AC_MSG_NOTICE([glibconfig.h is unchanged])
2366           rm -f $outfile
2367         else
2368           mv $outfile glibconfig.h
2369         fi
2370 ],[
2371
2372 # Note that if two cases are the same, case goes with the first one.
2373 # Note also that this is inside an AC_OUTPUT_COMMAND.  We do not depend
2374 # on variable expansion in case labels.  Look at the generated config.status
2375 # for a hint.
2376
2377 if test "x${ac_cv_working_alloca_h+set}" = xset ; then
2378   glib_header_alloca_h="$ac_cv_working_alloca_h"
2379 else
2380   glib_header_alloca_h="$ac_cv_header_alloca_h"
2381 fi
2382
2383 case xyes in
2384 x$ac_cv_header_float_h)
2385   glib_float_h=yes
2386   glib_mf=FLT_MIN glib_Mf=FLT_MAX
2387   glib_md=DBL_MIN glib_Md=DBL_MAX
2388   ;;
2389 x$ac_cv_header_values_h)
2390   glib_values_h=yes
2391   glib_mf=MINFLOAT  glib_Mf=MAXFLOAT
2392   glib_md=MINDOUBLE glib_Md=MAXDOUBLE
2393   ;;
2394 esac
2395
2396 case xyes in
2397 x$ac_cv_header_limits_h)
2398   glib_limits_h=yes
2399   glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
2400   glib_mi=INT_MIN  glib_Mi=INT_MAX  glib_Mui=UINT_MAX
2401   glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
2402   ;;
2403 x$ac_cv_header_values_h)
2404   glib_values_h=yes
2405   glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
2406   glib_mi=MININT   glib_Mi=MAXINT   glib_Mui="(((guint)G_MAXINT)*2+1)"
2407   glib_ml=MINLONG  glib_Ml=MAXLONG  glib_Mul="(((gulong)G_MAXLONG)*2+1)"
2408   ;;
2409 esac
2410
2411 if test x$ac_cv_header_sys_poll_h = xyes ; then
2412   glib_sys_poll_h=yes
2413 fi
2414
2415 case 2 in
2416 $ac_cv_sizeof_short)            
2417   gint16=short
2418   gint16_modifier='"h"'
2419   gint16_format='"hi"'
2420   guint16_format='"hu"'
2421   ;;
2422 $ac_cv_sizeof_int)              
2423   gint16=int
2424   gint16_modifier='""'
2425   gint16_format='"i"'
2426   guint16_format='"u"'
2427   ;;
2428 esac
2429 case 4 in
2430 $ac_cv_sizeof_short)            
2431   gint32=short
2432   gint32_modifier='"h"'
2433   gint32_format='"hi"'
2434   guint32_format='"hu"'
2435   ;;
2436 $ac_cv_sizeof_int)              
2437   gint32=int
2438   gint32_modifier='""'
2439   gint32_format='"i"'
2440   guint32_format='"u"'
2441   ;;
2442 $ac_cv_sizeof_long)             
2443   gint32=long
2444   gint32_modifier='"l"'
2445   gint32_format='"li"'
2446   guint32_format='"lu"'
2447   ;;
2448 esac
2449 case 8 in
2450 $ac_cv_sizeof_int)
2451   gint64=int
2452   gint64_modifier='""'
2453   gint64_format='"i"'
2454   guint64_format='"u"'
2455   glib_extension=
2456   gint64_constant='(val)'
2457   ;;
2458 $ac_cv_sizeof_long)
2459   gint64=long
2460   gint64_modifier='"l"'
2461   gint64_format='"li"'
2462   guint64_format='"lu"'
2463   glib_extension=
2464   gint64_constant='(val##L)'
2465   ;;
2466 $ac_cv_sizeof_long_long)
2467   gint64='long long'
2468   if test -n "$glib_cv_long_long_format"; then
2469     gint64_modifier='"'$glib_cv_long_long_format'"'
2470     gint64_format='"'$glib_cv_long_long_format'i"'
2471     guint64_format='"'$glib_cv_long_long_format'u"'
2472   fi
2473   glib_extension='G_GNUC_EXTENSION '
2474   gint64_constant='(G_GNUC_EXTENSION (val##LL))'
2475   ;;
2476 $ac_cv_sizeof___int64)
2477   gint64='__int64'
2478   if test -n "$glib_cv_long_long_format"; then
2479     gint64_modifier='"'$glib_cv_long_long_format'"'
2480     gint64_format='"'$glib_cv_long_long_format'i"'
2481     guint64_format='"'$glib_cv_long_long_format'u"'
2482   fi
2483   glib_extension=
2484   gint64_constant='(val##i64)'
2485   ;;
2486 esac
2487 glib_size_t=$ac_cv_sizeof_size_t
2488 glib_size_type_define=$glib_size_type
2489 glib_void_p=$ac_cv_sizeof_long
2490 glib_long=$ac_cv_sizeof_void_p
2491
2492 case $glib_size_type in
2493 short)
2494   gsize_modifier='"h"'
2495   gsize_format='"hu"'
2496   gssize_format='"hi"'
2497   glib_msize_type='SHRT'
2498   ;;
2499 int)
2500   gsize_modifier='""'
2501   gsize_format='"u"'
2502   gssize_format='"i"'
2503   glib_msize_type='INT'
2504   ;;
2505 long)
2506   gsize_modifier='"l"'
2507   gsize_format='"lu"'
2508   gssize_format='"li"'
2509   glib_msize_type='LONG'
2510   ;;
2511 esac
2512
2513 gintbits=`expr $ac_cv_sizeof_int \* 8`
2514 glongbits=`expr $ac_cv_sizeof_long \* 8`
2515
2516
2517 case $ac_cv_sizeof_void_p in
2518 $ac_cv_sizeof_int)      glib_gpi_cast=''        glib_gpui_cast=''         ;;
2519 $ac_cv_sizeof_long)     glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
2520 *)                      glib_unknown_void_p=yes ;;
2521 esac
2522
2523
2524 case xyes in
2525 x$ac_cv_func_atexit)
2526   glib_atexit="
2527 #ifdef NeXT /* @#%@! NeXTStep */
2528 # define g_ATEXIT(proc) (!atexit (proc))
2529 #else
2530 # define g_ATEXIT(proc) (atexit (proc))
2531 #endif"
2532   ;;
2533 x$ac_cv_func_on_exit)
2534   glib_atexit="
2535 #define g_ATEXIT(proc)  (on_exit ((void (*)(int, void*))(proc), NULL))"
2536   ;;
2537 esac
2538
2539 case xyes in
2540 x$ac_cv_func_memmove)
2541   glib_memmove='
2542 #define g_memmove(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END'
2543   ;;
2544 x$glib_cv_working_bcopy)
2545   glib_memmove="
2546 /* memmove isn't available, but bcopy can copy overlapping memory regions */
2547 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
2548   ;;
2549 *)  
2550   glib_memmove="
2551 /* memmove isn't found and bcopy can't copy overlapping memory regions, 
2552  * so we have to roll our own copy routine. */
2553 void g_memmove (void* dest, const void * src, unsigned long len);"
2554   ;;
2555 esac
2556
2557 glib_defines="
2558 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
2559 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
2560 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
2561 "
2562
2563 case xyes in
2564 x$glib_cv_va_copy)      glib_vacopy='#define G_VA_COPY  va_copy' ;;
2565 x$glib_cv___va_copy)    glib_vacopy='#define G_VA_COPY  __va_copy' ;;
2566 *)                      glib_vacopy=''
2567 esac
2568
2569 if test x$glib_cv_va_val_copy = xno; then
2570   glib_vacopy="\$glib_vacopy
2571 #define G_VA_COPY_AS_ARRAY 1"
2572 fi
2573
2574 if test x$glib_cv_hasinline = xyes; then
2575     glib_inline='#define G_HAVE_INLINE 1'
2576 fi
2577 if test x$glib_cv_has__inline = xyes; then
2578     glib_inline="\$glib_inline
2579 #define G_HAVE___INLINE 1"
2580 fi
2581 if test x$glib_cv_has__inline__ = xyes; then
2582     glib_inline="\$glib_inline
2583 #define G_HAVE___INLINE__ 1"
2584 fi
2585
2586 g_have_gnuc_varargs=$g_have_gnuc_varargs
2587 g_have_iso_c_varargs=$g_have_iso_c_varargs
2588 g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
2589
2590 g_have_gnuc_visibility=$g_have_gnuc_visibility
2591
2592 case xyes in
2593 x$ac_cv_c_bigendian)
2594   g_byte_order=G_BIG_ENDIAN
2595   g_bs_native=BE
2596   g_bs_alien=LE
2597   ;;
2598 *)
2599   g_byte_order=G_LITTLE_ENDIAN
2600   g_bs_native=LE
2601   g_bs_alien=BE
2602   ;;
2603 esac
2604
2605 g_pollin=$glib_cv_value_POLLIN
2606 g_pollout=$glib_cv_value_POLLOUT
2607 g_pollpri=$glib_cv_value_POLLPRI
2608 g_pollhup=$glib_cv_value_POLLHUP
2609 g_pollerr=$glib_cv_value_POLLERR
2610 g_pollnval=$glib_cv_value_POLLNVAL
2611
2612 g_stack_grows=$glib_cv_stack_grows
2613
2614 g_have_eilseq=$have_eilseq
2615
2616 case x$have_threads in
2617 xno)    g_enable_threads_def="#undef";;
2618 *)      g_enable_threads_def="#define";;
2619 esac
2620
2621 g_threads_impl_def=$g_threads_impl
2622
2623 g_mutex_has_default="$mutex_has_default"
2624 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
2625 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
2626 g_mutex_contents="$glib_cv_byte_contents_gmutex"
2627
2628 g_memory_barrier_needed="$glib_memory_barrier_needed"
2629
2630 g_module_suffix="$glib_gmodule_suffix"
2631
2632 g_pid_type="$glib_pid_type"
2633 case $host in
2634   *-*-beos*)
2635     glib_os="#define G_OS_BEOS"
2636     ;;
2637   *-*-cygwin*)
2638     glib_os="#define G_OS_UNIX
2639 #define G_PLATFORM_WIN32
2640 #define G_WITH_CYGWIN"
2641     ;;
2642   *-*-mingw*)
2643     glib_os="#define G_OS_WIN32
2644 #define G_PLATFORM_WIN32"
2645     ;;
2646   *)
2647     glib_os="#define G_OS_UNIX"
2648     ;;
2649 esac
2650 ])
2651
2652 AC_CONFIG_FILES([
2653 glib-2.0.pc
2654 glib-2.0-uninstalled.pc
2655 gmodule-2.0.pc
2656 gmodule-2.0-uninstalled.pc
2657 gthread-2.0.pc
2658 gthread-2.0-uninstalled.pc
2659 gobject-2.0.pc
2660 gobject-2.0-uninstalled.pc
2661 glib-zip
2662 glib-gettextize
2663 Makefile
2664 build/Makefile
2665 build/win32/Makefile
2666 build/win32/dirent/Makefile
2667 glib/Makefile
2668 glib/libcharset/Makefile
2669 glib/gnulib/Makefile
2670 gmodule/Makefile
2671 gmodule/gmoduleconf.h
2672 gobject/Makefile
2673 gobject/glib-mkenums
2674 gthread/Makefile
2675 po/Makefile.in
2676 docs/Makefile
2677 docs/reference/Makefile
2678 docs/reference/glib/Makefile
2679 docs/reference/glib/version.xml
2680 docs/reference/gobject/Makefile
2681 docs/reference/gobject/version.xml
2682 tests/Makefile
2683 tests/gobject/Makefile
2684 m4macros/Makefile
2685 ])
2686
2687 AC_CONFIG_COMMANDS([chmod-scripts],
2688 [chmod 0755 glib-zip
2689 chmod 0755 glib-gettextize
2690 chmod 0755 gobject/glib-mkenums])
2691
2692 # we want to invoke this macro solely so that the config.status script
2693 # and automake generated makefiles know about these generated files.
2694 # They are only needed to distcheck the package
2695 if false; then
2696   AC_CONFIG_FILES([
2697     INSTALL
2698     README
2699     config.h.win32
2700     glibconfig.h.win32
2701     glib/makefile.msc
2702     glib/glib.rc
2703     gmodule/makefile.msc
2704     gmodule/gmodule.rc
2705     gobject/makefile.msc
2706     gobject/gobject.rc
2707     gthread/makefile.msc
2708     gthread/gthread.rc
2709     tests/makefile.msc
2710   ])
2711 fi
2712
2713 AC_OUTPUT