configure.in

   1 # Process this file with autoconf to produce a configure script.
   2 AC_INIT(glist.c)
   3
   4 # Save this value here, since automake will set cflags later
   5 cflags_set=${CFLAGS+set}
   6
   7 # The following version number definitions apply to GLib and GModule
   8 # as a whole, so if changes occoured in either of them, they are both
   9 # treated with the same interface and binary age.
  10 #
  11 # Making releases:
  12 #   GLIB_MICRO_VERSION += 1;
  13 #   GLIB_INTERFACE_AGE += 1;
  14 #   GLIB_BINARY_AGE += 1;
  15 # if any functions have been added, set GLIB_INTERFACE_AGE to 0.
  16 # if backwards compatibility has been broken,
  17 # set GLIB_BINARY_AGE and GLIB_INTERFACE_AGE to 0.
  18 #
  19 GLIB_MAJOR_VERSION=1
  20 GLIB_MINOR_VERSION=1
  21 GLIB_MICRO_VERSION=5
  22 GLIB_INTERFACE_AGE=0
  23 GLIB_BINARY_AGE=0
  24 GLIB_VERSION=$GLIB_MAJOR_VERSION.$GLIB_MINOR_VERSION.$GLIB_MICRO_VERSION
  25 AC_SUBST(GLIB_VERSION)
  26
  27 # libtool versioning
  28 LT_RELEASE=$GLIB_MAJOR_VERSION.$GLIB_MINOR_VERSION
  29 LT_CURRENT=`expr $GLIB_MICRO_VERSION - $GLIB_INTERFACE_AGE`
  30 LT_REVISION=$GLIB_INTERFACE_AGE
  31 LT_AGE=`expr $GLIB_BINARY_AGE - $GLIB_INTERFACE_AGE`
  32 AC_SUBST(LT_RELEASE)
  33 AC_SUBST(LT_CURRENT)
  34 AC_SUBST(LT_REVISION)
  35 AC_SUBST(LT_AGE)
  36
  37 VERSION=$GLIB_VERSION
  38 PACKAGE=glib
  39
  40 AM_INIT_AUTOMAKE($PACKAGE, $VERSION, no-define)
  41
  42 # Specify a configuration file
  43 AM_CONFIG_HEADER(config.h)
  44
  45 AC_DEFINE_UNQUOTED(GLIB_MAJOR_VERSION, $GLIB_MAJOR_VERSION)
  46 AC_DEFINE_UNQUOTED(GLIB_MINOR_VERSION, $GLIB_MINOR_VERSION)
  47 AC_DEFINE_UNQUOTED(GLIB_MICRO_VERSION, $GLIB_MICRO_VERSION)
  48 AC_DEFINE_UNQUOTED(GLIB_INTERFACE_AGE, $GLIB_INTERFACE_AGE)
  49 AC_DEFINE_UNQUOTED(GLIB_BINARY_AGE, $GLIB_BINARY_AGE)
  50
  51 dnl Initialize libtool
  52 AM_PROG_LIBTOOL
  53
  54 dnl Initialize maintainer mode
  55 AM_MAINTAINER_MODE
  56
  57 AC_CANONICAL_HOST
  58
  59 AC_ARG_ENABLE(debug, [  --enable-debug=[no/minimum/yes] turn on debugging [default=minimum]],,enable_debug=minimum)
  60 AC_ARG_ENABLE(mem_check, [  --enable-mem-check=[no/yes] turn on malloc/free sanity checking [default=no]],,enable_mem_check=no)
  61 AC_ARG_ENABLE(mem_profile, [  --enable-mem-profile=[no/yes] turn on malloc profiling atexit [default=no]],,enable_mem_profile=no)
  62
  63 AC_ARG_ENABLE(ansi, [  --enable-ansi           turn on strict ansi [default=no]],
  64                     , enable_ansi=no)
  65
  66 AC_MSG_CHECKING(whether to enable memory checking)
  67 if test "x$enable_mem_check" = "xyes"; then
  68   AC_DEFINE(ENABLE_MEM_CHECK, 1)
  69   AC_SUBST(ENABLE_MEM_CHECK)
  70   AC_MSG_RESULT(yes)
  71 else
  72   AC_MSG_RESULT(no)
  73 fi
  74
  75 AC_MSG_CHECKING(whether to enable memory profiling)
  76 if test "x$enable_mem_profile" = "xyes"; then
  77   AC_DEFINE(ENABLE_MEM_PROFILE, 1)
  78   AC_SUBST(ENABLE_MEM_PROFILE)
  79   AC_MSG_RESULT(yes)
  80 else
  81   AC_MSG_RESULT(no)
  82 fi
  83
  84 if test "x$enable_debug" = "xyes"; then
  85   test "$cflags_set" = set || CFLAGS="$CFLAGS -g"
  86   GLIB_DEBUG_FLAGS="-DG_ENABLE_DEBUG"
  87 else
  88   if test "x$enable_debug" = "xno"; then
  89     GLIB_DEBUG_FLAGS="-DG_DISABLE_ASSERT -DG_DISABLE_CHECKS"
  90   fi
  91 fi
  92
  93 AC_DEFINE_UNQUOTED(G_COMPILED_WITH_DEBUGGING, "${enable_debug}")
  94
  95 # Checks for programs.
  96 AC_PROG_CC
  97 AM_PROG_CC_STDC
  98 AC_PROG_INSTALL
  99
 100 changequote(,)dnl
 101 if test "x$GCC" = "xyes"; then
 102   case " $CFLAGS " in
 103   *[\ \ ]-Wall[\ \      ]*) ;;
 104   *) CFLAGS="$CFLAGS -Wall" ;;
 105   esac
 106
 107   if test "x$enable_ansi" = "xyes"; then
 108     case " $CFLAGS " in
 109     *[\ \       ]-ansi[\ \      ]*) ;;
 110     *) CFLAGS="$CFLAGS -ansi" ;;
 111     esac
 112
 113     case " $CFLAGS " in
 114     *[\ \       ]-pedantic[\ \  ]*) ;;
 115     *) CFLAGS="$CFLAGS -pedantic" ;;
 116     esac
 117   fi
 118 fi
 119 changequote([,])dnl
 120
 121 dnl DU4 native cc currently needs -std1 for ANSI mode (instead of K&R)
 122 AC_MSG_CHECKING([for extra flags to get ANSI library prototypes])
 123 glib_save_LIBS=$LIBS
 124 LIBS="$LIBS -lm"
 125 AC_TRY_RUN([#include <math.h>
 126              int main (void) { return (log(1) != log(1.)); }],
 127      AC_MSG_RESULT(none needed),
 128      glib_save_CFLAGS=$CFLAGS
 129      CFLAGS="$CFLAGS -std1"
 130      AC_TRY_RUN([#include <math.h>
 131                  int main (void) { return (log(1) != log(1.)); }],
 132          AC_MSG_RESULT(-std1),
 133          AC_MSG_RESULT()
 134          CFLAGS=$glib_save_CFLAGS
 135          AC_MSG_WARN(
 136                 [No ANSI prototypes found in library. (-std1 didn't work.)])
 137      )
 138 )
 139 LIBS=$glib_save_LIBS
 140
 141 dnl NeXTStep cc seems to need this
 142 AC_MSG_CHECKING([for extra flags for POSIX compliance])
 143 AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
 144   AC_MSG_RESULT(none needed),
 145   glib_save_CFLAGS=$CFLAGS
 146   CFLAGS="$CFLAGS -posix"
 147   AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
 148     AC_MSG_RESULT(-posix),
 149     AC_MSG_RESULT()
 150     CFLAGS=$glib_save_CFLAGS
 151     AC_MSG_WARN([Could not determine POSIX flag. (-posix didn't work.)])))
 152
 153 # Checks for header files.
 154 AC_HEADER_STDC
 155
 156 # Checks for library functions.
 157 AC_FUNC_VPRINTF
 158
 159 AC_CHECK_FUNCS(atexit on_exit)
 160
 161 AC_CHECK_SIZEOF(char)
 162 AC_CHECK_SIZEOF(short)
 163 AC_CHECK_SIZEOF(long)
 164 AC_CHECK_SIZEOF(int)
 165 AC_CHECK_SIZEOF(void *)
 166 AC_CHECK_SIZEOF(long long)
 167
 168 dnl long doubles were not used, and a portability problem
 169 dnl AC_C_LONG_DOUBLE
 170 AC_C_CONST
 171
 172 dnl AC_C_INLINE is useless to us since it bails out too early, we need to
 173 dnl truely know which ones of `inline', `__inline' and `__inline__' are
 174 dnl actually supported.
 175 AC_MSG_CHECKING(for __inline)
 176 AC_CACHE_VAL(glib_cv_has__inline,[
 177         AC_TRY_RUN([
 178         __inline int foo () { return 0; }
 179         int main () { return foo (); }
 180         ],
 181         glib_cv_has__inline=yes
 182         ,
 183         glib_cv_has__inline=no
 184         ,)
 185 ])
 186 AC_MSG_RESULT($glib_cv_has__inline)
 187 case x$glib_cv_has__inline in
 188 xyes) AC_DEFINE(G_HAVE___INLINE)
 189 esac
 190 AC_MSG_CHECKING(for __inline__)
 191 AC_CACHE_VAL(glib_cv_has__inline__,[
 192         AC_TRY_RUN([
 193         __inline__ int foo () { return 0; }
 194         int main () { return foo (); }
 195         ],
 196         glib_cv_has__inline__=yes
 197         ,
 198         glib_cv_has__inline__=no
 199         ,)
 200 ])
 201 AC_MSG_RESULT($glib_cv_has__inline__)
 202 case x$glib_cv_has__inline__ in
 203 xyes) AC_DEFINE(G_HAVE___INLINE__)
 204 esac
 205 AC_MSG_CHECKING(for inline)
 206 AC_CACHE_VAL(glib_cv_hasinline,[
 207         AC_TRY_RUN([
 208         inline int foo () { return 0; }
 209         int main () { return foo (); }
 210         ],
 211         glib_cv_hasinline=yes
 212         ,
 213         glib_cv_hasinline=no
 214         ,)
 215 ])
 216 AC_MSG_RESULT($glib_cv_hasinline)
 217 case x$glib_cv_hasinline in
 218 xyes) AC_DEFINE(G_HAVE_INLINE)
 219 esac
 220
 221 dnl for bytesex stuff
 222 AC_C_BIGENDIAN
 223
 224 dnl header file checks
 225 AC_CHECK_HEADERS(float.h, AC_DEFINE(HAVE_FLOAT_H))
 226 AC_CHECK_HEADERS(limits.h, AC_DEFINE(HAVE_LIMITS_H))
 227 AC_CHECK_HEADERS(pwd.h, AC_DEFINE(HAVE_PWD_H))
 228 AC_CHECK_HEADERS(sys/param.h, AC_DEFINE(HAVE_SYS_PARAM_H))
 229 AC_CHECK_HEADERS(sys/select.h, AC_DEFINE(HAVE_SYS_SELECT_H))
 230 AC_CHECK_HEADERS(sys/time.h, AC_DEFINE(HAVE_SYS_TIME_H))
 231 AC_CHECK_HEADERS(sys/times.h, AC_DEFINE(HAVE_SYS_TIMES_H))
 232 AC_CHECK_HEADERS(unistd.h, AC_DEFINE(HAVE_UNISTD_H))
 233 AC_CHECK_HEADERS(values.h, AC_DEFINE(HAVE_VALUES_H))
 234
 235 # Check for some functions
 236 AC_CHECK_FUNCS(lstat strerror strsignal memmove vsnprintf strcasecmp strncasecmp)
 237
 238 # Check for sys_errlist
 239 AC_MSG_CHECKING(for sys_errlist)
 240 AC_TRY_LINK(, [
 241 extern char *sys_errlist[];
 242 extern int sys_nerr;
 243 sys_errlist[sys_nerr-1][0] = 0;
 244 ], glib_ok=yes, glib_ok=no)
 245 AC_MSG_RESULT($glib_ok)
 246 if test $glib_ok = no; then
 247     AC_DEFINE(NO_SYS_ERRLIST)
 248 fi
 249
 250 # Check for sys_siglist
 251 AC_MSG_CHECKING(for sys_siglist)
 252 AC_TRY_LINK(, [
 253 extern char *sys_siglist[];
 254 sys_siglist[1][0] = 0;
 255 ], glib_ok=yes, glib_ok=no)
 256 AC_MSG_RESULT($glib_ok)
 257 if test $glib_ok = no; then
 258     AC_DEFINE(NO_SYS_SIGLIST)
 259 fi
 260
 261 # Check if <sys/select.h> needs to be included for fd_set
 262 AC_MSG_CHECKING([for fd_set])
 263 AC_TRY_COMPILE([#include <sys/types.h>],
 264         [fd_set readMask, writeMask;], gtk_ok=yes, gtk_ok=no)
 265 if test $gtk_ok = yes; then
 266     AC_MSG_RESULT([yes, found in sys/types.h])
 267 else
 268     AC_HEADER_EGREP(fd_mask, sys/select.h, gtk_ok=yes)
 269     if test $gtk_ok = yes; then
 270         AC_DEFINE(HAVE_SYS_SELECT_H)
 271         AC_MSG_RESULT([yes, found in sys/select.h])
 272     else
 273         AC_DEFINE(NO_FD_SET)
 274         AC_MSG_RESULT(no)
 275     fi
 276 fi
 277
 278 # These are used only in GDK (gdki18n.h)
 279 # This stuff is here only so that we can define these
 280 # things in glibconfig.h. If gtk+ started using an installed
 281 # gdkconfig.h file, then the definitions would belong there.
 282
 283 # Check for wchar.h
 284
 285 AC_MSG_CHECKING(for wchar.h)
 286 AC_TRY_CPP([#include <wchar.h>], glib_wchar_h=yes, glib_wchar_h=no)
 287 if test $glib_wchar_h = yes; then
 288    AC_DEFINE(HAVE_WCHAR_H)
 289 fi
 290 AC_MSG_RESULT($glib_wchar_h)
 291
 292 # Check for wctype.h (for iswalnum)
 293
 294 AC_MSG_CHECKING(for wctype.h)
 295 AC_TRY_CPP([#include <wctype.h>], glib_wctype_h=yes, glib_wctype_h=no)
 296 if test $glib_wctype_h = yes; then
 297    AC_DEFINE(HAVE_WCTYPE_H)
 298 fi
 299 AC_MSG_RESULT($glib_wctype_h)
 300
 301 oLIBS="$LIBS"
 302 # in Solaris 2.5, `iswalnum' is in -lw
 303 AC_CHECK_FUNC(iswalnum,,[AC_CHECK_LIB(w,iswalnum)])
 304
 305 # The following is necessary for Linux libc-5.4.38
 306 AC_MSG_CHECKING(if iswalnum() and friends are properly defined)
 307 AC_TRY_LINK([#include <stdlib.h>],[
 308 #if (defined(HAVE_WCTYPE_H) || defined(HAVE_WCHAR_H))
 309 #  ifdef HAVE_WCTYPE_H
 310 #    include <wctype.h>
 311 #  else
 312 #    ifdef HAVE_WCHAR_H
 313 #      include <wchar.h>
 314 #    endif
 315 #  endif
 316 #else
 317 #  define iswalnum(c) ((wchar_t)(c) <= 0xFF && isalnum(c))
 318 #endif
 319 iswalnum((wchar_t) 0);
 320 ], glib_working_wctype=yes, glib_working_wctype=no)
 321 LIBS="$oLIBS"
 322
 323 if test $glib_working_wctype = no; then
 324    AC_DEFINE(HAVE_BROKEN_WCTYPE)
 325 fi
 326 AC_MSG_RESULT($glib_working_wctype)
 327
 328
 329 dnl **********************
 330 dnl *** va_copy checks ***
 331 dnl **********************
 332 dnl we currently check for all three va_copy possibilities, so we get
 333 dnl all results in config.log for bug reports.
 334 AC_MSG_CHECKING(for an implementation of va_copy())
 335 AC_CACHE_VAL(glib_cv_va_copy,[
 336         AC_TRY_RUN([
 337         #include <stdarg.h>
 338         void f (int i, ...) {
 339         va_list args1, args2;
 340         va_start (args1, i);
 341         va_copy (args2, args1);
 342         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
 343           exit (1);
 344         va_end (args1); va_end (args2);
 345         }
 346         int main() {
 347           f (0, 42);
 348           return 0;
 349         }],
 350         glib_cv_va_copy=yes
 351         ,
 352         glib_cv_va_copy=no
 353         ,)
 354 ])
 355 AC_MSG_RESULT($glib_cv_va_copy)
 356 AC_MSG_CHECKING(for an implementation of __va_copy())
 357 AC_CACHE_VAL(glib_cv___va_copy,[
 358         AC_TRY_RUN([
 359         #include <stdarg.h>
 360         void f (int i, ...) {
 361         va_list args1, args2;
 362         va_start (args1, i);
 363         __va_copy (args2, args1);
 364         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
 365           exit (1);
 366         va_end (args1); va_end (args2);
 367         }
 368         int main() {
 369           f (0, 42);
 370           return 0;
 371         }],
 372         glib_cv___va_copy=yes
 373         ,
 374         glib_cv___va_copy=no
 375         ,)
 376 ])
 377 AC_MSG_RESULT($glib_cv___va_copy)
 378 AC_MSG_CHECKING(whether va_lists can be copied by value)
 379 AC_CACHE_VAL(glib_cv_va_val_copy,[
 380         AC_TRY_RUN([
 381         #include <stdarg.h>
 382         void f (int i, ...) {
 383         va_list args1, args2;
 384         va_start (args1, i);
 385         args2 = args1;
 386         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
 387           exit (1);
 388         va_end (args1); va_end (args2);
 389         }
 390         int main() {
 391           f (0, 42);
 392           return 0;
 393         }],
 394         glib_cv_va_val_copy=yes
 395         ,
 396         glib_cv_va_val_copy=no
 397         ,)
 398 ])
 399 if test "x$glib_cv_va_copy" = "xyes"; then
 400   AC_DEFINE(G_VA_COPY, va_copy)
 401 else if test "x$glib_cv___va_copy" = "xyes"; then
 402   AC_DEFINE(G_VA_COPY, __va_copy)
 403 fi
 404 fi
 405 if test "x$glib_cv_va_val_copy" = "xno"; then
 406   AC_DEFINE(G_VA_COPY_AS_ARRAY)
 407 fi
 408 AC_MSG_RESULT($glib_cv_va_val_copy)
 409
 410
 411 dnl ***********************
 412 dnl *** g_module checks ***
 413 dnl ***********************
 414 G_MODULE_LIBS=
 415 G_MODULE_LDFLAGS=
 416 G_MODULE_IMPL=
 417 G_MODULE_NEED_USCORE=0
 418 G_MODULE_HAVE_DLERROR=0
 419 dnl *** dlopen() in system libraries
 420 if test -z "$G_MODULE_IMPL"; then
 421         AC_CHECK_FUNC(dlopen,
 422                 G_MODULE_IMPL=G_MODULE_IMPL_DL
 423         ,)
 424 fi
 425 dnl *** dlopen() in libdl
 426 if test -z "$G_MODULE_IMPL"; then
 427         AC_CHECK_LIB(dl, dlopen,
 428                 G_MODULE_LIBS=-ldl
 429                 G_MODULE_IMPL=G_MODULE_IMPL_DL
 430         ,)
 431 fi
 432 dnl *** shl_load() in libdld (HP-UX)
 433 if test -z "$G_MODULE_IMPL"; then
 434         AC_MSG_CHECKING(how to export all symbols)
 435         SAVED_LDFLAGS=$LDFLAGS
 436         LDFLAGS="$LDFLAGS -Wl,-E"
 437         AC_TRY_LINK(,[ return 0; ],
 438                 [ G_MODULE_LDFLAGS="-Wl,-E" ],[
 439                 LDFLAGS="$SAVED_LDFLAGS -bexpall"
 440                 AC_TRY_LINK(,[ return 0; ],
 441                         G_MODULE_LDFLAGS="-bexpall",
 442                         G_MODULE_LDFLAGS="none"
 443                 )
 444         ])
 445         LDFLAGS=$SAVED_LDFLAGS
 446         AC_MSG_RESULT($G_MODULE_LDFLAGS)
 447         if test "x$G_MODULE_LDFLAGS" = "xnone"; then
 448                 G_MODULE_LDFLAGS=
 449         fi
 450         AC_CHECK_LIB(dld, shl_load,
 451                 G_MODULE_LIBS=-ldld
 452                 G_MODULE_IMPL=G_MODULE_IMPL_DLD
 453         ,)
 454 fi
 455 dnl *** additional checks for G_MODULE_IMPL_DL
 456 if test "$G_MODULE_IMPL" = "G_MODULE_IMPL_DL"; then
 457         case "$host_os" in
 458           linux*)
 459             G_MODULE_LDFLAGS='-rdynamic'
 460             ;;
 461         esac
 462         LIBS_orig="$LIBS"
 463         LDFLAGS_orig="$LDFLAGS"
 464         LIBS="$LIBS $G_MODULE_LIBS"
 465         LDFLAGS="$LDFLAGS $G_MODULE_LDFLAGS"
 466 dnl *** check whether we need preceeding underscores
 467         AC_MSG_CHECKING(for preceeding underscore in symbols)
 468         AC_CACHE_VAL(glib_cv_uscore,[
 469                 AC_TRY_RUN([
 470                 #include <dlfcn.h>
 471                 int glib_underscore_test (void) { return 42; }
 472                 int main() {
 473                   void *f1 = (void*)0, *f2 = (void*)0, *handle;
 474                   handle = dlopen ((void*)0, 0);
 475                   if (handle) {
 476                     f1 = dlsym (handle, "glib_underscore_test");
 477                     f2 = dlsym (handle, "_glib_underscore_test");
 478                   } return (!f2 || f1);
 479                 }],
 480                         glib_cv_uscore=yes,
 481                         glib_cv_uscore=no,
 482                 )
 483                 rm -f plugin.c plugin.o plugin.lo
 484         ])
 485         AC_MSG_RESULT($glib_cv_uscore)
 486         if test "x$glib_cv_uscore" = "xyes"; then
 487                 G_MODULE_NEED_USCORE=1
 488         else
 489                 G_MODULE_NEED_USCORE=0
 490         fi
 491
 492         LDFLAGS="$LDFLAGS_orig"
 493 dnl *** check for having dlerror()
 494         AC_CHECK_FUNC(dlerror,
 495                 G_MODULE_HAVE_DLERROR=1,
 496                 G_MODULE_HAVE_DLERROR=0)
 497         LIBS="$LIBS_orig"
 498 fi
 499 dnl *** done, have e got an implementation?
 500 if test -z "$G_MODULE_IMPL"; then
 501         G_MODULE_IMPL=0
 502 fi
 503 AC_SUBST(G_MODULE_IMPL)
 504 AC_SUBST(G_MODULE_LIBS)
 505 AC_SUBST(G_MODULE_LDFLAGS)
 506 AC_SUBST(G_MODULE_HAVE_DLERROR)
 507 AC_SUBST(G_MODULE_NEED_USCORE)
 508 AC_SUBST(GLIB_DEBUG_FLAGS)
 509
 510 AC_OUTPUT_COMMANDS([
 511
 512 ## Generate `glibconfig.h' in two cases
 513 ## 1. `config.status' is run either explicitly, or via configure.
 514 ##     Esp. not when it is run in `Makefile' to generate makefiles and
 515 ##     config.h
 516 ## 2. CONFIG_OTHER is set explicitly
 517 ##
 518 ## Case 1 is difficult.  We know that `automake' sets one of
 519 ## CONFIG_FILES or CONFIG_HEADERS to empty.  This heuristic works
 520 ## only when AM_CONFIG_HEADER is set, however.
 521
 522 if test -n "${CONFIG_FILES}" && test -n "${CONFIG_HEADERS}"; then
 523   # Both CONFIG_FILES and CONFIG_HEADERS are non-empty ==> Case 1
 524   CONFIG_OTHER=${CONFIG_OTHER:-glibconfig.h}
 525 fi
 526 case "$CONFIG_OTHER" in
 527 *glibconfig.h*)
 528   echo creating glibconfig.h
 529   outfile=glibconfig.h-tmp
 530   cat > $outfile <<\outfile_EOF
 531 /* glibconfig.h */
 532 /* This is a generated file.  Please modify `configure.in' */
 533
 534 #ifndef GLIBCONFIG_H
 535 #define GLIBCONFIG_H
 536
 537 #ifdef __cplusplus
 538 extern "C" {
 539 #endif /* __cplusplus */
 540
 541 outfile_EOF
 542
 543   if test x$glib_limits_h = xyes; then
 544     echo '#include <limits.h>' >> $outfile
 545   fi
 546   if test x$glib_float_h = xyes; then
 547     echo '#include <float.h>' >> $outfile
 548   fi
 549   if test x$glib_values_h = xyes; then
 550     echo '#include <values.h>' >> $outfile
 551   fi
 552
 553   cat >> $outfile <<outfile_EOF
 554
 555 #define G_MINFLOAT $glib_mf
 556 #define G_MAXFLOAT $glib_Mf
 557 #define G_MINDOUBLE $glib_md
 558 #define G_MAXDOUBLE $glib_Md
 559 #define G_MINSHORT $glib_ms
 560 #define G_MAXSHORT $glib_Ms
 561 #define G_MININT $glib_mi
 562 #define G_MAXINT $glib_Mi
 563 #define G_MINLONG $glib_ml
 564 #define G_MAXLONG $glib_Ml
 565
 566 outfile_EOF
 567
 568   ## this should always be true in a modern C/C++ compiler
 569   cat >>$outfile <<outfile_EOF
 570 typedef signed char gint8;
 571 typedef unsigned char guint8;
 572 outfile_EOF
 573
 574   if test -n "$gint16"; then
 575     cat >>$outfile <<outfile_EOF
 576 typedef signed $gint16 gint16;
 577 typedef unsigned $gint16 guint16;
 578 outfile_EOF
 579   fi
 580   if test -n "$gint32"; then
 581     cat >>$outfile <<outfile_EOF
 582 typedef signed $gint32 gint32;
 583 typedef unsigned $gint32 guint32;
 584 outfile_EOF
 585   fi
 586   if test -n "$gint64"; then
 587     cat >>$outfile <<outfile_EOF
 588 ${glib_warning_guard}#define G_HAVE_GINT64 1
 589
 590 ${glib_extension}typedef signed $gint64 gint64;
 591 ${glib_extension}typedef unsigned $gint64 guint64;
 592
 593 #define G_GINT64_CONSTANT(val)  $gint64_constant
 594 outfile_EOF
 595   fi
 596
 597   if test -z "$glib_unknown_void_p"; then
 598     cat >>$outfile <<outfile_EOF
 599
 600 #define GPOINTER_TO_INT(p)      ((gint)${glib_gpi_cast}(p))
 601 #define GPOINTER_TO_UINT(p)     ((guint)${glib_gpui_cast}(p))
 602
 603 #define GINT_TO_POINTER(i)      ((gpointer)${glib_gpi_cast}(i))
 604 #define GUINT_TO_POINTER(u)     ((gpointer)${glib_gpui_cast}(u))
 605 outfile_EOF
 606   else
 607     echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
 608   fi
 609
 610   cat >>$outfile <<outfile_EOF
 611 $glib_atexit
 612 $glib_memmove
 613 $glib_defines
 614
 615 $glib_vacopy
 616
 617 $glib_inline
 618
 619 #define G_BYTE_ORDER $g_byte_order
 620 outfile_EOF
 621
 622   g_bit_sizes="16 32"
 623   if test -n "$gint64"; then
 624     g_bit_sizes="$g_bit_sizes 64"
 625   fi
 626
 627   for bits in $g_bit_sizes; do
 628     cat >>$outfile <<outfile_EOF
 629
 630 #define GINT${bits}_TO_${g_bs_native}(val)      ((gint${bits}) (val))
 631 #define GUINT${bits}_TO_${g_bs_native}(val)     ((guint${bits}) (val))
 632 #define GINT${bits}_TO_${g_bs_alien}(val)       ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
 633 #define GUINT${bits}_TO_${g_bs_alien}(val)      (GUINT${bits}_SWAP_LE_BE (val))
 634 outfile_EOF
 635 done
 636
 637   cat >>$outfile <<outfile_EOF
 638
 639 #define GLONG_TO_LE(val)        ((glong) GINT${glongbits}_TO_LE (val))
 640 #define GULONG_TO_LE(val)       ((gulong) GUINT${glongbits}_TO_LE (val))
 641 #define GLONG_TO_BE(val)        ((glong) GINT${glongbits}_TO_BE (val))
 642 #define GULONG_TO_BE(val)       ((gulong) GUINT${glongbits}_TO_BE (val))
 643
 644 #define GINT_TO_LE(val)         ((gint) GINT${gintbits}_TO_LE (val))
 645 #define GUINT_TO_LE(val)        ((guint) GUINT${gintbits}_TO_LE (val))
 646 #define GINT_TO_BE(val)         ((gint) GINT${gintbits}_TO_BE (val))
 647 #define GUINT_TO_BE(val)        ((guint) GUINT${gintbits}_TO_BE (val))
 648 $glib_wc
 649
 650 #ifdef __cplusplus
 651 }
 652 #endif /* __cplusplus */
 653
 654 #endif /* GLIBCONFIG_H */
 655
 656 outfile_EOF
 657
 658   if cmp -s $outfile glibconfig.h; then
 659     echo glibconfig.h is unchanged
 660     rm -f $outfile
 661   else
 662     mv $outfile glibconfig.h
 663   fi ;;
 664 esac
 665 ],[
 666
 667 # Note that if two cases are the same, case goes with the first one.
 668 # Note also that this is inside an AC_OUTPUT_COMMAND.  We do not depend
 669 # on variable expansion in case labels.  Look at the generated config.status
 670 # for a hint.
 671
 672 case xyes in
 673 x$ac_cv_header_float_h)
 674   glib_float_h=yes
 675   glib_mf=FLT_MIN glib_Mf=FLT_MAX
 676   glib_md=DBL_MIN glib_Md=DBL_MAX
 677   ;;
 678 x$ac_cv_header_values_h)
 679   glib_values_h=yes
 680   glib_mf=MINFLOAT  glib_Mf=MAXFLOAT
 681   glib_md=MINDOUBLE glib_Md=MAXDOUBLE
 682   ;;
 683 esac
 684
 685 case xyes in
 686 x$ac_cv_header_limits_h)
 687   glib_limits_h=yes
 688   glib_ms=SHRT_MIN glib_Ms=SHRT_MAX
 689   glib_mi=INT_MIN  glib_Mi=INT_MAX
 690   glib_ml=LONG_MIN glib_Ml=LONG_MAX
 691   ;;
 692 x$ac_cv_header_values_h)
 693   glib_values_h=yes
 694   glib_ms=MINSHORT glib_Ms=MAXSHORT
 695   glib_mi=MININT   glib_Mi=MAXINT
 696   glib_ml=MINLONG  glib_Ml=MAXLONG
 697   ;;
 698 esac
 699
 700 case 2 in
 701 $ac_cv_sizeof_short)            gint16=short;;
 702 $ac_cv_sizeof_int)              gint16=int;;
 703 esac
 704 case 4 in
 705 $ac_cv_sizeof_short)            gint32=short;;
 706 $ac_cv_sizeof_int)              gint32=int;;
 707 $ac_cv_sizeof_long)             gint32=long;;
 708 esac
 709 case 8 in
 710 $ac_cv_sizeof_int)
 711   gint64=int
 712   glib_extension=
 713   glib_warning_guard=
 714   gint64_constant='(val)'
 715   ;;
 716 $ac_cv_sizeof_long)
 717   gint64=long
 718   glib_extension=
 719   glib_warning_guard=
 720   gint64_constant='(val##L)'
 721   ;;
 722 $ac_cv_sizeof_long_long)
 723   gint64='long long'
 724   glib_extension='GLIB_WARNINGS_MAKE_PEOPLE_CRY '
 725   glib_warning_guard="
 726 #if defined (__GNUC__) && __GNUC__ >= 2 && __GNUC_MINOR__ >= 8
 727 #  define GLIB_WARNINGS_MAKE_PEOPLE_CRY __extension__
 728 #else
 729 #  define GLIB_WARNINGS_MAKE_PEOPLE_CRY
 730 #endif
 731
 732 "
 733   gint64_constant='(GLIB_WARNINGS_MAKE_PEOPLE_CRY (val##LL))'
 734   ;;
 735 esac
 736
 737 gintbits=`expr $ac_cv_sizeof_int \* 8`
 738 glongbits=`expr $ac_cv_sizeof_long \* 8`
 739
 740
 741 case $ac_cv_sizeof_void_p in
 742 $ac_cv_sizeof_int)      glib_gpi_cast=''        glib_gpui_cast=''         ;;
 743 $ac_cv_sizeof_long)     glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
 744 *)                      glib_unknown_void_p=yes ;;
 745 esac
 746
 747
 748 case xyes in
 749 x$ac_cv_func_atexit)
 750   glib_atexit="
 751 #ifdef NeXT /* @#%@! NeXTStep */
 752 # define g_ATEXIT(proc) (!atexit (proc))
 753 #else
 754 # define g_ATEXIT(proc) (atexit (proc))
 755 #endif"
 756   ;;
 757 x$ac_cv_func_on_exit)
 758   glib_atexit="
 759 #define g_ATEXIT(proc)  (on_exit ((void (*)(int, void*))(proc), NULL))"
 760   ;;
 761 esac
 762
 763 case xyes in
 764 x$ac_cv_func_memmove)
 765   glib_memmove='
 766 #define g_memmove(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END'
 767   ;;
 768 *)
 769   glib_memmove="
 770 /* We make the assumption that if memmove isn't available, then
 771  * bcopy will do the job. This isn't safe everywhere. (bcopy can't
 772  * necessarily handle overlapping copies) */
 773 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
 774   ;;
 775 esac
 776
 777 glib_defines="
 778 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
 779 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
 780 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
 781
 782 #define G_COMPILED_WITH_DEBUGGING \"$enable_debug\""
 783
 784 case xyes in
 785 x$glib_cv_va_copy)      glib_vacopy='#define G_VA_COPY  va_copy' ;;
 786 x$glib_cv___va_copy)    glib_vacopy='#define G_VA_COPY  __va_copy' ;;
 787 *)                      glib_vacopy=''
 788 esac
 789
 790 if test x$glib_cv_va_val_copy = xno; then
 791   glib_vacopy="\$glib_vacopy
 792 #define G_VA_COPY_AS_ARRAY 1"
 793 fi
 794
 795 if test x$glib_cv_hasinline = xyes; then
 796     glib_inline='#define G_HAVE_INLINE 1'
 797 fi
 798 if test x$glib_cv_has__inline = xyes; then
 799     glib_inline="\$glib_inline
 800 #define G_HAVE___INLINE 1"
 801 fi
 802 if test x$glib_cv_has__inline__ = xyes; then
 803     glib_inline="\$glib_inline
 804 #define G_HAVE___INLINE__ 1"
 805 fi
 806
 807 case xyes in
 808 x$ac_cv_c_bigendian)
 809   g_byte_order=G_BIG_ENDIAN
 810   g_bs_native=BE
 811   g_bs_alien=LE
 812   ;;
 813 *)
 814   g_byte_order=G_LITTLE_ENDIAN
 815   g_bs_native=LE
 816   g_bs_alien=BE
 817   ;;
 818 esac
 819
 820 if test x$glib_wchar_h = xyes; then
 821   glib_wc='
 822 #define G_HAVE_WCHAR_H 1'
 823 fi
 824 if test x$glib_wctype_h = xyes; then
 825   glib_wc="\$glib_wc
 826 #define G_HAVE_WCTYPE_H 1"
 827 fi
 828 if test x$glib_working_wctype = xno; then
 829   glib_wc="\$glib_wc
 830 #define G_HAVE_BROKEN_WCTYPE 1"
 831 fi
 832 ])
 833
 834 AC_OUTPUT([
 835 Makefile
 836 glib-config
 837 gmodule/gmoduleconf.h
 838 gmodule/Makefile
 839 docs/Makefile
 840 ],[case "$CONFIG_FILES" in
 841 *glib-config*)chmod +x glib-config;;
 842 esac])