dnl @(#)aclocal.m4 1.39 04/07/25 Copyright 1998 J. Schilling dnl Set VARIABLE to VALUE in C-string form, verbatim, or 1. dnl AC_DEFINE_STRING(VARIABLE [, VALUE]) define(AC_DEFINE_STRING, [cat >> confdefs.h <<\EOF [#define] $1 ifelse($#, 2, "[$2]", $#, 3, "[$2]", 1) EOF ]) dnl Similar, but perform shell substitutions $ ` \ once on VALUE. define(AC_DEFINE_UNQUOTED_STRING, [cat >> confdefs.h < #include ], [struct stat s; s.st_spare1 = 0;], [ac_cv_struct_st_spare1=yes], [ac_cv_struct_st_spare1=no])]) if test $ac_cv_struct_st_spare1 = yes; then AC_DEFINE(HAVE_ST_SPARE1) fi]) dnl Checks if structure 'stat' have field 'st_atimensec'. dnl Defines HAVE_ST_ATIMENSEC on success. AC_DEFUN([AC_STRUCT_ST_ATIMENSEC], [AC_CACHE_CHECK([if struct stat contains st_atimensec], ac_cv_struct_st_atimensec, [AC_TRY_COMPILE([#include #include ], [struct stat s; s.st_atimensec = 0;], [ac_cv_struct_st_atimensec=yes], [ac_cv_struct_st_atimensec=no])]) if test $ac_cv_struct_st_atimensec = yes; then AC_DEFINE(HAVE_ST_ATIMENSEC) fi]) dnl Checks if structure 'stat' have field 'st_atim.tv_nsec'. dnl Defines HAVE_ST_NSEC on success. AC_DEFUN([AC_STRUCT_ST_NSEC], [AC_CACHE_CHECK([if struct stat contains st_atim.tv_nsec], ac_cv_struct_st_nsec, [AC_TRY_COMPILE([#include #include ], [struct stat s; s.st_atim.tv_nsec = 0;], [ac_cv_struct_st_nsec=yes], [ac_cv_struct_st_nsec=no])]) if test $ac_cv_struct_st_nsec = yes; then AC_DEFINE(HAVE_ST_NSEC) fi]) dnl Checks if structure 'stat' have field 'st_atim.st__tim.tv_nsec'. dnl Defines HAVE_ST__TIM on success. AC_DEFUN([AC_STRUCT_ST__TIM], [AC_CACHE_CHECK([if struct stat contains st_atim.st__tim.tv_nsec], ac_cv_struct_st__tim, [AC_TRY_COMPILE([#include #include ], [struct stat s; s.st_atim.st__tim.tv_nsec = 0;], [ac_cv_struct_st__tim=yes], [ac_cv_struct_st__tim=no])]) if test $ac_cv_struct_st__tim = yes; then AC_DEFINE(HAVE_ST__TIM) fi]) dnl Checks if structure 'stat' have field 'st_atimspec.tv_nsec'. dnl Defines HAVE_ST_ATIMESPEC on success. AC_DEFUN([AC_STRUCT_ST_ATIMESPEC], [AC_CACHE_CHECK([if struct stat contains st_atimespec.tv_nsec], ac_cv_struct_st_atimespec, [AC_TRY_COMPILE([#include #include ], [struct stat s; s.st_atimespec.tv_nsec = 0;], [ac_cv_struct_st_atimespec=yes], [ac_cv_struct_st_atimespec=no])]) if test $ac_cv_struct_st_atimespec = yes; then AC_DEFINE(HAVE_ST_ATIMESPEC) fi]) dnl Checks if structure 'stat' have field 'st_flags'. dnl Defines HAVE_ST_FLAGS on success. AC_DEFUN([AC_STRUCT_ST_FLAGS], [AC_CACHE_CHECK([if struct stat contains st_flags], ac_cv_struct_st_flags, [AC_TRY_COMPILE([#include #include ], [struct stat s; s.st_flags = 0;], [ac_cv_struct_st_flags=yes], [ac_cv_struct_st_flags=no])]) if test $ac_cv_struct_st_flags = yes; then AC_DEFINE(HAVE_ST_FLAGS) fi]) dnl Checks if structure 'stat' have field 'st_fstype'. dnl Defines HAVE_ST_FSTYPE on success. AC_DEFUN([AC_STRUCT_ST_FSTYPE], [AC_CACHE_CHECK([if struct stat contains st_fstype], ac_cv_struct_st_fstype, [AC_TRY_COMPILE([#include #include ], [struct stat s; s.st_fstype[0] = 0;], [ac_cv_struct_st_fstype=yes], [ac_cv_struct_st_fstype=no])]) if test $ac_cv_struct_st_fstype = yes; then AC_DEFINE(HAVE_ST_FSTYPE) fi]) dnl Checks if structure 'mtget' have field 'mt_type'. dnl Defines HAVE_MTGET_TYPE on success. AC_DEFUN([AC_STRUCT_MTGET_TYPE], [AC_CACHE_CHECK([if struct mtget contains mt_type], ac_cv_struct_mtget_type, [AC_TRY_COMPILE([#include #include ], [struct mtget t; t.mt_type = 0;], [ac_cv_struct_mtget_type=yes], [ac_cv_struct_mtget_type=no])]) if test $ac_cv_struct_mtget_type = yes; then AC_DEFINE(HAVE_MTGET_TYPE) fi]) dnl Checks if structure 'mtget' have field 'mt_model'. dnl Defines HAVE_MTGET_MODEL on success. AC_DEFUN([AC_STRUCT_MTGET_MODEL], [AC_CACHE_CHECK([if struct mtget contains mt_model], ac_cv_struct_mtget_model, [AC_TRY_COMPILE([#include #include ], [struct mtget t; t.mt_model = 0;], [ac_cv_struct_mtget_model=yes], [ac_cv_struct_mtget_model=no])]) if test $ac_cv_struct_mtget_model = yes; then AC_DEFINE(HAVE_MTGET_MODEL) fi]) dnl Checks if structure 'mtget' have field 'mt_dsreg'. dnl Defines HAVE_MTGET_DSREG on success. AC_DEFUN([AC_STRUCT_MTGET_DSREG], [AC_CACHE_CHECK([if struct mtget contains mt_dsreg], ac_cv_struct_mtget_dsreg, [AC_TRY_COMPILE([#include #include ], [struct mtget t; t.mt_dsreg = 0;], [ac_cv_struct_mtget_dsreg=yes], [ac_cv_struct_mtget_dsreg=no])]) if test $ac_cv_struct_mtget_dsreg = yes; then AC_DEFINE(HAVE_MTGET_DSREG) fi]) dnl Checks if structure 'mtget' have field 'mt_dsreg1'. dnl Defines HAVE_MTGET_DSREG on success. AC_DEFUN([AC_STRUCT_MTGET_DSREG1], [AC_CACHE_CHECK([if struct mtget contains mt_dsreg1], ac_cv_struct_mtget_dsreg1, [AC_TRY_COMPILE([#include #include ], [struct mtget t; t.mt_dsreg1 = 0;], [ac_cv_struct_mtget_dsreg1=yes], [ac_cv_struct_mtget_dsreg1=no])]) if test $ac_cv_struct_mtget_dsreg1 = yes; then AC_DEFINE(HAVE_MTGET_DSREG1) fi]) dnl Checks if structure 'mtget' have field 'mt_dsreg2'. dnl Defines HAVE_MTGET_DSREG2 on success. AC_DEFUN([AC_STRUCT_MTGET_DSREG2], [AC_CACHE_CHECK([if struct mtget contains mt_dsreg2], ac_cv_struct_mtget_dsreg2, [AC_TRY_COMPILE([#include #include ], [struct mtget t; t.mt_dsreg2 = 0;], [ac_cv_struct_mtget_dsreg2=yes], [ac_cv_struct_mtget_dsreg2=no])]) if test $ac_cv_struct_mtget_dsreg2 = yes; then AC_DEFINE(HAVE_MTGET_DSREG2) fi]) dnl Checks if structure 'mtget' have field 'mt_gstat'. dnl Defines HAVE_MTGET_GSTAT on success. AC_DEFUN([AC_STRUCT_MTGET_GSTAT], [AC_CACHE_CHECK([if struct mtget contains mt_gstat], ac_cv_struct_mtget_gstat, [AC_TRY_COMPILE([#include #include ], [struct mtget t; t.mt_gstat = 0;], [ac_cv_struct_mtget_gstat=yes], [ac_cv_struct_mtget_gstat=no])]) if test $ac_cv_struct_mtget_gstat = yes; then AC_DEFINE(HAVE_MTGET_GSTAT) fi]) dnl Checks if structure 'mtget' have field 'mt_erreg'. dnl Defines HAVE_MTGET_ERREG on success. AC_DEFUN([AC_STRUCT_MTGET_ERREG], [AC_CACHE_CHECK([if struct mtget contains mt_erreg], ac_cv_struct_mtget_erreg, [AC_TRY_COMPILE([#include #include ], [struct mtget t; t.mt_erreg = 0;], [ac_cv_struct_mtget_erreg=yes], [ac_cv_struct_mtget_erreg=no])]) if test $ac_cv_struct_mtget_erreg = yes; then AC_DEFINE(HAVE_MTGET_ERREG) fi]) dnl Checks if structure 'mtget' have field 'mt_resid'. dnl Defines HAVE_MTGET_RESID on success. AC_DEFUN([AC_STRUCT_MTGET_RESID], [AC_CACHE_CHECK([if struct mtget contains mt_resid], ac_cv_struct_mtget_resid, [AC_TRY_COMPILE([#include #include ], [struct mtget t; t.mt_resid = 0;], [ac_cv_struct_mtget_resid=yes], [ac_cv_struct_mtget_resid=no])]) if test $ac_cv_struct_mtget_resid = yes; then AC_DEFINE(HAVE_MTGET_RESID) fi]) dnl Checks if structure 'mtget' have field 'mt_fileno'. dnl Defines HAVE_MTGET_FILENO on success. AC_DEFUN([AC_STRUCT_MTGET_FILENO], [AC_CACHE_CHECK([if struct mtget contains mt_fileno], ac_cv_struct_mtget_fileno, [AC_TRY_COMPILE([#include #include ], [struct mtget t; t.mt_fileno = 0;], [ac_cv_struct_mtget_fileno=yes], [ac_cv_struct_mtget_fileno=no])]) if test $ac_cv_struct_mtget_fileno = yes; then AC_DEFINE(HAVE_MTGET_FILENO) fi]) dnl Checks if structure 'mtget' have field 'mt_blkno'. dnl Defines HAVE_MTGET_BLKNO on success. AC_DEFUN([AC_STRUCT_MTGET_BLKNO], [AC_CACHE_CHECK([if struct mtget contains mt_blkno], ac_cv_struct_mtget_blkno, [AC_TRY_COMPILE([#include #include ], [struct mtget t; t.mt_blkno = 0;], [ac_cv_struct_mtget_blkno=yes], [ac_cv_struct_mtget_blkno=no])]) if test $ac_cv_struct_mtget_blkno = yes; then AC_DEFINE(HAVE_MTGET_BLKNO) fi]) dnl Checks if structure 'mtget' have field 'mt_flags'. dnl Defines HAVE_MTGET_FLAGS on success. AC_DEFUN([AC_STRUCT_MTGET_FLAGS], [AC_CACHE_CHECK([if struct mtget contains mt_flags], ac_cv_struct_mtget_flags, [AC_TRY_COMPILE([#include #include ], [struct mtget t; t.mt_flags = 0;], [ac_cv_struct_mtget_flags=yes], [ac_cv_struct_mtget_flags=no])]) if test $ac_cv_struct_mtget_flags = yes; then AC_DEFINE(HAVE_MTGET_FLAGS) fi]) dnl Checks if structure 'mtget' have field 'mt_bf'. dnl Defines HAVE_MTGET_BF on success. AC_DEFUN([AC_STRUCT_MTGET_BF], [AC_CACHE_CHECK([if struct mtget contains mt_bf], ac_cv_struct_mtget_bf, [AC_TRY_COMPILE([#include #include ], [struct mtget t; t.mt_bf = 0;], [ac_cv_struct_mtget_bf=yes], [ac_cv_struct_mtget_bf=no])]) if test $ac_cv_struct_mtget_bf = yes; then AC_DEFINE(HAVE_MTGET_BF) fi]) dnl Checks for illegal declaration of 'union semun' in sys/sem.h. dnl Defines HAVE_UNION_SEMUN on success. AC_DEFUN([AC_STRUCT_UNION_SEMUN], [AC_CACHE_CHECK([if an illegal declaration for union semun in sys/sem.h exists], ac_cv_struct_union_semun, [AC_TRY_COMPILE([#include #include #include ], [union semun s;], [ac_cv_struct_union_semun=yes], [ac_cv_struct_union_semun=no])]) if test $ac_cv_struct_union_semun = yes; then AC_DEFINE(HAVE_UNION_SEMUN) fi]) dnl Checks if 'union wait' is declared in 'wait.h' or 'sys/wait.h'. dnl Defines HAVE_UNION_WAIT on success. AC_DEFUN([AC_STRUCT_UNION_WAIT], [AC_CACHE_CHECK([if union wait is declared in wait.h or sys/wait.h], ac_cv_struct_union_wait, [AC_TRY_COMPILE([#include #if defined(HAVE_WAIT_H) # include #else #include #endif], [union wait w;], [ac_cv_struct_union_wait=yes], [ac_cv_struct_union_wait=no])]) if test $ac_cv_struct_union_wait = yes; then AC_DEFINE(HAVE_UNION_WAIT) fi]) dnl Checks if 'struct rusage' is declared in sys/resource.h. dnl Defines HAVE_STRUCT_RUSAGE on success. AC_DEFUN([AC_STRUCT_RUSAGE], [AC_CACHE_CHECK([if struct rusage is declared in sys/resource.h], ac_cv_struct_rusage, [AC_TRY_COMPILE([#include #include ], [struct rusage r;], [ac_cv_struct_rusage=yes], [ac_cv_struct_rusage=no])]) if test $ac_cv_struct_rusage = yes; then AC_DEFINE(HAVE_STRUCT_RUSAGE) fi]) dnl Checks if structure 'siginfo' have field 'si_utime'. dnl Defines HAVE_SI_UTIME on success. AC_DEFUN([AC_STRUCT_SI_UTIME], [AC_CACHE_CHECK([if struct siginfo contains si_utime], ac_cv_struct_si_utime, [AC_TRY_COMPILE([#include #include ], [struct siginfo si; si.si_utime = 0;], [ac_cv_struct_si_utime=yes], [ac_cv_struct_si_utime=no])]) if test $ac_cv_struct_si_utime = yes; then AC_DEFINE(HAVE_SI_UTIME) fi]) dnl Checks wether major(), minor() and makedev() are defined in dnl 'sys/mkdev.h' or in 'sys/sysmacros.h. Defines MAJOR_IN_MKDEV or dnl MAJOR_IN_SYSMACROS or nothing. AC_DEFUN([AC_HEADER_MAKEDEV], [AC_CACHE_CHECK([for header file containing major(), minor() and makedev()], ac_cv_header_makedev, [ac_cv_header_makedev=none AC_TRY_COMPILE([#include #include ], [int i = major(0); i = minor(0); i = makedev(0,0);], [ac_cv_header_makedev=sys/mkdev.h]) if test $ac_cv_header_makedev = none; then AC_TRY_COMPILE([#include #include ], [int i = major(0); i = minor(0); i = makedev(0,0);], [ac_cv_header_makedev=sys/sysmacros.h]) fi]) if test $ac_cv_header_makedev = sys/mkdev.h; then AC_DEFINE(MAJOR_IN_MKDEV) fi if test $ac_cv_header_makedev = sys/sysmacros.h; then AC_DEFINE(MAJOR_IN_SYSMACROS) fi]) dnl Checks for USG derived STDIO that uses _filbuf() dnl Defines HAVE__FILBUF on success. AC_DEFUN([AC_HEADER__FILBUF], [AC_CACHE_CHECK([for _filbuf()], ac_cv_func__filbuf, [AC_TRY_LINK([#include ], [FILE *f; int flag; int count; char *ptr; char c = 0; f = fopen("confdefs.h", "r"); _filbuf(f); _flsbuf(c, f); flag = f->_flag & _IONBF; flag |= f->_flag & _IOERR; flag |= f->_flag & _IOEOF; count = f->_cnt; ptr = (char *)f->_ptr; fclose(f);], [ac_cv_func__filbuf=yes], [ac_cv_func__filbuf=no])]) if test $ac_cv_func__filbuf = yes; then AC_DEFINE(HAVE__FILBUF) fi]) dnl Checks for USG derived STDIO that uses __filbuf() dnl Defines HAVE___FILBUF on success. AC_DEFUN([AC_HEADER___FILBUF], [AC_CACHE_CHECK([for __filbuf()], ac_cv_func___filbuf, [AC_TRY_LINK([#include ], [FILE *f; int flag; int count; char *ptr; char c = 0; f = fopen("confdefs.h", "r"); __filbuf(f); __flsbuf(c, f); flag = f->_flag & _IONBF; flag |= f->_flag & _IOERR; flag |= f->_flag & _IOEOF; count = f->_cnt; ptr = (char *)f->_ptr; fclose(f);], [ac_cv_func___filbuf=yes], [ac_cv_func___filbuf=no])]) if test $ac_cv_func___filbuf = yes; then AC_DEFINE(HAVE___FILBUF) fi]) dnl Checks for USG derived STDIO dnl Defines HAVE_USG_STDIO on success. AC_DEFUN([AC_HEADER_USG_STDIO], [AC_REQUIRE([AC_HEADER__FILBUF])AC_REQUIRE([AC_HEADER___FILBUF])dnl AC_CACHE_CHECK([for USG derived STDIO], ac_cv_header_usg_stdio, [AC_TRY_LINK([#include ], [FILE *f; int flag; int count; char *ptr; char c = 0; f = fopen("confdefs.h", "r"); #ifdef HAVE___FILBUF __filbuf(f); __flsbuf(c, f); #else # ifdef HAVE__FILBUF _filbuf(f); _flsbuf(c, f); # else no filbuf() # endif #endif flag = f->_flag & _IONBF; flag |= f->_flag & _IOERR; flag |= f->_flag & _IOEOF; count = f->_cnt; ptr = (char *)f->_ptr; fclose(f);], [ac_cv_header_usg_stdio=yes], [ac_cv_header_usg_stdio=no])]) if test $ac_cv_header_usg_stdio = yes; then AC_DEFINE(HAVE_USG_STDIO) fi]) dnl Checks for errno definition in dnl Defines HAVE_ERRNO_DEF on success. AC_DEFUN([AC_HEADER_ERRNO_DEF], [AC_CACHE_CHECK([for errno definition in errno.h], ac_cv_header_errno_def, [AC_TRY_COMPILE([#include ], [errno = 0;], [ac_cv_header_errno_def=yes], [ac_cv_header_errno_def=no])]) if test $ac_cv_header_errno_def = yes; then AC_DEFINE(HAVE_ERRNO_DEF) fi]) dnl Checks for UNIX-98 compliant dnl Defines HAVE_INTTYPES_H on success. AC_DEFUN([AC_HEADER_INTTYPES], [AC_CACHE_CHECK([for UNIX-98 compliant inttypes.h], ac_cv_header_inttypes, [AC_TRY_COMPILE([#include ], [int8_t c; uint8_t uc; int16_t s; uint16_t us; int32_t i; uint32_t ui; int64_t ll; uint64_t ull; intptr_t ip; uintptr_t uip;], [ac_cv_header_inttypes=yes], [ac_cv_header_inttypes=no])]) if test $ac_cv_header_inttypes = yes; then AC_DEFINE(HAVE_INTTYPES_H) fi]) dnl Checks for type time_t dnl Defines time_t to long on failure. AC_DEFUN([AC_TYPE_TIME_T], [AC_REQUIRE([AC_HEADER_TIME])dnl AC_CACHE_CHECK([for time_t], ac_cv_type_time_t, [AC_TRY_COMPILE([ #include #ifdef TIME_WITH_SYS_TIME_H # include # include #else #ifdef HAVE_SYS_TIME_H # include #else # include #endif #endif], [time_t t;], [ac_cv_type_time_t=yes], [ac_cv_type_time_t=no])]) if test $ac_cv_type_time_t = no; then AC_DEFINE(time_t, long) fi]) dnl Checks for type clock_t dnl Defines clock_t to long on failure. AC_DEFUN([AC_TYPE_CLOCK_T], [AC_REQUIRE([AC_HEADER_TIME])dnl AC_CACHE_CHECK([for clock_t], ac_cv_type_clock_t, [AC_TRY_COMPILE([ #include /* * time.h is needed because of a bug in Next Step. * Next Step needs time.h for clock_t */ #ifdef TIME_WITH_SYS_TIME # ifndef _INCL_SYS_TIME_H # include # define _INCL_SYS_TIME_H # endif # ifndef _INCL_TIME_H # include # define _INCL_TIME_H # endif #else #ifdef HAVE_SYS_TIME_H # ifndef _INCL_SYS_TIME_H # include # define _INCL_SYS_TIME_H # endif #else # ifndef _INCL_TIME_H # include # define _INCL_TIME_H # endif #endif #endif #include ], [clock_t t;], [ac_cv_type_clock_t=yes], [ac_cv_type_clock_t=no])]) if test $ac_cv_type_clock_t = no; then AC_DEFINE(clock_t, long) fi]) dnl Checks for type socklen_t dnl Defines socklen_t to int on failure. AC_DEFUN([AC_TYPE_SOCKLEN_T], [AC_REQUIRE([AC_HEADER_STDC])dnl AC_MSG_CHECKING(for socklen_t) AC_CACHE_VAL(ac_cv_type_socklen_t, [AC_EGREP_CPP(dnl changequote(<<,>>)dnl <<(^|[^a-zA-Z_0-9])socklen_t[^a-zA-Z_0-9]>>dnl changequote([,]), [#include #if STDC_HEADERS #include #include #endif #include ], ac_cv_type_socklen_t=yes, ac_cv_type_socklen_t=no)])dnl AC_MSG_RESULT($ac_cv_type_socklen_t) if test $ac_cv_type_socklen_t = no; then AC_DEFINE(socklen_t, int) fi]) dnl Checks for type struct sockaddr_storage dnl Defines HAVE_SOCKADDR_STORAGE on success. AC_DEFUN([AC_STRUCT_SOCKADDR_STORAGE], [AC_CACHE_CHECK([if struct sockaddr_storage is declared in socket.h], ac_cv_struct_sockaddr_storage, [AC_TRY_COMPILE([#include ], [struct sockaddr_storage ss; ss.ss_family = 0;], [ac_cv_struct_sockaddr_storage=yes], [ac_cv_struct_sockaddr_storage=no])]) if test $ac_cv_struct_sockaddr_storage = yes; then AC_DEFINE(HAVE_SOCKADDR_STORAGE) fi]) dnl Checks for type long long dnl Defines HAVE_LONGLONG on success. AC_DEFUN([AC_TYPE_LONGLONG], [AC_CACHE_CHECK([for type long long], ac_cv_type_longlong, [AC_TRY_COMPILE([], [long long i;], [ac_cv_type_longlong=yes], [ac_cv_type_longlong=no])]) if test $ac_cv_type_longlong = yes; then AC_DEFINE(HAVE_LONGLONG) fi]) dnl Checks if C-compiler orders bitfields htol dnl Defines BITFIELDS_HTOL on success. AC_DEFUN([AC_C_BITFIELDS], [AC_CACHE_CHECK([whether bitorder in bitfields is htol], ac_cv_c_bitfields_htol, [AC_TRY_RUN([ struct { unsigned char x1:4; unsigned char x2:4; } a; int main() { char *cp; cp = (char *)&a; *cp = 0x12; exit(a.x1 == 2);}], [ac_cv_c_bitfields_htol=yes], [ac_cv_c_bitfields_htol=no])]) if test $ac_cv_c_bitfields_htol = yes; then AC_DEFINE(BITFIELDS_HTOL) fi]) dnl Checks if C-compiler understands prototypes dnl Defines PROTOTYPES on success. AC_DEFUN([AC_TYPE_PROTOTYPES], [AC_CACHE_CHECK([for prototypes], ac_cv_type_prototypes, [AC_TRY_RUN([ doit(int i, ...) {return 0;} int main(int ac, char *av[]) { doit(1, 2, 3); exit(0);}], [ac_cv_type_prototypes=yes], [ac_cv_type_prototypes=no])]) if test $ac_cv_type_prototypes = yes; then AC_DEFINE(PROTOTYPES) fi]) dnl Checks for type size_t dnl Defines HAVE_SIZE_T_ on success. AC_DEFUN([AC_TYPE_SIZE_T_], [AC_CACHE_CHECK([for type size_t], ac_cv_type_size_t_, [AC_TRY_COMPILE([#include ], [size_t s;], [ac_cv_type_size_t_=yes], [ac_cv_type_size_t_=no])]) if test $ac_cv_type_size_t_ = yes; then AC_DEFINE(HAVE_SIZE_T) else AC_DEFINE(NO_SIZE_T) fi]) dnl Checks if type char is unsigned dnl Defines CHAR_IS_UNSIGNED on success. AC_DEFUN([AC_TYPE_CHAR], [AC_CACHE_CHECK([if char is unsigned], ac_cv_type_char_unsigned, [AC_TRY_RUN([ int main() { char c; c = -1; exit(c < 0);}], [ac_cv_type_char_unsigned=yes], [ac_cv_type_char_unsigned=no], [ac_cv_type_char_unsigned=no])]) if test $ac_cv_type_char_unsigned = yes; then AC_DEFINE(CHAR_IS_UNSIGNED) fi]) dnl Checks if function/macro va_copy() is available dnl Defines HAVE_VA_COPY on success. AC_DEFUN([AC_FUNC_VA_COPY], [AC_CACHE_CHECK([for va_copy], ac_cv_func_va_copy, [AC_TRY_LINK([ #ifdef HAVE_STDARG_H # include #else # include #endif], [ va_list a, b; va_copy(a, b);], [ac_cv_func_va_copy=yes], [ac_cv_func_va_copy=no])]) if test $ac_cv_func_va_copy = yes; then AC_DEFINE(HAVE_VA_COPY) fi]) dnl Checks if function/macro __va_copy() is available dnl Defines HAVE__VA_COPY on success. AC_DEFUN([AC_FUNC__VA_COPY], [AC_CACHE_CHECK([for __va_copy], ac_cv_func__va_copy, [AC_TRY_LINK([ #ifdef HAVE_STDARG_H # include #else # include #endif], [ va_list a, b; __va_copy(a, b);], [ac_cv_func__va_copy=yes], [ac_cv_func__va_copy=no])]) if test $ac_cv_func__va_copy = yes; then AC_DEFINE(HAVE__VA_COPY) fi]) dnl Checks if va_list is an array dnl Defines VA_LIST_IS_ARRAY on success. AC_DEFUN([AC_TYPE_VA_LIST], [AC_CACHE_CHECK([if va_list is an array], ac_cv_type_va_list_array, [AC_TRY_LINK([ #ifdef HAVE_STDARG_H # include #else # include #endif ], [ va_list a, b; a = b;], [ac_cv_type_va_list_array=no], [ac_cv_type_va_list_array=yes])]) if test $ac_cv_type_va_list_array = yes; then AC_DEFINE(VA_LIST_IS_ARRAY) fi]) dnl Checks if quotactl is present as ioctl dnl Defines HAVE_QUOTAIOCTL on success. AC_DEFUN([AC_FUNC_QUOTAIOCTL], [AC_CACHE_CHECK([if quotactl is an ioctl], ac_cv_func_quotaioctl, [AC_TRY_LINK([#include #include ], [struct quotctl q; ioctl(0, Q_QUOTACTL, &q)], [ac_cv_func_quotaioctl=yes], [ac_cv_func_quotaioctl=no])]) if test $ac_cv_func_quotaioctl = yes; then AC_DEFINE(HAVE_QUOTAIOCTL) fi]) dnl Checks if function __dtoa() is available dnl Defines HAVE_DTOA on success. AC_DEFUN([AC_FUNC_DTOA], [AC_CACHE_CHECK([for __dtoa], ac_cv_func_dtoa, [AC_TRY_LINK([extern char *__dtoa();], [int decpt; int sign; char *ep; char *bp; bp = __dtoa(0.0, 2, 6, &decpt, &sign, &ep);], [ac_cv_func_dtoa=yes], [ac_cv_func_dtoa=no])]) if test $ac_cv_func_dtoa = yes; then AC_DEFINE(HAVE_DTOA) fi]) dnl Checks if reentrant __dtoa() exists (needs a result prt) dnl Defines HAVE_DTOA_R on success. AC_DEFUN([AC_FUNC_DTOA_R], [AC_REQUIRE([AC_FUNC_DTOA])dnl AC_CACHE_CHECK([for __dtoa that needs result ptr], ac_cv_func_dtoa_r, [AC_TRY_RUN([ extern char *__dtoa(); int main() { #ifdef HAVE_DTOA int decpt, sign; char *bp; char *ep; char *result; result = 0; bp = __dtoa(1.9, 2, 5, &decpt, &sign, &ep, &result); exit(result == 0); #else exit(1); #endif }], [ac_cv_func_dtoa_r=yes], [ac_cv_func_dtoa_r=no])]) if test $ac_cv_func_dtoa_r = yes; then AC_DEFINE(HAVE_DTOA_R) fi]) dnl Checks if working ecvt() exists dnl Defines HAVE_ECVT on success. AC_DEFUN([AC_FUNC_ECVT], [AC_CACHE_CHECK([for working ecvt() ], ac_cv_func_ecvt, [AC_TRY_RUN([ extern char *ecvt(); sprintf(s) char *s; { strcpy(s, "DEAD"); } int main() { int a, b; /* exit (strcmp("DEAD", ecvt(1.9, 2, &a, &b)) == 0);*/ exit (strcmp("19", ecvt(1.9, 2, &a, &b)) != 0); }], [ac_cv_func_ecvt=yes], [ac_cv_func_ecvt=no])]) if test $ac_cv_func_ecvt = yes; then AC_DEFINE(HAVE_ECVT) fi]) dnl Checks if working fcvt() exists dnl Defines HAVE_FCVT on success. AC_DEFUN([AC_FUNC_FCVT], [AC_CACHE_CHECK([for working fcvt() ], ac_cv_func_fcvt, [AC_TRY_RUN([ extern char *fcvt(); sprintf(s) char *s; { strcpy(s, "DEAD"); } int main() { int a, b; /* exit (strcmp("DEAD", fcvt(1.9, 2, &a, &b)) == 0);*/ exit (strcmp("190", fcvt(1.9, 2, &a, &b)) != 0); }], [ac_cv_func_fcvt=yes], [ac_cv_func_fcvt=no])]) if test $ac_cv_func_fcvt = yes; then AC_DEFINE(HAVE_FCVT) fi]) dnl Checks if working gcvt() exists dnl Defines HAVE_GCVT on success. AC_DEFUN([AC_FUNC_GCVT], [AC_CACHE_CHECK([for working gcvt() ], ac_cv_func_gcvt, [AC_TRY_RUN([ extern char *gcvt(); sprintf(s) char *s; { strcpy(s, "DEAD"); } int main() { char buf[32]; /* exit (strcmp("DEAD", gcvt(1.9, 10, buf)) == 0);*/ exit (strcmp("1.9", gcvt(1.9, 10, buf)) != 0); }], [ac_cv_func_gcvt=yes], [ac_cv_func_gcvt=no])]) if test $ac_cv_func_gcvt = yes; then AC_DEFINE(HAVE_GCVT) fi]) dnl Checks if function uname() is available dnl Defines HAVE_UNAME on success. AC_DEFUN([AC_FUNC_UNAME], [AC_CACHE_CHECK([for uname], ac_cv_func_uname, [AC_TRY_LINK([#include ], [struct utsname un; uname(&un);], [ac_cv_func_uname=yes], [ac_cv_func_uname=no])]) if test $ac_cv_func_uname = yes; then AC_DEFINE(HAVE_UNAME) fi]) dnl Checks if function mlockall() is available dnl beware HP-UX 10.x it contains a bad mlockall() in libc dnl Defines HAVE_MLOCK on success. AC_DEFUN([AC_FUNC_MLOCK], [AC_REQUIRE([AC_HEADER_ERRNO_DEF])dnl AC_CACHE_CHECK([for mlock], ac_cv_func_mlock, [AC_TRY_RUN([ #include #include #ifndef HAVE_ERRNO_DEF extern int errno; #endif main() { if (mlock(0, 0) < 0) { if (errno == EINVAL || errno == ENOMEM || errno == EPERM || errno == EACCES) exit(0); exit(-1); } exit(0); }], [ac_cv_func_mlock=yes], [ac_cv_func_mlock=no])]) if test $ac_cv_func_mlock = yes; then AC_DEFINE(HAVE_MLOCK) fi]) dnl Checks if function mlockall() is available dnl beware HP-UX 10.x it contains a bad mlockall() in libc dnl Defines HAVE_MLOCKALL on success. AC_DEFUN([AC_FUNC_MLOCKALL], [AC_REQUIRE([AC_HEADER_ERRNO_DEF])dnl AC_CACHE_CHECK([for mlockall], ac_cv_func_mlockall, [AC_TRY_RUN([ #include #include #include #ifndef HAVE_ERRNO_DEF extern int errno; #endif int main() { if (mlockall(MCL_CURRENT|MCL_FUTURE) < 0) { if (errno == EINVAL || errno == ENOMEM || errno == EPERM || errno == EACCES) exit(0); exit(-1); } exit(0); } ], [ac_cv_func_mlockall=yes], [ac_cv_func_mlockall=no])]) if test $ac_cv_func_mlockall = yes; then AC_DEFINE(HAVE_MLOCKALL) fi]) AC_DEFUN([jsAC_FUNC_MMAP], [AC_REQUIRE([AC_MMAP_SIZEP])dnl AC_CHECK_HEADERS(unistd.h) AC_CHECK_FUNCS(getpagesize) AC_CACHE_CHECK(for working mmap, ac_cv_func_mmap_fixed_mapped, [AC_TRY_RUN([ /* Thanks to Mike Haertel and Jim Avera for this test. Here is a matrix of mmap possibilities: mmap private not fixed mmap private fixed at somewhere currently unmapped mmap private fixed at somewhere already mapped mmap shared not fixed mmap shared fixed at somewhere currently unmapped mmap shared fixed at somewhere already mapped For private mappings, we should verify that changes cannot be read() back from the file, nor mmap's back from the file at a different address. (There have been systems where private was not correctly implemented like the infamous i386 svr4.0, and systems where the VM page cache was not coherent with the filesystem buffer cache like early versions of FreeBSD and possibly contemporary NetBSD.) For shared mappings, we should conversely verify that changes get propogated back to all the places they're supposed to be. Grep wants private fixed already mapped. The main things grep needs to know about mmap are: * does it exist and is it safe to write into the mmap'd area * how to use it (BSD variants) */ #include #include #include /* * Needed for Apollo Domain/OS and may be for others? */ #ifdef _MMAP_WITH_SIZEP # define mmap_sizeparm(s) (&(s)) #else # define mmap_sizeparm(s) (s) #endif /* This mess was copied from the GNU getpagesize.h. */ #ifndef HAVE_GETPAGESIZE # ifdef HAVE_UNISTD_H # include # endif /* Assume that all systems that can run configure have sys/param.h. */ # ifndef HAVE_SYS_PARAM_H # define HAVE_SYS_PARAM_H 1 # endif # ifdef _SC_PAGESIZE # define getpagesize() sysconf(_SC_PAGESIZE) # else /* no _SC_PAGESIZE */ # ifdef HAVE_SYS_PARAM_H # include # ifdef EXEC_PAGESIZE # define getpagesize() EXEC_PAGESIZE # else /* no EXEC_PAGESIZE */ # ifdef NBPG # define getpagesize() NBPG * CLSIZE # ifndef CLSIZE # define CLSIZE 1 # endif /* no CLSIZE */ # else /* no NBPG */ # ifdef NBPC # define getpagesize() NBPC # else /* no NBPC */ # ifdef PAGESIZE # define getpagesize() PAGESIZE # endif /* PAGESIZE */ # endif /* no NBPC */ # endif /* no NBPG */ # endif /* no EXEC_PAGESIZE */ # else /* no HAVE_SYS_PARAM_H */ # define getpagesize() 8192 /* punt totally */ # endif /* no HAVE_SYS_PARAM_H */ # endif /* no _SC_PAGESIZE */ #endif /* no HAVE_GETPAGESIZE */ #ifdef __cplusplus extern "C" { void *malloc(unsigned); } #else char *malloc(); #endif int main() { char *data, *data2, *data3; int i, pagesize; int fd; pagesize = getpagesize(); /* * First, make a file with some known garbage in it. */ data = malloc(pagesize); if (!data) exit(1); for (i = 0; i < pagesize; ++i) *(data + i) = rand(); umask(0); fd = creat("conftestmmap", 0600); if (fd < 0) exit(1); if (write(fd, data, pagesize) != pagesize) exit(1); close(fd); /* * Next, try to mmap the file at a fixed address which * already has something else allocated at it. If we can, * also make sure that we see the same garbage. */ fd = open("conftestmmap", O_RDWR); if (fd < 0) exit(1); data2 = malloc(2 * pagesize); if (!data2) exit(1); data2 += (pagesize - ((int) data2 & (pagesize - 1))) & (pagesize - 1); if (data2 != mmap(data2, mmap_sizeparm(pagesize), PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_FIXED, fd, 0L)) exit(1); for (i = 0; i < pagesize; ++i) if (*(data + i) != *(data2 + i)) exit(1); /* * Finally, make sure that changes to the mapped area * do not percolate back to the file as seen by read(). * (This is a bug on some variants of i386 svr4.0.) */ for (i = 0; i < pagesize; ++i) *(data2 + i) = *(data2 + i) + 1; data3 = malloc(pagesize); if (!data3) exit(1); if (read(fd, data3, pagesize) != pagesize) exit(1); for (i = 0; i < pagesize; ++i) if (*(data + i) != *(data3 + i)) exit(1); close(fd); unlink("conftestmmap"); exit(0); } ], ac_cv_func_mmap_fixed_mapped=yes, ac_cv_func_mmap_fixed_mapped=no, ac_cv_func_mmap_fixed_mapped=no)]) if test $ac_cv_func_mmap_fixed_mapped = yes; then AC_DEFINE(HAVE_MMAP) fi ]) AC_DEFUN([AC_MMAP_SIZEP], [AC_CHECK_HEADERS(unistd.h) AC_CHECK_FUNCS(getpagesize) AC_CACHE_CHECK(for mmap that needs ptr to size, ac_cv_func_mmap_sizep, [AC_TRY_RUN([ #include #include #include #include #include #ifndef MAP_FILE #define MAP_FILE 0 /* Needed on Apollo Domain/OS */ #endif /* This mess was copied from the GNU getpagesize.h. */ #ifndef HAVE_GETPAGESIZE # ifdef HAVE_UNISTD_H # include # endif /* Assume that all systems that can run configure have sys/param.h. */ # ifndef HAVE_SYS_PARAM_H # define HAVE_SYS_PARAM_H 1 # endif # ifdef _SC_PAGESIZE # define getpagesize() sysconf(_SC_PAGESIZE) # else /* no _SC_PAGESIZE */ # ifdef HAVE_SYS_PARAM_H # include # ifdef EXEC_PAGESIZE # define getpagesize() EXEC_PAGESIZE # else /* no EXEC_PAGESIZE */ # ifdef NBPG # define getpagesize() NBPG * CLSIZE # ifndef CLSIZE # define CLSIZE 1 # endif /* no CLSIZE */ # else /* no NBPG */ # ifdef NBPC # define getpagesize() NBPC # else /* no NBPC */ # ifdef PAGESIZE # define getpagesize() PAGESIZE # endif /* PAGESIZE */ # endif /* no NBPC */ # endif /* no NBPG */ # endif /* no EXEC_PAGESIZE */ # else /* no HAVE_SYS_PARAM_H */ # define getpagesize() 8192 /* punt totally */ # endif /* no HAVE_SYS_PARAM_H */ # endif /* no _SC_PAGESIZE */ #endif /* no HAVE_GETPAGESIZE */ #ifdef __cplusplus extern "C" { void *malloc(unsigned); } #else char *malloc(); #endif jmp_buf jenv; int intr() { signal(SIGSEGV, intr); longjmp(jenv, 1); } int main() { char *data, *data2; int i, pagesize, ps; int fd; pagesize = getpagesize(); /* * First, make a file with some known garbage in it. */ data = malloc(pagesize); if (!data) exit(1); for (i = 0; i < pagesize; ++i) *(data + i) = rand(); umask(0); fd = creat("conftestmmap", 0600); if (fd < 0) exit(1); if (write(fd, data, pagesize) != pagesize) exit(1); close(fd); /* * Next, try to mmap the file at a fixed address which * already has something else allocated at it. If we can, * also make sure that we see the same garbage. */ fd = open("conftestmmap", O_RDWR); if (fd < 0) exit(1); /* * Keep a copy, Apollo modifies the value... */ ps = pagesize; /* * Apollo mmap() is not a syscall but a library function and fails * if it tries to dereference 'ps'. We must use setjmp in order to * catch the failure. */ signal(SIGSEGV, intr); if (setjmp(jenv) == 0) { data2 = mmap(0, ps, PROT_READ, MAP_FILE | MAP_PRIVATE, fd, 0L); } else { data2 = (char *)-1; } if (data2 != (char *)-1) exit(1); signal(SIGSEGV, intr); if (setjmp(jenv) == 0) { data2 = mmap(0, &ps, PROT_READ, MAP_FILE | MAP_PRIVATE, fd, 0L); } else { data2 = (char *)-1; } if (data2 == (char *)-1) exit(1); for (i = 0; i < pagesize; ++i) if (*(data + i) != *(data2 + i)) exit(1); close(fd); unlink("conftestmmap"); exit(0); } ], ac_cv_func_mmap_sizep=yes, ac_cv_func_mmap_sizep=no, ac_cv_func_mmap_sizep=no)]) if test $ac_cv_func_mmap_sizep = yes; then AC_DEFINE(_MMAP_WITH_SIZEP) fi ]) dnl Checks if mmap() works to get shared memory dnl Defines HAVE_SMMAP on success. AC_DEFUN([AC_FUNC_SMMAP], [AC_CACHE_CHECK([if mmap works to get shared memory], ac_cv_func_smmap, [AC_TRY_RUN([ #include #include #ifndef MAP_ANONYMOUS # ifdef MAP_ANON # define MAP_ANONYMOUS MAP_ANON # endif #endif /* * Needed for Apollo Domain/OS and may be for others? */ #ifdef _MMAP_WITH_SIZEP # define mmap_sizeparm(s) (&(s)) #else # define mmap_sizeparm(s) (s) #endif char * mkshare() { int size = 8192; int f; char *addr; #ifdef MAP_ANONYMOUS /* HP/UX */ f = -1; addr = mmap(0, mmap_sizeparm(size), PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, f, 0); #else if ((f = open("/dev/zero", 2)) < 0) exit(1); addr = mmap(0, mmap_sizeparm(size), PROT_READ|PROT_WRITE, MAP_SHARED, f, 0); #endif if (addr == (char *)-1) exit(1); close(f); return (addr); } int main() { char *addr; addr = mkshare(); *addr = 'I'; switch (fork()) { case -1: printf("help\n"); exit(1); case 0: /* child */ *addr = 'N'; _exit(0); break; default: /* parent */ wait(0); sleep(1); break; } if (*addr != 'N') exit(1); exit(0); } ], [ac_cv_func_smmap=yes], [ac_cv_func_smmap=no], [ac_cv_func_smmap=no])]) if test $ac_cv_func_smmap = yes; then AC_DEFINE(HAVE_SMMAP) fi]) dnl Checks if sys_siglist[] exists dnl Defines HAVE_SYS_SIGLIST on success. AC_DEFUN([AC_FUNC_SYS_SIGLIST], [AC_CACHE_CHECK([for sys_siglist], ac_cv_func_sys_siglist, [AC_TRY_RUN([ int main() { extern char *sys_siglist[]; if (sys_siglist[1] == 0) exit(1); exit(0);}], [ac_cv_func_sys_siglist=yes], [ac_cv_func_sys_siglist=no])]) if test $ac_cv_func_sys_siglist = yes; then AC_DEFINE(HAVE_SYS_SIGLIST) fi]) dnl Checks for maximum number of bits in minor device number AC_DEFUN([AC_CHECK_MINOR_BITS], [AC_REQUIRE([AC_HEADER_MAKEDEV])dnl changequote(<<, >>)dnl define(<>, DEV_MINOR_BITS)dnl dnl The cache variable name. define(<>, ac_cv_dev_minor_bits)dnl changequote([, ])dnl AC_MSG_CHECKING(bits in minor device number) AC_CACHE_VAL(AC_CV_NAME, [AC_TRY_RUN([#include #include #ifdef major # define _FOUND_MAJOR_ #endif #ifdef MAJOR_IN_MKDEV # include # define _FOUND_MAJOR_ #endif #ifndef _FOUND_MAJOR_ # ifdef MAJOR_IN_SYSMACROS # include # define _FOUND_MAJOR_ # endif #endif #ifndef _FOUND_MAJOR_ # if defined(hpux) || defined(__hpux__) || defined(__hpux) # include # define _FOUND_MAJOR_ # endif #endif #ifndef _FOUND_MAJOR_ # define major(dev) (((dev) >> 8) & 0xFF) # define minor(dev) ((dev) & 0xFF) # define makedev(majo, mino) (((majo) << 8) | (mino)) #endif int main() { long l = 1; int i; int m; int c = 0; FILE *f=fopen("conftestval", "w"); if (!f) exit(1); for (i=1, m=0; i <= 32; i++, l<<=1) { if (minor(l) == 0 && c == 0) c = m; if (minor(l) != 0) m = i; } fprintf(f, "%d\n", m); exit(0); }], AC_CV_NAME=`cat conftestval`, AC_CV_NAME=0, ifelse([$2], , , AC_CV_NAME=$2))])dnl AC_MSG_RESULT($AC_CV_NAME) AC_DEFINE_UNQUOTED(AC_MACRO_NAME, $AC_CV_NAME) undefine([AC_MACRO_NAME])dnl undefine([AC_CV_NAME])dnl ]) dnl Checks for maximum number of bits in minor device numbers are non contiguous dnl Defines DEV_MINOR_NONCONTIG on success. AC_DEFUN([AC_CHECK_MINOR_NONCONTIG], [AC_REQUIRE([AC_HEADER_MAKEDEV])dnl AC_CACHE_CHECK([whether bits in minor device numbers are non contiguous], ac_cv_dev_minor_noncontig, [AC_TRY_RUN([ #include #ifdef major # define _FOUND_MAJOR_ #endif #ifdef MAJOR_IN_MKDEV # include # define _FOUND_MAJOR_ #endif #ifndef _FOUND_MAJOR_ # ifdef MAJOR_IN_SYSMACROS # include # define _FOUND_MAJOR_ # endif #endif #ifndef _FOUND_MAJOR_ # if defined(hpux) || defined(__hpux__) || defined(__hpux) # include # define _FOUND_MAJOR_ # endif #endif #ifndef _FOUND_MAJOR_ # define major(dev) (((dev) >> 8) & 0xFF) # define minor(dev) ((dev) & 0xFF) # define makedev(majo, mino) (((majo) << 8) | (mino)) #endif int main() { long l = 1; int i; int m; int c = 0; for (i=1, m=0; i <= 32; i++, l<<=1) { if (minor(l) == 0 && c == 0) c = m; if (minor(l) != 0) m = i; } exit (m == c);}], [ac_cv_dev_minor_noncontig=yes], [ac_cv_dev_minor_noncontig=no])]) if test $ac_cv_dev_minor_noncontig = yes; then AC_DEFINE(DEV_MINOR_NONCONTIG) fi]) dnl Checks if we may not define our own malloc() dnl Defines NO_USER_MALLOC if we cannot. AC_DEFUN([AC_USER_MALLOC], [AC_CACHE_CHECK([if we may not define our own malloc()], ac_cv_no_user_malloc, [AC_TRY_RUN([ static int mcalled; char * malloc(s) int s; { extern char *sbrk(); mcalled++; _exit(0); return (sbrk(s)); } free(p) char *p;{} main() { #ifdef HAVE_STRDUP strdup("aaa"); #else exit(0); #endif exit(1);}], [ac_cv_no_user_malloc=no], [ac_cv_no_user_malloc=yes])]) if test $ac_cv_no_user_malloc = yes; then AC_DEFINE(NO_USER_MALLOC) fi]) dnl Checks if BSD-4.2 compliant getpgrp() exists dnl Defines HAVE_BSD_GETPGRP on success. AC_DEFUN([AC_FUNC_BSD_GETPGRP], [AC_CACHE_CHECK([for BSD compliant getpgrp], ac_cv_func_bsd_getpgrp, [AC_TRY_RUN([ int main() { long p; /* * POSIX getpgrp() has void parameter... */ p = getpgrp(-1); if (p == getpgrp(1) && p == getpgrp(getpid())) exit(1); exit(0);}], [ac_cv_func_bsd_getpgrp=yes], [ac_cv_func_bsd_getpgrp=no])]) if test $ac_cv_func_bsd_getpgrp = yes; then AC_DEFINE(HAVE_BSD_GETPGRP) fi]) dnl Checks if BSD-4.2 compliant setpgrp() exists dnl Defines HAVE_BSD_SETPGRP on success. AC_DEFUN([AC_FUNC_BSD_SETPGRP], [AC_REQUIRE([AC_HEADER_ERRNO_DEF])dnl AC_CACHE_CHECK([for BSD compliant setpgrp], ac_cv_func_bsd_setpgrp, [AC_TRY_RUN([ #include #ifndef HAVE_ERRNO_DEF extern int errno; #endif int main() { errno = 0; /* * Force illegal pid on BSD */ if (setpgrp(-1, 100) < 0 && errno == ESRCH) exit(0); exit(1);}], [ac_cv_func_bsd_setpgrp=yes], [ac_cv_func_bsd_setpgrp=no])]) if test $ac_cv_func_bsd_setpgrp = yes; then AC_DEFINE(HAVE_BSD_SETPGRP) fi]) dnl Checks if select() needs more than sys/time.h & sys/types.h dnl Defines SELECT_NONSTD_HDR on success. AC_DEFUN([AC_HEADER_SELECT_NONSTD], [AC_CACHE_CHECK([if select needs nonstd include files], ac_cv_header_slect_nonstd_hdr, [AC_TRY_COMPILE([#include #include ], [fd_set rfd; FD_ZERO(&rfd); select(1, &rfd, 0, 0, 0);], [ac_cv_header_slect_nonstd_hdr=no], [ac_cv_header_slect_nonstd_hdr=yes])]) if test $ac_cv_header_slect_nonstd_hdr = yes; then AC_DEFINE(SELECT_NONSTD_HDR) fi]) dnl Checks if select() needs sys/select.h dnl Defines NEED_SYS_SELECT_H on success. AC_DEFUN([AC_HEADER_SYS_SELECT], [AC_REQUIRE([AC_HEADER_SELECT_NONSTD])dnl AC_CACHE_CHECK([if sys/select.h is needed for select], ac_cv_header_need_sys_select_h, [AC_TRY_COMPILE([#include #include #include #ifndef SELECT_NONSTD_HDR do not compile if we do not need nonstandard headers #endif], [fd_set rfd; FD_ZERO(&rfd); select(1, &rfd, 0, 0, 0);], [ac_cv_header_need_sys_select_h=yes], [ac_cv_header_need_sys_select_h=no])]) if test $ac_cv_header_need_sys_select_h = yes; then AC_DEFINE(NEED_SYS_SELECT_H) fi]) dnl Checks if select() needs sys/socket.h dnl Defines NEED_SYS_SOCKET_H on success. AC_DEFUN([AC_HEADER_SELECT2], [AC_REQUIRE([AC_HEADER_SELECT_NONSTD])dnl AC_CACHE_CHECK([if sys/socket.h is needed for select], ac_cv_header_need_sys_socket_h, [AC_TRY_COMPILE([#include #include #include #ifndef SELECT_NONSTD_HDR do not compile if we do not need nonstandard headers #endif], [fd_set rfd; FD_ZERO(&rfd); select(1, &rfd, 0, 0, 0);], [ac_cv_header_need_sys_socket_h=yes], [ac_cv_header_need_sys_socket_h=no])]) if test $ac_cv_header_need_sys_socket_h = yes; then AC_DEFINE(NEED_SYS_SOCKET_H) fi]) dnl Checks if file locking via fcntl() is available dnl Defines HAVE_FCNTL_LOCKF on success. AC_DEFUN([AC_FUNC_FCNTL_LOCKF], [AC_CACHE_CHECK([for file locking via fcntl], ac_cv_func_fcntl_lock, [AC_TRY_LINK([ #include #include ], [ struct flock fl; fcntl(0, F_SETLK, &fl);], [ac_cv_func_fcntl_lock=yes], [ac_cv_func_fcntl_lock=no])]) if test $ac_cv_func_fcntl_lock = yes; then AC_DEFINE(HAVE_FCNTL_LOCKF) fi]) dnl Checks if link() allows hard links on symlinks dnl Defines HAVE_HARD_SYMLINKS on success. AC_DEFUN([AC_HARD_SYMLINKS], [AC_CACHE_CHECK([if link() allows hard links on symlinks], ac_cv_hard_symlinks, [AC_TRY_RUN([ main() { int ret = 0; unlink("confdefs.f1"); unlink("confdefs.l1"); unlink("confdefs.h1"); if (symlink("confdefs.f1", "confdefs.l1") < 0) ret = 1; if (link("confdefs.l1", "confdefs.h1") < 0) ret = 1; unlink("confdefs.l1"); unlink("confdefs.h1"); exit(ret); }], [ac_cv_hard_symlinks=yes], [ac_cv_hard_symlinks=no])]) if test $ac_cv_hard_symlinks = yes; then AC_DEFINE(HAVE_HARD_SYMLINKS) fi]) dnl Checks if link() does not follow symlinks dnl Defines HAVE_LINK_NOFOLLOW on success. AC_DEFUN([AC_LINK_NOFOLLOW], [AC_CACHE_CHECK([if link() does not folow symlinks], ac_cv_link_nofollow, [AC_TRY_RUN([ #include #include main() { int ret = 0; int f; struct stat sb; unlink("confdefs.f1"); unlink("confdefs.l1"); unlink("confdefs.h1"); f = creat("confdefs.f1", 0666); close(f); if (symlink("confdefs.f1", "confdefs.l1") < 0) ret = 1; if (link("confdefs.l1", "confdefs.h1") < 0) ret = 1; stat("confdefs.f1", &sb); if (sb.st_nlink == 2) ret = 1; unlink("confdefs.f1"); unlink("confdefs.l1"); unlink("confdefs.h1"); exit(ret); }], [ac_cv_link_nofollow=yes], [ac_cv_link_nofollow=no])]) if test $ac_cv_link_nofollow = yes; then AC_DEFINE(HAVE_LINK_NOFOLLOW) fi]) dnl Checks if access() does implement E_OK (010) for effective UIDs dnl Defines HAVE_ACCESS_E_OK on success. AC_DEFUN([AC_ACCESS_E_OK], [AC_REQUIRE([AC_HEADER_ERRNO_DEF])dnl AC_CHECK_HEADERS(unistd.h) AC_CACHE_CHECK([if access() does implement E_OK], ac_cv_access_e_ok, [AC_TRY_RUN([ # ifdef HAVE_UNISTD_H # include # endif #ifndef R_OK #define R_OK 4 /* Test for Read permission */ #define W_OK 2 /* Test for Write permission */ #define X_OK 1 /* Test for eXecute permission */ #define F_OK 0 /* Test for existence of File */ #endif #ifndef E_OK #ifdef EFF_ONLY_OK #define E_OK EFF_ONLY_OK /* Irix */ #else #ifdef EUID_OK #define E_OK EUID_OK /* UNICOS (0400) */ #else #define E_OK 010 /* Test effective uids */ #endif #endif #endif #include #ifndef HAVE_ERRNO_DEF extern int errno; #endif main() { int ret = 0; if (access(".", F_OK) != 0) ret = 1; else if (access(".", E_OK|F_OK) != 0) ret = 1; else if (access(".", (R_OK<<4)|F_OK) == 0) ret = 1; exit(ret); }], [ac_cv_access_e_ok=yes], [ac_cv_access_e_ok=no])]) if test $ac_cv_access_e_ok = yes; then AC_DEFINE(HAVE_ACCESS_E_OK) fi]) dnl XXXXXXXXXXXXXXXXXX Begin Stolen (but modified) from GNU tar XXXXXXXXXXXXXXXXXXXXXXXXXXX dnl Changes: dnl One line has been changed to: [ac_save_CC="${CC-cc}" to default to "'cc" dnl AC_SYS_LARGEFILE_MACRO_VALUE test moved from AC_FUNC_FSEEKO into AC_SYS_LARGEFILE dnl Do not call AC_FUNC_FSEEKO because it does not check whether fseeko() is dnl available on non Large File mode. There are additionoal tests for fseeko()/ftello() dnl inside the AC_HAVE_LARGEFILES test. dnl largefile_cc_opt definition added #serial 18 dnl By default, many hosts won't let programs access large files; dnl one must use special compiler options to get large-file access to work. dnl For more details about this brain damage please see: dnl http://www.sas.com/standards/large.file/x_open.20Mar96.html dnl Written by Paul Eggert . dnl Internal subroutine of AC_SYS_LARGEFILE. dnl AC_SYS_LARGEFILE_TEST_INCLUDES AC_DEFUN([AC_SYS_LARGEFILE_TEST_INCLUDES], [[#include /* Check that off_t can represent 2**63 - 1 correctly. We can't simply "#define LARGE_OFF_T 9223372036854775807", since some C++ compilers masquerading as C compilers incorrectly reject 9223372036854775807. */ # define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62)) int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 && LARGE_OFF_T % 2147483647 == 1) ? 1 : -1]; ]]) dnl Internal subroutine of AC_SYS_LARGEFILE. dnl AC_SYS_LARGEFILE_MACRO_VALUE(C-MACRO, VALUE, CACHE-VAR, COMMENT, INCLUDES, FUNCTION-BODY) AC_DEFUN([AC_SYS_LARGEFILE_MACRO_VALUE], [AC_CACHE_CHECK([for $1 value needed for large files], $3, [$3=no AC_TRY_COMPILE([$5], [$6], , [AC_TRY_COMPILE([#define $1 $2] [$5] , [$6], [$3=$2])])]) if test "[$]$3" != no; then AC_DEFINE_UNQUOTED([$1], [$]$3, [$4]) fi]) AC_DEFUN([AC_SYS_LARGEFILE], [AC_ARG_ENABLE(largefile, [ --disable-largefile omit support for large files]) if test "$enable_largefile" != no; then AC_CACHE_CHECK([for special C compiler options needed for large files], ac_cv_sys_largefile_CC, [ac_cv_sys_largefile_CC=no largefile_cc_opt="" if test "$GCC" != yes; then # IRIX 6.2 and later do not support large files by default, # so use the C compiler's -n32 option if that helps. AC_TRY_COMPILE(AC_SYS_LARGEFILE_TEST_INCLUDES, , , [ac_save_CC="${CC-cc}" CC="$CC -n32" AC_TRY_COMPILE(AC_SYS_LARGEFILE_TEST_INCLUDES, , ac_cv_sys_largefile_CC=' -n32') CC="$ac_save_CC"]) fi]) if test "$ac_cv_sys_largefile_CC" != no; then CC="$CC$ac_cv_sys_largefile_CC" largefile_cc_opt="$ac_cv_sys_largefile_CC" fi AC_SYS_LARGEFILE_MACRO_VALUE(_FILE_OFFSET_BITS, 64, ac_cv_sys_file_offset_bits, [Number of bits in a file offset, on hosts where this is settable.], AC_SYS_LARGEFILE_TEST_INCLUDES) AC_SYS_LARGEFILE_MACRO_VALUE(_LARGE_FILES, 1, ac_cv_sys_large_files, [Define for large files, on AIX-style hosts.], AC_SYS_LARGEFILE_TEST_INCLUDES) AC_SYS_LARGEFILE_MACRO_VALUE(_LARGEFILE_SOURCE, 1, ac_cv_sys_largefile_source, [Define to make fseeko visible on some hosts (e.g. glibc 2.2).], [#include ], [return !fseeko;]) fi ]) AC_DEFUN([AC_FUNC_FSEEKO], [AC_SYS_LARGEFILE_MACRO_VALUE(_LARGEFILE_SOURCE, 1, ac_cv_sys_largefile_source, [Define to make fseeko visible on some hosts (e.g. glibc 2.2).], [#include ], [return !fseeko;]) # We used to try defining _XOPEN_SOURCE=500 too, to work around a bug # in glibc 2.1.3, but that breaks too many other things. # If you want fseeko and ftello with glibc, upgrade to a fixed glibc. AC_CACHE_CHECK([for fseeko], ac_cv_func_fseeko, [ac_cv_func_fseeko=no AC_TRY_LINK([#include ], [return fseeko && fseeko (stdin, 0, 0);], [ac_cv_func_fseeko=yes])]) if test $ac_cv_func_fseeko != no; then AC_DEFINE(HAVE_FSEEKO, 1, [Define if fseeko (and presumably ftello) exists and is declared.]) fi]) dnl XXXXXXXXXXXXXXXXXX End Stolen (but modified) from GNU tar XXXXXXXXXXXXXXXXXXXXXXXXXXXXX AC_DEFUN([AC_HAVE_LARGEFILES], [AC_CACHE_CHECK([if system supports Large Files at all], ac_cv_largefiles, [AC_TRY_COMPILE([#include #include ], [ /* * Check that off_t can represent 2**63 - 1 correctly. * We can't simply "#define LARGE_OFF_T 9223372036854775807", * since some C++ compilers masquerading as C compilers * incorrectly reject 9223372036854775807. */ # define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62)) int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 && LARGE_OFF_T % 2147483647 == 1) ? 1 : -1]; return !fseeko; return !ftello;], [ac_cv_largefiles=yes], [ac_cv_largefiles=no])]) if test $ac_cv_largefiles = yes; then AC_DEFINE(HAVE_LARGEFILES) fi]) dnl Checks for whether fseeko() is available in non large file mode dnl and whether there is a prototype for fseeko() dnl Defines HAVE_FSEEKO on success. AC_DEFUN([AC_SMALL_FSEEKO], [AC_CACHE_CHECK([for fseeko()], ac_cv_func_fseeko, [AC_TRY_LINK([#include ], [return !fseeko;], [ac_cv_func_fseeko=yes], [ac_cv_func_fseeko=no])]) if test $ac_cv_func_fseeko = yes; then AC_DEFINE(HAVE_FSEEKO) fi]) dnl Checks for whether ftello() is available in non large file mode dnl and whether there is a prototype for ftello() dnl Defines HAVE_FTELLO on success. AC_DEFUN([AC_SMALL_FTELLO], [AC_CACHE_CHECK([for ftello()], ac_cv_func_ftello, [AC_TRY_LINK([#include ], [return !ftello;], [ac_cv_func_ftello=yes], [ac_cv_func_ftello=no])]) if test $ac_cv_func_ftello = yes; then AC_DEFINE(HAVE_FTELLO) fi]) dnl Checks if compiler allows dynamic arrays. dnl Defines HAVE_DYN_ARRAYS on success. AC_DEFUN([AC_DYN_ARRAYS], [AC_CACHE_CHECK([if compiler allows dynamic arrays], ac_cv_dyn_arrays, [AC_TRY_COMPILE([], [extern int __aa(); int len = __aa(); char some_array[len];], [ac_cv_dyn_arrays=yes], [ac_cv_dyn_arrays=no])]) if test $ac_cv_dyn_arrays = yes; then AC_DEFINE(HAVE_DYN_ARRAYS) fi])