git.gag.com Git - debian/amanda/blob - config/acinclude.m4i

   1 dnl Check if the compiler can handle unsigned long constants, ie 2ul.
   2 AC_DEFUN([AMANDA_C_UNSIGNED_LONG_CONSTANTS],
   3     [
   4         AC_CACHE_CHECK(
   5             [for working unsigned long constants],
   6             amanda_cv_c_unsigned_long_constants,
   7             [
   8                 AC_TRY_COMPILE(
   9                     [
  10                     ],
  11                     [
  12                         long l = 1ul;
  13                     ],
  14                     amanda_cv_c_unsigned_long_constants=yes,
  15                     amanda_cv_c_unsigned_long_constants=no
  16                 )
  17             ]
  18         )
  19         if test "$amanda_cv_c_unsigned_long_constants" = yes; then
  20             AC_DEFINE(HAVE_UNSIGNED_LONG_CONSTANTS,1,[Define if the compiler support unsigned long constants. ])
  21         fi
  22     ]
  23 )
  24
  25 dnl Check for the argument type for shmat() and shmdt()
  26 AC_DEFUN([AMANDA_FUNC_SHM_ARG_TYPE],
  27     [
  28         AC_CACHE_CHECK(
  29             [for shmdt() argument type],
  30             amanda_cv_shmdt_arg_type,
  31             [
  32                 if test "$ac_cv_func_shmget" = yes; then
  33                     cat <<EOF >conftest.$ac_ext
  34 #include "confdefs.h"
  35 #ifdef HAVE_SYS_TYPES_H
  36 # include <sys/types.h>
  37 #endif
  38 #ifdef HAVE_SYS_IPC_H
  39 # include <sys/ipc.h>
  40 #endif
  41 #ifdef HAVE_SYS_SHM_H
  42 # include <sys/shm.h>
  43 #endif
  44
  45 #ifdef __cplusplus
  46 extern "C" void *shmat(int, void *, int);
  47 #else
  48 void *shmat();
  49 #endif
  50
  51 int main()
  52 {
  53     int i;
  54     return 0;
  55 }
  56 EOF
  57                     ${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext >/dev/null 2>/dev/null
  58                     if test $? = 0; then
  59                         amanda_cv_shmdt_arg_type=void
  60                     else
  61                         amanda_cv_shmdt_arg_type=char
  62                     fi
  63                     rm -f conftest*
  64                 else
  65                     amanda_cv_shmdt_arg_type=nothing
  66                 fi
  67             ]
  68         )
  69         AC_DEFINE_UNQUOTED(SHM_ARG_TYPE,$amanda_cv_shmdt_arg_type,[Define to type of shmget() function argument. ])
  70     ]
  71 )
  72
  73 dnl Figure out the select() argument type.
  74 AC_DEFUN([AMANDA_FUNC_SELECT_ARG_TYPE],
  75     [
  76         AC_CACHE_CHECK(
  77             [for select() argument type],
  78             amanda_cv_select_arg_type,
  79             [
  80                 rm -f conftest.c
  81                 cat <<EOF >conftest.$ac_ext
  82 #include "confdefs.h"
  83 #ifdef HAVE_SYS_TIME_H
  84 # include <sys/time.h>
  85 #endif
  86 #ifdef HAVE_SYS_TYPES_H
  87 # include <sys/types.h>
  88 #endif
  89 #ifdef HAVE_SYS_SELECT_H
  90 #  include <sys/select.h>
  91 #endif
  92 #ifdef HAVE_SYS_SOCKET_H
  93 #  include <sys/socket.h>
  94 #endif
  95 #ifdef HAVE_UNISTD_H
  96 # include <unistd.h>
  97 #endif
  98
  99 int main()
 100 {
 101 #ifdef FD_SET_POINTER
 102         (void)select(0, (fd_set *) 0, (fd_set *) 0, (fd_set *) 0, 0);
 103 #else
 104         (void)select(0, (int *) 0, (int *) 0, (int *) 0, 0);
 105 #endif
 106         return 0;
 107 }
 108 EOF
 109
 110                 dnl Figure out the select argument type by first trying to
 111                 dnl compile with the fd_set argument.  If the compile fails,
 112                 dnl then we know to use the int.  If it suceeds, then try to
 113                 dnl use the int.  If the int fails, then use fd_set.  If
 114                 dnl both suceeed, then do a line count on the number of
 115                 dnl lines that the compiler spit out, assuming that the
 116                 dnl compile outputing more lines had more errors.
 117                 amanda_cv_select_arg_type=no
 118                 select_compile="${CC-cc} -c $CFLAGS $CPPFLAGS"
 119                 $select_compile -DFD_SET_POINTER conftest.$ac_ext 1>conftest.fd_set 2>&1
 120                 if test $? -ne 0; then
 121                     amanda_cv_select_arg_type=int
 122                 fi
 123                 if test "$amanda_cv_select_arg_type" = no; then
 124                     $select_compile conftest.$ac_ext 1>conftest.int 2>&1
 125                     if test $? -ne 0; then
 126                         amanda_cv_select_arg_type=fd_set
 127                     fi
 128                 fi
 129                 if test "$amanda_cv_select_arg_type" = no; then
 130                     wc_fdset=`wc -l <conftest.fd_set`
 131                     wc_int=`wc -l <conftest.int`
 132                     if test "$wc_fdset" -le "$wc_int"; then
 133                         amanda_cv_select_arg_type=fd_set
 134                     else
 135                         amanda_cv_select_arg_type=int
 136                     fi
 137                 fi
 138                 rm -f conftest*
 139             ]
 140         )
 141         AC_DEFINE_UNQUOTED(SELECT_ARG_TYPE,$amanda_cv_select_arg_type,[Define to type of select arguments. ])
 142     ]
 143 )
 144
 145 dnl Check if setsockopt can use the SO_SNDTIMEO option.
 146 dnl This defines HAVE_SO_SNDTIMEO if setsockopt works
 147 dnl with SO_SNDTIMEO.
 148 AC_DEFUN([AMANDA_FUNC_SETSOCKOPT_SO_SNDTIMEO],
 149     [
 150         AC_CACHE_CHECK(
 151             [for setsockopt SO_SNDTIMEO option],
 152             amanda_cv_setsockopt_SO_SNDTIMEO,
 153             [
 154                 AC_TRY_RUN(
 155                     [
 156 #include <sys/types.h>
 157 #include <sys/socket.h>
 158 #ifdef TIME_WITH_SYS_TIME
 159 #  include <sys/time.h>
 160 #  include <time.h>
 161 #else
 162 #  ifdef HAVE_SYS_TIME_H
 163 #    include <sys/time.h>
 164 #  else
 165 #    include <time.h>
 166 #  endif
 167 #endif
 168
 169 main() {
 170 #ifdef SO_SNDTIMEO
 171     int sock = socket(AF_INET, SOCK_STREAM, 0);
 172     struct timeval timeout;
 173     timeout.tv_sec = 1;
 174     timeout.tv_usec = 0;
 175     return (setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO,
 176              (void *)&timeout, sizeof(timeout)));
 177 #else
 178     return -1;
 179 #endif
 180 }
 181                     ],
 182                     amanda_cv_setsockopt_SO_SNDTIMEO=yes,
 183                     amanda_cv_setsockopt_SO_SNDTIMEO=no,
 184                     amanda_cv_setsockopt_SO_SNDTIMEO=no
 185                 )
 186             ]
 187         )
 188         if test "$amanda_cv_setsockopt_SO_SNDTIMEO" = yes; then
 189             AC_DEFINE(HAVE_SO_SNDTIMEO,1,[Define if SO_SNDTIMEO is available. ])
 190         fi
 191     ]
 192 )
 193
 194 dnl Find out how {awk,gawk,nawk,mawk} likes to assign variables, if it
 195 dnl can do so at all.
 196 AC_DEFUN([AMANDA_PROG_AWK_VAR],
 197     [
 198         AC_REQUIRE([AC_PROG_AWK])
 199         AC_CACHE_CHECK(
 200             [for $AWK command line variable assignment],
 201             amanda_cv_awk_var_assignment,
 202             [
 203                 echo 'BEGIN{print i; exit}' > conftest.awk
 204                 result=`$AWK -f conftest.awk i=xx | wc -c`
 205                 if test "$result" -le 1; then
 206                     result=`$AWK -f conftest.awk -v i=xx | wc -c`
 207                     if test "$result" -le 1; then
 208                         amanda_cv_awk_var_assignment=no
 209                     else
 210                         amanda_cv_awk_var_assignment="yes with -v"
 211                     fi
 212                 else
 213                     amanda_cv_awk_var_assignment="yes"
 214                 fi
 215                 rm -fr conftest.awk
 216             ]
 217         )
 218         AWK_VAR_ASSIGNMENT_OPT=
 219         case "$amanda_cv_awk_var_assignment" in
 220             no)
 221                 HAVE_AWK_WITH_VAR=no
 222                 ;;
 223             yes)
 224                 HAVE_AWK_WITH_VAR=yes
 225                 ;;
 226             "yes with -v")
 227                 HAVE_AWK_WITH_VAR=yes
 228                 AWK_VAR_ASSIGNMENT_OPT=-v
 229                 ;;
 230         esac
 231         AC_SUBST(AWK_VAR_ASSIGNMENT_OPT)
 232     ]
 233 )
 234
 235 dnl Check for the one or two argument version of gettimeofday.
 236 AC_DEFUN([AMANDA_FUNC_GETTIMEOFDAY_ARGS],
 237     [
 238         AC_REQUIRE([AC_HEADER_TIME])
 239         AC_CACHE_CHECK(
 240             [for gettimeofday number of arguments],
 241             amanda_cv_gettimeofday_args,
 242             [
 243                 AC_TRY_COMPILE(
 244                     [
 245 #ifdef TIME_WITH_SYS_TIME
 246 #  include <sys/time.h>
 247 #  include <time.h>
 248 #else
 249 #  ifdef HAVE_SYS_TIME_H
 250 #    include <sys/time.h>
 251 #  else
 252 #    include <time.h>
 253 #  endif
 254 #endif
 255                     ],
 256                     [
 257                         struct timeval val;
 258                         struct timezone zone;
 259                         gettimeofday(&val, &zone);
 260                     ],
 261                     amanda_cv_gettimeofday_args=2,
 262                     amanda_cv_gettimeofday_args=1
 263                 )
 264             ]
 265         )
 266         if test "$amanda_cv_gettimeofday_args" = 2; then
 267             AC_DEFINE(HAVE_TWO_ARG_GETTIMEOFDAY,1,[Define if gettimeofday takes two arguments. ])
 268         fi
 269     ]
 270 )
 271
 272
 273
 274 dnl Check if the compiler understands volatile.
 275 AC_DEFUN([AMANDA_C_VOLATILE],
 276     [
 277         AC_CACHE_CHECK(
 278             [for working volatile],
 279             amanda_cv_c_volatile,
 280             [
 281                 AC_TRY_COMPILE(,
 282                     [
 283                         volatile int aaa = 0;
 284                     ],
 285                     amanda_cv_c_volatile=yes,
 286                     amanda_cv_c_volatile=no
 287                 )
 288             ]
 289         )
 290         if test $amanda_cv_c_volatile = no; then
 291             AC_DEFINE(volatile, [],[Define to empty if the compiler does not support volatile. ])
 292         fi
 293     ]
 294 )
 295
 296
 297 dnl Check for if pid_t is a long, int, or short.
 298 AC_DEFUN([AMANDA_TYPE_PID_T],
 299     [
 300         AC_REQUIRE([AC_TYPE_PID_T])
 301         AC_CACHE_CHECK([for pid_t type], amanda_cv_pid_type,
 302             [
 303                 amanda_cv_pid_type=unknown
 304                 if test "$ac_cv_type_pid_t" = no; then
 305                     amanda_cv_pid_type=int
 306                 fi
 307                 for TEST_amanda_cv_pid_type in long short int; do
 308                     if test $amanda_cv_pid_type = unknown; then
 309                         AC_EGREP_CPP(typedef.*${TEST_amanda_cv_pid_type}.*pid_t,
 310                             [
 311 #include <sys/types.h>
 312 #if STDC_HEADERS
 313 #include <stdlib.h>
 314 #include <stddef.h>
 315 #endif
 316                             ],
 317                         amanda_cv_pid_type=$TEST_amanda_cv_pid_type)
 318                     fi
 319                     if test $amanda_cv_pid_type = unknown; then
 320                         AC_EGREP_CPP(ZZZZ.*${TEST_amanda_cv_pid_type},
 321                             [
 322 #include <sys/types.h>
 323 #if STDC_HEADERS
 324 #include <stdlib.h>
 325 #include <stddef.h>
 326 #endif
 327                                 ZZZZ pid_t
 328                         ],
 329                         amanda_cv_pid_type=$TEST_amanda_cv_pid_type)
 330                     fi
 331                 done
 332                 if test $amanda_cv_pid_type = unknown; then
 333                     amanda_cv_pid_type=int
 334                 fi
 335             ]
 336         )
 337         case $amanda_cv_pid_type in
 338             int)        AC_DEFINE_UNQUOTED(PRINTF_PID_T,"%d",[Define to printf formatting string to print a PID. ]) ;;
 339             long)       AC_DEFINE_UNQUOTED(PRINTF_PID_T,"%ld") ;;
 340             short)      AC_DEFINE_UNQUOTED(PRINTF_PID_T,"%d") ;;
 341         esac
 342     ]
 343 )
 344
 345 dnl
 346 dnl
 347 dnl ICE_CHECK_DECL (FUNCTION, HEADER-FILE...)
 348 dnl If FUNCTION is available, define `HAVE_FUNCTION'.  If it is declared
 349 dnl in one of the headers named in the whitespace-separated list
 350 dnl HEADER_FILE, define `HAVE_FUNCTION_DECL` (in all capitals).
 351 dnl
 352 AC_DEFUN([ICE_CHECK_DECL],
 353 [
 354 ice_have_$1=no
 355 AC_CHECK_FUNCS($1, ice_have_$1=yes)
 356 if test "${ice_have_$1}" = yes; then
 357 AC_MSG_CHECKING(for $1 declaration in $2)
 358 AC_CACHE_VAL(ice_cv_have_$1_decl,
 359 [
 360 ice_cv_have_$1_decl=no
 361 changequote(,)dnl
 362 ice_re_params='[a-zA-Z_][a-zA-Z0-9_]*'
 363 ice_re_word='(^|[^a-zA-Z0-9_])'
 364 changequote([,])dnl
 365 for header in $2; do
 366 # Check for ordinary declaration
 367 AC_EGREP_HEADER([${ice_re_word}$1[      ]*\(], $header,
 368         ice_cv_have_$1_decl=yes)
 369 if test "$ice_cv_have_$1_decl" = yes; then
 370         break
 371 fi
 372 # Check for "fixed" declaration like "getpid _PARAMS((int))"
 373 AC_EGREP_HEADER([${ice_re_word}$1[      ]*$ice_re_params\(\(], $header,
 374         ice_cv_have_$1_decl=yes)
 375 if test "$ice_cv_have_$1_decl" = yes; then
 376         break
 377 fi
 378 done
 379 ])
 380 AC_MSG_RESULT($ice_cv_have_$1_decl)
 381 if test "$ice_cv_have_$1_decl" = yes; then
 382 AC_DEFINE_UNQUOTED([HAVE_]translit($1,[a-z],[A-Z])[_DECL],1,[Define if $1 is declared. ])
 383 fi
 384 fi
 385 ])dnl
 386 dnl Test for the presence of <sys/wait.h>, 'union wait', arg-type of 'wait()'.
 387 dnl by T.E.Dickey" , Jim Spath <jspath@mail.bcpl.lib.md.us>
 388 dnl
 389 dnl     FIXME: These tests should have been in autoconf 1.11!
 390 dnl
 391 dnl     Note that we cannot simply grep for 'union wait' in the wait.h file,
 392 dnl     because some Posix systems turn this on only when a BSD variable is
 393 dnl     defined. Since I'm trying to do without special defines, I'll live
 394 dnl     with the default behavior of the include-file.
 395 dnl
 396 dnl     I do _2_ compile checks, because we may have union-wait, but the
 397 dnl     prototype for 'wait()' may want an int.
 398 dnl
 399 dnl     Don't use HAVE_UNION_WAIT, because the autoconf documentation implies
 400 dnl     that if we've got union-wait, we'll automatically use it.
 401 dnl
 402 dnl Garrett Wollman adds:
 403 dnl     The tests described above don't quite do the right thing,
 404 dnl     since some systems have hacks which allow `union wait' to
 405 dnl     still work even though `int' is preferred (and generates
 406 dnl     fewer warnings).  Since all of these systems use prototypes,
 407 dnl     we can use the prototype of wait(2) to disambiguate them.
 408 dnl
 409 dnl Alexandre Oliva adds:
 410 dnl     A single compile check is enough.  If we don't have union wait,
 411 dnl     it's obvious that the test will fail, and that we must use int.
 412 dnl     If we do, the prototype (on STDC systems) and WIFEXITED will tell
 413 dnl     whether we're supposed to be using union wait instead of int.
 414 dnl
 415 AC_DEFUN([CF_WAIT],
 416 [
 417 AC_REQUIRE([AC_TYPE_PID_T])
 418 AC_HAVE_HEADERS(sys/wait.h wait.h)
 419 AC_CACHE_CHECK([whether wait uses union wait], [cf_cv_arg_union_wait],
 420         [AC_TRY_COMPILE([
 421 #include <sys/types.h>
 422
 423 #if HAVE_SYS_WAIT_H
 424 # include <sys/wait.h>
 425 #else
 426 # if HAVE_WAIT_H
 427 #  include <wait.h>
 428 # endif
 429 #endif
 430
 431 #ifdef __STDC__
 432 pid_t wait(union wait *);
 433 #endif
 434 ], [
 435   union wait x; int i;
 436   wait(&x); i = WIFEXITED(x)
 437 ], [cf_cv_arg_union_wait=yes], [cf_cv_arg_union_wait=no])])
 438 if test $cf_cv_arg_union_wait = yes; then
 439         AC_DEFINE(WAIT_USES_UNION,1,[Defined if wait() puts the status in a union wait instead of int. ])
 440 fi
 441 ])dnl
 442 AC_DEFUN([CF_WAIT_INT],
 443 [
 444 AC_REQUIRE([AC_TYPE_PID_T])
 445 AC_HAVE_HEADERS(sys/wait.h wait.h)
 446 AC_CACHE_CHECK([whether wait uses int], [cf_cv_arg_int],
 447         [AC_TRY_COMPILE([
 448 #include <sys/types.h>
 449
 450 #if HAVE_SYS_WAIT_H
 451 # include <sys/wait.h>
 452 #else
 453 # if HAVE_WAIT_H
 454 #  include <wait.h>
 455 # endif
 456 #endif
 457
 458 #ifdef __STDC__
 459 pid_t wait(int *);
 460 #endif
 461 ], [
 462   int x; int i;
 463   wait(&x); i = WIFEXITED(x)
 464 ], [cf_cv_arg_int=yes], [cf_cv_arg_int=no])])
 465 if test $cf_cv_arg_int = yes; then
 466         AC_DEFINE(WAIT_USES_INT,1,[Defined if wait() puts the status in a int instead of a union wait. ])
 467 fi
 468 ])dnl
 469
 470 dnl @synopsis AX_CREATE_STDINT_H [( HEADER-TO-GENERATE [, HEDERS-TO-CHECK])]
 471 dnl
 472 dnl the "ISO C9X: 7.18 Integer types <stdint.h>" section requires the
 473 dnl existence of an include file <stdint.h> that defines a set of
 474 dnl typedefs, especially uint8_t,int32_t,uintptr_t.
 475 dnl Many older installations will not provide this file, but some will
 476 dnl have the very same definitions in <inttypes.h>. In other enviroments
 477 dnl we can use the inet-types in <sys/types.h> which would define the
 478 dnl typedefs int8_t and u_int8_t respectivly.
 479 dnl
 480 dnl This macros will create a local "_stdint.h" or the headerfile given as
 481 dnl an argument. In many cases that file will just "#include <stdint.h>"
 482 dnl or "#include <inttypes.h>", while in other environments it will provide
 483 dnl the set of basic 'stdint's definitions/typedefs:
 484 dnl   int8_t,uint8_t,int16_t,uint16_t,int32_t,uint32_t,intptr_t,uintptr_t
 485 dnl   int_least32_t.. int_fast32_t.. intmax_t
 486 dnl which may or may not rely on the definitions of other files,
 487 dnl or using the AC_CHECK_SIZEOF macro to determine the actual
 488 dnl sizeof each type.
 489 dnl
 490 dnl if your header files require the stdint-types you will want to create an
 491 dnl installable file mylib-int.h that all your other installable header
 492 dnl may include. So if you have a library package named "mylib", just use
 493 dnl      AX_CREATE_STDINT_H(mylib-int.h)
 494 dnl in configure.ac and go to install that very header file in Makefile.am
 495 dnl along with the other headers (mylib.h) - and the mylib-specific headers
 496 dnl can simply use "#include <mylib-int.h>" to obtain the stdint-types.
 497 dnl
 498 dnl Remember, if the system already had a valid <stdint.h>, the generated
 499 dnl file will include it directly. No need for fuzzy HAVE_STDINT_H things...
 500 dnl
 501 dnl @, (status: used on new platforms) (see http://ac-archive.sf.net/gstdint/)
 502 dnl @version $Id: acinclude.m4i,v 1.1.2.5.8.3 2004/04/29 20:47:22 martinea Exp $
 503 dnl @author  Guido Draheim <guidod@gmx.de>
 504
 505 AC_DEFUN([AX_CREATE_STDINT_H],
 506 [# ------ AX CREATE STDINT H -------------------------------------
 507 AC_MSG_CHECKING([for stdint types])
 508 ac_stdint_h=`echo ifelse($1, , _stdint.h, $1)`
 509 # try to shortcircuit - if the default include path of the compiler
 510 # can find a "stdint.h" header then we assume that all compilers can.
 511 AC_CACHE_VAL([ac_cv_header_stdint_t],[
 512 old_CXXFLAGS="$CXXFLAGS" ; CXXFLAGS=""
 513 old_CPPFLAGS="$CPPFLAGS" ; CPPFLAGS=""
 514 old_CFLAGS="$CFLAGS"     ; CFLAGS=""
 515 AC_TRY_COMPILE([#include <stdint.h>],[int_least32_t v = 0;],
 516 [ac_cv_stdint_result="(assuming C99 compatible system)"
 517  ac_cv_header_stdint_t="stdint.h"; ],
 518 [ac_cv_header_stdint_t=""])
 519 CXXFLAGS="$old_CXXFLAGS"
 520 CPPFLAGS="$old_CPPFLAGS"
 521 CFLAGS="$old_CFLAGS" ])
 522
 523 v="... $ac_cv_header_stdint_h"
 524 if test "$ac_stdint_h" = "stdint.h" ; then
 525  AC_MSG_RESULT([(are you sure you want them in ./stdint.h?)])
 526 elif test "$ac_stdint_h" = "inttypes.h" ; then
 527  AC_MSG_RESULT([(are you sure you want them in ./inttypes.h?)])
 528 elif test "_$ac_cv_header_stdint_t" = "_" ; then
 529  AC_MSG_RESULT([(putting them into $ac_stdint_h)$v])
 530 else
 531  ac_cv_header_stdint="$ac_cv_header_stdint_t"
 532  AC_MSG_RESULT([$ac_cv_header_stdint (shortcircuit)])
 533 fi
 534
 535 if test "_$ac_cv_header_stdint_t" = "_" ; then # can not shortcircuit..
 536
 537 dnl .....intro message done, now do a few system checks.....
 538 dnl btw, all CHECK_TYPE macros do automatically "DEFINE" a type, therefore
 539 dnl we use the autoconf implementation detail _AC CHECK_TYPE_NEW instead
 540
 541 inttype_headers=`echo $2 | sed -e 's/,/ /g'`
 542
 543 ac_cv_stdint_result="(no helpful system typedefs seen)"
 544 AC_CACHE_CHECK([for stdint uintptr_t], [ac_cv_header_stdint_x],[
 545  ac_cv_header_stdint_x="" # the 1997 typedefs (inttypes.h)
 546   AC_MSG_RESULT([(..)])
 547   for i in stdint.h inttypes.h sys/inttypes.h $inttype_headers ; do
 548    unset ac_cv_type_uintptr_t
 549    unset ac_cv_type_uint64_t
 550    _AC_CHECK_TYPE_NEW(uintptr_t,[ac_cv_header_stdint_x=$i],dnl
 551      continue,[#include <$i>])
 552    AC_CHECK_TYPE(uint64_t,[and64="/uint64_t"],[and64=""],[#include<$i>])
 553    ac_cv_stdint_result="(seen uintptr_t$and64 in $i)"
 554    break;
 555   done
 556   AC_MSG_CHECKING([for stdint uintptr_t])
 557  ])
 558
 559 if test "_$ac_cv_header_stdint_x" = "_" ; then
 560 AC_CACHE_CHECK([for stdint uint32_t], [ac_cv_header_stdint_o],[
 561  ac_cv_header_stdint_o="" # the 1995 typedefs (sys/inttypes.h)
 562   AC_MSG_RESULT([(..)])
 563   for i in inttypes.h sys/inttypes.h stdint.h $inttype_headers ; do
 564    unset ac_cv_type_uint32_t
 565    unset ac_cv_type_uint64_t
 566    AC_CHECK_TYPE(uint32_t,[ac_cv_header_stdint_o=$i],dnl
 567      continue,[#include <$i>])
 568    AC_CHECK_TYPE(uint64_t,[and64="/uint64_t"],[and64=""],[#include<$i>])
 569    ac_cv_stdint_result="(seen uint32_t$and64 in $i)"
 570    break;
 571   done
 572   AC_MSG_CHECKING([for stdint uint32_t])
 573  ])
 574 fi
 575
 576 if test "_$ac_cv_header_stdint_x" = "_" ; then
 577 if test "_$ac_cv_header_stdint_o" = "_" ; then
 578 AC_CACHE_CHECK([for stdint u_int32_t], [ac_cv_header_stdint_u],[
 579  ac_cv_header_stdint_u="" # the BSD typedefs (sys/types.h)
 580   AC_MSG_RESULT([(..)])
 581   for i in sys/types.h inttypes.h sys/inttypes.h $inttype_headers ; do
 582    unset ac_cv_type_u_int32_t
 583    unset ac_cv_type_u_int64_t
 584    AC_CHECK_TYPE(u_int32_t,[ac_cv_header_stdint_u=$i],dnl
 585      continue,[#include <$i>])
 586    AC_CHECK_TYPE(u_int64_t,[and64="/u_int64_t"],[and64=""],[#include<$i>])
 587    ac_cv_stdint_result="(seen u_int32_t$and64 in $i)"
 588    break;
 589   done
 590   AC_MSG_CHECKING([for stdint u_int32_t])
 591  ])
 592 fi fi
 593
 594 dnl if there was no good C99 header file, do some typedef checks...
 595 if test "_$ac_cv_header_stdint_x" = "_" ; then
 596    AC_MSG_CHECKING([for stdint datatype model])
 597    AC_MSG_RESULT([(..)])
 598    AC_CHECK_SIZEOF(char)
 599    AC_CHECK_SIZEOF(short)
 600    AC_CHECK_SIZEOF(int)
 601    AC_CHECK_SIZEOF(long)
 602    AC_CHECK_SIZEOF(void*)
 603    ac_cv_stdint_char_model=""
 604    ac_cv_stdint_char_model="$ac_cv_stdint_char_model$ac_cv_sizeof_char"
 605    ac_cv_stdint_char_model="$ac_cv_stdint_char_model$ac_cv_sizeof_short"
 606    ac_cv_stdint_char_model="$ac_cv_stdint_char_model$ac_cv_sizeof_int"
 607    ac_cv_stdint_long_model=""
 608    ac_cv_stdint_long_model="$ac_cv_stdint_long_model$ac_cv_sizeof_int"
 609    ac_cv_stdint_long_model="$ac_cv_stdint_long_model$ac_cv_sizeof_long"
 610    ac_cv_stdint_long_model="$ac_cv_stdint_long_model$ac_cv_sizeof_voidp"
 611    name="$ac_cv_stdint_long_model"
 612    case "$ac_cv_stdint_char_model/$ac_cv_stdint_long_model" in
 613     122/242)     name="$name,  IP16 (standard 16bit machine)" ;;
 614     122/244)     name="$name,  LP32 (standard 32bit mac/win)" ;;
 615     122/*)       name="$name        (unusual int16 model)" ;;
 616     124/444)     name="$name, ILP32 (standard 32bit unixish)" ;;
 617     124/488)     name="$name,  LP64 (standard 64bit unixish)" ;;
 618     124/448)     name="$name, LLP64 (unusual  64bit unixish)" ;;
 619     124/*)       name="$name        (unusual int32 model)" ;;
 620     128/888)     name="$name, ILP64 (unusual  64bit numeric)" ;;
 621     128/*)       name="$name        (unusual int64 model)" ;;
 622     222/*|444/*) name="$name        (unusual dsptype)" ;;
 623      *)          name="$name        (very unusal model)" ;;
 624    esac
 625    AC_MSG_RESULT([combined for stdint datatype model...  $name])
 626 fi
 627
 628 if test "_$ac_cv_header_stdint_x" != "_" ; then
 629    ac_cv_header_stdint="$ac_cv_header_stdint_x"
 630 elif  test "_$ac_cv_header_stdint_o" != "_" ; then
 631    ac_cv_header_stdint="$ac_cv_header_stdint_o"
 632 elif  test "_$ac_cv_header_stdint_u" != "_" ; then
 633    ac_cv_header_stdint="$ac_cv_header_stdint_u"
 634 else
 635    ac_cv_header_stdint="stddef.h"
 636 fi
 637
 638 AC_MSG_CHECKING([for extra inttypes in chosen header])
 639 AC_MSG_RESULT([($ac_cv_header_stdint)])
 640 dnl see if int_least and int_fast types are present in _this_ header.
 641 unset ac_cv_type_int_least32_t
 642 unset ac_cv_type_int_fast32_t
 643 AC_CHECK_TYPE(int_least32_t,,,[#include <$ac_cv_header_stdint>])
 644 AC_CHECK_TYPE(int_fast32_t,,,[#include<$ac_cv_header_stdint>])
 645 AC_CHECK_TYPE(intmax_t,,,[#include <$ac_cv_header_stdint>])
 646
 647 fi # shortcircut to system "stdint.h"
 648 # ------------------ PREPARE VARIABLES ------------------------------
 649 if test "$GCC" = "yes" ; then
 650 ac_cv_stdint_message="using gnu compiler "`$CC --version | head -1`
 651 else
 652 ac_cv_stdint_message="using $CC"
 653 fi
 654
 655 AC_MSG_RESULT([make use of $ac_cv_header_stdint in $ac_stdint_h dnl
 656 $ac_cv_stdint_result])
 657
 658 # ----------------- DONE inttypes.h checks START header -------------
 659 AC_CONFIG_COMMANDS([$ac_stdint_h],[
 660 AC_MSG_NOTICE(creating $ac_stdint_h : $_ac_stdint_h)
 661 ac_stdint=$tmp/_stdint.h
 662
 663 echo "#ifndef" $_ac_stdint_h >$ac_stdint
 664 echo "#define" $_ac_stdint_h "1" >>$ac_stdint
 665 echo "#ifndef" _GENERATED_STDINT_H >>$ac_stdint
 666 echo "#define" _GENERATED_STDINT_H '"'$PACKAGE $VERSION'"' >>$ac_stdint
 667 echo "/* generated $ac_cv_stdint_message */" >>$ac_stdint
 668 if test "_$ac_cv_header_stdint_t" != "_" ; then
 669 echo "#define _STDINT_HAVE_STDINT_H" "1" >>$ac_stdint
 670 fi
 671
 672 cat >>$ac_stdint <<STDINT_EOF
 673
 674 /* ................... shortcircuit part ........................... */
 675
 676 #if defined HAVE_STDINT_H || defined _STDINT_HAVE_STDINT_H
 677 #include <stdint.h>
 678 #else
 679 #include <stddef.h>
 680
 681 /* .................... configured part ............................ */
 682
 683 STDINT_EOF
 684
 685 echo "/* whether we have a C99 compatible stdint header file */" >>$ac_stdint
 686 if test "_$ac_cv_header_stdint_x" != "_" ; then
 687   ac_header="$ac_cv_header_stdint_x"
 688   echo "#define _STDINT_HEADER_INTPTR" '"'"$ac_header"'"' >>$ac_stdint
 689 else
 690   echo "/* #undef _STDINT_HEADER_INTPTR */" >>$ac_stdint
 691 fi
 692
 693 echo "/* whether we have a C96 compatible inttypes header file */" >>$ac_stdint
 694 if  test "_$ac_cv_header_stdint_o" != "_" ; then
 695   ac_header="$ac_cv_header_stdint_o"
 696   echo "#define _STDINT_HEADER_UINT32" '"'"$ac_header"'"' >>$ac_stdint
 697 else
 698   echo "/* #undef _STDINT_HEADER_UINT32 */" >>$ac_stdint
 699 fi
 700
 701 echo "/* whether we have a BSD compatible inet types header */" >>$ac_stdint
 702 if  test "_$ac_cv_header_stdint_u" != "_" ; then
 703   ac_header="$ac_cv_header_stdint_u"
 704   echo "#define _STDINT_HEADER_U_INT32" '"'"$ac_header"'"' >>$ac_stdint
 705 else
 706   echo "/* #undef _STDINT_HEADER_U_INT32 */" >>$ac_stdint
 707 fi
 708
 709 echo "" >>$ac_stdint
 710
 711 if test "_$ac_header" != "_" ; then if test "$ac_header" != "stddef.h" ; then
 712   echo "#include <$ac_header>" >>$ac_stdint
 713   echo "" >>$ac_stdint
 714 fi fi
 715
 716 echo "/* which 64bit typedef has been found */" >>$ac_stdint
 717 if test "$ac_cv_type_uint64_t" = "yes" ; then
 718 echo "#define   _STDINT_HAVE_UINT64_T" "1"  >>$ac_stdint
 719 else
 720 echo "/* #undef _STDINT_HAVE_UINT64_T */" >>$ac_stdint
 721 fi
 722 if test "$ac_cv_type_u_int64_t" = "yes" ; then
 723 echo "#define   _STDINT_HAVE_U_INT64_T" "1"  >>$ac_stdint
 724 else
 725 echo "/* #undef _STDINT_HAVE_U_INT64_T */" >>$ac_stdint
 726 fi
 727 echo "" >>$ac_stdint
 728
 729 echo "/* which type model has been detected */" >>$ac_stdint
 730 if test "_$ac_cv_stdint_char_model" != "_" ; then
 731 echo "#define   _STDINT_CHAR_MODEL" "$ac_cv_stdint_char_model" >>$ac_stdint
 732 echo "#define   _STDINT_LONG_MODEL" "$ac_cv_stdint_long_model" >>$ac_stdint
 733 else
 734 echo "/* #undef _STDINT_CHAR_MODEL // skipped */" >>$ac_stdint
 735 echo "/* #undef _STDINT_LONG_MODEL // skipped */" >>$ac_stdint
 736 fi
 737 echo "" >>$ac_stdint
 738
 739 echo "/* whether int_least types were detected */" >>$ac_stdint
 740 if test "$ac_cv_type_int_least32_t" = "yes"; then
 741 echo "#define   _STDINT_HAVE_INT_LEAST32_T" "1"  >>$ac_stdint
 742 else
 743 echo "/* #undef _STDINT_HAVE_INT_LEAST32_T */" >>$ac_stdint
 744 fi
 745 echo "/* whether int_fast types were detected */" >>$ac_stdint
 746 if test "$ac_cv_type_int_fast32_t" = "yes"; then
 747 echo "#define   _STDINT_HAVE_INT_FAST32_T" "1" >>$ac_stdint
 748 else
 749 echo "/* #undef _STDINT_HAVE_INT_FAST32_T */" >>$ac_stdint
 750 fi
 751 echo "/* whether intmax_t type was detected */" >>$ac_stdint
 752 if test "$ac_cv_type_intmax_t" = "yes"; then
 753 echo "#define   _STDINT_HAVE_INTMAX_T" "1" >>$ac_stdint
 754 else
 755 echo "/* #undef _STDINT_HAVE_INTMAX_T */" >>$ac_stdint
 756 fi
 757 echo "" >>$ac_stdint
 758
 759   cat >>$ac_stdint <<STDINT_EOF
 760 /* .................... detections part ............................ */
 761
 762 /* whether we need to define bitspecific types from compiler base types */
 763 #ifndef _STDINT_HEADER_INTPTR
 764 #ifndef _STDINT_HEADER_UINT32
 765 #ifndef _STDINT_HEADER_U_INT32
 766 #define _STDINT_NEED_INT_MODEL_T
 767 #else
 768 #define _STDINT_HAVE_U_INT_TYPES
 769 #endif
 770 #endif
 771 #endif
 772
 773 #ifdef _STDINT_HAVE_U_INT_TYPES
 774 #undef _STDINT_NEED_INT_MODEL_T
 775 #endif
 776
 777 #ifdef  _STDINT_CHAR_MODEL
 778 #if     _STDINT_CHAR_MODEL+0 == 122 || _STDINT_CHAR_MODEL+0 == 124
 779 #ifndef _STDINT_BYTE_MODEL
 780 #define _STDINT_BYTE_MODEL 12
 781 #endif
 782 #endif
 783 #endif
 784
 785 #ifndef _STDINT_HAVE_INT_LEAST32_T
 786 #define _STDINT_NEED_INT_LEAST_T
 787 #endif
 788
 789 #ifndef _STDINT_HAVE_INT_FAST32_T
 790 #define _STDINT_NEED_INT_FAST_T
 791 #endif
 792
 793 #ifndef _STDINT_HEADER_INTPTR
 794 #define _STDINT_NEED_INTPTR_T
 795 #ifndef _STDINT_HAVE_INTMAX_T
 796 #define _STDINT_NEED_INTMAX_T
 797 #endif
 798 #endif
 799
 800
 801 /* .................... definition part ............................ */
 802
 803 /* some system headers have good uint64_t */
 804 #ifndef _HAVE_UINT64_T
 805 #if     defined _STDINT_HAVE_UINT64_T  || defined HAVE_UINT64_T
 806 #define _HAVE_UINT64_T
 807 #elif   defined _STDINT_HAVE_U_INT64_T || defined HAVE_U_INT64_T
 808 #define _HAVE_UINT64_T
 809 typedef u_int64_t uint64_t;
 810 #endif
 811 #endif
 812
 813 #ifndef _HAVE_UINT64_T
 814 /* .. here are some common heuristics using compiler runtime specifics */
 815 #if defined __STDC_VERSION__ && defined __STDC_VERSION__ >= 199901L
 816 #define _HAVE_UINT64_T
 817 typedef long long int64_t;
 818 typedef unsigned long long uint64_t;
 819
 820 #elif !defined __STRICT_ANSI__
 821 #if defined _MSC_VER || defined __WATCOMC__ || defined __BORLANDC__
 822 #define _HAVE_UINT64_T
 823 typedef __int64 int64_t;
 824 typedef unsigned __int64 uint64_t;
 825
 826 #elif defined __GNUC__ || defined __MWERKS__ || defined __ELF__
 827 /* note: all ELF-systems seem to have loff-support which needs 64-bit */
 828 #if !defined _NO_LONGLONG
 829 #define _HAVE_UINT64_T
 830 typedef long long int64_t;
 831 typedef unsigned long long uint64_t;
 832 #endif
 833
 834 #elif defined __alpha || (defined __mips && defined _ABIN32)
 835 #if !defined _NO_LONGLONG
 836 typedef long int64_t;
 837 typedef unsigned long uint64_t;
 838 #endif
 839   /* compiler/cpu type to define int64_t */
 840 #endif
 841 #endif
 842 #endif
 843
 844 #if defined _STDINT_HAVE_U_INT_TYPES
 845 /* int8_t int16_t int32_t defined by inet code, redeclare the u_intXX types */
 846 typedef u_int8_t uint8_t;
 847 typedef u_int16_t uint16_t;
 848 typedef u_int32_t uint32_t;
 849
 850 /* glibc compatibility */
 851 #ifndef __int8_t_defined
 852 #define __int8_t_defined
 853 #endif
 854 #endif
 855
 856 #ifdef _STDINT_NEED_INT_MODEL_T
 857 /* we must guess all the basic types. Apart from byte-adressable system, */
 858 /* there a few 32-bit-only dsp-systems that we guard with BYTE_MODEL 8-} */
 859 /* (btw, those nibble-addressable systems are way off, or so we assume) */
 860
 861 dnl   /* have a look at "64bit and data size neutrality" at */
 862 dnl   /* http://unix.org/version2/whatsnew/login_64bit.html */
 863 dnl   /* (the shorthand "ILP" types always have a "P" part) */
 864
 865 #if defined _STDINT_BYTE_MODEL
 866 #if _STDINT_LONG_MODEL+0 == 242
 867 /* 2:4:2 =  IP16 = a normal 16-bit system                */
 868 typedef unsigned char   uint8_t;
 869 typedef unsigned short  uint16_t;
 870 typedef unsigned long   uint32_t;
 871 #ifndef __int8_t_defined
 872 #define __int8_t_defined
 873 typedef          char    int8_t;
 874 typedef          short   int16_t;
 875 typedef          long    int32_t;
 876 #endif
 877 #elif _STDINT_LONG_MODEL+0 == 244 || _STDINT_LONG_MODEL == 444
 878 /* 2:4:4 =  LP32 = a 32-bit system derived from a 16-bit */
 879 /* 4:4:4 = ILP32 = a normal 32-bit system                */
 880 typedef unsigned char   uint8_t;
 881 typedef unsigned short  uint16_t;
 882 typedef unsigned int    uint32_t;
 883 #ifndef __int8_t_defined
 884 #define __int8_t_defined
 885 typedef          char    int8_t;
 886 typedef          short   int16_t;
 887 typedef          int     int32_t;
 888 #endif
 889 #elif _STDINT_LONG_MODEL+0 == 484 || _STDINT_LONG_MODEL+0 == 488
 890 /* 4:8:4 =  IP32 = a 32-bit system prepared for 64-bit    */
 891 /* 4:8:8 =  LP64 = a normal 64-bit system                 */
 892 typedef unsigned char   uint8_t;
 893 typedef unsigned short  uint16_t;
 894 typedef unsigned int    uint32_t;
 895 #ifndef __int8_t_defined
 896 #define __int8_t_defined
 897 typedef          char    int8_t;
 898 typedef          short   int16_t;
 899 typedef          int     int32_t;
 900 #endif
 901 /* this system has a "long" of 64bit */
 902 #ifndef _HAVE_UINT64_T
 903 #define _HAVE_UINT64_T
 904 typedef unsigned long   uint64_t;
 905 typedef          long    int64_t;
 906 #endif
 907 #elif _STDINT_LONG_MODEL+0 == 448
 908 /*      LLP64   a 64-bit system derived from a 32-bit system */
 909 typedef unsigned char   uint8_t;
 910 typedef unsigned short  uint16_t;
 911 typedef unsigned int    uint32_t;
 912 #ifndef __int8_t_defined
 913 #define __int8_t_defined
 914 typedef          char    int8_t;
 915 typedef          short   int16_t;
 916 typedef          int     int32_t;
 917 #endif
 918 /* assuming the system has a "long long" */
 919 #ifndef _HAVE_UINT64_T
 920 #define _HAVE_UINT64_T
 921 typedef unsigned long long uint64_t;
 922 typedef          long long  int64_t;
 923 #endif
 924 #else
 925 #define _STDINT_NO_INT32_T
 926 #endif
 927 #else
 928 #define _STDINT_NO_INT8_T
 929 #define _STDINT_NO_INT32_T
 930 #endif
 931 #endif
 932
 933 /*
 934  * quote from SunOS-5.8 sys/inttypes.h:
 935  * Use at your own risk.  As of February 1996, the committee is squarely
 936  * behind the fixed sized types; the "least" and "fast" types are still being
 937  * discussed.  The probability that the "fast" types may be removed before
 938  * the standard is finalized is high enough that they are not currently
 939  * implemented.
 940  */
 941
 942 #if defined _STDINT_NEED_INT_LEAST_T
 943 typedef  int8_t    int_least8_t;
 944 typedef  int16_t   int_least16_t;
 945 typedef  int32_t   int_least32_t;
 946 #ifdef _HAVE_UINT64_T
 947 typedef  int64_t   int_least64_t;
 948 #endif
 949
 950 typedef uint8_t   uint_least8_t;
 951 typedef uint16_t  uint_least16_t;
 952 typedef uint32_t  uint_least32_t;
 953 #ifdef _HAVE_UINT64_T
 954 typedef uint64_t  uint_least64_t;
 955 #endif
 956   /* least types */
 957 #endif
 958
 959 #if defined _STDINT_NEED_INT_FAST_T
 960 typedef  int8_t    int_fast8_t;
 961 typedef  int       int_fast16_t;
 962 typedef  int32_t   int_fast32_t;
 963 #ifdef _HAVE_UINT64_T
 964 typedef  int64_t   int_fast64_t;
 965 #endif
 966
 967 typedef uint8_t   uint_fast8_t;
 968 typedef unsigned  uint_fast16_t;
 969 typedef uint32_t  uint_fast32_t;
 970 #ifdef _HAVE_UINT64_T
 971 typedef uint64_t  uint_fast64_t;
 972 #endif
 973   /* fast types */
 974 #endif
 975
 976 #ifdef _STDINT_NEED_INTMAX_T
 977 #ifdef _HAVE_UINT64_T
 978 typedef  int64_t       intmax_t;
 979 typedef uint64_t      uintmax_t;
 980 #else
 981 typedef          long  intmax_t;
 982 typedef unsigned long uintmax_t;
 983 #endif
 984 #endif
 985
 986 #ifdef _STDINT_NEED_INTPTR_T
 987 #ifndef __intptr_t_defined
 988 #define __intptr_t_defined
 989 /* we encourage using "long" to store pointer values, never use "int" ! */
 990 #if   _STDINT_LONG_MODEL+0 == 242 || _STDINT_LONG_MODEL+0 == 484
 991 typedef  unsinged int   uintptr_t;
 992 typedef           int    intptr_t;
 993 #elif _STDINT_LONG_MODEL+0 == 244 || _STDINT_LONG_MODEL+0 == 444
 994 typedef  unsigned long  uintptr_t;
 995 typedef           long   intptr_t;
 996 #elif _STDINT_LONG_MODEL+0 == 448 && defined _HAVE_UINT64_T
 997 typedef        uint64_t uintptr_t;
 998 typedef         int64_t  intptr_t;
 999 #else /* matches typical system types ILP32 and LP64 - but not IP16 or LLP64 */
1000 typedef  unsigned long  uintptr_t;
1001 typedef           long   intptr_t;
1002 #endif
1003 #endif
1004 #endif
1005
1006   /* shortcircuit*/
1007 #endif
1008   /* once */
1009 #endif
1010 #endif
1011 STDINT_EOF
1012     if cmp -s $ac_stdint_h $ac_stdint 2>/dev/null; then
1013       AC_MSG_NOTICE([$ac_stdint_h is unchanged])
1014     else
1015       ac_dir=`AS_DIRNAME(["$ac_stdint_h"])`
1016       AS_MKDIR_P(["$ac_dir"])
1017       rm -f $ac_stdint_h
1018       mv $ac_stdint $ac_stdint_h
1019     fi
1020 ],[# variables for create stdint.h replacement
1021 PACKAGE="$PACKAGE"
1022 VERSION="$VERSION"
1023 ac_stdint_h="$ac_stdint_h"
1024 _ac_stdint_h=AS_TR_CPP(_$PACKAGE-$ac_stdint_h)
1025 ac_cv_stdint_message="$ac_cv_stdint_message"
1026 ac_cv_header_stdint_t="$ac_cv_header_stdint_t"
1027 ac_cv_header_stdint_x="$ac_cv_header_stdint_x"
1028 ac_cv_header_stdint_o="$ac_cv_header_stdint_o"
1029 ac_cv_header_stdint_u="$ac_cv_header_stdint_u"
1030 ac_cv_type_uint64_t="$ac_cv_type_uint64_t"
1031 ac_cv_type_u_int64_t="$ac_cv_type_u_int64_t"
1032 ac_cv_stdint_char_model="$ac_cv_stdint_char_model"
1033 ac_cv_stdint_long_model="$ac_cv_stdint_long_model"
1034 ac_cv_type_int_least32_t="$ac_cv_type_int_least32_t"
1035 ac_cv_type_int_fast32_t="$ac_cv_type_int_fast32_t"
1036 ac_cv_type_intmax_t="$ac_cv_type_intmax_t"
1037 ])
1038 ])