configure.in

   1 dnl ***********************************
   2 dnl *** include special GLib macros ***
   3 dnl ***********************************
   4 builtin(include, acglib.m4)dnl
   5 builtin(include, glib/libcharset/codeset.m4)dnl
   6 builtin(include, glib/libcharset/glibc21.m4)dnl
   7
   8 # require autoconf 2.13
   9 AC_PREREQ(2.13)
  10
  11 # Process this file with autoconf to produce a configure script.
  12 AC_INIT(glib/glib.h)
  13
  14 # Save this value here, since automake will set cflags later
  15 cflags_set=${CFLAGS+set}
  16
  17 # we rewrite this file
  18 rm -f glibconfig-sysdefs.h
  19
  20 GLIB_AC_DIVERT_BEFORE_HELP([
  21 #
  22 # The following version number definitions apply to GLib, GModule, GObject
  23 # and GThread 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=9
  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
  42 AC_SUBST(GLIB_MAJOR_VERSION)
  43 AC_SUBST(GLIB_MINOR_VERSION)
  44 AC_SUBST(GLIB_MICRO_VERSION)
  45 AC_SUBST(GLIB_VERSION)
  46 AC_SUBST(GLIB_INTERFACE_AGE)
  47 AC_SUBST(GLIB_BINARY_AGE)
  48
  49 # libtool versioning
  50 LT_RELEASE=$GLIB_MAJOR_VERSION.$GLIB_MINOR_VERSION
  51 LT_CURRENT=`expr $GLIB_MICRO_VERSION - $GLIB_INTERFACE_AGE`
  52 LT_REVISION=$GLIB_INTERFACE_AGE
  53 LT_AGE=`expr $GLIB_BINARY_AGE - $GLIB_INTERFACE_AGE`
  54 LT_CURRENT_MINUS_AGE=`expr $LT_CURRENT - $LT_AGE`
  55 AC_SUBST(LT_RELEASE)
  56 AC_SUBST(LT_CURRENT)
  57 AC_SUBST(LT_REVISION)
  58 AC_SUBST(LT_AGE)
  59 AC_SUBST(LT_CURRENT_MINUS_AGE)
  60
  61 VERSION=$GLIB_VERSION
  62 PACKAGE=glib
  63
  64 AM_INIT_AUTOMAKE($PACKAGE, $VERSION, no-define)
  65
  66 # Specify a configuration file
  67 AM_CONFIG_HEADER(config.h)
  68
  69 AC_DEFINE_UNQUOTED(GLIB_MAJOR_VERSION, $GLIB_MAJOR_VERSION,
  70                    [Define to the GLIB major version])
  71 AC_DEFINE_UNQUOTED(GLIB_MINOR_VERSION, $GLIB_MINOR_VERSION,
  72                    [Define to the GLIB minor version])
  73 AC_DEFINE_UNQUOTED(GLIB_MICRO_VERSION, $GLIB_MICRO_VERSION,
  74                    [Define to the GLIB micro version])
  75 AC_DEFINE_UNQUOTED(GLIB_INTERFACE_AGE, $GLIB_INTERFACE_AGE,
  76                    [Define to the GLIB interface age])
  77 AC_DEFINE_UNQUOTED(GLIB_BINARY_AGE, $GLIB_BINARY_AGE,
  78                    [Define to the GLIB binary age])
  79
  80 dnl Initialize maintainer mode
  81 AM_MAINTAINER_MODE
  82
  83 AC_CANONICAL_HOST
  84
  85 AC_MSG_CHECKING(for the BeOS)
  86 case $host in
  87   *-*-beos*)
  88     glib_native_beos="yes"
  89     ;;
  90   *)
  91     glib_native_beos="no"
  92     ;;
  93 esac
  94 AC_MSG_RESULT([$glib_native_beos])
  95
  96 dnl
  97
  98 AC_MSG_CHECKING([for Win32])
  99 case "$host" in
 100   *-*-mingw*)
 101     glib_native_win32=yes
 102     G_LIB_WIN32_RESOURCE=glib-win32res.lo
 103     G_MODULE_WIN32_RESOURCE=gmodule-win32res.lo
 104     G_OBJECT_WIN32_RESOURCE=gobject-win32res.lo
 105     G_THREAD_WIN32_RESOURCE=gthread-win32res.lo
 106     GLIB_DEF=glib.def
 107     GMODULE_DEF=gmodule.def
 108     GOBJECT_DEF=gobject.def
 109     GTHREAD_DEF=gthread.def
 110     TESTGMODULE_EXP=testgmodule.exp
 111     ;;
 112   *)
 113     glib_native_win32=no
 114     G_LIB_WIN32_RESOURCE=
 115     G_MODULE_WIN32_RESOURCE=
 116     G_OBJECT_WIN32_RESOURCE=
 117     G_THREAD_WIN32_RESOURCE=
 118     GLIB_DEF=
 119     GMODULE_DEF=
 120     GOBJECT_DEF=
 121     GTHREAD_DEF=
 122     TESTGMODULE_EXP=
 123     ;;
 124 esac
 125 AC_MSG_RESULT([$glib_native_win32])
 126 AM_CONDITIONAL(OS_WIN32, test "$glib_native_win32" = "yes")
 127 AC_SUBST(G_LIB_WIN32_RESOURCE)
 128 AC_SUBST(G_MODULE_WIN32_RESOURCE)
 129 AC_SUBST(G_OBJECT_WIN32_RESOURCE)
 130 AC_SUBST(G_THREAD_WIN32_RESOURCE)
 131 AC_SUBST(GLIB_DEF)
 132 AC_SUBST(GMODULE_DEF)
 133 AC_SUBST(GOBJECT_DEF)
 134 AC_SUBST(GTHREAD_DEF)
 135 AC_SUBST(TESTGMODULE_EXP)
 136
 137 ms_librarian=no
 138 if test "$glib_native_win32" = "yes"; then
 139   AC_CHECK_PROG(ms_librarian, lib.exe, yes, no)
 140 fi
 141 AM_CONDITIONAL(MS_LIB_AVAILABLE, test x$ms_librarian = xyes)
 142
 143 GLIB_AC_DIVERT_BEFORE_HELP([
 144 # figure debugging default, prior to $ac_help setup
 145 case $GLIB_MINOR_VERSION in
 146 *[[13579]]) debug_default=yes ;;
 147 *)          debug_default=minimum ;;
 148 esac[]dnl
 149 ])
 150
 151 dnl declare --enable-* args and collect ac_help strings
 152 AC_ARG_ENABLE(debug, [  --enable-debug=[no/minimum/yes] turn on debugging [default=$debug_default]],,enable_debug=$debug_default)
 153 AC_ARG_ENABLE(gc_friendly, [  --enable-gc-friendly    turn on garbage collector friendliness [default=no]],,enable_gc_friendly=no)
 154 AC_ARG_ENABLE(mem_pools, [  --disable-mem-pools     disable all glib memory pools],,disable_mem_pools=no)
 155 AC_ARG_ENABLE(ansi, [  --enable-ansi           turn on strict ansi [default=no]],
 156                     , enable_ansi=no)
 157 AC_ARG_ENABLE(threads, [  --enable-threads        turn on basic thread support [default=yes]
 158                           ([=no] will override --with-threads)],,enable_threads=yes)
 159 AC_ARG_ENABLE(rebuilds, [  --disable-rebuilds      disable all source autogeneration rules],,enable_rebuilds=yes)
 160
 161 if test "x$enable_threads" != "xyes"; then
 162   enable_threads=no
 163 fi
 164
 165 AC_DEFINE_UNQUOTED(G_COMPILED_WITH_DEBUGGING, "${enable_debug}",
 166         [Whether glib was compiled with debugging enabled])
 167
 168 AC_MSG_CHECKING(whether to enable garbage collector friendliness)
 169 if test "x$enable_gc_friendly" = "xyes"; then
 170   AC_DEFINE(ENABLE_GC_FRIENDLY, 1, [Whether to enable GC friendliness])
 171   AC_SUBST(ENABLE_GC_FRIENDLY)
 172   AC_MSG_RESULT(yes)
 173 else
 174   AC_MSG_RESULT(no)
 175 fi
 176
 177 AC_MSG_CHECKING(whether to disable memory pools)
 178 if test "x$disable_mem_pools" = "xno"; then
 179   AC_MSG_RESULT(no)
 180 else
 181   AC_DEFINE(DISABLE_MEM_POOLS, 1, [Whether to disable memory pools])
 182   AC_SUBST(DISABLE_MEM_POOLS)
 183   AC_MSG_RESULT(yes)
 184 fi
 185
 186 dnl Checks for programs.
 187 AC_PROG_CC
 188
 189 dnl Check for a working C++ compiler, but do not bail out, if none is found.
 190 AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, gcc)
 191 AC_LANG_SAVE
 192 AC_LANG_CPLUSPLUS
 193 AC_TRY_COMPILE(,[class a { int b; } c;], ,CXX=)
 194 AM_CONDITIONAL(HAVE_CXX, test "$CXX" != "")
 195 AC_LANG_RESTORE
 196
 197 AM_PROG_CC_STDC
 198 AC_PROG_INSTALL
 199
 200 #
 201 # Find pkg-config
 202 #
 203 AC_PATH_PROG(PKG_CONFIG, pkg-config, no)
 204 if test x$PKG_CONFIG = xno ; then
 205   AC_MSG_ERROR([*** pkg-config not found. See http://www.freedesktop.org/software/pkgconfig/])
 206 fi
 207
 208 if pkg-config --atleast-pkgconfig-version 0.5 ; then
 209   :
 210 else
 211   AC_MSG_ERROR([*** pkg-config too old; version 0.5 or better required.])
 212 fi
 213
 214 if test "x$enable_debug" = "xyes"; then
 215   if test x$cflags_set != xset ; then
 216       case " $CFLAGS " in
 217       *[[\ \    ]]-g[[\ \       ]]*) ;;
 218       *) CFLAGS="$CFLAGS -g" ;;
 219       esac
 220   fi
 221
 222   GLIB_DEBUG_FLAGS="-DG_ENABLE_DEBUG"
 223 else
 224   if test "x$enable_debug" = "xno"; then
 225     GLIB_DEBUG_FLAGS="-DG_DISABLE_ASSERT -DG_DISABLE_CHECKS"
 226   fi
 227 fi
 228
 229 # Ensure -fnative-struct is used when compiling for Win32
 230 if test "x$glib_native_win32" = "xyes"; then
 231   if test "x$GCC" = "xyes"; then
 232     case " $CFLAGS " in
 233     *[[\ \      ]]-fnative-struct[[\ \  ]]*) ;;
 234     *) CFLAGS="$CFLAGS -fnative-struct" ;;
 235     esac
 236   fi
 237 fi
 238
 239 AC_CYGWIN
 240 AC_EXEEXT
 241
 242 # define a MAINT-like variable REBUILD which is set if Perl
 243 # and awk are found, so autogenerated sources can be rebuilt
 244 AC_PROG_AWK
 245 AC_CHECK_PROGS(PERL, perl5 perl)
 246 # We would like indent, but don't require it.
 247 AC_CHECK_PROG(INDENT, indent, indent)
 248 REBUILD=\#
 249 if test "x$enable_rebuilds" = "xyes" && \
 250      test -n "$PERL" && \
 251      $PERL -e 'exit !($] >= 5.002)' > /dev/null 2>&1 && \
 252      test -n "$AWK" ; then
 253   REBUILD=
 254 fi
 255 AC_SUBST(REBUILD)
 256
 257
 258 dnl
 259 dnl gettext support
 260 dnl
 261
 262 ALL_LINGUAS="az ca de es eu fr nn no ru sk sl sv ta tr uk zh_TW"
 263 AM_GLIB_GNU_GETTEXT
 264
 265 if test "$gt_cv_func_dgettext_libc" = "yes" || test "$gt_cv_func_dgettext_libintl" = "yes"; then
 266   :
 267 else
 268   AC_MSG_ERROR([
 269 *** You must have either have gettext support in your C library, or use the
 270 *** GNU gettext library. (http://www.gnu.org/software/gettext/gettext.html
 271 ])
 272 fi
 273
 274 LIBS="$LIBS $INTLLIBS"
 275
 276 GETTEXT_PACKAGE=glib20
 277 AC_SUBST(GETTEXT_PACKAGE)
 278 AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE,"$GETTEXT_PACKAGE")
 279
 280 # AM_GLIB_GNU_GETTEXT above substs $DATADIRNAME
 281 # this is the directory where the *.{mo,gmo} files are installed
 282 GLIB_LOCALE_DIR="${prefix}/${DATADIRNAME}/locale"
 283 AC_DEFINE_UNQUOTED(GLIB_LOCALE_DIR,"$GLIB_LOCALE_DIR")
 284
 285 dnl Initialize libtool
 286 AC_LIBTOOL_WIN32_DLL
 287 AM_PROG_LIBTOOL
 288
 289 if test "x$GCC" = "xyes"; then
 290   case " $CFLAGS " in
 291   *[[\ \        ]]-Wall[[\ \    ]]*) ;;
 292   *) CFLAGS="$CFLAGS -Wall" ;;
 293   esac
 294
 295   if test "x$enable_ansi" = "xyes"; then
 296     case " $CFLAGS " in
 297     *[[\ \      ]]-ansi[[\ \    ]]*) ;;
 298     *) CFLAGS="$CFLAGS -ansi" ;;
 299     esac
 300
 301     case " $CFLAGS " in
 302     *[[\ \      ]]-pedantic[[\ \        ]]*) ;;
 303     *) CFLAGS="$CFLAGS -pedantic" ;;
 304     esac
 305   fi
 306 fi
 307
 308 dnl DU4 native cc currently needs -std1 for ANSI mode (instead of K&R)
 309 AC_MSG_CHECKING([for extra flags to get ANSI library prototypes])
 310 glib_save_LIBS=$LIBS
 311 LIBS="$LIBS -lm"
 312 AC_TRY_RUN([#include <math.h>
 313              int main (void) { return (log(1) != log(1.)); }],
 314      AC_MSG_RESULT(none needed),
 315      glib_save_CFLAGS=$CFLAGS
 316      CFLAGS="$CFLAGS -std1"
 317      AC_TRY_RUN([#include <math.h>
 318                  int main (void) { return (log(1) != log(1.)); }],
 319          AC_MSG_RESULT(-std1),
 320          AC_MSG_RESULT()
 321          CFLAGS=$glib_save_CFLAGS
 322          AC_MSG_WARN(
 323                 [No ANSI prototypes found in library. (-std1 didn't work.)])
 324      )
 325 )
 326 LIBS=$glib_save_LIBS
 327
 328 dnl NeXTStep cc seems to need this
 329 AC_MSG_CHECKING([for extra flags for POSIX compliance])
 330 AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
 331   AC_MSG_RESULT(none needed),
 332   glib_save_CFLAGS=$CFLAGS
 333   CFLAGS="$CFLAGS -posix"
 334   AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
 335     AC_MSG_RESULT(-posix),
 336     AC_MSG_RESULT()
 337     CFLAGS=$glib_save_CFLAGS
 338     AC_MSG_WARN([Could not determine POSIX flag. (-posix didn't work.)])))
 339
 340 # Checks for header files.
 341 AC_HEADER_STDC
 342
 343 # Checks for library functions.
 344 AC_FUNC_VPRINTF
 345
 346 AC_FUNC_ALLOCA
 347
 348 AC_CHECK_FUNCS(atexit on_exit)
 349
 350 AC_CHECK_SIZEOF(char)
 351 AC_CHECK_SIZEOF(short)
 352 AC_CHECK_SIZEOF(long)
 353 AC_CHECK_SIZEOF(int)
 354 AC_CHECK_SIZEOF(void *)
 355 AC_CHECK_SIZEOF(long long)
 356 AC_CHECK_SIZEOF(__int64)
 357
 358 if test x$ac_cv_sizeof_long = x8 || test x$ac_cv_sizeof_long_long = x8 || test x$ac_cv_sizeof___int64 = x8 ; then
 359   :
 360 else
 361   AC_MSG_ERROR([
 362 *** GLib requires a 64 bit type. You might want to consider
 363 *** using the GNU C compiler.
 364 ])
 365 fi
 366
 367 if test x$ac_cv_sizeof_long_long = x8; then
 368         # long long is a 64 bit integer.
 369         AC_MSG_CHECKING(for format to printf and scanf a gint64)
 370         AC_CACHE_VAL(glib_cv_long_long_format,[
 371                 for format in ll q I64; do
 372                   AC_TRY_RUN([#include <stdio.h>
 373                         int main()
 374                         {
 375                           long long b, a = -0x3AFAFAFAFAFAFAFALL;
 376                           char buffer[1000];
 377                           sprintf (buffer, "%${format}u", a);
 378                           sscanf (buffer, "%${format}u", &b);
 379                           exit (b!=a);
 380                         }
 381                         ],
 382                         glib_cv_long_long_format=${format}
 383                         break)
 384                 done])
 385         if test -n "$glib_cv_long_long_format"; then
 386           AC_MSG_RESULT(%${glib_cv_long_long_format}u)
 387         else
 388           AC_MSG_RESULT(none)
 389         fi
 390 elif test x$ac_cv_sizeof___int64 = x8; then
 391         # __int64 is a 64 bit integer.
 392         AC_MSG_CHECKING(for format to printf and scanf a gint64)
 393         # We know this is MSVC, and what the formats are
 394         glib_cv_long_long_format=I64
 395         AC_MSG_RESULT(%${glib_cv_long_long_format}u)
 396 fi
 397
 398 dnl long doubles were not used, and a portability problem
 399 dnl AC_C_LONG_DOUBLE
 400 AC_C_CONST
 401
 402 dnl ok, here we try to check whether the systems prototypes for
 403 dnl malloc and friends actually match the prototypes provided
 404 dnl by gmem.h (keep in sync). i currently only know how to check
 405 dnl this reliably with gcc (-Werror), improvements for other
 406 dnl compilers are apprechiated.
 407 SANE_MALLOC_PROTOS=no
 408 AC_MSG_CHECKING([if malloc() and friends prototypes are gmem.h compatible])
 409 glib_save_CFLAGS=$CFLAGS
 410 if test "x$GCC" = "xyes"; then
 411   CFLAGS="$CFLAGS -Werror"
 412   AC_TRY_COMPILE([#include <stdlib.h>], [
 413     void* (*my_calloc_p)  (size_t, size_t) = calloc;
 414     void* (*my_malloc_p)  (size_t)         = malloc;
 415     void  (*my_free_p)    (void*)          = free;
 416     void* (*my_realloc_p) (void*, size_t)  = realloc;
 417     my_calloc_p = 0;
 418     my_malloc_p = 0;
 419     my_free_p = 0;
 420     my_realloc_p = 0;
 421   ],
 422     AC_DEFINE(SANE_MALLOC_PROTOS)
 423     SANE_MALLOC_PROTOS=yes)
 424 fi
 425 AC_MSG_RESULT($SANE_MALLOC_PROTOS)
 426 CFLAGS=$glib_save_CFLAGS
 427
 428
 429 dnl AC_C_INLINE is useless to us since it bails out too early, we need to
 430 dnl truely know which ones of `inline', `__inline' and `__inline__' are
 431 dnl actually supported.
 432 AC_CACHE_CHECK([for __inline],glib_cv_has__inline,[
 433         AC_TRY_RUN([
 434         __inline int foo () { return 0; }
 435         int main () { return foo (); }
 436         ],
 437         glib_cv_has__inline=yes
 438         ,
 439         glib_cv_has__inline=no
 440         ,)
 441 ])
 442 case x$glib_cv_has__inline in
 443 xyes) AC_DEFINE(G_HAVE___INLINE,1,[Have __inline keyword])
 444 esac
 445 AC_CACHE_CHECK([for __inline__],glib_cv_has__inline__,[
 446         AC_TRY_RUN([
 447         __inline__ int foo () { return 0; }
 448         int main () { return foo (); }
 449         ],
 450         glib_cv_has__inline__=yes
 451         ,
 452         glib_cv_has__inline__=no
 453         ,)
 454 ])
 455 case x$glib_cv_has__inline__ in
 456 xyes) AC_DEFINE(G_HAVE___INLINE__,1,[Have __inline__ keyword])
 457 esac
 458 AC_CACHE_CHECK([for inline], glib_cv_hasinline,[
 459         AC_TRY_RUN([
 460         #undef inline
 461         inline int foo () { return 0; }
 462         int main () { return foo (); }
 463         ],
 464         glib_cv_hasinline=yes
 465         ,
 466         glib_cv_hasinline=no
 467         ,)
 468 ])
 469 case x$glib_cv_hasinline in
 470 xyes) AC_DEFINE(G_HAVE_INLINE,1,[Have inline keyword])
 471 esac
 472
 473 # check for flavours of varargs macros
 474 AC_MSG_CHECKING(for ISO C99 varargs macros in C)
 475 AC_TRY_COMPILE([],[
 476 int a(int p1, int p2, int p3);
 477 #define call_a(...) a(1,__VA_ARGS__)
 478 call_a(2,3);
 479 ],g_have_iso_c_varargs=yes,g_have_iso_c_varargs=no)
 480 AC_MSG_RESULT($g_have_iso_c_varargs)
 481
 482 AC_MSG_CHECKING(for ISO C99 varargs macros in C++)
 483 if test "$CXX" = ""; then
 484 dnl No C++ compiler
 485   g_have_iso_cxx_varargs=no
 486 else
 487   AC_LANG_CPLUSPLUS
 488   AC_TRY_COMPILE([],[
 489 int a(int p1, int p2, int p3);
 490 #define call_a(...) a(1,__VA_ARGS__)
 491 call_a(2,3);
 492 ],g_have_iso_cxx_varargs=yes,g_have_iso_cxx_varargs=no)
 493   AC_LANG_C
 494 fi
 495 AC_MSG_RESULT($g_have_iso_cxx_varargs)
 496
 497 AC_MSG_CHECKING(for GNUC varargs macros)
 498 AC_TRY_COMPILE([],[
 499 int a(int p1, int p2, int p3);
 500 #define call_a(params...) a(1,params)
 501 call_a(2,3);
 502 ],g_have_gnuc_varargs=yes,g_have_gnuc_varargs=no)
 503 AC_MSG_RESULT($g_have_gnuc_varargs)
 504
 505 # check for bytesex stuff
 506 AC_C_BIGENDIAN
 507
 508 # check for header files
 509 AC_CHECK_HEADERS([float.h limits.h pwd.h sys/param.h sys/poll.h sys/select.h])
 510 AC_CHECK_HEADERS([sys/time.h sys/times.h unistd.h values.h stdint.h sched.h])
 511
 512 # Checks for libcharset
 513 jm_LANGINFO_CODESET
 514 jm_GLIBC21
 515 AC_CHECK_HEADERS([stddef.h stdlib.h string.h])
 516 AC_CHECK_FUNCS(setlocale)
 517
 518 AC_MSG_CHECKING(whether make is GNU Make)
 519 STRIP_BEGIN=
 520 STRIP_END=
 521 if $ac_make --version 2>/dev/null | grep '^GNU Make ' >/dev/null ; then
 522         STRIP_BEGIN='$(strip $(STRIP_DUMMY)'
 523         STRIP_END=')'
 524         AC_MSG_RESULT(yes)
 525 else
 526         AC_MSG_RESULT(no)
 527 fi
 528 STRIP_DUMMY=
 529 AC_SUBST(STRIP_DUMMY)
 530 AC_SUBST(STRIP_BEGIN)
 531 AC_SUBST(STRIP_END)
 532
 533 # check additional type sizes
 534 size_includes=["
 535 #include <stdarg.h>
 536 #include <stdio.h>
 537 #include <ctype.h>
 538 #include <string.h>
 539 "]
 540 if test "x$ac_cv_header_stdint_h" = "xyes"; then
 541   size_includes=["$size_includes
 542 #include <stdint.h>
 543 "]
 544 fi
 545 if test "x$ac_cv_header_unistd_h" = "xyes"; then
 546   size_includes=["$size_includes
 547 #include <unistd.h>
 548 "]
 549 fi
 550 GLIB_SIZEOF([$size_includes], size_t, size_t)
 551 GLIB_SIZEOF([$size_includes], ptrdiff_t, ptrdiff_t)
 552 GLIB_SIZEOF([$size_includes], intmax_t, intmax_t)
 553
 554 # Check for some functions
 555 AC_CHECK_FUNCS(lstat strerror strsignal memmove mkstemp vsnprintf stpcpy strcasecmp strncasecmp poll getcwd nanosleep vasprintf)
 556
 557 # Check if bcopy can be used for overlapping copies, if memmove isn't found.
 558 # The check is borrowed from the PERL Configure script.
 559 if test "$ac_cv_func_memmove" != "yes"; then
 560   AC_CACHE_CHECK(whether bcopy can handle overlapping copies,
 561     glib_cv_working_bcopy,[AC_TRY_RUN([
 562       int main() {
 563         char buf[128], abc[128], *b;
 564         int len, off, align;
 565         bcopy("abcdefghijklmnopqrstuvwxyz0123456789", abc, 36);
 566         for (align = 7; align >= 0; align--) {
 567           for (len = 36; len; len--) {
 568             b = buf+align; bcopy(abc, b, len);
 569             for (off = 1; off <= len; off++) {
 570               bcopy(b, b+off, len); bcopy(b+off, b, len);
 571                 if (bcmp(b, abc, len)) return(1);
 572             }
 573           }
 574         }
 575         return(0);
 576       }],glib_cv_working_bcopy=yes,glib_cv_working_bcopy=no)])
 577   if test "$glib_cv_working_bcopy" = "yes"; then
 578     AC_DEFINE(HAVE_WORKING_BCOPY,1,[Have a working bcopy])
 579   fi
 580 fi
 581
 582 # Check for sys_errlist
 583 AC_MSG_CHECKING(for sys_errlist)
 584 AC_TRY_LINK(, [
 585 extern char *sys_errlist[];
 586 extern int sys_nerr;
 587 sys_errlist[sys_nerr-1][0] = 0;
 588 ], glib_ok=yes, glib_ok=no)
 589 AC_MSG_RESULT($glib_ok)
 590 if test "$glib_ok" = "no"; then
 591     AC_DEFINE(NO_SYS_ERRLIST,1,[global 'sys_errlist' not found])
 592 fi
 593
 594 # Check for sys_siglist
 595 AC_MSG_CHECKING(for sys_siglist)
 596 AC_TRY_LINK(, [
 597 extern char *sys_siglist[];
 598 exit (sys_siglist[0]);
 599 ], glib_ok=yes, glib_ok=no)
 600 AC_MSG_RESULT($glib_ok)
 601 if test "$glib_ok" = "no"; then
 602     AC_DEFINE(NO_SYS_SIGLIST,1,[global 'sys_siglist' not found])
 603 fi
 604
 605 # Check for sys_siglist decl (see Tue Jan 19 00:44:24 1999 in changelog)
 606 AC_MSG_CHECKING(for sys_siglist declaration)
 607 AC_TRY_COMPILE([#include <signal.h>], [
 608 strlen (sys_siglist[0]);
 609 ], glib_ok=yes, glib_ok=no)
 610 AC_MSG_RESULT($glib_ok)
 611 if test "$glib_ok" = "no"; then
 612     AC_DEFINE(NO_SYS_SIGLIST_DECL,1,[global 'sys_siglist' not declared])
 613 fi
 614
 615 # Check if <sys/select.h> needs to be included for fd_set
 616 AC_MSG_CHECKING([for fd_set])
 617 AC_TRY_COMPILE([#include <sys/types.h>],
 618         [fd_set readMask, writeMask;], gtk_ok=yes, gtk_ok=no)
 619 if test "$gtk_ok" = "yes"; then
 620     AC_MSG_RESULT([yes, found in sys/types.h])
 621 else
 622     AC_EGREP_HEADER(fd_set, sys/select.h, gtk_ok=yes)
 623     if test "$gtk_ok" = "yes"; then
 624         # *** FIXME: give it a different name
 625         AC_DEFINE(HAVE_SYS_SELECT_H,1,[found fd_set in sys/select.h])
 626         AC_MSG_RESULT([yes, found in sys/select.h])
 627     else
 628         AC_DEFINE(NO_FD_SET,1,[didn't find fd_set])
 629         AC_MSG_RESULT(no)
 630     fi
 631 fi
 632
 633 dnl *** check for sane realloc() ***
 634 AC_CACHE_CHECK([whether realloc (NULL,) will work],glib_cv_sane_realloc,[
 635         AC_TRY_RUN([
 636         #include <stdlib.h>
 637         int main() {
 638           return realloc (0, sizeof (int)) == 0;
 639         }],
 640         [glib_cv_sane_realloc=yes],
 641         [glib_cv_sane_realloc=no],
 642         [])
 643 ])
 644 if test x$glib_cv_sane_realloc = xyes; then
 645   AC_DEFINE(REALLOC_0_WORKS,1,[whether realloc (NULL,) works])
 646 fi
 647
 648 dnl Check for nl_langinfo and CODESET
 649
 650 AC_MSG_CHECKING([for nl_langinfo (CODESET)])
 651 AC_TRY_COMPILE([#include <langinfo.h>],
 652         [char *codeset = nl_langinfo (CODESET);],
 653    AC_DEFINE(HAVE_CODESET,1,[Have nl_langinfo (CODESET)])
 654    have_codeset=yes,
 655    have_codeset=no)
 656 AC_MSG_RESULT($have_codeset)
 657
 658
 659 dnl ****************************************
 660 dnl *** strlcpy/strlcat                  ***
 661 dnl ****************************************
 662 # Check for strlcpy
 663 AC_MSG_CHECKING(for strlcpy/strlcat)
 664 AC_TRY_LINK([#include <stdlib.h>
 665 #include <string.h>], [
 666 char *p = malloc(10);
 667 (void) strlcpy(p, "hi", 10);
 668 (void) strlcat(p, "bye", 10);
 669 ], glib_ok=yes, glib_ok=no)
 670 AC_MSG_RESULT($glib_ok)
 671 if test "$glib_ok" = "yes"; then
 672     AC_DEFINE(HAVE_STRLCPY,1,[Have functions strlcpy and strlcat])
 673 fi
 674
 675
 676 dnl **********************
 677 dnl *** va_copy checks ***
 678 dnl **********************
 679 dnl we currently check for all three va_copy possibilities, so we get
 680 dnl all results in config.log for bug reports.
 681 AC_CACHE_CHECK([for an implementation of va_copy()],glib_cv_va_copy,[
 682         AC_TRY_RUN([
 683         #include <stdarg.h>
 684         void f (int i, ...) {
 685         va_list args1, args2;
 686         va_start (args1, i);
 687         va_copy (args2, args1);
 688         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
 689           exit (1);
 690         va_end (args1); va_end (args2);
 691         }
 692         int main() {
 693           f (0, 42);
 694           return 0;
 695         }],
 696         [glib_cv_va_copy=yes],
 697         [glib_cv_va_copy=no],
 698         [])
 699 ])
 700 AC_CACHE_CHECK([for an implementation of __va_copy()],glib_cv___va_copy,[
 701         AC_TRY_RUN([
 702         #include <stdarg.h>
 703         void f (int i, ...) {
 704         va_list args1, args2;
 705         va_start (args1, i);
 706         __va_copy (args2, args1);
 707         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
 708           exit (1);
 709         va_end (args1); va_end (args2);
 710         }
 711         int main() {
 712           f (0, 42);
 713           return 0;
 714         }],
 715         [glib_cv___va_copy=yes],
 716         [glib_cv___va_copy=no],
 717         [])
 718 ])
 719
 720 if test "x$glib_cv_va_copy" = "xyes"; then
 721   g_va_copy_func=va_copy
 722 else if test "x$glib_cv___va_copy" = "xyes"; then
 723   g_va_copy_func=__va_copy
 724 fi
 725 fi
 726
 727 if test -n "$g_va_copy_func"; then
 728   AC_DEFINE_UNQUOTED(G_VA_COPY,$g_va_copy_func,[A 'va_copy' style function])
 729 fi
 730
 731 AC_CACHE_CHECK([whether va_lists can be copied by value],glib_cv_va_val_copy,[
 732         AC_TRY_RUN([
 733         #include <stdarg.h>
 734         void f (int i, ...) {
 735         va_list args1, args2;
 736         va_start (args1, i);
 737         args2 = args1;
 738         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
 739           exit (1);
 740         va_end (args1); va_end (args2);
 741         }
 742         int main() {
 743           f (0, 42);
 744           return 0;
 745         }],
 746         [glib_cv_va_val_copy=yes],
 747         [glib_cv_va_val_copy=no],
 748         [])
 749 ])
 750
 751 if test "x$glib_cv_va_val_copy" = "xno"; then
 752   AC_DEFINE(G_VA_COPY_AS_ARRAY,1, ['va_lists' cannot be copies as values])
 753 fi
 754
 755 dnl ***********************
 756 dnl *** g_module checks ***
 757 dnl ***********************
 758 G_MODULE_LIBS=
 759 G_MODULE_LIBS_EXTRA=
 760 G_MODULE_PLUGIN_LIBS=
 761 G_MODULE_LDFLAGS=
 762 dnl G_MODULE_IMPL= don't reset, so cmd-line can override
 763 G_MODULE_NEED_USCORE=0
 764 G_MODULE_BROKEN_RTLD_GLOBAL=0
 765 G_MODULE_HAVE_DLERROR=0
 766 dnl *** force native WIN32 shared lib loader
 767 if test -z "$G_MODULE_IMPL"; then
 768   case "$host" in
 769   *-*-mingw*|*-*-cygwin*) G_MODULE_IMPL=G_MODULE_IMPL_WIN32 ;;
 770   esac
 771 fi
 772 dnl *** dlopen() and dlsym() in system libraries
 773 if test -z "$G_MODULE_IMPL"; then
 774         AC_CHECK_FUNC(dlopen,
 775                       [AC_CHECK_FUNC(dlsym,
 776                                      [G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
 777                       [])
 778 fi
 779 dnl *** load_image (BeOS)
 780 if test -z "$G_MODULE_IMPL" && test "x$glib_native_beos" = "xyes"; then
 781   AC_CHECK_LIB(root, load_image,
 782       [G_MODULE_LIBS="-lbe -lroot -lglib"
 783       G_MODULE_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
 784       G_MODULE_PLUGIN_LIBS="-L\$(top_builddir_full)/gmodule/.libs -lgmodule"
 785       G_MODULE_IMPL=G_MODULE_IMPL_BEOS],
 786       [])
 787 fi
 788 dnl *** dlopen() and dlsym() in libdl
 789 if test -z "$G_MODULE_IMPL"; then
 790         AC_CHECK_LIB(dl, dlopen,
 791                      [AC_CHECK_LIB(dl, dlsym,
 792                                    [G_MODULE_LIBS=-ldl
 793                                    G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
 794                      [])
 795 fi
 796 dnl *** NSLinkModule (dyld) in system libraries (Darwin)
 797 if test -z "$G_MODULE_IMPL"; then
 798         AC_CHECK_FUNC(NSLinkModule,
 799                       [G_MODULE_IMPL=G_MODULE_IMPL_DYLD
 800                        G_MODULE_NEED_USCORE=1],
 801                       [])
 802 fi
 803 dnl *** shl_load() in libdld (HP-UX)
 804 if test -z "$G_MODULE_IMPL"; then
 805         AC_MSG_CHECKING(how to export all symbols)
 806         SAVED_LDFLAGS=$LDFLAGS
 807         LDFLAGS="$LDFLAGS -Wl,-E"
 808         AC_TRY_LINK(,[ return 0; ],
 809                 [ G_MODULE_LDFLAGS="-Wl,-E" ],[
 810                 LDFLAGS="$SAVED_LDFLAGS -bexpall"
 811                 AC_TRY_LINK(,[ return 0; ],
 812                         [G_MODULE_LDFLAGS="-bexpall"],
 813                         [G_MODULE_LDFLAGS="none"])
 814         ])
 815         LDFLAGS=$SAVED_LDFLAGS
 816         AC_MSG_RESULT($G_MODULE_LDFLAGS)
 817         if test "x$G_MODULE_LDFLAGS" = "xnone"; then
 818                 G_MODULE_LDFLAGS=
 819         fi
 820         AC_CHECK_LIB(dld, shl_load,
 821                 [G_MODULE_LIBS=-ldld
 822                 G_MODULE_IMPL=G_MODULE_IMPL_DLD],
 823                 [])
 824 fi
 825 dnl *** additional checks for G_MODULE_IMPL_DL
 826 if test "$G_MODULE_IMPL" = "G_MODULE_IMPL_DL"; then
 827         case "$host_os" in
 828           linux*)
 829             G_MODULE_LDFLAGS='-rdynamic'
 830             ;;
 831         esac
 832         LIBS_orig="$LIBS"
 833         LDFLAGS_orig="$LDFLAGS"
 834         LIBS="$LIBS $G_MODULE_LIBS"
 835         LDFLAGS="$LDFLAGS $G_MODULE_LDFLAGS"
 836 dnl *** check for OSF1/5.0 RTLD_GLOBAL brokenness
 837         AC_CACHE_CHECK([for RTLD_GLOBAL brokenness],
 838                 glib_cv_rtldglobal_broken,[
 839                 AC_TRY_RUN([
 840                 #include <dlfcn.h>
 841                 #ifndef RTLD_GLOBAL
 842                 #define RTLD_GLOBAL 0
 843                 #endif
 844                 #ifndef RTLD_LAZY
 845                 #define RTLD_LAZY 0
 846                 #endif
 847                 int pthread_create;
 848                 int main () {
 849                 void *handle, *global, *local;
 850                 global = &pthread_create;
 851                 handle = dlopen ("libpthread.so", RTLD_GLOBAL | RTLD_LAZY);
 852                 if (!handle) return 0;
 853                 local = dlsym (handle, "pthread_create");
 854                 return global == local;
 855                 }],
 856                         [glib_cv_rtldglobal_broken=no],
 857                         [glib_cv_rtldglobal_broken=yes],
 858                         [])
 859                 rm -f plugin.c plugin.o plugin.lo
 860         ])
 861         if test "x$glib_cv_rtldglobal_broken" = "xyes"; then
 862                 G_MODULE_BROKEN_RTLD_GLOBAL=1
 863         else
 864                 G_MODULE_BROKEN_RTLD_GLOBAL=0
 865         fi
 866 dnl *** check whether we need preceeding underscores
 867         AC_CACHE_CHECK([for preceeding underscore in symbols],
 868                 glib_cv_uscore,[
 869                 AC_TRY_RUN([
 870                 #include <dlfcn.h>
 871                 int glib_underscore_test (void) { return 42; }
 872                 int main() {
 873                   void *f1 = (void*)0, *f2 = (void*)0, *handle;
 874                   handle = dlopen ((void*)0, 0);
 875                   if (handle) {
 876                     f1 = dlsym (handle, "glib_underscore_test");
 877                     f2 = dlsym (handle, "_glib_underscore_test");
 878                   } return (!f2 || f1);
 879                 }],
 880                         [glib_cv_uscore=yes],
 881                         [glib_cv_uscore=no],
 882                         [])
 883                 rm -f plugin.c plugin.$ac_objext plugin.lo
 884         ])
 885         if test "x$glib_cv_uscore" = "xyes"; then
 886                 G_MODULE_NEED_USCORE=1
 887         else
 888                 G_MODULE_NEED_USCORE=0
 889         fi
 890
 891         LDFLAGS="$LDFLAGS_orig"
 892 dnl *** check for having dlerror()
 893         AC_CHECK_FUNC(dlerror,
 894                 [G_MODULE_HAVE_DLERROR=1],
 895                 [G_MODULE_HAVE_DLERROR=0])
 896         LIBS="$LIBS_orig"
 897 fi
 898 dnl *** done, have we got an implementation?
 899 if test -z "$G_MODULE_IMPL"; then
 900         G_MODULE_IMPL=0
 901         G_MODULE_SUPPORTED=false
 902 else
 903         G_MODULE_SUPPORTED=true
 904 fi
 905
 906 AC_MSG_CHECKING(for the suffix of shared libraries)
 907 case "$host_os" in
 908   hpux9* | hpux10* | hpux11*)  # taken from ltconfig
 909     glib_gmodule_suffix='sl'
 910     ;;
 911   cygwin* | mingw*)
 912     glib_gmodule_suffix='dll'
 913     ;;
 914   *)
 915     glib_gmodule_suffix='so'
 916     ;;
 917 esac
 918 AC_MSG_RESULT(.$glib_gmodule_suffix)
 919
 920 AC_SUBST(G_MODULE_SUPPORTED)
 921 AC_SUBST(G_MODULE_IMPL)
 922 AC_SUBST(G_MODULE_LIBS)
 923 AC_SUBST(G_MODULE_LIBS_EXTRA)
 924 AC_SUBST(G_MODULE_PLUGIN_LIBS)
 925 AC_SUBST(G_MODULE_LDFLAGS)
 926 AC_SUBST(G_MODULE_HAVE_DLERROR)
 927 AC_SUBST(G_MODULE_BROKEN_RTLD_GLOBAL)
 928 AC_SUBST(G_MODULE_NEED_USCORE)
 929 AC_SUBST(GLIB_DEBUG_FLAGS)
 930
 931 dnl **********************
 932 dnl *** g_spawn checks ***
 933 dnl **********************
 934
 935 AC_MSG_CHECKING(for gspawn implementation)
 936 case "$host" in
 937   *-*-mingw*)
 938     GSPAWN=gspawn-win32.lo
 939     ;;
 940   *)
 941     GSPAWN=gspawn.lo
 942     ;;
 943 esac
 944 AC_MSG_RESULT($GSPAWN)
 945 AC_SUBST(GSPAWN)
 946
 947 dnl *************************
 948 dnl *** GIOChannel checks ***
 949 dnl *************************
 950
 951 AC_MSG_CHECKING(for GIOChannel implementation)
 952 case "$host" in
 953   *-*-mingw*)
 954     GIO=giowin32.lo
 955     ;;
 956   *)
 957     GIO=giounix.lo
 958     ;;
 959 esac
 960 AC_MSG_RESULT($GIO)
 961 AC_SUBST(GIO)
 962
 963 dnl ****************************************
 964 dnl *** platform dependent source checks ***
 965 dnl ****************************************
 966
 967 AC_MSG_CHECKING(for platform-dependent source)
 968 case "$host" in
 969   *-*-cygwin*|*-*-mingw*)
 970     PLATFORMDEP=gwin32.lo
 971     ;;
 972   *)
 973     PLATFORMDEP=
 974     ;;
 975 esac
 976 AC_MSG_RESULT($PLATFORMDEP)
 977 AC_SUBST(PLATFORMDEP)
 978
 979 AC_MSG_CHECKING([whether to compile timeloop])
 980 case "$host" in
 981   *-*-cygwin*|*-*-mingw*)
 982     enable_timeloop=no
 983     ;;
 984   *)
 985     enable_timeloop=yes
 986     ;;
 987 esac
 988 AC_MSG_RESULT($enable_timeloop)
 989 AM_CONDITIONAL(ENABLE_TIMELOOP, test x$enable_timeloop = xyes)
 990
 991 AC_MSG_CHECKING([if building for some Win32 platform])
 992 case "$host" in
 993   *-*-mingw*|*-*-cygwin*)
 994     platform_win32=yes
 995     ;;
 996   *)
 997     platform_win32=no
 998     ;;
 999 esac
1000 AC_MSG_RESULT($platform_win32)
1001 AM_CONDITIONAL(PLATFORM_WIN32, test x$platform_win32 = xyes)
1002
1003 dnl ***********************
1004 dnl *** g_thread checks ***
1005 dnl ***********************
1006
1007 AC_ARG_WITH(threads, [  --with-threads=[none/posix/dce/solaris/win32] specify a thread implementation to use],
1008         if test "x$with_threads" = x; then
1009                 want_threads=yes
1010         else
1011                 want_threads=$with_threads
1012         fi,
1013         want_threads=yes)
1014 if test "x$enable_threads" = "xno"; then
1015         want_threads=no
1016 fi
1017 if test "x$want_threads" = "xnone"; then
1018         want_threads=no
1019 fi
1020
1021 dnl error and warning message
1022 dnl *************************
1023
1024 THREAD_NO_IMPLEMENTATION="You do not have any known thread system on your
1025                 computer. GLib will not have a default thread implementation."
1026
1027 FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your
1028                 platform (normally it's "_REENTRANT"). I'll not use any flag on
1029                 compilation now, but then your programs might not work.
1030                 Please provide information on how it is done on your system."
1031
1032 LIBS_NOT_FOUND_1="I can't find the libraries for the thread implementation
1033                 "
1034
1035 LIBS_NOT_FOUND_2=". Please choose another thread implementation or
1036                 provide information on your thread implementation.
1037                 You can also run 'configure --disable-threads'
1038                 to compile without thread support."
1039
1040 FUNC_NO_GETPWUID_R="the 'g_get_(user_name|real_name|home_dir|tmp_dir)'
1041                 functions will not be MT-safe during their first call because
1042                 there is no working 'getpwuid_r' on your system."
1043
1044 FUNC_NO_LOCALTIME_R="the 'g_date_set_time' function will not be MT-safe
1045                 because there is no 'localtime_r' on your system."
1046
1047 POSIX_NO_YIELD="I can not find a yield functions for your platform. A rather
1048                 crude surrogate will be used. If you happen to know a
1049                 yield function for your system, please inform the GLib
1050                 developers."
1051
1052 POSIX_NO_PRIORITIES="I can not find the minimal and maximal priorities for
1053                 threads on your system. Thus threads can only have the default
1054                 priority. If you happen to know these main/max
1055                 priorities, please inform the GLib developers."
1056
1057
1058 dnl determination of thread implementation
1059 dnl ***************************************
1060
1061 have_threads=none
1062 if test "x$want_threads" = xyes || test "x$want_threads" = xsolaris; then
1063         case $host in
1064                 *-*-solaris*)
1065                 AC_CHECK_LIB(thread, cond_init, have_threads=solaris)
1066                 ;;
1067         esac
1068 fi
1069 if test "x$want_threads" = xyes || test "x$want_threads" = xposix \
1070                                 || test "x$want_threads" = xdce; then
1071         # -D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE is for DG/UX
1072         # -U_OSF_SOURCE is for Digital UNIX 4.0d
1073         GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE"
1074         glib_save_CPPFLAGS="$CPPFLAGS"
1075         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1076         if test "x$have_threads" = xnone; then
1077                 AC_TRY_COMPILE([#include <pthread.h>],
1078                         [pthread_attr_t attr; pthread_attr_init(&attr);],
1079                         have_threads=posix)
1080         fi
1081         if test "x$have_threads" = xnone; then
1082                 AC_TRY_COMPILE([#include <pthread.h>],
1083                         [pthread_attr_t attr; pthread_attr_create(&attr);],
1084                         have_threads=posix)
1085         fi
1086         CPPFLAGS="$glib_save_CPPFLAGS"
1087 fi
1088 if test "x$want_threads" = xyes || test "x$want_threads" = xwin32; then
1089         case $host in
1090                 *-*-mingw*|*-*-cygwin*)
1091                 have_threads=win32
1092                 ;;
1093         esac
1094 fi
1095
1096 AC_MSG_CHECKING(for thread implementation)
1097
1098 if test "x$have_threads" = xnone && test "x$want_threads" != xno; then
1099         AC_MSG_RESULT(none available)
1100         AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
1101 else
1102         AC_MSG_RESULT($have_threads)
1103 fi
1104
1105
1106 dnl determination of G_THREAD_CFLAGS
1107 dnl ********************************
1108
1109 G_THREAD_LIBS=
1110 G_THREAD_LIBS_EXTRA=
1111 G_THREAD_CFLAGS=
1112
1113 if test x"$have_threads" != xnone; then
1114
1115     G_THREAD_CFLAGS="-D_REENTRANT" # good default guess
1116
1117     case $host in
1118         *-aix*)
1119                 G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_THREAD_SAFE"
1120                 if test x"$GCC" = xyes; then
1121                         G_THREAD_CFLAGS="$G_THREAD_CFLAGS -mthreads"
1122                 fi
1123                 ;;
1124         *-freebsd2.2*)
1125                 G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_THREAD_SAFE"
1126
1127                 # FreeBSD 2.2.x shiped with gcc 2.7.2.x, which doesn't support
1128                 # -mthreads flag.
1129                 ;;
1130         *-sysv5uw7*)  # UnixWare 7
1131                 if test "$GCC" != "yes"; then
1132                         G_THREAD_CFLAGS="$G_THREAD_CFLAGS -Kthread"
1133                 else
1134                         G_THREAD_CFLAGS="$G_THREAD_CFLAGS -pthread"
1135                 fi
1136                 ;;
1137         *-dg-dgux*)  # DG/UX
1138                 G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_POSIX4A_DRAFT10_SOURCE"
1139     esac
1140
1141     # if we are not finding the localtime_r function, then we probably are
1142     # not using the proper multithread flag
1143
1144     glib_save_CPPFLAGS="$CPPFLAGS"
1145     CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1146
1147     # First we test, whether localtime_r is declared in time.h
1148     # directly. Then we test whether a macro localtime_r exists, in
1149     # which case localtime_r in the test program is replaced and thus
1150     # if we still find localtime_r in the output, it is not defined as
1151     # a macro.
1152
1153     AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>], ,
1154       [AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>
1155                                                            localtime_r(a,b)],
1156                    AC_MSG_WARN($FLAG_DOES_NOT_WORK))])
1157
1158     CPPFLAGS="$glib_save_CPPFLAGS"
1159
1160     AC_MSG_CHECKING(thread related cflags)
1161     AC_MSG_RESULT($G_THREAD_CFLAGS)
1162     CFLAGS="$CFLAGS $G_THREAD_CFLAGS"
1163 fi
1164
1165 dnl determination of G_THREAD_LIBS
1166 dnl ******************************
1167
1168 mutex_has_default=no
1169 case $have_threads in
1170         posix|dce)
1171            glib_save_CPPFLAGS="$CPPFLAGS"
1172            CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1173            G_THREAD_LIBS=error
1174            glib_save_LIBS="$LIBS"
1175            case $host in
1176              *-sysv5uw7*) # UnixWare 7
1177                 if test "$GCC" != "yes"; then
1178                         G_THREAD_LIBS="-Kthread"
1179                 else
1180                         G_THREAD_LIBS="-pthread"
1181                 fi
1182                 ;;
1183              *)
1184                 for thread_lib in "" pthread pthread32 pthreads c_r thread dce; do
1185                         if test x"$thread_lib" = x; then
1186                                 add_thread_lib=""
1187                                 IN=""
1188                         else
1189                                 add_thread_lib="-l$thread_lib"
1190                                 IN=" in -l$thread_lib"
1191                         fi
1192                         if test x"$have_threads" = xposix; then
1193                                 defattr=0
1194                         else
1195                                 defattr=pthread_attr_default
1196                         fi
1197
1198                         LIBS="$glib_save_LIBS $add_thread_lib"
1199
1200                         AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
1201                         AC_TRY_RUN([#include <pthread.h>
1202                                 int check_me = 0;
1203                                 void* func(void* data) {check_me = 42;}
1204                                 main()
1205                                 { pthread_t t;
1206                                   void *ret;
1207                                   pthread_create (&t, $defattr, func, 0);
1208                                   pthread_join (t, &ret);
1209                                   exit (check_me != 42);
1210                                 }],
1211                                 [AC_MSG_RESULT(yes)
1212                                 G_THREAD_LIBS="$add_thread_lib"
1213                                 break],
1214                                 [AC_MSG_RESULT(no)])
1215                 done
1216                 if test "x$G_THREAD_LIBS" = xerror; then
1217                   AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1218                 fi
1219                 for thread_lib in "" rt rte; do
1220                         if test x"$thread_lib" = x; then
1221                                 add_thread_lib=""
1222                                 IN=""
1223                         else
1224                                 add_thread_lib="-l$thread_lib"
1225                                 IN=" in -l$thread_lib"
1226                         fi
1227                         LIBS="$glib_save_LIBS $add_thread_lib"
1228
1229                         AC_MSG_CHECKING(for sched_get_priority_min$IN)
1230                         AC_TRY_RUN([#include <sched.h>
1231                                 #include <errno.h>
1232                                 int main() {
1233                                 errno = 0;
1234                                 return sched_get_priority_min(SCHED_OTHER)==-1
1235                                         && errno != 0;
1236                                 }],
1237                                 [AC_MSG_RESULT(yes)
1238                                 G_THREAD_LIBS="$G_THREAD_LIBS $add_thread_lib"
1239                                 posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
1240                                 posix_priority_max="sched_get_priority_max(SCHED_OTHER)"
1241                                 break],
1242                                 [AC_MSG_RESULT(no)])
1243                 done
1244                 LIBS="$glib_save_LIBS"
1245                 ;;
1246            esac
1247            mutex_has_default=yes
1248            mutex_default_type='pthread_mutex_t'
1249            mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
1250            mutex_header_file='pthread.h'
1251            if test "x$have_threads" = "xposix"; then
1252              g_threads_impl="POSIX"
1253            else
1254              g_threads_impl="DCE"
1255              have_threads="posix"
1256            fi
1257            AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
1258            CPPFLAGS="$glib_save_CPPFLAGS"
1259            ;;
1260         solaris)
1261            G_THREAD_LIBS=error
1262            AC_CHECK_LIB(thread, cond_init, G_THREAD_LIBS="-lthread")
1263            mutex_has_default=yes
1264            mutex_default_type='mutex_t'
1265            mutex_default_init="DEFAULTMUTEX"
1266            mutex_header_file='thread.h'
1267            g_threads_impl="SOLARIS"
1268            ;;
1269         win32)
1270            g_threads_impl="WIN32"
1271            G_THREAD_LIBS=""
1272            ;;
1273         none)
1274            g_threads_impl="NONE"
1275            ;;
1276         *)
1277            g_threads_impl="NONE"
1278            G_THREAD_LIBS=error
1279            ;;
1280 esac
1281
1282 if test "x$G_THREAD_LIBS" = xerror; then
1283         AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1284 fi
1285
1286 case $host in
1287   *-*-beos*)
1288     G_THREAD_LIBS="-lbe -lroot -lglib "
1289     G_THREAD_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
1290     ;;
1291   *)
1292     ;;
1293 esac
1294
1295 AC_MSG_CHECKING(thread related libraries)
1296 AC_MSG_RESULT($G_THREAD_LIBS)
1297
1298 dnl check for mt safe function variants and some posix functions
1299 dnl ************************************************************
1300
1301 if test x"$have_threads" != xnone; then
1302         glib_save_LIBS="$LIBS"
1303         # we are not doing the following for now, as this might require glib
1304         # to always be linked with the thread libs on some platforms.
1305         # LIBS="$LIBS $G_THREAD_LIBS"
1306         AC_CHECK_FUNCS(localtime_r)
1307         if test "$ac_cv_header_pwd_h" = "yes"; then
1308                 AC_CACHE_CHECK([for posix getpwuid_r],
1309                         ac_cv_func_posix_getpwuid_r,
1310                         [AC_TRY_RUN([#include <errno.h>
1311                                 #include <pwd.h>
1312                                 int main () { char buffer[10000];
1313                                 struct passwd pwd, *pwptr = &pwd;
1314                                 int error;
1315                                 errno = 0;
1316                                 error = getpwuid_r (0, &pwd, buffer,
1317                                         sizeof (buffer), &pwptr);
1318                                 return (error < 0 && errno == ENOSYS)
1319                                         || error == ENOSYS; }],
1320                                 [ac_cv_func_posix_getpwuid_r=yes],
1321                                 [ac_cv_func_posix_getpwuid_r=no])])
1322                 if test "$ac_cv_func_posix_getpwuid_r" = yes; then
1323                         AC_DEFINE(HAVE_POSIX_GETPWUID_R,1,
1324                                 [Have POSIX function getpwuid_r])
1325                 else
1326                         AC_CACHE_CHECK([for nonposix getpwuid_r],
1327                                 ac_cv_func_nonposix_getpwuid_r,
1328                                 [AC_TRY_LINK([#include <pwd.h>],
1329                                         [char buffer[10000];
1330                                         struct passwd pwd;
1331                                         getpwuid_r (0, &pwd, buffer,
1332                                                         sizeof (buffer));],
1333                                         [ac_cv_func_nonposix_getpwuid_r=yes],
1334                                         [ac_cv_func_nonposix_getpwuid_r=no])])
1335                         if test "$ac_cv_func_nonposix_getpwuid_r" = yes; then
1336                                 AC_DEFINE(HAVE_NONPOSIX_GETPWUID_R,1,
1337                                         [Have non-POSIX function getpwuid_r])
1338                         fi
1339                 fi
1340         fi
1341         LIBS="$LIBS $G_THREAD_LIBS"
1342         if test x"$have_threads" = xposix; then
1343                 glib_save_CPPFLAGS="$CPPFLAGS"
1344                 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1345                 dnl we might grow sizeof(pthread_t) later on, so use a dummy name here
1346                 GLIB_SIZEOF([#include <pthread.h>], pthread_t, system_thread)
1347                 # This is not AC_CHECK_FUNC to also work with function
1348                 # name mangling in header files.
1349                 AC_MSG_CHECKING(for pthread_attr_setstacksize)
1350                 AC_TRY_LINK([#include <pthread.h>],
1351                         [pthread_attr_t t; pthread_attr_setstacksize(&t,0)],
1352                         [AC_MSG_RESULT(yes)
1353                         AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE,1,
1354                                   [Have function pthread_attr_setstacksize])],
1355                         [AC_MSG_RESULT(no)])
1356                 AC_MSG_CHECKING(for minimal/maximal thread priority)
1357                 if test x"$posix_priority_min" = xnone; then
1358                         AC_EGREP_CPP(PX_PRIO_MIN,[#include <pthread.h>
1359                                 PX_PRIO_MIN],,[
1360                                 posix_priority_min=PX_PRIO_MIN
1361                                 posix_priority_max=PX_PRIO_MAX])
1362                 fi
1363                 if test x"$posix_priority_min" = xnone; then
1364                         AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
1365                                 PRI_OTHER_MIN],,[
1366                                 posix_priority_min=PRI_OTHER_MIN
1367                                 posix_priority_max=PRI_OTHER_MAX])
1368                 fi
1369                 if test x"$posix_priority_min" = x; then
1370                         AC_MSG_RESULT(none found)
1371                         AC_MSG_WARN($POSIX_NO_PRIORITIES)
1372                         posix_priority_min=-1
1373                         posix_priority_max=-1
1374                 else
1375                         AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
1376                         AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
1377                         AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])
1378                 fi
1379                 posix_yield_func=none
1380                 AC_MSG_CHECKING(for posix yield function)
1381                 for yield_func in sched_yield pthread_yield_np pthread_yield \
1382                                                         thr_yield; do
1383                         AC_TRY_LINK([#include <pthread.h>],
1384                                 [$yield_func()],
1385                                 [posix_yield_func="$yield_func"
1386                                 break])
1387                 done
1388                 if test x"$posix_yield_func" = xnone; then
1389                         AC_MSG_RESULT(none found)
1390                         AC_MSG_WARN($POSIX_NO_YIELD)
1391                         posix_yield_func="g_usleep(1000)"
1392                 else
1393                         AC_MSG_RESULT($posix_yield_func)
1394                         posix_yield_func="$posix_yield_func()"
1395                 fi
1396                 AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func,[The POSIX RT yield function])
1397                 CPPFLAGS="$glib_save_CPPFLAGS"
1398
1399                 AC_MSG_CHECKING(whether to use the PID niceness surrogate for thread priorities)
1400                 AC_TRY_RUN([#include <pthread.h>
1401                         #include <sys/types.h>
1402                         #include <unistd.h>
1403                         pid_t other_pid = 0;
1404
1405                         void* func(void* data) {other_pid = getpid();}
1406                         main()
1407                         { pthread_t t;
1408                           void *ret;
1409                           pthread_create (&t, $defattr, func, NULL);
1410                           pthread_join (t, &ret);
1411                           exit (getpid()==other_pid ||
1412                                 $posix_priority_min != $posix_priority_max);
1413                         }],
1414                         [AC_MSG_RESULT(yes)
1415                           AC_DEFINE(G_THREAD_USE_PID_SURROGATE, 1, [whether to use the PID niceness surrogate for thread priorities])
1416                         ],
1417                         [AC_MSG_RESULT(no)])
1418         elif test x"$have_threads" = xwin32; then
1419                 # It's a pointer to a private struct
1420                 GLIB_SIZEOF(,struct _GThreadData *, system_thread)
1421         else # solaris threads
1422                 GLIB_SIZEOF([#include <thread.h>], thread_t, system_thread)
1423         fi
1424
1425         LIBS="$glib_save_LIBS"
1426
1427         # now spit out all the warnings.
1428         if test "$ac_cv_func_posix_getpwuid_r" != "yes" &&
1429            test "$ac_cv_func_nonposix_getpwuid_r" != "yes"; then
1430                 AC_MSG_WARN($FUNC_NO_GETPWUID_R)
1431         fi
1432         if test "$ac_cv_func_localtime_r" != "yes"; then
1433                 AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
1434         fi
1435 else
1436         # If no thread implementation exists, we will provide enough
1437         # space for a pointer
1438         GLIB_SIZEOF(, void*, system_thread)
1439 fi
1440
1441 AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
1442                    [Source file containing theread implementation])
1443 AC_SUBST(G_THREAD_CFLAGS)
1444 AC_SUBST(G_THREAD_LIBS)
1445 AC_SUBST(G_THREAD_LIBS_EXTRA)
1446
1447 dnl **********************************************
1448 dnl *** GDefaultMutex setup and initialization ***
1449 dnl **********************************************
1450 dnl
1451 dnl if mutex_has_default = yes, we also got
1452 dnl mutex_default_type, mutex_default_init and mutex_header_file
1453 GLIB_IF_VAR_EQ(mutex_has_default, yes,
1454         glib_save_CPPFLAGS="$CPPFLAGS"
1455         glib_save_LIBS="$LIBS"
1456         LIBS="$LIBS $G_THREAD_LIBS"
1457         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1458         GLIB_SIZEOF([#include <$mutex_header_file>],
1459                     $mutex_default_type,
1460                     gmutex,
1461                     )
1462         GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
1463                            $mutex_default_type,
1464                            gmutex,
1465                            $glib_cv_sizeof_gmutex,
1466                            $mutex_default_init)
1467         if test x"$glib_cv_byte_contents_gmutex" = xno; then
1468                 mutex_has_default=no
1469         fi
1470         CPPFLAGS="$glib_save_CPPFLAGS"
1471         LIBS="$glib_save_LIBS"
1472         ,
1473 )
1474
1475
1476 dnl ****************************************
1477 dnl *** GLib POLL* compatibility defines ***
1478 dnl ****************************************
1479 GLIB_SYSDEFS(
1480 [#include <sys/types.h>
1481 #include <sys/poll.h>],
1482         POLLIN:1 POLLOUT:4 POLLPRI:2 POLLERR:8 POLLHUP:16 POLLNVAL:32,
1483         glibconfig-sysdefs.h,
1484         =)
1485
1486 dnl **********************
1487 dnl *** Win32 API libs ***
1488 dnl **********************
1489
1490 case $host in
1491   *-*-cygwin*)
1492         G_LIBS_EXTRA="-luser32 -lwsock32 -lkernel32"
1493     ;;
1494   *-*-mingw*)
1495         G_LIBS_EXTRA="-lwsock32"
1496     ;;
1497   *)
1498         G_LIBS_EXTRA=""
1499     ;;
1500 esac
1501 AC_SUBST(G_LIBS_EXTRA)
1502
1503 dnl ***********************
1504 dnl *** Tests for iconv ***
1505 dnl ***********************
1506
1507 AC_ARG_WITH(libiconv, [ --with-libiconv     Use the libiconv library ],,with_libiconv=maybe)
1508
1509 found_iconv=no
1510
1511 if test "x$with_libiconv" != "xyes" ; then
1512    #
1513    # Check in the C library
1514    #
1515    AC_CHECK_FUNC(iconv_open, with_libiconv=no; found_iconv=yes)
1516 fi
1517
1518 if test "x$with_libiconv" != "xno" ; then
1519    #
1520    # Check for libiconv
1521    #
1522    AC_CHECK_LIB(iconv, libiconv_open, with_libiconv=yes; found_iconv=yes)
1523 fi
1524
1525 if test "x$found_iconv" = "xno" ; then
1526    AC_MSG_ERROR([*** No iconv() implementation found in C library or libiconv])
1527 fi
1528
1529 if test "x$with_libiconv" = "xyes" ; then
1530   ICONV_LIBS="-liconv"
1531   AC_DEFINE(USE_LIBICONV)
1532 fi
1533 AC_SUBST(ICONV_LIBS)
1534
1535 dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
1536 dnl since we need it for g_iconv()
1537
1538 AC_MSG_CHECKING([for EILSEQ])
1539 AC_TRY_COMPILE([
1540 #include <errno.h>
1541 ],
1542 [
1543 int error = EILSEQ;
1544 ], have_eilseq=yes, have_eilseq=no);
1545 AC_MSG_RESULT($have_eilseq)
1546
1547 dnl **************************
1548 dnl *** Checks for gtk-doc ***
1549 dnl **************************
1550
1551 AC_ARG_WITH(html-dir, [  --with-html-dir=PATH    path to installed docs])
1552
1553 if test "x$with_html_dir" = "x" ; then
1554   HTML_DIR='${datadir}/gtk-doc/html'
1555 else
1556   HTML_DIR=$with_html_dir
1557 fi
1558
1559 AC_SUBST(HTML_DIR)
1560
1561 AC_CHECK_PROG(GTKDOC, gtkdoc-mkdb, true, false)
1562
1563 gtk_doc_min_version=0.6
1564 if $GTKDOC ; then
1565     gtk_doc_version=`gtkdoc-mkdb --version`
1566     AC_MSG_CHECKING([gtk-doc version ($gtk_doc_version) >= $gtk_doc_min_version])
1567     if perl <<EOF ; then
1568       exit (("$gtk_doc_version" =~ /^[[0-9]]+\.[[0-9]]+$/) &&
1569             ("$gtk_doc_version" >= "$gtk_doc_min_version") ? 0 : 1);
1570 EOF
1571       AC_MSG_RESULT(yes)
1572    else
1573       AC_MSG_RESULT(no)
1574       GTKDOC=false
1575    fi
1576 fi
1577
1578 AM_CONDITIONAL(HAVE_GTK_DOC, $GTKDOC)
1579 AC_SUBST(HAVE_GTK_DOC)
1580
1581 AC_CHECK_PROG(DB2HTML, db2html, true, false)
1582 AM_CONDITIONAL(HAVE_DOCBOOK, $DB2HTML)
1583
1584 dnl Let people disable the gtk-doc stuff.
1585 AC_ARG_ENABLE(gtk-doc, [  --enable-gtk-doc        use gtk-doc to build documentation [default=auto]], enable_gtk_doc="$enableval", enable_gtk_doc=auto)
1586
1587 if test x$enable_gtk_doc = xauto ; then
1588   if test x$GTKDOC = xtrue ; then
1589     enable_gtk_doc=yes
1590   else
1591     enable_gtk_doc=no
1592   fi
1593 fi
1594
1595 dnl NOTE: We need to use a separate automake conditional for this
1596 dnl       to make this work with the tarballs.
1597 AM_CONDITIONAL(ENABLE_GTK_DOC, test x$enable_gtk_doc = xyes)
1598
1599 dnl ******************************
1600 dnl *** output the whole stuff ***
1601 dnl ******************************
1602
1603 AC_OUTPUT_COMMANDS([
1604
1605 ## Generate `glibconfig.h' in two cases
1606 ## 1. `config.status' is run either explicitly, or via configure.
1607 ##     Esp. not when it is run in `Makefile' to generate makefiles and
1608 ##     config.h
1609 ## 2. CONFIG_OTHER is set explicitly
1610 ##
1611 ## Case 1 is difficult.  We know that `automake' sets one of
1612 ## CONFIG_FILES or CONFIG_HEADERS to empty.  This heuristic works
1613 ## only when AM_CONFIG_HEADER is set, however.
1614
1615 if test -n "${CONFIG_FILES}" && test -n "${CONFIG_HEADERS}"; then
1616   # Both CONFIG_FILES and CONFIG_HEADERS are non-empty ==> Case 1
1617   CONFIG_OTHER=${CONFIG_OTHER:-glibconfig.h}
1618 fi
1619 case "$CONFIG_OTHER" in
1620 *glibconfig.h*)
1621         echo creating glibconfig.h
1622         outfile=glibconfig.h-tmp
1623         cat > $outfile <<\_______EOF
1624 /* glibconfig.h
1625  *
1626  * This is a generated file.  Please modify 'configure.in'
1627  */
1628
1629 #ifndef __G_LIBCONFIG_H__
1630 #define __G_LIBCONFIG_H__
1631
1632 #include <glib/gmacros.h>
1633
1634 _______EOF
1635
1636         if test x$glib_limits_h = xyes; then
1637           echo '#include <limits.h>' >> $outfile
1638         fi
1639         if test x$glib_float_h = xyes; then
1640           echo '#include <float.h>' >> $outfile
1641         fi
1642         if test x$glib_values_h = xyes; then
1643           echo '#include <values.h>' >> $outfile
1644         fi
1645         if test "$glib_header_alloca_h" = "yes"; then
1646           echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
1647         fi
1648         if test x$glib_sys_poll_h = xyes; then
1649           echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
1650         fi
1651
1652         cat >> $outfile <<_______EOF
1653
1654 G_BEGIN_DECLS
1655
1656 #define G_MINFLOAT      $glib_mf
1657 #define G_MAXFLOAT      $glib_Mf
1658 #define G_MINDOUBLE     $glib_md
1659 #define G_MAXDOUBLE     $glib_Md
1660 #define G_MINSHORT      $glib_ms
1661 #define G_MAXSHORT      $glib_Ms
1662 #define G_MAXUSHORT     $glib_Mus
1663 #define G_MININT        $glib_mi
1664 #define G_MAXINT        $glib_Mi
1665 #define G_MAXUINT       $glib_Mui
1666 #define G_MINLONG       $glib_ml
1667 #define G_MAXLONG       $glib_Ml
1668 #define G_MAXULONG      $glib_Mul
1669
1670 #define G_MININT64      ((gint64)  0x8000000000000000)
1671 #define G_MAXINT64      ((gint64)  0x7fffffffffffffff)
1672 #define G_MAXUINT64     ((guint64) 0xffffffffffffffff)
1673
1674 _______EOF
1675
1676
1677         ### this should always be true in a modern C/C++ compiler
1678         cat >>$outfile <<_______EOF
1679 typedef signed char gint8;
1680 typedef unsigned char guint8;
1681 _______EOF
1682
1683
1684         if test -n "$gint16"; then
1685           cat >>$outfile <<_______EOF
1686 typedef signed $gint16 gint16;
1687 typedef unsigned $gint16 guint16;
1688 #define G_GINT16_FORMAT $gint16_format
1689 #define G_GUINT16_FORMAT $guint16_format
1690 _______EOF
1691         fi
1692
1693
1694         if test -n "$gint32"; then
1695           cat >>$outfile <<_______EOF
1696 typedef signed $gint32 gint32;
1697 typedef unsigned $gint32 guint32;
1698 #define G_GINT32_FORMAT $gint32_format
1699 #define G_GUINT32_FORMAT $guint32_format
1700 _______EOF
1701         fi
1702
1703         cat >>$outfile <<_______EOF
1704 #define G_HAVE_GINT64 1          /* deprecated, always true */
1705
1706 ${glib_extension}typedef signed $gint64 gint64;
1707 ${glib_extension}typedef unsigned $gint64 guint64;
1708
1709 #define G_GINT64_CONSTANT(val)  $gint64_constant
1710
1711 #define G_GINT64_FORMAT $gint64_format
1712 #define G_GUINT64_FORMAT $guint64_format
1713 _______EOF
1714
1715         cat >>$outfile <<_______EOF
1716
1717 #define GLIB_SIZEOF_VOID_P $glib_void_p
1718 #define GLIB_SIZEOF_LONG   $glib_long
1719
1720 _______EOF
1721
1722         case x$glib_size_t in
1723         x2) echo "typedef gint16  gssize;" >> $outfile
1724             echo "typedef guint16 gsize;"  >> $outfile
1725             ;;
1726         x4) echo "typedef gint32  gssize;" >> $outfile
1727             echo "typedef guint32 gsize;"  >> $outfile
1728             ;;
1729         x8) echo "typedef gint64  gssize;" >> $outfile
1730             echo "typedef guint64 gsize;"  >> $outfile
1731             ;;
1732         *)  echo "#error size of size_t is unknown" >> $outfile
1733             ;;
1734         esac
1735
1736         if test -z "$glib_unknown_void_p"; then
1737           cat >>$outfile <<_______EOF
1738
1739 #define GPOINTER_TO_INT(p)      ((gint)  ${glib_gpi_cast} (p))
1740 #define GPOINTER_TO_UINT(p)     ((guint) ${glib_gpui_cast} (p))
1741
1742 #define GINT_TO_POINTER(i)      ((gpointer) ${glib_gpi_cast} (i))
1743 #define GUINT_TO_POINTER(u)     ((gpointer) ${glib_gpui_cast} (u))
1744 _______EOF
1745         else
1746           echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
1747         fi
1748
1749
1750
1751         cat >>$outfile <<_______EOF
1752 $glib_atexit
1753 $glib_memmove
1754 $glib_defines
1755 $glib_os
1756
1757 $glib_vacopy
1758
1759 #ifdef  __cplusplus
1760 #define G_HAVE_INLINE   1
1761 #else   /* !__cplusplus */
1762 $glib_inline
1763 #endif  /* !__cplusplus */
1764
1765 _______EOF
1766
1767         if test x$g_have_iso_c_varargs = xyes ; then
1768                 cat >>$outfile <<_______EOF
1769 #ifndef __cplusplus
1770 # define G_HAVE_ISO_VARARGS 1
1771 #endif
1772 _______EOF
1773         fi
1774         if test x$g_have_iso_cxx_varargs = xyes ; then
1775                 cat >>$outfile <<_______EOF
1776 #ifdef __cplusplus
1777 # define G_HAVE_ISO_VARARGS 1
1778 #endif
1779 _______EOF
1780         fi
1781         if test x$g_have_gnuc_varargs = xyes ; then
1782                 cat >>$outfile <<_______EOF
1783
1784 #define G_HAVE_GNUC_VARARGS 1
1785 _______EOF
1786         fi
1787
1788         echo >>$outfile
1789         if test x$g_have_eilseq = xno; then
1790                 cat >>$outfile <<_______EOF
1791 #ifndef EILSEQ
1792 /* On some systems, like SunOS and NetBSD, EILSEQ is not defined.
1793  * The correspondence between this and the corresponding definition
1794  * in libiconv is essential.
1795  */
1796 #  define EILSEQ ENOENT
1797 #endif
1798 _______EOF
1799
1800         fi
1801
1802         echo >>$outfile
1803         if test x$g_mutex_has_default = xyes; then
1804                 cat >>$outfile <<_______EOF
1805 $g_enable_threads_def G_THREADS_ENABLED
1806 #define G_THREADS_IMPL_$g_threads_impl_def
1807 typedef struct _GStaticMutex GStaticMutex;
1808 struct _GStaticMutex
1809 {
1810   struct _GMutex *runtime_mutex;
1811   union {
1812     char   pad[$g_mutex_sizeof];
1813     double dummy_double;
1814     void  *dummy_pointer;
1815     long   dummy_long;
1816   } static_mutex;
1817 };
1818 #define G_STATIC_MUTEX_INIT     { NULL, { { $g_mutex_contents} } }
1819 #define g_static_mutex_get_mutex(mutex) \
1820   (g_thread_use_default_impl ? ((GMutex*) &((mutex)->static_mutex)) : \
1821    g_static_mutex_get_mutex_impl (&((mutex)->runtime_mutex)))
1822 _______EOF
1823         else
1824                 cat >>$outfile <<_______EOF
1825 $g_enable_threads_def G_THREADS_ENABLED
1826 #define G_THREADS_IMPL_$g_threads_impl_def
1827 typedef struct _GMutex* GStaticMutex;
1828 #define G_STATIC_MUTEX_INIT NULL
1829 #define g_static_mutex_get_mutex(mutex) (g_static_mutex_get_mutex_impl (mutex))
1830 _______EOF
1831         fi
1832
1833         cat >>$outfile <<_______EOF
1834 /* This represents a system thread as used by the implementation. An
1835  * alien implementaion, as loaded by g_thread_init can only count on
1836  * "sizeof (gpointer)" bytes to store their info. We however need more
1837  * for some of our native implementations. */
1838 typedef union _GSystemThread GSystemThread;
1839 union _GSystemThread
1840 {
1841   char   data[$g_system_thread_sizeof];
1842   double dummy_double;
1843   void  *dummy_pointer;
1844   long   dummy_long;
1845 };
1846 _______EOF
1847
1848         echo >>$outfile
1849         g_bit_sizes="16 32 64"
1850         for bits in $g_bit_sizes; do
1851           cat >>$outfile <<_______EOF
1852 #define GINT${bits}_TO_${g_bs_native}(val)      ((gint${bits}) (val))
1853 #define GUINT${bits}_TO_${g_bs_native}(val)     ((guint${bits}) (val))
1854 #define GINT${bits}_TO_${g_bs_alien}(val)       ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
1855 #define GUINT${bits}_TO_${g_bs_alien}(val)      (GUINT${bits}_SWAP_LE_BE (val))
1856 _______EOF
1857         done
1858
1859         cat >>$outfile <<_______EOF
1860 #define GLONG_TO_LE(val)        ((glong) GINT${glongbits}_TO_LE (val))
1861 #define GULONG_TO_LE(val)       ((gulong) GUINT${glongbits}_TO_LE (val))
1862 #define GLONG_TO_BE(val)        ((glong) GINT${glongbits}_TO_BE (val))
1863 #define GULONG_TO_BE(val)       ((gulong) GUINT${glongbits}_TO_BE (val))
1864 #define GINT_TO_LE(val)         ((gint) GINT${gintbits}_TO_LE (val))
1865 #define GUINT_TO_LE(val)        ((guint) GUINT${gintbits}_TO_LE (val))
1866 #define GINT_TO_BE(val)         ((gint) GINT${gintbits}_TO_BE (val))
1867 #define GUINT_TO_BE(val)        ((guint) GUINT${gintbits}_TO_BE (val))
1868 #define G_BYTE_ORDER $g_byte_order
1869
1870 _______EOF
1871
1872         if test -r glibconfig-sysdefs.h; then
1873           cat glibconfig-sysdefs.h >>$outfile
1874         fi
1875
1876         cat >>$outfile <<_______EOF
1877
1878 #define G_MODULE_SUFFIX "$g_module_suffix"
1879
1880 G_END_DECLS
1881
1882 #endif /* GLIBCONFIG_H */
1883 _______EOF
1884
1885
1886         if cmp -s $outfile glibconfig.h; then
1887           echo glibconfig.h is unchanged
1888           rm -f $outfile
1889         else
1890           mv $outfile glibconfig.h
1891         fi ;;
1892 esac
1893 ],[
1894
1895 # Note that if two cases are the same, case goes with the first one.
1896 # Note also that this is inside an AC_OUTPUT_COMMAND.  We do not depend
1897 # on variable expansion in case labels.  Look at the generated config.status
1898 # for a hint.
1899
1900 if test "x${ac_cv_working_alloca_h+set}" = xset ; then
1901   glib_header_alloca_h="$ac_cv_working_alloca_h"
1902 else
1903   glib_header_alloca_h="$ac_cv_header_alloca_h"
1904 fi
1905
1906 case xyes in
1907 x$ac_cv_header_float_h)
1908   glib_float_h=yes
1909   glib_mf=FLT_MIN glib_Mf=FLT_MAX
1910   glib_md=DBL_MIN glib_Md=DBL_MAX
1911   ;;
1912 x$ac_cv_header_values_h)
1913   glib_values_h=yes
1914   glib_mf=MINFLOAT  glib_Mf=MAXFLOAT
1915   glib_md=MINDOUBLE glib_Md=MAXDOUBLE
1916   ;;
1917 esac
1918
1919 case xyes in
1920 x$ac_cv_header_limits_h)
1921   glib_limits_h=yes
1922   glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
1923   glib_mi=INT_MIN  glib_Mi=INT_MAX  glib_Mui=UINT_MAX
1924   glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
1925   ;;
1926 x$ac_cv_header_values_h)
1927   glib_values_h=yes
1928   glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
1929   glib_mi=MININT   glib_Mi=MAXINT   glib_Mui="(((guint)G_MAXINT)*2+1)"
1930   glib_ml=MINLONG  glib_Ml=MAXLONG  glib_Mul="(((gulong)G_MAXLONG)*2+1)"
1931   ;;
1932 esac
1933
1934 if test x$ac_cv_header_sys_poll_h = xyes ; then
1935   glib_sys_poll_h=yes
1936 fi
1937
1938 case 2 in
1939 $ac_cv_sizeof_short)
1940   gint16=short
1941   gint16_format='"hi"'
1942   guint16_format='"hu"'
1943   ;;
1944 $ac_cv_sizeof_int)
1945   gint16=int
1946   gint16_format='"i"'
1947   guint16_format='"u"'
1948   ;;
1949 esac
1950 case 4 in
1951 $ac_cv_sizeof_short)
1952   gint32=short
1953   gint32_format='"hi"'
1954   guint32_format='"hu"'
1955   ;;
1956 $ac_cv_sizeof_int)
1957   gint32=int
1958   gint32_format='"i"'
1959   guint32_format='"u"'
1960   ;;
1961 $ac_cv_sizeof_long)
1962   gint32=long
1963   gint32_format='"li"'
1964   guint32_format='"lu"'
1965   ;;
1966 esac
1967 case 8 in
1968 $ac_cv_sizeof_int)
1969   gint64=int
1970   gint64_format='"i"'
1971   guint64_format='"u"'
1972   glib_extension=
1973   gint64_constant='(val)'
1974   ;;
1975 $ac_cv_sizeof_long)
1976   gint64=long
1977   gint64_format='"li"'
1978   guint64_format='"lu"'
1979   glib_extension=
1980   gint64_constant='(val##L)'
1981   ;;
1982 $ac_cv_sizeof_long_long)
1983   gint64='long long'
1984   if test -n "$glib_cv_long_long_format"; then
1985     gint64_format='"'$glib_cv_long_long_format'i"'
1986     guint64_format='"'$glib_cv_long_long_format'u"'
1987   fi
1988   glib_extension='G_GNUC_EXTENSION '
1989   gint64_constant='(G_GNUC_EXTENSION (val##LL))'
1990   ;;
1991 $ac_cv_sizeof___int64)
1992   gint64='__int64'
1993   if test -n "$glib_cv_long_long_format"; then
1994     gint64_format='"'$glib_cv_long_long_format'i"'
1995     guint64_format='"'$glib_cv_long_long_format'u"'
1996   fi
1997   glib_extension=
1998   gint64_constant='(val##i64)'
1999   ;;
2000 esac
2001 glib_size_t=$glib_cv_sizeof_size_t
2002 glib_void_p=$ac_cv_sizeof_long
2003 glib_long=$ac_cv_sizeof_void_p
2004
2005 gintbits=`expr $ac_cv_sizeof_int \* 8`
2006 glongbits=`expr $ac_cv_sizeof_long \* 8`
2007
2008
2009 case $ac_cv_sizeof_void_p in
2010 $ac_cv_sizeof_int)      glib_gpi_cast=''        glib_gpui_cast=''         ;;
2011 $ac_cv_sizeof_long)     glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
2012 *)                      glib_unknown_void_p=yes ;;
2013 esac
2014
2015
2016 case xyes in
2017 x$ac_cv_func_atexit)
2018   glib_atexit="
2019 #ifdef NeXT /* @#%@! NeXTStep */
2020 # define g_ATEXIT(proc) (!atexit (proc))
2021 #else
2022 # define g_ATEXIT(proc) (atexit (proc))
2023 #endif"
2024   ;;
2025 x$ac_cv_func_on_exit)
2026   glib_atexit="
2027 #define g_ATEXIT(proc)  (on_exit ((void (*)(int, void*))(proc), NULL))"
2028   ;;
2029 esac
2030
2031 case xyes in
2032 x$ac_cv_func_memmove)
2033   glib_memmove='
2034 #define g_memmove(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END'
2035   ;;
2036 x$glib_cv_working_bcopy)
2037   glib_memmove="
2038 /* memmove isn't available, but bcopy can copy overlapping memory regions */
2039 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
2040   ;;
2041 *)
2042   glib_memmove="
2043 /* memmove isn't found and bcopy can't copy overlapping memory regions,
2044  * so we have to roll our own copy routine. */
2045 void g_memmove (void* dest, const void * src, unsigned long len);"
2046   ;;
2047 esac
2048
2049 glib_defines="
2050 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
2051 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
2052 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
2053 "
2054
2055 case xyes in
2056 x$glib_cv_va_copy)      glib_vacopy='#define G_VA_COPY  va_copy' ;;
2057 x$glib_cv___va_copy)    glib_vacopy='#define G_VA_COPY  __va_copy' ;;
2058 *)                      glib_vacopy=''
2059 esac
2060
2061 if test x$glib_cv_va_val_copy = xno; then
2062   glib_vacopy="\$glib_vacopy
2063 #define G_VA_COPY_AS_ARRAY 1"
2064 fi
2065
2066 if test x$glib_cv_hasinline = xyes; then
2067     glib_inline='#define G_HAVE_INLINE 1'
2068 fi
2069 if test x$glib_cv_has__inline = xyes; then
2070     glib_inline="\$glib_inline
2071 #define G_HAVE___INLINE 1"
2072 fi
2073 if test x$glib_cv_has__inline__ = xyes; then
2074     glib_inline="\$glib_inline
2075 #define G_HAVE___INLINE__ 1"
2076 fi
2077
2078 g_have_gnuc_varargs=$g_have_gnuc_varargs
2079 g_have_iso_c_varargs=$g_have_iso_c_varargs
2080 g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
2081
2082 case xyes in
2083 x$ac_cv_c_bigendian)
2084   g_byte_order=G_BIG_ENDIAN
2085   g_bs_native=BE
2086   g_bs_alien=LE
2087   ;;
2088 *)
2089   g_byte_order=G_LITTLE_ENDIAN
2090   g_bs_native=LE
2091   g_bs_alien=BE
2092   ;;
2093 esac
2094
2095 g_have_eilseq=$have_eilseq
2096
2097 case x$have_threads in
2098 xnone)  g_enable_threads_def="#undef";;
2099 *)      g_enable_threads_def="#define";;
2100 esac
2101
2102 g_threads_impl_def=$g_threads_impl
2103
2104 g_mutex_has_default="$mutex_has_default"
2105 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
2106 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
2107 g_mutex_contents="$glib_cv_byte_contents_gmutex"
2108
2109 g_module_suffix="$glib_gmodule_suffix"
2110
2111 case $host in
2112   *-*-beos*)
2113     glib_os="#define G_OS_BEOS"
2114     ;;
2115   *-*-cygwin*)
2116     glib_os="#define G_OS_UNIX
2117 #define G_PLATFORM_WIN32
2118 #define G_WITH_CYGWIN"
2119     ;;
2120   *-*-mingw*)
2121     glib_os="#define G_OS_WIN32
2122 #define G_PLATFORM_WIN32"
2123     ;;
2124   *)
2125     glib_os="#define G_OS_UNIX"
2126     ;;
2127 esac
2128 ])
2129
2130 AC_OUTPUT([
2131 glib-2.0.pc
2132 glib-2.0-uninstalled.pc
2133 gmodule-2.0.pc
2134 gmodule-2.0-uninstalled.pc
2135 gthread-2.0.pc
2136 gthread-2.0-uninstalled.pc
2137 gobject-2.0.pc
2138 gobject-2.0-uninstalled.pc
2139 glib.spec
2140 Makefile
2141 build/Makefile
2142 build/win32/Makefile
2143 build/win32/dirent/Makefile
2144 glib/Makefile
2145 glib/libcharset/Makefile
2146 gmodule/gmoduleconf.h
2147 gmodule/Makefile
2148 gobject/Makefile
2149 gthread/Makefile
2150 po/Makefile.in
2151 docs/Makefile
2152 docs/reference/Makefile
2153 docs/reference/glib/Makefile
2154 docs/reference/gobject/Makefile
2155 tests/Makefile
2156 m4macros/Makefile
2157 ],[echo ""
2158 echo " *** IMPORTANT *** "
2159 echo ""
2160 echo "This is a development version of GLib.  You should be using a stable"
2161 echo "version, which is available at ftp://ftp.gtk.org/pub/gtk/v1.2/.  The"
2162 echo "version you just configured is meant for developers of GLib only:"
2163 echo ""
2164 echo "  * You should not base stable software on this version of GLib."
2165 echo "  * GNOME developers should use a stable version of GLib."
2166 echo ""
2167 echo " *** You should be using GLib 1.2 instead. ***"
2168 ])