Test for sched_yield as the native yield function first. Corrected typo
[platform/upstream/glib.git] / configure.in
1 dnl ***********************************
2 dnl *** include special GLib macros ***
3 dnl ***********************************
4 builtin(include, acglib.m4)dnl
5
6 # require autoconf 2.13
7 AC_PREREQ(2.13)
8
9 # Process this file with autoconf to produce a configure script.
10 AC_INIT(glist.c)
11
12 # Save this value here, since automake will set cflags later
13 cflags_set=${CFLAGS+set}
14
15 # we rewrite this file
16 rm -f glibconfig-sysdefs.h
17
18 dnl we need to AC_DIVERT_PUSH/AC_DIVERT_POP these variable definitions so they
19 dnl are available for $ac_help expansion (don't we all *love* autoconf?)
20 AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)dnl
21 #
22 # The following version number definitions apply to GLib, GModule and GThread
23 # as a whole, so if changes occoured in any of them, they are all
24 # treated with the same interface and binary age.
25 #
26 # Making releases:
27 #   GLIB_MICRO_VERSION += 1;
28 #   GLIB_INTERFACE_AGE += 1;
29 #   GLIB_BINARY_AGE += 1;
30 # if any functions have been added, set GLIB_INTERFACE_AGE to 0.
31 # if backwards compatibility has been broken,
32 # set GLIB_BINARY_AGE _and_ GLIB_INTERFACE_AGE to 0.
33 #
34 GLIB_MAJOR_VERSION=1
35 GLIB_MINOR_VERSION=3
36 GLIB_MICRO_VERSION=1
37 GLIB_INTERFACE_AGE=0
38 GLIB_BINARY_AGE=0
39 GLIB_VERSION=$GLIB_MAJOR_VERSION.$GLIB_MINOR_VERSION.$GLIB_MICRO_VERSION
40 dnl
41 AC_DIVERT_POP()dnl
42
43 AC_SUBST(GLIB_MAJOR_VERSION)
44 AC_SUBST(GLIB_MINOR_VERSION)
45 AC_SUBST(GLIB_MICRO_VERSION)
46 AC_SUBST(GLIB_VERSION)
47 AC_SUBST(GLIB_INTERFACE_AGE)
48 AC_SUBST(GLIB_BINARY_AGE)
49
50 # libtool versioning
51 LT_RELEASE=$GLIB_MAJOR_VERSION.$GLIB_MINOR_VERSION
52 LT_CURRENT=`expr $GLIB_MICRO_VERSION - $GLIB_INTERFACE_AGE`
53 LT_REVISION=$GLIB_INTERFACE_AGE
54 LT_AGE=`expr $GLIB_BINARY_AGE - $GLIB_INTERFACE_AGE`
55 AC_SUBST(LT_RELEASE)
56 AC_SUBST(LT_CURRENT)
57 AC_SUBST(LT_REVISION)
58 AC_SUBST(LT_AGE)
59
60 VERSION=$GLIB_VERSION
61 PACKAGE=glib
62
63 AM_INIT_AUTOMAKE($PACKAGE, $VERSION, no-define)
64
65 # Specify a configuration file
66 AM_CONFIG_HEADER(config.h)
67
68 AC_DEFINE_UNQUOTED(GLIB_MAJOR_VERSION, $GLIB_MAJOR_VERSION)
69 AC_DEFINE_UNQUOTED(GLIB_MINOR_VERSION, $GLIB_MINOR_VERSION)
70 AC_DEFINE_UNQUOTED(GLIB_MICRO_VERSION, $GLIB_MICRO_VERSION)
71 AC_DEFINE_UNQUOTED(GLIB_INTERFACE_AGE, $GLIB_INTERFACE_AGE)
72 AC_DEFINE_UNQUOTED(GLIB_BINARY_AGE, $GLIB_BINARY_AGE)
73
74 dnl Initialize libtool
75 AM_PROG_LIBTOOL
76
77 dnl Initialize maintainer mode
78 AM_MAINTAINER_MODE
79
80 AC_CANONICAL_HOST
81
82 AC_MSG_CHECKING(for the BeOS)
83 case $host in
84   *-*-beos*)
85     glib_native_beos="yes"
86     ;;
87   *)
88     glib_native_beos="no"
89     ;;
90 esac
91 AC_MSG_RESULT([$glib_native_beos])
92
93 dnl figure debugging default, prior to $ac_help setup
94 dnl
95 AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)dnl
96 if test `expr $GLIB_MINOR_VERSION \% 2` = 1 ; then
97         debug_default=yes
98 else
99         debug_default=minimum
100 fi
101 AC_DIVERT_POP()dnl
102
103 dnl declare --enable-* args and collect ac_help strings
104 AC_ARG_ENABLE(debug, [  --enable-debug=[no/minimum/yes] turn on debugging [default=$debug_default]],,enable_debug=$debug_default)
105 AC_ARG_ENABLE(msg-prefix, [  --enable-msg-prefix     turn on program name and PID prefixing of messages and warnings],,enable_msg_prefix=no)
106 AC_ARG_ENABLE(mem_check, [  --enable-mem-check      turn on malloc/free sanity checking [default=no]],,enable_mem_check=no)
107 AC_ARG_ENABLE(mem_profile, [  --enable-mem-profile    turn on malloc profiling atexit [default=no]],,enable_mem_profile=no)
108 AC_ARG_ENABLE(ansi, [  --enable-ansi           turn on strict ansi [default=no]],
109                     , enable_ansi=no)
110 AC_ARG_ENABLE(threads, [  --enable-threads        turn on basic thread support [default=yes]
111                           ([=no] will override --with-threads)],,enable_threads=yes)
112
113 if test "x$enable_threads" != "xyes"; then
114   enable_threads=no
115 fi
116
117 AC_MSG_CHECKING(whether to enable memory checking)
118 if test "x$enable_mem_check" = "xyes"; then
119   AC_DEFINE(ENABLE_MEM_CHECK, 1)
120   AC_SUBST(ENABLE_MEM_CHECK)
121   AC_MSG_RESULT(yes)
122 else
123   AC_MSG_RESULT(no)
124 fi
125
126 AC_MSG_CHECKING(whether to enable memory profiling)
127 if test "x$enable_mem_profile" = "xyes"; then
128   AC_DEFINE(ENABLE_MEM_PROFILE, 1)
129   AC_SUBST(ENABLE_MEM_PROFILE)
130   AC_MSG_RESULT(yes)
131 else
132   AC_MSG_RESULT(no)
133 fi
134
135 if test "x$enable_debug" = "xyes"; then
136   test "$cflags_set" = set || CFLAGS="$CFLAGS -g"
137   GLIB_DEBUG_FLAGS="-DG_ENABLE_DEBUG"
138 else
139   if test "x$enable_debug" = "xno"; then
140     GLIB_DEBUG_FLAGS="-DG_DISABLE_ASSERT -DG_DISABLE_CHECKS"
141   fi
142 fi
143
144 AC_DEFINE_UNQUOTED(G_COMPILED_WITH_DEBUGGING, "${enable_debug}")
145
146 if test "x$enable_msg_prefix" = "xyes"; then
147   AC_DEFINE_UNQUOTED(G_ENABLE_MSG_PREFIX, 1)
148 fi
149
150 # Checks for programs.
151 AC_PROG_CC
152 AM_PROG_CC_STDC
153 AC_PROG_INSTALL
154
155 changequote(,)dnl
156 if test "x$GCC" = "xyes"; then
157   case " $CFLAGS " in
158   *[\ \ ]-Wall[\ \      ]*) ;;
159   *) CFLAGS="$CFLAGS -Wall" ;;
160   esac
161
162   if test "x$enable_ansi" = "xyes"; then
163     case " $CFLAGS " in
164     *[\ \       ]-ansi[\ \      ]*) ;;
165     *) CFLAGS="$CFLAGS -ansi" ;;
166     esac
167
168     case " $CFLAGS " in
169     *[\ \       ]-pedantic[\ \  ]*) ;;
170     *) CFLAGS="$CFLAGS -pedantic" ;;
171     esac
172   fi
173 fi
174 changequote([,])dnl
175
176 dnl DU4 native cc currently needs -std1 for ANSI mode (instead of K&R)
177 AC_MSG_CHECKING([for extra flags to get ANSI library prototypes])
178 glib_save_LIBS=$LIBS
179 LIBS="$LIBS -lm"
180 AC_TRY_RUN([#include <math.h>
181              int main (void) { return (log(1) != log(1.)); }],
182      AC_MSG_RESULT(none needed),
183      glib_save_CFLAGS=$CFLAGS
184      CFLAGS="$CFLAGS -std1"
185      AC_TRY_RUN([#include <math.h>
186                  int main (void) { return (log(1) != log(1.)); }],
187          AC_MSG_RESULT(-std1),
188          AC_MSG_RESULT()
189          CFLAGS=$glib_save_CFLAGS
190          AC_MSG_WARN(
191                 [No ANSI prototypes found in library. (-std1 didn't work.)])
192      )
193 )
194 LIBS=$glib_save_LIBS
195
196 dnl NeXTStep cc seems to need this
197 AC_MSG_CHECKING([for extra flags for POSIX compliance])
198 AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
199   AC_MSG_RESULT(none needed),
200   glib_save_CFLAGS=$CFLAGS
201   CFLAGS="$CFLAGS -posix"
202   AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
203     AC_MSG_RESULT(-posix),
204     AC_MSG_RESULT()
205     CFLAGS=$glib_save_CFLAGS
206     AC_MSG_WARN([Could not determine POSIX flag. (-posix didn't work.)])))
207
208 # Checks for header files.
209 AC_HEADER_STDC
210
211 # Checks for library functions.
212 AC_FUNC_VPRINTF
213
214 AC_CHECK_FUNCS(atexit on_exit)
215
216 AC_CHECK_SIZEOF(char)
217 AC_CHECK_SIZEOF(short)
218 AC_CHECK_SIZEOF(long)
219 AC_CHECK_SIZEOF(int)
220 AC_CHECK_SIZEOF(void *)
221 AC_CHECK_SIZEOF(long long)
222
223 if test x$ac_cv_sizeof_long_long = x8; then
224         # long long is a 64 bit integer.
225         AC_MSG_CHECKING(for format to printf and scanf a gint64)
226         AC_CACHE_VAL(glib_cv_long_long_format,[
227                 AC_TRY_RUN([#include <stdio.h>  
228                         int main()
229                         {
230                           long long b, a = -0x3AFAFAFAFAFAFAFALL;
231                           char buffer[1000];
232                           sprintf (buffer, "%llu", a);
233                           sscanf (buffer, "%llu", &b);
234                           exit (b!=a);
235                         }
236                         ],
237                         glib_cv_long_long_format=ll,
238                         glib_cv_long_long_format=q)])
239         AC_MSG_RESULT(%${glib_cv_long_long_format}i)
240 fi
241
242 dnl long doubles were not used, and a portability problem
243 dnl AC_C_LONG_DOUBLE
244 AC_C_CONST
245
246 dnl AC_C_INLINE is useless to us since it bails out too early, we need to
247 dnl truely know which ones of `inline', `__inline' and `__inline__' are
248 dnl actually supported.
249 AC_MSG_CHECKING(for __inline)
250 AC_CACHE_VAL(glib_cv_has__inline,[
251         AC_TRY_RUN([
252         __inline int foo () { return 0; }
253         int main () { return foo (); }
254         ],
255         glib_cv_has__inline=yes
256         ,
257         glib_cv_has__inline=no
258         ,)
259 ])
260 AC_MSG_RESULT($glib_cv_has__inline)
261 case x$glib_cv_has__inline in
262 xyes) AC_DEFINE(G_HAVE___INLINE)
263 esac
264 AC_MSG_CHECKING(for __inline__)
265 AC_CACHE_VAL(glib_cv_has__inline__,[
266         AC_TRY_RUN([
267         __inline__ int foo () { return 0; }
268         int main () { return foo (); }
269         ],
270         glib_cv_has__inline__=yes
271         ,
272         glib_cv_has__inline__=no
273         ,)
274 ])
275 AC_MSG_RESULT($glib_cv_has__inline__)
276 case x$glib_cv_has__inline__ in
277 xyes) AC_DEFINE(G_HAVE___INLINE__)
278 esac
279 AC_MSG_CHECKING(for inline)
280 AC_CACHE_VAL(glib_cv_hasinline,[
281         AC_TRY_RUN([
282         inline int foo () { return 0; }
283         int main () { return foo (); }
284         ],
285         glib_cv_hasinline=yes
286         ,
287         glib_cv_hasinline=no
288         ,)
289 ])
290 AC_MSG_RESULT($glib_cv_hasinline)
291 case x$glib_cv_hasinline in
292 xyes) AC_DEFINE(G_HAVE_INLINE)
293 esac
294
295 # check for bytesex stuff
296 AC_C_BIGENDIAN
297
298 # xhexk for header files
299 AC_CHECK_HEADERS(float.h, AC_DEFINE(HAVE_FLOAT_H))
300 AC_CHECK_HEADERS(limits.h, AC_DEFINE(HAVE_LIMITS_H))
301 AC_CHECK_HEADERS(pwd.h, AC_DEFINE(HAVE_PWD_H))
302 AC_CHECK_HEADERS(sys/param.h, AC_DEFINE(HAVE_SYS_PARAM_H))
303 AC_CHECK_HEADERS(sys/poll.h, AC_DEFINE(HAVE_SYS_POLL_H))
304 AC_CHECK_HEADERS(sys/select.h, AC_DEFINE(HAVE_SYS_SELECT_H))
305 AC_CHECK_HEADERS(sys/time.h, AC_DEFINE(HAVE_SYS_TIME_H))
306 AC_CHECK_HEADERS(sys/times.h, AC_DEFINE(HAVE_SYS_TIMES_H))
307 AC_CHECK_HEADERS(unistd.h, AC_DEFINE(HAVE_UNISTD_H))
308 AC_CHECK_HEADERS(values.h, AC_DEFINE(HAVE_VALUES_H))
309 AC_CHECK_HEADERS(stdint.h, AC_DEFINE(HAVE_VALUES_H))
310
311 # check additional type sizes
312 size_includes=["
313 #include <stdarg.h>
314 #include <stdio.h>
315 #include <stdlib.h>
316 #include <ctype.h>
317 #include <string.h>
318 "]
319 if test "x$ac_cv_header_stdint_h" = "xyes"; then
320   size_includes=["$size_includes
321 #include <stdint.h>
322 "]
323 fi
324 if test "x$ac_cv_header_unistd_h" = "xyes"; then
325   size_includes=["$size_includes
326 #include <unistd.h>
327 "]
328 fi
329 GLIB_SIZEOF([$size_includes], size_t, size_t)
330 GLIB_SIZEOF([$size_includes], ptrdiff_t, ptrdiff_t)
331 GLIB_SIZEOF([$size_includes], intmax_t, intmax_t)
332
333 # Check for some functions
334 AC_CHECK_FUNCS(lstat strerror strsignal memmove vsnprintf strcasecmp strncasecmp poll)
335
336 # Check if bcopy can be used for overlapping copies, if memmove isn't found.
337 # The check is borrowed from the PERL Configure script.
338 if test "$ac_cv_func_memmove" != "yes"; then
339   AC_CACHE_CHECK(whether bcopy can handle overlapping copies,
340     glib_cv_working_bcopy,[AC_TRY_RUN([
341       int main() {
342         char buf[128], abc[128], *b;
343         int len, off, align;
344         bcopy("abcdefghijklmnopqrstuvwxyz0123456789", abc, 36);
345         for (align = 7; align >= 0; align--) {
346           for (len = 36; len; len--) {
347             b = buf+align; bcopy(abc, b, len);
348             for (off = 1; off <= len; off++) {
349               bcopy(b, b+off, len); bcopy(b+off, b, len);
350                 if (bcmp(b, abc, len)) return(1);
351             }
352           }
353         }
354         return(0);
355       }],glib_cv_working_bcopy=yes,glib_cv_working_bcopy=no)])
356   if test "$glib_cv_working_bcopy" == "yes"; then
357     AC_DEFINE(HAVE_WORKING_BCOPY)
358   fi
359 fi
360
361 # Check for sys_errlist
362 AC_MSG_CHECKING(for sys_errlist)
363 AC_TRY_LINK(, [
364 extern char *sys_errlist[];
365 extern int sys_nerr;
366 sys_errlist[sys_nerr-1][0] = 0;
367 ], glib_ok=yes, glib_ok=no)
368 AC_MSG_RESULT($glib_ok)
369 if test $glib_ok = no; then
370     AC_DEFINE(NO_SYS_ERRLIST)
371 fi
372
373 # Check for sys_siglist
374 AC_MSG_CHECKING(for sys_siglist)
375 AC_TRY_LINK(, [
376 extern char *sys_siglist[];
377 strlen (sys_siglist[0]);
378 ], glib_ok=yes, glib_ok=no)
379 AC_MSG_RESULT($glib_ok)
380 if test $glib_ok = no; then
381     AC_DEFINE(NO_SYS_SIGLIST)
382 fi
383
384 # Check for sys_siglist decl (see Tue Jan 19 00:44:24 1999 in changelog)
385 AC_MSG_CHECKING(for sys_siglist declaration)
386 AC_TRY_COMPILE([#include <signal.h>], [
387 strlen (sys_siglist[0]);
388 ], glib_ok=yes, glib_ok=no)
389 AC_MSG_RESULT($glib_ok)
390 if test $glib_ok = no; then
391     AC_DEFINE(NO_SYS_SIGLIST_DECL)
392 fi
393
394 # Check if <sys/select.h> needs to be included for fd_set
395 AC_MSG_CHECKING([for fd_set])
396 AC_TRY_COMPILE([#include <sys/types.h>],
397         [fd_set readMask, writeMask;], gtk_ok=yes, gtk_ok=no)
398 if test $gtk_ok = yes; then
399     AC_MSG_RESULT([yes, found in sys/types.h])
400 else
401     AC_HEADER_EGREP(fd_set, sys/select.h, gtk_ok=yes)
402     if test $gtk_ok = yes; then
403         AC_DEFINE(HAVE_SYS_SELECT_H)
404         AC_MSG_RESULT([yes, found in sys/select.h])
405     else
406         AC_DEFINE(NO_FD_SET)
407         AC_MSG_RESULT(no)
408     fi
409 fi
410
411 dnl *** check for sane realloc() ***
412 AC_MSG_CHECKING(whether realloc (NULL,) will work)
413 AC_CACHE_VAL(glib_cv_sane_realloc,[
414         AC_TRY_RUN([
415         #include <stdlib.h>
416         int main() {
417           return realloc (0, sizeof (int)) == 0;
418         }],
419         glib_cv_sane_realloc=yes
420         AC_DEFINE(REALLOC_0_WORKS)
421         ,
422         glib_cv_sane_realloc=no
423         ,)
424 ])
425 AC_MSG_RESULT($glib_cv_sane_realloc)
426
427
428 dnl **********************
429 dnl *** va_copy checks ***
430 dnl **********************
431 dnl we currently check for all three va_copy possibilities, so we get
432 dnl all results in config.log for bug reports.
433 AC_MSG_CHECKING(for an implementation of va_copy())
434 AC_CACHE_VAL(glib_cv_va_copy,[
435         AC_TRY_RUN([
436         #include <stdarg.h>
437         void f (int i, ...) {
438         va_list args1, args2;
439         va_start (args1, i);
440         va_copy (args2, args1);
441         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
442           exit (1);
443         va_end (args1); va_end (args2);
444         }
445         int main() {
446           f (0, 42);
447           return 0;
448         }],
449         glib_cv_va_copy=yes
450         ,
451         glib_cv_va_copy=no
452         ,)
453 ])
454 AC_MSG_RESULT($glib_cv_va_copy)
455 AC_MSG_CHECKING(for an implementation of __va_copy())
456 AC_CACHE_VAL(glib_cv___va_copy,[
457         AC_TRY_RUN([
458         #include <stdarg.h>
459         void f (int i, ...) {
460         va_list args1, args2;
461         va_start (args1, i);
462         __va_copy (args2, args1);
463         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
464           exit (1);
465         va_end (args1); va_end (args2);
466         }
467         int main() {
468           f (0, 42);
469           return 0;
470         }],
471         glib_cv___va_copy=yes
472         ,
473         glib_cv___va_copy=no
474         ,)
475 ])
476 AC_MSG_RESULT($glib_cv___va_copy)
477 AC_MSG_CHECKING(whether va_lists can be copied by value)
478 AC_CACHE_VAL(glib_cv_va_val_copy,[
479         AC_TRY_RUN([
480         #include <stdarg.h>
481         void f (int i, ...) {
482         va_list args1, args2;
483         va_start (args1, i);
484         args2 = args1;
485         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
486           exit (1);
487         va_end (args1); va_end (args2);
488         }
489         int main() {
490           f (0, 42);
491           return 0;
492         }],
493         glib_cv_va_val_copy=yes
494         ,
495         glib_cv_va_val_copy=no
496         ,)
497 ])
498 if test "x$glib_cv_va_copy" = "xyes"; then
499   AC_DEFINE(G_VA_COPY, va_copy)
500 else if test "x$glib_cv___va_copy" = "xyes"; then
501   AC_DEFINE(G_VA_COPY, __va_copy)
502 fi
503 fi
504 if test "x$glib_cv_va_val_copy" = "xno"; then
505   AC_DEFINE(G_VA_COPY_AS_ARRAY)
506 fi
507 AC_MSG_RESULT($glib_cv_va_val_copy)
508
509
510 dnl ***********************
511 dnl *** g_module checks ***
512 dnl ***********************
513 G_MODULE_LIBS=
514 G_MODULE_LIBS_EXTRA=
515 G_MODULE_PLUGIN_LIBS=
516 G_MODULE_LDFLAGS=
517 dnl G_MODULE_IMPL= don't reset, so cmd-line can override
518 G_MODULE_NEED_USCORE=0
519 G_MODULE_HAVE_DLERROR=0
520 dnl *** dlopen() and dlsym() in system libraries
521 if test -z "$G_MODULE_IMPL"; then
522         AC_CHECK_FUNC(dlopen,
523                 AC_CHECK_FUNC(dlsym,
524                         G_MODULE_IMPL=G_MODULE_IMPL_DL
525                 ,)
526         ,)
527 fi
528 dnl *** load_image (BeOS)
529 if test -z "$G_MODULE_IMPL" -a "x$glib_native_beos" = "xyes"; then
530   AC_CHECK_LIB(root, load_image,
531       G_MODULE_LIBS="-lbe -lroot -lglib"
532       G_MODULE_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
533       G_MODULE_PLUGIN_LIBS="-L\$(top_builddir_full)/gmodule/.libs -lgmodule"
534       G_MODULE_IMPL=G_MODULE_IMPL_BEOS 
535 ,)
536 fi   
537 dnl *** dlopen() and dlsym() in libdl
538 if test -z "$G_MODULE_IMPL"; then
539         AC_CHECK_LIB(dl, dlopen,
540                 AC_CHECK_LIB(dl, dlsym,
541                         G_MODULE_LIBS=-ldl
542                         G_MODULE_IMPL=G_MODULE_IMPL_DL
543                 ,)
544         ,)
545 fi
546 dnl *** shl_load() in libdld (HP-UX)
547 if test -z "$G_MODULE_IMPL"; then
548         AC_MSG_CHECKING(how to export all symbols)
549         SAVED_LDFLAGS=$LDFLAGS
550         LDFLAGS="$LDFLAGS -Wl,-E"
551         AC_TRY_LINK(,[ return 0; ],
552                 [ G_MODULE_LDFLAGS="-Wl,-E" ],[
553                 LDFLAGS="$SAVED_LDFLAGS -bexpall"
554                 AC_TRY_LINK(,[ return 0; ],
555                         G_MODULE_LDFLAGS="-bexpall",
556                         G_MODULE_LDFLAGS="none"
557                 )
558         ])
559         LDFLAGS=$SAVED_LDFLAGS
560         AC_MSG_RESULT($G_MODULE_LDFLAGS)
561         if test "x$G_MODULE_LDFLAGS" = "xnone"; then
562                 G_MODULE_LDFLAGS=
563         fi
564         AC_CHECK_LIB(dld, shl_load,
565                 G_MODULE_LIBS=-ldld
566                 G_MODULE_IMPL=G_MODULE_IMPL_DLD
567         ,)
568 fi
569 dnl *** additional checks for G_MODULE_IMPL_DL
570 if test "$G_MODULE_IMPL" = "G_MODULE_IMPL_DL"; then
571         case "$host_os" in
572           linux*)
573             G_MODULE_LDFLAGS='-rdynamic'
574             ;;
575         esac
576         LIBS_orig="$LIBS"
577         LDFLAGS_orig="$LDFLAGS"
578         LIBS="$LIBS $G_MODULE_LIBS"
579         LDFLAGS="$LDFLAGS $G_MODULE_LDFLAGS"
580 dnl *** check whether we need preceeding underscores
581         AC_MSG_CHECKING(for preceeding underscore in symbols)
582         AC_CACHE_VAL(glib_cv_uscore,[
583                 AC_TRY_RUN([
584                 #include <dlfcn.h>
585                 int glib_underscore_test (void) { return 42; }
586                 int main() {
587                   void *f1 = (void*)0, *f2 = (void*)0, *handle;
588                   handle = dlopen ((void*)0, 0);
589                   if (handle) {
590                     f1 = dlsym (handle, "glib_underscore_test");
591                     f2 = dlsym (handle, "_glib_underscore_test");
592                   } return (!f2 || f1);
593                 }],
594                         glib_cv_uscore=yes,
595                         glib_cv_uscore=no,
596                 )
597                 rm -f plugin.c plugin.o plugin.lo
598         ])
599         AC_MSG_RESULT($glib_cv_uscore)
600         if test "x$glib_cv_uscore" = "xyes"; then
601                 G_MODULE_NEED_USCORE=1
602         else
603                 G_MODULE_NEED_USCORE=0
604         fi
605
606         LDFLAGS="$LDFLAGS_orig"
607 dnl *** check for having dlerror()
608         AC_CHECK_FUNC(dlerror,
609                 G_MODULE_HAVE_DLERROR=1,
610                 G_MODULE_HAVE_DLERROR=0)
611         LIBS="$LIBS_orig"
612 fi
613 dnl *** done, have e got an implementation?
614 if test -z "$G_MODULE_IMPL"; then
615         G_MODULE_IMPL=0
616 fi
617 AC_SUBST(G_MODULE_IMPL)
618 AC_SUBST(G_MODULE_LIBS)
619 AC_SUBST(G_MODULE_LIBS_EXTRA)
620 AC_SUBST(G_MODULE_PLUGIN_LIBS)
621 AC_SUBST(G_MODULE_LDFLAGS)
622 AC_SUBST(G_MODULE_HAVE_DLERROR)
623 AC_SUBST(G_MODULE_NEED_USCORE)
624 AC_SUBST(GLIB_DEBUG_FLAGS)
625
626
627 dnl ***********************
628 dnl *** g_thread checks ***
629 dnl ***********************
630
631 AC_ARG_WITH(threads, [  --with-threads=[none/posix/dce/solaris] specify a thread implementation to use],
632         if test "x$with_threads" = x; then
633                 want_threads=yes
634         else
635                 want_threads=$with_threads
636         fi,
637         want_threads=yes)
638 if test "x$enable_threads" = "xno"; then
639         want_threads=no
640 fi
641 if test "x$want_threads" = "xnone"; then
642         want_threads=no
643 fi
644
645 dnl error and warning message
646 dnl *************************
647
648 THREAD_NO_IMPLEMENTATION="You do not have any known thread system on your
649                 computer. GLib will not have a default thread implementation."
650
651 FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your
652                 platform (normaly it's "_REENTRANT"). I'll not use any flag on
653                 compilation now, but then your programs might not work.
654                 Please provide information on how it is done on your system."
655
656 LIBS_NOT_FOUND_1="I can't find the libraries for the thread implementation
657                 "
658
659 LIBS_NOT_FOUND_2=". Please choose another thread implementation or
660                 provide information on your thread implementation.
661                 You can also run 'configure --disable-threads' 
662                 to compile without thread support."
663
664 FUNC_NO_GETPWUID_R="the 'g_get_(user_name|real_name|home_dir|tmp_dir)'
665                 functions will not be MT-safe during their first call because
666                 there is no working 'getpwuid_r' on your system."
667
668 FUNC_NO_LOCALTIME_R="the 'g_date_set_time' function will not be MT-safe
669                 because there is no 'localtime_r' on your system."
670
671 POSIX_NO_YIELD="I can not find a yield functions for your platform. A rather
672                 crude surrogate will be used. If you happen to know a 
673                 yield function for your system, please inform the GLib 
674                 developers."
675
676 POSIX_NO_PRIORITIES="I can not find the minimal and maximal priorities for 
677                 threads on your system. Thus threads can only have the default 
678                 priority. If you happen to know these main/max
679                 priorities, please inform the GLib developers."
680
681
682 dnl determination of thread implementation
683 dnl ***************************************
684
685 have_threads=none
686 if test "x$want_threads" = xyes || test "x$want_threads" = xsolaris; then
687         case $host in
688                 *-*-solaris*)
689                 AC_CHECK_LIB(thread, cond_init, have_threads=solaris)
690                 ;;
691         esac
692 fi
693 if test "x$want_threads" = xyes || test "x$want_threads" = xposix \
694                                 || test "x$want_threads" = xdce; then
695         # -D_POSIX4A_DRAFT10_SOURCE is for DG/UX
696         # -U_OSF_SOURCE is for Digital UNIX 4.0d
697         GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE"
698         glib_save_CPPFLAGS="$CPPFLAGS"
699         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
700         if test "x$have_threads" = xnone; then
701                 AC_EGREP_HEADER([(^|[^a-zA-Z_])pthread_attr_init[^a-zA-Z_]],
702                         pthread.h,
703                         have_threads=posix)
704         fi
705         if test "x$have_threads" = xnone; then
706                 AC_EGREP_HEADER([(^|[^a-zA-Z_])pthread_attr_create[^a-zA-Z_]],
707                         pthread.h,
708                         have_threads=dce)
709         fi
710         CPPFLAGS="$glib_save_CPPFLAGS"
711 fi
712
713 AC_MSG_CHECKING(for thread implementation)
714
715 if test "x$have_threads" = xnone && test "x$want_threads" != xno; then
716         AC_MSG_RESULT(none available)
717         AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
718 else
719         AC_MSG_RESULT($have_threads)
720 fi
721
722
723 dnl determination of G_THREAD_LIBS
724 dnl ******************************
725
726 G_THREAD_LIBS=
727 G_THREAD_LIBS_EXTRA=
728 G_THREAD_CFLAGS=
729
730 mutex_has_default=no
731 case $have_threads in
732         posix|dce)
733                 G_THREAD_LIBS=error
734                 glib_save_LIBS="$LIBS"
735                 for thread_lib in "" pthread pthreads c_r thread dce; do
736                         # This is not AC_CHECK_LIB to also work with function
737                         # name mangling in header files.
738                         if test x"$thread_lib" = x; then
739                                 add_thread_lib=""
740                                 IN=""
741                         else
742                                 add_thread_lib="-l$thread_lib"
743                                 IN=" in -l$thread_lib"
744                         fi
745                         if test x"$have_threads" = xposix; then
746                                 defattr=NULL
747                         else
748                                 defattr=pthread_attr_default
749                         fi
750                         
751                         LIBS="$glib_save_LIBS $add_thread_lib"
752                         
753                         AC_MSG_CHECKING(for pthread_create$IN)
754                         AC_TRY_RUN([#include <pthread.h> 
755                                 void* func(void* data) {}
756                                 main()
757                                 { pthread_t t; 
758                                   exit(pthread_create (&t, $defattr, func, 
759                                                 NULL));
760                                 }],
761                                 [AC_MSG_RESULT(yes)
762                                 G_THREAD_LIBS="$add_thread_lib"
763                                 break],
764                                 [AC_MSG_RESULT(no)])
765                 done
766                 LIBS="$glib_save_LIBS"
767                 mutex_has_default=yes
768                 mutex_default_type='pthread_mutex_t'
769                 mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
770                 mutex_header_file='pthread.h'
771                 if test "x$have_threads" = "xposix"; then
772                         g_threads_impl="POSIX"
773                 else
774                         g_threads_impl="DCE"
775                         have_threads="posix"
776                 fi
777                 AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
778                 ;;
779         solaris)
780                 G_THREAD_LIBS=error
781                 AC_CHECK_LIB(thread, cond_init, G_THREAD_LIBS="-lthread")
782                 mutex_has_default=yes
783                 mutex_default_type='mutex_t'
784                 mutex_default_init="DEFAULTMUTEX"
785                 mutex_header_file='thread.h'
786                 g_threads_impl="SOLARIS"
787                 ;;
788         none)
789                 g_threads_impl="NONE"
790                 ;;
791         *)
792                 g_threads_impl="NONE"
793                 G_THREAD_LIBS=error
794                 ;;
795 esac
796
797 if test "x$G_THREAD_LIBS" = xerror; then
798         AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
799 fi
800
801 case $host in
802   *-*-beos*)
803     G_THREAD_LIBS="-lbe -lroot -lglib "
804     G_THREAD_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
805     ;;
806   *)
807     ;;
808 esac
809
810 AC_MSG_CHECKING(thread related libraries)
811 AC_MSG_RESULT($G_THREAD_LIBS)
812
813 dnl determination of G_THREAD_CFLAGS
814 dnl ********************************
815
816 if test x"$enable_threads" = xyes; then
817
818     G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_REENTRANT" # good default guess
819
820     case $host in
821         *-aix*)
822                 G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_THREAD_SAFE"
823                 if test x"$GCC" = xyes; then
824                         G_THREAD_CFLAGS="$G_THREAD_CFLAGS -mthreads"
825                 fi
826                 ;;
827         *-freebsd2.2*)
828                 G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_THREAD_SAFE"
829
830                 # FreeBSD 2.2.x shiped with gcc 2.7.2.x, which doesn't support
831                 # -mthreads flag.
832                 ;;
833     esac
834
835     # if we are not finding the ctime_r function, then we probably are
836     # not using the proper multithread flag
837     old_CPPFLAGS=$CPPFLAGS
838     CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
839     # Note: Digital UNIX 4.0d #defines ctime_r to _Pctime_r for gcc.
840     AC_EGREP_HEADER([[^a-zA-Z_](_P)?ctime_r[^a-zA-Z_]], time.h, ,
841     G_THREAD_CFLAGS=
842     AC_MSG_WARN($FLAG_DOES_NOT_WORK))
843     CPPFLAGS=$old_CPPFLAGS
844
845     AC_MSG_CHECKING(thread related cflags)
846
847     AC_MSG_RESULT($G_THREAD_CFLAGS)
848 else
849     G_THREAD_CFLAGS=
850 fi
851
852 dnl check for mt safe function variants and some posix functions
853 dnl ************************************************************
854
855 if test x"$enable_threads" = xyes; then
856         glib_save_LIBS="$LIBS"
857         glib_save_CFLAGS="$CFLAGS"
858         # we are not doing the following for now, as this might require glib 
859         # to always be linked with the thread libs on some platforms. 
860         # LIBS="$LIBS $G_THREAD_LIBS"
861         CFLAGS="$CFLAGS $G_THREAD_CFLAGS"
862         AC_CHECK_FUNCS(localtime_r)
863         if test "$ac_cv_header_pwd_h" = "yes"; then
864                 AC_MSG_CHECKING([for getpwuid_r])
865                 AC_CACHE_VAL(ac_cv_func_getpwuid_r,
866                         [AC_TRY_RUN([#include <errno.h>
867                                 int main () { char buffer[10000], *pointer; 
868                                 char getpwuid_r (long, void*, void*,
869                                         int, void*);
870                                 errno = 0;
871                                 getpwuid_r (0, &buffer, &buffer, 
872                                         sizeof (buffer), &pointer);
873                                 return errno == ENOSYS;}],
874                                 [ac_cv_func_getpwuid_r=yes],
875                                 [ac_cv_func_getpwuid_r=no])])
876                 if test "$ac_cv_func_getpwuid_r" = yes; then
877                         AC_MSG_RESULT(yes)
878                         AC_DEFINE(HAVE_GETPWUID_R)
879                 else
880                         AC_MSG_RESULT(no)
881                 fi
882                 if test "$ac_cv_func_getpwuid_r" = "yes"; then
883                         AC_MSG_CHECKING(whether getpwuid_r is posix like)
884                         # The signature for the POSIX version is:
885                         # int getpwuid_r(uid_t, struct passwd *, char *, size_t, struct passwd **)
886                         AC_TRY_COMPILE([#include <pwd.h>
887                                         #include <sys/types.h>
888                                         #include <stdlib.h>],
889                                 [getpwuid_r((uid_t)0, NULL, NULL, (size_t)0, NULL);],
890                                 [AC_DEFINE(HAVE_GETPWUID_R_POSIX)
891                                 AC_MSG_RESULT(yes)],
892                                 [AC_MSG_RESULT(no)])
893                 fi
894         fi
895         LIBS="$LIBS $G_THREAD_LIBS"
896         if test x"$have_threads" = xposix; then
897                 glib_save_CPPFLAGS="$CPPFLAGS"
898                 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
899                 GLIB_SIZEOF([#include <pthread.h>],
900                         pthread_t,
901                         system_thread)
902                 # This is not AC_CHECK_FUNC to also work with function
903                 # name mangling in header files.
904                 AC_MSG_CHECKING(for pthread_attr_setstacksize)
905                 AC_TRY_LINK([#include <pthread.h>],
906                         [pthread_attr_t t; pthread_attr_setstacksize(&t,0)],
907                         [AC_MSG_RESULT(yes)
908                         AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE)],
909                         [AC_MSG_RESULT(no)])
910                 # If sched_get_priority_min(SCHED_OTHER) returns something 
911                 # negative, we ignore it.
912                 AC_MSG_CHECKING(for minimal/maximal thread priority)
913                 AC_TRY_RUN([#include <pthread.h>
914                      int main () 
915                      { return sched_get_priority_min(SCHED_OTHER) == -1;}],
916                      [posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
917                      posix_priority_max="sched_get_priority_max(SCHED_OTHER)"],
918                      [posix_priority_min=none])
919                 # On some platforms we need to link to -lrt to use the 
920                 # sched_* functions
921                 LIBS="$LIBS -lrt"
922                 AC_TRY_RUN([#include <pthread.h>
923                      int main () 
924                      { return sched_get_priority_min(SCHED_OTHER) == -1;}],
925                      [posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
926                      posix_priority_max="sched_get_priority_max(SCHED_OTHER)"
927                      G_THREAD_LIBS="$G_THREAD_LIBS -lrt"],
928                      [posix_priority_min=none])
929                 LIBS="$glib_save_LIBS $G_THREAD_LIBS"
930                 if test x"$posix_priority_min" = xnone; then
931                         AC_EGREP_CPP(PX_PRIO_MIN,[#include <pthread.h>
932                                 PX_PRIO_MIN],,[
933                                 posix_priority_min=PX_PRIO_MIN
934                                 posix_priority_max=PX_PRIO_MAX])
935                 fi
936                 if test x"$posix_priority_min" = xnone; then
937                         AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
938                                 PRI_OTHER_MIN],,[
939                                 posix_priority_min=PRI_OTHER_MIN        
940                                 posix_priority_max=PRI_OTHER_MAX])
941                 fi
942                 if test x"$posix_priority_min" = xnone; then
943                         AC_MSG_RESULT(none found)
944                         AC_MSG_WARN($POSIX_NO_PRIORITIES)
945                         posix_priority_min=-1
946                         posix_priority_max=-1
947                 else
948                         AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
949                         AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min)
950                         AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max)
951                 fi
952                 posix_yield_func=none
953                 AC_MSG_CHECKING(for posix yield function)
954                 for yield_func in sched_yield pthread_yield_np pthread_yield \
955                                                         thr_yield; do
956                         AC_TRY_LINK([#include <pthread.h>],
957                                 [$yield_func()],
958                                 [posix_yield_func="$yield_func"
959                                 break])
960                 done            
961                 if test x"$posix_yield_func" = xnone; then
962                         AC_MSG_RESULT(none found)
963                         AC_MSG_WARN($POSIX_NO_YIELD)
964                         posix_yield_func="g_usleep(1000)"
965                 else
966                         AC_MSG_RESULT($posix_yield_func)
967                         posix_yield_func="$posix_yield_func()"
968                 fi
969                 AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func)
970                 CPPFLAGS="$glib_save_CPPFLAGS"
971         else # solaris threads
972                 GLIB_SIZEOF([#include <thread.h>],
973                         thread_t,
974                         system_thread)
975         fi
976
977         LIBS="$glib_save_LIBS"
978         CFLAGS="$glib_save_CFLAGS"
979
980         # now spit out all the warnings.
981         if test "$ac_cv_func_getpwuid_r" != "yes"; then
982                 AC_MSG_WARN($FUNC_NO_GETPWUID_R)
983         fi
984         if test "$ac_cv_func_localtime_r" != "yes"; then
985                 AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
986         fi
987 else 
988         # If no thread implementation exists, we will provide enough
989         # space for a pointer
990         GLIB_SIZEOF(, void*, system_thread)
991 fi      
992
993 AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c")
994 AC_SUBST(G_THREAD_CFLAGS)
995 AC_SUBST(G_THREAD_LIBS)
996 AC_SUBST(G_THREAD_LIBS_EXTRA)
997
998 CFLAGS="$CFLAGS $G_THREAD_CFLAGS"
999
1000 dnl **********************************************
1001 dnl *** GDefaultMutex setup and initialization ***
1002 dnl **********************************************
1003 dnl
1004 dnl if mutex_has_default = yes, we also got
1005 dnl mutex_default_type, mutex_default_init and mutex_header_file
1006 GLIB_IF_VAR_EQ(mutex_has_default, yes,
1007         glib_save_CPPFLAGS="$CPPFLAGS"
1008         glib_save_LIBS="$LIBS"
1009         LIBS="$LIBS $G_THREAD_LIBS"
1010         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1011         GLIB_SIZEOF([#include <$mutex_header_file>],
1012                     $mutex_default_type,
1013                     gmutex,
1014                     )
1015         GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
1016                            $mutex_default_type,
1017                            gmutex,
1018                            $glib_cv_sizeof_gmutex,
1019                            $mutex_default_init)
1020         if test x"$glib_cv_byte_contents_gmutex" = xno; then
1021                 mutex_has_default=no
1022         fi
1023         CPPFLAGS="$glib_save_CPPFLAGS"
1024         LIBS="$glib_save_LIBS"
1025         ,
1026 )
1027
1028
1029 dnl ****************************************
1030 dnl *** GLib POLL* compatibility defines ***
1031 dnl ****************************************
1032 GLIB_SYSDEFS(
1033 [#include <sys/types.h>
1034 #include <sys/poll.h>],
1035         POLLIN:1 POLLOUT:4 POLLPRI:2 POLLERR:8 POLLHUP:16 POLLNVAL:32,
1036         glibconfig-sysdefs.h,
1037         =)
1038
1039
1040 dnl ******************************
1041 dnl *** output the whole stuff ***
1042 dnl ******************************
1043
1044 AC_OUTPUT_COMMANDS([
1045
1046 ## Generate `glibconfig.h' in two cases
1047 ## 1. `config.status' is run either explicitly, or via configure.
1048 ##     Esp. not when it is run in `Makefile' to generate makefiles and
1049 ##     config.h
1050 ## 2. CONFIG_OTHER is set explicitly
1051 ##
1052 ## Case 1 is difficult.  We know that `automake' sets one of
1053 ## CONFIG_FILES or CONFIG_HEADERS to empty.  This heuristic works
1054 ## only when AM_CONFIG_HEADER is set, however.
1055
1056 if test -n "${CONFIG_FILES}" && test -n "${CONFIG_HEADERS}"; then
1057   # Both CONFIG_FILES and CONFIG_HEADERS are non-empty ==> Case 1
1058   CONFIG_OTHER=${CONFIG_OTHER:-glibconfig.h}
1059 fi
1060 case "$CONFIG_OTHER" in
1061 *glibconfig.h*)
1062         echo creating glibconfig.h
1063         outfile=glibconfig.h-tmp
1064         cat > $outfile <<\_______EOF
1065 /* glibconfig.h
1066  *
1067  * This is a generated file.  Please modify `configure.in'
1068  */
1069
1070 #ifndef GLIBCONFIG_H
1071 #define GLIBCONFIG_H
1072
1073 #ifdef __cplusplus
1074 extern "C" {
1075 #endif /* __cplusplus */
1076
1077 _______EOF
1078
1079         if test x$glib_limits_h = xyes; then
1080           echo '#include <limits.h>' >> $outfile
1081         fi
1082         if test x$glib_float_h = xyes; then
1083           echo '#include <float.h>' >> $outfile
1084         fi
1085         if test x$glib_values_h = xyes; then
1086           echo '#include <values.h>' >> $outfile
1087         fi
1088         if test x$g_mutex_header_file != x; then
1089           echo '#include <'"$g_mutex_header_file"'>' >> $outfile
1090         fi
1091         if test x$glib_sys_poll_h = xyes; then
1092           echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
1093         fi
1094
1095         cat >> $outfile <<_______EOF
1096
1097 #define G_MINFLOAT      $glib_mf
1098 #define G_MAXFLOAT      $glib_Mf
1099 #define G_MINDOUBLE     $glib_md
1100 #define G_MAXDOUBLE     $glib_Md
1101 #define G_MINSHORT      $glib_ms
1102 #define G_MAXSHORT      $glib_Ms
1103 #define G_MAXUSHORT     $glib_Mus
1104 #define G_MININT        $glib_mi
1105 #define G_MAXINT        $glib_Mi
1106 #define G_MAXUINT       $glib_Mui
1107 #define G_MINLONG       $glib_ml
1108 #define G_MAXLONG       $glib_Ml
1109 #define G_MAXULONG      $glib_Mul
1110
1111 _______EOF
1112
1113
1114         ### this should always be true in a modern C/C++ compiler
1115         cat >>$outfile <<_______EOF
1116 typedef signed char gint8;
1117 typedef unsigned char guint8;
1118 _______EOF
1119
1120
1121         if test -n "$gint16"; then
1122           cat >>$outfile <<_______EOF
1123 typedef signed $gint16 gint16;
1124 typedef unsigned $gint16 guint16;
1125 #define G_GINT16_FORMAT $gint16_format
1126 #define G_GUINT16_FORMAT $guint16_format
1127 _______EOF
1128         fi
1129
1130
1131         if test -n "$gint32"; then
1132           cat >>$outfile <<_______EOF
1133 typedef signed $gint32 gint32;
1134 typedef unsigned $gint32 guint32;
1135 #define G_GINT32_FORMAT $gint32_format
1136 #define G_GUINT32_FORMAT $guint32_format
1137 _______EOF
1138         fi
1139
1140
1141         if test -n "$gint64"; then
1142           cat >>$outfile <<_______EOF
1143 #define G_HAVE_GINT64 1
1144
1145 ${glib_extension}typedef signed $gint64 gint64;
1146 ${glib_extension}typedef unsigned $gint64 guint64;
1147
1148 #define G_GINT64_FORMAT $gint64_format
1149 #define G_GUINT64_FORMAT $guint64_format
1150 #define G_GINT64_CONSTANT(val)  $gint64_constant
1151 _______EOF
1152         fi
1153
1154
1155         if test -z "$glib_unknown_void_p"; then
1156           cat >>$outfile <<_______EOF
1157
1158 #define GPOINTER_TO_INT(p)      ((gint)  ${glib_gpi_cast} (p))
1159 #define GPOINTER_TO_UINT(p)     ((guint) ${glib_gpui_cast} (p))
1160
1161 #define GINT_TO_POINTER(i)      ((gpointer) ${glib_gpi_cast} (i))
1162 #define GUINT_TO_POINTER(u)     ((gpointer) ${glib_gpui_cast} (u))
1163 _______EOF
1164         else
1165           echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
1166         fi
1167
1168
1169
1170         cat >>$outfile <<_______EOF
1171 $glib_atexit
1172 $glib_memmove
1173 $glib_defines
1174 $glib_os
1175
1176 $glib_vacopy
1177
1178 #ifdef  __cplusplus
1179 #define G_HAVE_INLINE   1
1180 #else   /* !__cplusplus */
1181 $glib_inline
1182 #endif  /* !__cplusplus */
1183 _______EOF
1184
1185         echo >>$outfile
1186         if test x$g_mutex_has_default = xyes; then
1187                 cat >>$outfile <<_______EOF
1188 $g_enable_threads_def G_THREADS_ENABLED
1189 #define G_THREADS_IMPL_$g_threads_impl_def
1190 typedef struct _GStaticMutex GStaticMutex;
1191 struct _GStaticMutex
1192 {
1193   struct _GMutex *runtime_mutex;
1194   union {
1195     char   pad[$g_mutex_sizeof];
1196     double dummy_double;
1197     void  *dummy_pointer;
1198     long   dummy_long;
1199   } aligned_pad_u;
1200 };
1201 #define G_STATIC_MUTEX_INIT     { NULL, { { $g_mutex_contents} } }
1202 #define g_static_mutex_get_mutex(mutex) \
1203   (g_thread_use_default_impl ? ((GMutex*) &((mutex)->aligned_pad_u)) : \
1204    g_static_mutex_get_mutex_impl (&((mutex)->runtime_mutex)))
1205 _______EOF
1206         else
1207                 cat >>$outfile <<_______EOF
1208 $g_enable_threads_def G_THREADS_ENABLED
1209 #define G_THREADS_IMPL_$g_threads_impl_def
1210 typedef struct _GMutex* GStaticMutex;
1211 #define G_STATIC_MUTEX_INIT NULL
1212 #define g_static_mutex_get_mutex(mutex) (g_static_mutex_get_mutex_impl (mutex))
1213 _______EOF
1214         fi
1215
1216         cat >>$outfile <<_______EOF
1217 /* This represents a system thread as used by the implementation. An
1218  * alien implementaion, as loaded by g_thread_init can only count on
1219  * "sizeof (gpointer)" bytes to store their info. We however need more
1220  * for some of our native implementations. */
1221 typedef union _GSystemThread GSystemThread;
1222 union _GSystemThread
1223 {
1224   char   data[$g_system_thread_sizeof];
1225   double dummy_double;
1226   void  *dummy_pointer;
1227   long   dummy_long;
1228 };
1229 _______EOF
1230
1231         echo >>$outfile
1232         g_bit_sizes="16 32"
1233         if test -n "$gint64"; then
1234           g_bit_sizes="$g_bit_sizes 64"
1235         fi
1236         for bits in $g_bit_sizes; do
1237           cat >>$outfile <<_______EOF
1238 #define GINT${bits}_TO_${g_bs_native}(val)      ((gint${bits}) (val))
1239 #define GUINT${bits}_TO_${g_bs_native}(val)     ((guint${bits}) (val))
1240 #define GINT${bits}_TO_${g_bs_alien}(val)       ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
1241 #define GUINT${bits}_TO_${g_bs_alien}(val)      (GUINT${bits}_SWAP_LE_BE (val))
1242 _______EOF
1243         done
1244
1245         cat >>$outfile <<_______EOF
1246 #define GLONG_TO_LE(val)        ((glong) GINT${glongbits}_TO_LE (val))
1247 #define GULONG_TO_LE(val)       ((gulong) GUINT${glongbits}_TO_LE (val))
1248 #define GLONG_TO_BE(val)        ((glong) GINT${glongbits}_TO_BE (val))
1249 #define GULONG_TO_BE(val)       ((gulong) GUINT${glongbits}_TO_BE (val))
1250 #define GINT_TO_LE(val)         ((gint) GINT${gintbits}_TO_LE (val))
1251 #define GUINT_TO_LE(val)        ((guint) GUINT${gintbits}_TO_LE (val))
1252 #define GINT_TO_BE(val)         ((gint) GINT${gintbits}_TO_BE (val))
1253 #define GUINT_TO_BE(val)        ((guint) GUINT${gintbits}_TO_BE (val))
1254 #define G_BYTE_ORDER $g_byte_order
1255
1256 _______EOF
1257
1258         if test -r glibconfig-sysdefs.h; then
1259           cat glibconfig-sysdefs.h >>$outfile
1260         fi
1261
1262         cat >>$outfile <<_______EOF
1263
1264 #ifdef __cplusplus
1265 }
1266 #endif /* __cplusplus */
1267
1268 #endif /* GLIBCONFIG_H */
1269 _______EOF
1270
1271
1272         if cmp -s $outfile glibconfig.h; then
1273           echo glibconfig.h is unchanged
1274           rm -f $outfile
1275         else
1276           mv $outfile glibconfig.h
1277         fi ;;
1278 esac
1279 ],[
1280
1281 # Note that if two cases are the same, case goes with the first one.
1282 # Note also that this is inside an AC_OUTPUT_COMMAND.  We do not depend
1283 # on variable expansion in case labels.  Look at the generated config.status
1284 # for a hint.
1285
1286 case xyes in
1287 x$ac_cv_header_float_h)
1288   glib_float_h=yes
1289   glib_mf=FLT_MIN glib_Mf=FLT_MAX
1290   glib_md=DBL_MIN glib_Md=DBL_MAX
1291   ;;
1292 x$ac_cv_header_values_h)
1293   glib_values_h=yes
1294   glib_mf=MINFLOAT  glib_Mf=MAXFLOAT
1295   glib_md=MINDOUBLE glib_Md=MAXDOUBLE
1296   ;;
1297 esac
1298
1299 case xyes in
1300 x$ac_cv_header_limits_h)
1301   glib_limits_h=yes
1302   glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
1303   glib_mi=INT_MIN  glib_Mi=INT_MAX  glib_Mui=UINT_MAX
1304   glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
1305   ;;
1306 x$ac_cv_header_values_h)
1307   glib_values_h=yes
1308   glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
1309   glib_mi=MININT   glib_Mi=MAXINT   glib_Mui="(((guint)G_MAXINT)*2+1)"
1310   glib_ml=MINLONG  glib_Ml=MAXLONG  glib_Mul="(((gulong)G_MAXLONG)*2+1)"
1311   ;;
1312 esac
1313
1314 if test x$ac_cv_header_sys_poll_h = xyes ; then
1315   glib_sys_poll_h=yes
1316 fi
1317
1318 case 2 in
1319 $ac_cv_sizeof_short)            
1320   gint16=short
1321   gint16_format='"hi"'
1322   guint16_format='"hu"'
1323   ;;
1324 $ac_cv_sizeof_int)              
1325   gint16=int
1326   gint16_format='"i"'
1327   guint16_format='"u"'
1328   ;;
1329 esac
1330 case 4 in
1331 $ac_cv_sizeof_short)            
1332   gint32=short
1333   gint32_format='"hi"'
1334   guint32_format='"hu"'
1335   ;;
1336 $ac_cv_sizeof_int)              
1337   gint32=int
1338   gint32_format='"i"'
1339   guint32_format='"u"'
1340   ;;
1341 $ac_cv_sizeof_long)             
1342   gint32=long
1343   gint32_format='"li"'
1344   guint32_format='"lu"'
1345   ;;
1346 esac
1347 case 8 in
1348 $ac_cv_sizeof_int)
1349   gint64=int
1350   gint64_format='"i"'
1351   guint64_format='"u"'
1352   glib_extension=
1353   gint64_constant='(val)'
1354   ;;
1355 $ac_cv_sizeof_long)
1356   gint64=long
1357   gint64_format='"li"'
1358   guint64_format='"lu"'
1359   glib_extension=
1360   gint64_constant='(val##L)'
1361   ;;
1362 $ac_cv_sizeof_long_long)
1363   gint64='long long'
1364   gint64_format='"'$glib_cv_long_long_format'i"'
1365   guint64_format='"'$glib_cv_long_long_format'u"'
1366   glib_extension='G_GNUC_EXTENSION '
1367   gint64_constant='(G_GNUC_EXTENSION (val##LL))'
1368   ;;
1369 esac
1370
1371 gintbits=`expr $ac_cv_sizeof_int \* 8`
1372 glongbits=`expr $ac_cv_sizeof_long \* 8`
1373
1374
1375 case $ac_cv_sizeof_void_p in
1376 $ac_cv_sizeof_int)      glib_gpi_cast=''        glib_gpui_cast=''         ;;
1377 $ac_cv_sizeof_long)     glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
1378 *)                      glib_unknown_void_p=yes ;;
1379 esac
1380
1381
1382 case xyes in
1383 x$ac_cv_func_atexit)
1384   glib_atexit="
1385 #ifdef NeXT /* @#%@! NeXTStep */
1386 # define g_ATEXIT(proc) (!atexit (proc))
1387 #else
1388 # define g_ATEXIT(proc) (atexit (proc))
1389 #endif"
1390   ;;
1391 x$ac_cv_func_on_exit)
1392   glib_atexit="
1393 #define g_ATEXIT(proc)  (on_exit ((void (*)(int, void*))(proc), NULL))"
1394   ;;
1395 esac
1396
1397 case xyes in
1398 x$ac_cv_func_memmove)
1399   glib_memmove='
1400 #define g_memmove(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END'
1401   ;;
1402 x$glib_cv_working_bcopy)
1403   glib_memmove="
1404 /* memmove isn't available, but bcopy can copy overlapping memory regions */
1405 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
1406   ;;
1407 *)  
1408   glib_memmove="
1409 /* memmove isn't found and bcopy can't copy overlapping memory regions, 
1410  * so we have to roll our own copy routine. */
1411 void g_memmove (void* dest, const void * src, unsigned long len);"
1412   ;;
1413 esac
1414
1415 glib_defines="
1416 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
1417 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
1418 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
1419 "
1420
1421 case xyes in
1422 x$glib_cv_va_copy)      glib_vacopy='#define G_VA_COPY  va_copy' ;;
1423 x$glib_cv___va_copy)    glib_vacopy='#define G_VA_COPY  __va_copy' ;;
1424 *)                      glib_vacopy=''
1425 esac
1426
1427 if test x$glib_cv_va_val_copy = xno; then
1428   glib_vacopy="\$glib_vacopy
1429 #define G_VA_COPY_AS_ARRAY 1"
1430 fi
1431
1432 if test x$glib_cv_hasinline = xyes; then
1433     glib_inline='#define G_HAVE_INLINE 1'
1434 fi
1435 if test x$glib_cv_has__inline = xyes; then
1436     glib_inline="\$glib_inline
1437 #define G_HAVE___INLINE 1"
1438 fi
1439 if test x$glib_cv_has__inline__ = xyes; then
1440     glib_inline="\$glib_inline
1441 #define G_HAVE___INLINE__ 1"
1442 fi
1443
1444 case xyes in
1445 x$ac_cv_c_bigendian)
1446   g_byte_order=G_BIG_ENDIAN
1447   g_bs_native=BE
1448   g_bs_alien=LE
1449   ;;
1450 *)
1451   g_byte_order=G_LITTLE_ENDIAN
1452   g_bs_native=LE
1453   g_bs_alien=BE
1454   ;;
1455 esac
1456
1457 case x$enable_threads in
1458 xyes)   g_enable_threads_def="#define";;
1459 *)      g_enable_threads_def="#undef ";;
1460 esac
1461
1462 g_threads_impl_def=$g_threads_impl
1463
1464 g_mutex_has_default="$mutex_has_default"
1465 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
1466 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
1467 g_mutex_contents="$glib_cv_byte_contents_gmutex"
1468
1469 case $host in
1470   *-*-beos*)
1471     glib_os="#define G_OS_BEOS"
1472     ;;
1473   *-*-cygwin*)
1474     glib_os="#define G_OS_UNIX
1475 #define G_WITH_CYGWIN"
1476     ;;
1477   *)
1478     glib_os="#define G_OS_UNIX"
1479     ;;
1480 esac
1481 ])
1482
1483 AC_OUTPUT([
1484 glib.spec
1485 Makefile
1486 glib-config
1487 gmodule/gmoduleconf.h
1488 gmodule/Makefile
1489 gthread/Makefile
1490 docs/Makefile
1491 docs/glib-config.1
1492 tests/Makefile
1493 ],[case "$CONFIG_FILES" in
1494 *glib-config*)chmod +x glib-config;;
1495 esac
1496 echo ""
1497 echo " *** IMPORTANT *** "
1498 echo ""
1499 echo "This is a development version of GLib.  You should be using a stable"
1500 echo "version, which is available at ftp://ftp.gtk.org/pub/gtk/v1.2/.  The"
1501 echo "version you just configured is meant for developers of GLib only:"
1502 echo ""
1503 echo "  * You should not base stable software on this version of GLib."
1504 echo "  * GNOME developers should use a stable version of GLib."
1505 echo ""
1506 echo "Distributions should *NOT* ship a development package of this GLib."
1507 echo "Do not ship the headers and do not ship the glib-config script.  These"
1508 echo "things will conflict with the stable 1.2 series.  Package only enough"
1509 echo "to satisfy the requirements of some other package.  Package only the"
1510 echo "library itself.  Doing otherwise will do no favors to the community."
1511 echo ""
1512 echo "If you install this version of GLib, we strongly recommend that you"
1513 echo "install it in a different prefix than GLib 1.2.  Use --prefix as an"
1514 echo "argument to configure to do this.  Otherwise, you will not be able to"
1515 echo "do development with GLib 1.2 any longer."
1516 echo ""
1517 echo " *** You should be using GLib 1.2 instead. ***"
1518 ])
1519