dnl $XTermId: aclocal.m4,v 1.342 2012/06/26 09:57:45 tom Exp $ dnl dnl --------------------------------------------------------------------------- dnl dnl Copyright 1997-2011,2012 by Thomas E. Dickey dnl dnl All Rights Reserved dnl dnl Permission is hereby granted, free of charge, to any person obtaining a dnl copy of this software and associated documentation files (the dnl "Software"), to deal in the Software without restriction, including dnl without limitation the rights to use, copy, modify, merge, publish, dnl distribute, sublicense, and/or sell copies of the Software, and to dnl permit persons to whom the Software is furnished to do so, subject to dnl the following conditions: dnl dnl The above copyright notice and this permission notice shall be included dnl in all copies or substantial portions of the Software. dnl dnl THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS dnl OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF dnl MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. dnl IN NO EVENT SHALL THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY dnl CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, dnl TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE dnl SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. dnl dnl Except as contained in this notice, the name(s) of the above copyright dnl holders shall not be used in advertising or otherwise to promote the dnl sale, use or other dealings in this Software without prior written dnl authorization. dnl dnl --------------------------------------------------------------------------- dnl See dnl http://invisible-island.net/autoconf/autoconf.html dnl --------------------------------------------------------------------------- dnl --------------------------------------------------------------------------- dnl AM_LANGINFO_CODESET version: 3 updated: 2002/10/27 23:21:42 dnl ------------------- dnl Inserted as requested by gettext 0.10.40 dnl File from /usr/share/aclocal dnl codeset.m4 dnl ==================== dnl serial AM1 dnl dnl From Bruno Haible. AC_DEFUN([AM_LANGINFO_CODESET], [ AC_CACHE_CHECK([for nl_langinfo and CODESET], am_cv_langinfo_codeset, [AC_TRY_LINK([#include ], [char* cs = nl_langinfo(CODESET);], am_cv_langinfo_codeset=yes, am_cv_langinfo_codeset=no) ]) if test $am_cv_langinfo_codeset = yes; then AC_DEFINE(HAVE_LANGINFO_CODESET, 1, [Define if you have and nl_langinfo(CODESET).]) fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_ACVERSION_CHECK version: 2 updated: 2011/05/08 11:22:03 dnl ------------------ dnl Conditionally generate script according to whether we're using a given autoconf. dnl dnl $1 = version to compare against dnl $2 = code to use if AC_ACVERSION is at least as high as $1. dnl $3 = code to use if AC_ACVERSION is older than $1. define(CF_ACVERSION_CHECK, [ ifdef([m4_version_compare], [m4_if(m4_version_compare(m4_defn([AC_ACVERSION]), [$1]), -1, [$3], [$2])], [CF_ACVERSION_COMPARE( AC_PREREQ_CANON(AC_PREREQ_SPLIT([$1])), AC_PREREQ_CANON(AC_PREREQ_SPLIT(AC_ACVERSION)), AC_ACVERSION, [$2], [$3])])])dnl dnl --------------------------------------------------------------------------- dnl CF_ACVERSION_COMPARE version: 2 updated: 2011/04/14 20:56:50 dnl -------------------- dnl CF_ACVERSION_COMPARE(MAJOR1, MINOR1, TERNARY1, dnl MAJOR2, MINOR2, TERNARY2, dnl PRINTABLE2, not FOUND, FOUND) define(CF_ACVERSION_COMPARE, [ifelse(builtin([eval], [$2 < $5]), 1, [ifelse([$8], , ,[$8])], [ifelse([$9], , ,[$9])])])dnl dnl --------------------------------------------------------------------------- dnl CF_ADD_CFLAGS version: 10 updated: 2010/05/26 05:38:42 dnl ------------- dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS dnl The second parameter if given makes this macro verbose. dnl dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS, dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily dnl confused by the quotes (which require backslashes to keep them usable). AC_DEFUN([CF_ADD_CFLAGS], [ cf_fix_cppflags=no cf_new_cflags= cf_new_cppflags= cf_new_extra_cppflags= for cf_add_cflags in $1 do case $cf_fix_cppflags in no) case $cf_add_cflags in #(vi -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi case $cf_add_cflags in -D*) cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'` test "${cf_add_cflags}" != "${cf_tst_cflags}" \ && test -z "${cf_tst_cflags}" \ && cf_fix_cppflags=yes if test $cf_fix_cppflags = yes ; then cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags" continue elif test "${cf_tst_cflags}" = "\"'" ; then cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags" continue fi ;; esac case "$CPPFLAGS" in *$cf_add_cflags) #(vi ;; *) #(vi case $cf_add_cflags in #(vi -D*) cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'` CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags) ;; esac cf_new_cppflags="$cf_new_cppflags $cf_add_cflags" ;; esac ;; *) cf_new_cflags="$cf_new_cflags $cf_add_cflags" ;; esac ;; yes) cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags" cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'` test "${cf_add_cflags}" != "${cf_tst_cflags}" \ && test -z "${cf_tst_cflags}" \ && cf_fix_cppflags=no ;; esac done if test -n "$cf_new_cflags" ; then ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)]) CFLAGS="$CFLAGS $cf_new_cflags" fi if test -n "$cf_new_cppflags" ; then ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)]) CPPFLAGS="$CPPFLAGS $cf_new_cppflags" fi if test -n "$cf_new_extra_cppflags" ; then ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)]) EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS" fi AC_SUBST(EXTRA_CPPFLAGS) ])dnl dnl --------------------------------------------------------------------------- dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05 dnl ---------- dnl Add a library, used to enforce consistency. dnl dnl $1 = library to add, without the "-l" dnl $2 = variable to update (default $LIBS) AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl dnl --------------------------------------------------------------------------- dnl CF_ADD_LIBS version: 1 updated: 2010/06/02 05:03:05 dnl ----------- dnl Add one or more libraries, used to enforce consistency. dnl dnl $1 = libraries to add, with the "-l", etc. dnl $2 = variable to update (default $LIBS) AC_DEFUN([CF_ADD_LIBS],[ifelse($2,,LIBS,[$2])="$1 [$]ifelse($2,,LIBS,[$2])"])dnl dnl --------------------------------------------------------------------------- dnl CF_ADD_LIB_AFTER version: 2 updated: 2010/11/08 20:33:46 dnl ---------------- dnl Add a given library after another, e.g., following the one it satisfies a dnl dependency for. dnl dnl $1 = the first library dnl $2 = its dependency AC_DEFUN([CF_ADD_LIB_AFTER],[ CF_VERBOSE(...before $LIBS) LIBS=`echo "$LIBS" | sed -e "s/[[ ]][[ ]]*/ /g" -e "s,$1 ,$1 $2 ," -e 's/ / /g'` CF_VERBOSE(...after $LIBS) ])dnl dnl --------------------------------------------------------------------------- dnl CF_ANSI_CC_CHECK version: 11 updated: 2011/07/01 19:47:45 dnl ---------------- dnl This was originally adapted from the macros 'fp_PROG_CC_STDC' and dnl 'fp_C_PROTOTYPES' in the sharutils 4.2 distribution. AC_DEFUN([CF_ANSI_CC_CHECK], [ # This should have been defined by AC_PROG_CC : ${CC:=cc} # Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content # into CC. This will not help with broken scripts that wrap the compiler with # options, but eliminates a more common category of user confusion. AC_MSG_CHECKING(\$CC variable) case "$CC" in #(vi *[[\ \ ]]-[[IUD]]*) AC_MSG_RESULT(broken) AC_MSG_WARN(your environment misuses the CC variable to hold CFLAGS/CPPFLAGS options) # humor him... cf_flags=`echo "$CC" | sed -e 's/^[[^ ]]*[[ ]]//'` CC=`echo "$CC" | sed -e 's/[[ ]].*//'` CF_ADD_CFLAGS($cf_flags) ;; *) AC_MSG_RESULT(ok) ;; esac AC_CACHE_CHECK(for ${CC:-cc} option to accept ANSI C, cf_cv_ansi_cc,[ cf_cv_ansi_cc=no cf_save_CFLAGS="$CFLAGS" cf_save_CPPFLAGS="$CPPFLAGS" # Don't try gcc -ansi; that turns off useful extensions and # breaks some systems' header files. # AIX -qlanglvl=ansi # Ultrix and OSF/1 -std1 # HP-UX -Aa -D_HPUX_SOURCE # SVR4 -Xc # UnixWare 1.2 (cannot use -Xc, since ANSI/POSIX clashes) for cf_arg in "-DCC_HAS_PROTOS" \ "" \ -qlanglvl=ansi \ -std1 \ -Ae \ "-Aa -D_HPUX_SOURCE" \ -Xc do CF_ADD_CFLAGS($cf_arg) AC_TRY_COMPILE( [ #ifndef CC_HAS_PROTOS #if !defined(__STDC__) || (__STDC__ != 1) choke me #endif #endif ],[ int test (int i, double x); struct s1 {int (*f) (int a);}; struct s2 {int (*f) (double a);};], [cf_cv_ansi_cc="$cf_arg"; break]) done CFLAGS="$cf_save_CFLAGS" CPPFLAGS="$cf_save_CPPFLAGS" ]) if test "$cf_cv_ansi_cc" != "no"; then if test ".$cf_cv_ansi_cc" != ".-DCC_HAS_PROTOS"; then CF_ADD_CFLAGS($cf_cv_ansi_cc) else AC_DEFINE(CC_HAS_PROTOS) fi fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31 dnl -------------- dnl Allow user to disable a normally-on option. AC_DEFUN([CF_ARG_DISABLE], [CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl dnl --------------------------------------------------------------------------- dnl CF_ARG_ENABLE version: 3 updated: 1999/03/30 17:24:31 dnl ------------- dnl Allow user to enable a normally-off option. AC_DEFUN([CF_ARG_ENABLE], [CF_ARG_OPTION($1,[$2],[$3],[$4],no)])dnl dnl --------------------------------------------------------------------------- dnl CF_ARG_OPTION version: 4 updated: 2010/05/26 05:38:42 dnl ------------- dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus dnl values. dnl dnl Parameters: dnl $1 = option name dnl $2 = help-string dnl $3 = action to perform if option is not default dnl $4 = action if perform if option is default dnl $5 = default option value (either 'yes' or 'no') AC_DEFUN([CF_ARG_OPTION], [AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes) if test "$enableval" != "$5" ; then ifelse([$3],,[ :]dnl ,[ $3]) ifelse([$4],,,[ else $4]) fi],[enableval=$5 ifelse([$4],,,[ $4 ])dnl ])])dnl dnl --------------------------------------------------------------------------- dnl CF_CHECK_CACHE version: 11 updated: 2008/03/23 14:45:59 dnl -------------- dnl Check if we're accidentally using a cache from a different machine. dnl Derive the system name, as a check for reusing the autoconf cache. dnl dnl If we've packaged config.guess and config.sub, run that (since it does a dnl better job than uname). Normally we'll use AC_CANONICAL_HOST, but allow dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM dnl which is useful in cross-compiles. dnl dnl Note: we would use $ac_config_sub, but that is one of the places where dnl autoconf 2.5x broke compatibility with autoconf 2.13 AC_DEFUN([CF_CHECK_CACHE], [ if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then ifelse([$1],,[AC_CANONICAL_HOST],[$1]) system_name="$host_os" else system_name="`(uname -s -r) 2>/dev/null`" if test -z "$system_name" ; then system_name="`(hostname) 2>/dev/null`" fi fi test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name") AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"]) test -z "$system_name" && system_name="$cf_cv_system_name" test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name) if test ".$system_name" != ".$cf_cv_system_name" ; then AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name)) AC_MSG_ERROR("Please remove config.cache and try again.") fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_CHECK_CFLAGS version: 2 updated: 2001/12/30 19:09:58 dnl --------------- dnl Conditionally add to $CFLAGS and $CPPFLAGS values which are derived from dnl a build-configuration such as imake. These have the pitfall that they dnl often contain compiler-specific options which we cannot use, mixed with dnl preprocessor options that we usually can. AC_DEFUN([CF_CHECK_CFLAGS], [ CF_VERBOSE(checking additions to CFLAGS) cf_check_cflags="$CFLAGS" cf_check_cppflags="$CPPFLAGS" CF_ADD_CFLAGS($1,yes) if test "$cf_check_cflags" != "$CFLAGS" ; then AC_TRY_LINK([#include ],[printf("Hello world");],, [CF_VERBOSE(test-compile failed. Undoing change to \$CFLAGS) if test "$cf_check_cppflags" != "$CPPFLAGS" ; then CF_VERBOSE(but keeping change to \$CPPFLAGS) fi CFLAGS="$cf_check_flags"]) fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_CHECK_ERRNO version: 11 updated: 2010/05/26 05:38:42 dnl -------------- dnl Check for data that is usually declared in or , e.g., dnl the 'errno' variable. Define a DECL_xxx symbol if we must declare it dnl ourselves. dnl dnl $1 = the name to check dnl $2 = the assumed type AC_DEFUN([CF_CHECK_ERRNO], [ AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[ AC_TRY_COMPILE([ #ifdef HAVE_STDLIB_H #include #endif #include #include #include ], ifelse([$2],,int,[$2]) x = (ifelse([$2],,int,[$2])) $1, [cf_cv_dcl_$1=yes], [cf_cv_dcl_$1=no]) ]) if test "$cf_cv_dcl_$1" = no ; then CF_UPPER(cf_result,decl_$1) AC_DEFINE_UNQUOTED($cf_result) fi # It's possible (for near-UNIX clones) that the data doesn't exist CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2])) ])dnl dnl --------------------------------------------------------------------------- dnl CF_CHECK_EXTERN_DATA version: 3 updated: 2001/12/30 18:03:23 dnl -------------------- dnl Check for existence of external data in the current set of libraries. If dnl we can modify it, it's real enough. dnl $1 = the name to check dnl $2 = its type AC_DEFUN([CF_CHECK_EXTERN_DATA], [ AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[ AC_TRY_LINK([ #undef $1 extern $2 $1; ], [$1 = 2], [cf_cv_have_$1=yes], [cf_cv_have_$1=no]) ]) if test "$cf_cv_have_$1" = yes ; then CF_UPPER(cf_result,have_$1) AC_DEFINE_UNQUOTED($cf_result) fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_CLANG_COMPILER version: 1 updated: 2012/06/16 14:55:39 dnl ----------------- dnl Check if the given compiler is really clang. clang's C driver defines dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does dnl not ignore some gcc options. dnl dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from dnl the wrappers for gcc and g++ warnings. dnl dnl $1 = GCC (default) or GXX dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS dnl $3 = CFLAGS (default) or CXXFLAGS AC_DEFUN([CF_CLANG_COMPILER],[ ifelse([$2],,CLANG_COMPILER,[$2])=no if test "$ifelse([$1],,[$1],GCC)" = yes ; then AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler) cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])" ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -Qunused-arguments" AC_TRY_COMPILE([],[ #ifdef __clang__ #else make an error #endif ],[ifelse([$2],,CLANG_COMPILER,[$2])=yes cf_save_CFLAGS="$cf_save_CFLAGS -Qunused-arguments" ],[]) ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS" AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2])) fi ]) dnl --------------------------------------------------------------------------- dnl CF_DISABLE_DESKTOP version: 2 updated: 2011/04/22 05:17:37 dnl ------------------ dnl Handle a configure option "--disable-desktop", which sets a shell dnl variable $desktop_utils to a "#" if the feature is not wanted, or to an dnl empty string if enabled. The variable is used to substitute in front of dnl corresponding makefile-rules. dnl dnl It also tells the configure script to substitute the environment variable dnl $DESKTOP_FLAGS, which can be used by external scripts to customize the dnl invocation of desktop-file-util. dnl dnl $1 = program name AC_DEFUN([CF_DISABLE_DESKTOP],[ # Comment-out the install-desktop rule if the desktop-utils are not found. AC_MSG_CHECKING(if you want to install desktop files) CF_ARG_OPTION(desktop, [ --disable-desktop disable install of $1 desktop files], [enable_desktop=$enableval], [enable_desktop=$enableval],yes) AC_MSG_RESULT($enable_desktop) desktop_utils= if test "$enable_desktop" = yes ; then AC_CHECK_PROG(desktop_utils,desktop-file-install,yes,no) fi test "$desktop_utils" = yes && desktop_utils= || desktop_utils="#" AC_SUBST(DESKTOP_FLAGS) ]) dnl --------------------------------------------------------------------------- dnl CF_DISABLE_ECHO version: 11 updated: 2009/12/13 13:16:57 dnl --------------- dnl You can always use "make -n" to see the actual options, but it's hard to dnl pick out/analyze warning messages when the compile-line is long. dnl dnl Sets: dnl ECHO_LT - symbol to control if libtool is verbose dnl ECHO_LD - symbol to prefix "cc -o" lines dnl RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o) dnl SHOW_CC - symbol to put before explicit "cc -c" lines dnl ECHO_CC - symbol to put before any "cc" line dnl AC_DEFUN([CF_DISABLE_ECHO],[ AC_MSG_CHECKING(if you want to see long compiling messages) CF_ARG_DISABLE(echo, [ --disable-echo display "compiling" commands], [ ECHO_LT='--silent' ECHO_LD='@echo linking [$]@;' RULE_CC='@echo compiling [$]<' SHOW_CC='@echo compiling [$]@' ECHO_CC='@' ],[ ECHO_LT='' ECHO_LD='' RULE_CC='' SHOW_CC='' ECHO_CC='' ]) AC_MSG_RESULT($enableval) AC_SUBST(ECHO_LT) AC_SUBST(ECHO_LD) AC_SUBST(RULE_CC) AC_SUBST(SHOW_CC) AC_SUBST(ECHO_CC) ])dnl dnl --------------------------------------------------------------------------- dnl CF_DISABLE_RPATH_HACK version: 2 updated: 2011/02/13 13:31:33 dnl --------------------- dnl The rpath-hack makes it simpler to build programs, particularly with the dnl *BSD ports which may have essential libraries in unusual places. But it dnl can interfere with building an executable for the base system. Use this dnl option in that case. AC_DEFUN([CF_DISABLE_RPATH_HACK], [ AC_MSG_CHECKING(if rpath-hack should be disabled) CF_ARG_DISABLE(rpath-hack, [ --disable-rpath-hack don't add rpath options for additional libraries], [cf_disable_rpath_hack=yes], [cf_disable_rpath_hack=no]) AC_MSG_RESULT($cf_disable_rpath_hack) if test "$cf_disable_rpath_hack" = no ; then CF_RPATH_HACK fi ]) dnl --------------------------------------------------------------------------- dnl CF_ENABLE_NARROWPROTO version: 3 updated: 2006/02/12 17:46:00 dnl --------------------- dnl If this is not set properly, Xaw's scrollbars will not work. dnl The so-called "modular" configuration for X.org omits most of the dnl configure checks that would be needed to provide compatibility with dnl older X builds. This one breaks things noticeably. AC_DEFUN([CF_ENABLE_NARROWPROTO], [ AC_MSG_CHECKING(if you want narrow prototypes for X libraries) case `$ac_config_guess` in #(vi *cygwin*|*freebsd*|*gnu*|*irix5*|*irix6*|*linux-gnu*|*netbsd*|*openbsd*|*qnx*|*sco*|*sgi*) #(vi cf_default_narrowproto=yes ;; *) cf_default_narrowproto=no ;; esac CF_ARG_OPTION(narrowproto, [ --enable-narrowproto enable narrow prototypes for X libraries], [enable_narrowproto=$enableval], [enable_narrowproto=$cf_default_narrowproto], [$cf_default_narrowproto]) AC_MSG_RESULT($enable_narrowproto) ]) dnl --------------------------------------------------------------------------- dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39 dnl -------- dnl Check if 'errno' is declared in AC_DEFUN([CF_ERRNO], [ CF_CHECK_ERRNO(errno) ])dnl dnl --------------------------------------------------------------------------- dnl CF_FUNC_GRANTPT version: 8 updated: 2012/06/11 17:37:05 dnl --------------- dnl Check for grantpt versus openpty, as well as functions that "should" be dnl available if grantpt is available. AC_DEFUN([CF_FUNC_GRANTPT],[ AC_CHECK_HEADERS( \ stropts.h \ ) cf_func_grantpt="grantpt ptsname" case $host_os in #(vi darwin[[0-9]].*) #(vi ;; *) cf_func_grantpt="$cf_func_grantpt posix_openpt" ;; esac AC_CHECK_FUNCS($cf_func_grantpt) cf_grantpt_opts= if test "x$ac_cv_func_grantpt" = "xyes" ; then AC_MSG_CHECKING(if grantpt really works) AC_TRY_LINK(CF__GRANTPT_HEAD,CF__GRANTPT_BODY,[ AC_TRY_RUN(CF__GRANTPT_HEAD int main(void) { CF__GRANTPT_BODY } , ,ac_cv_func_grantpt=no ,ac_cv_func_grantpt=maybe) ],ac_cv_func_grantpt=no) AC_MSG_RESULT($ac_cv_func_grantpt) if test "x$ac_cv_func_grantpt" != "xno" ; then if test "x$ac_cv_func_grantpt" = "xyes" ; then AC_MSG_CHECKING(for pty features) dnl if we have no stropts.h, skip the checks for streams modules if test "x$ac_cv_header_stropts_h" = xyes then cf_pty_this=0 else cf_pty_this=3 fi cf_pty_defines= while test $cf_pty_this != 6 do cf_pty_feature= cf_pty_next=`expr $cf_pty_this + 1` CF_MSG_LOG(pty feature test $cf_pty_next:5) AC_TRY_RUN(#define CONFTEST $cf_pty_this $cf_pty_defines CF__GRANTPT_HEAD int main(void) { CF__GRANTPT_BODY } , [ case $cf_pty_next in #(vi 1) #(vi - streams cf_pty_feature=ptem ;; 2) #(vi - streams cf_pty_feature=ldterm ;; 3) #(vi - streams cf_pty_feature=ttcompat ;; 4) #(vi cf_pty_feature=pty_isatty ;; 5) #(vi cf_pty_feature=pty_tcsetattr ;; 6) #(vi cf_pty_feature=tty_tcsetattr ;; esac ],[ case $cf_pty_next in #(vi 1|2|3) CF_MSG_LOG(skipping remaining streams features $cf_pty_this..2) cf_pty_next=3 ;; esac ]) if test -n "$cf_pty_feature" then cf_pty_defines="$cf_pty_defines #define CONFTEST_$cf_pty_feature 1 " cf_grantpt_opts="$cf_grantpt_opts $cf_pty_feature" fi cf_pty_this=$cf_pty_next done AC_MSG_RESULT($cf_grantpt_opts) cf_grantpt_opts=`echo "$cf_grantpt_opts" | sed -e 's/ isatty//'` fi fi fi dnl If we found grantpt, but no features, e.g., for streams or if we are not dnl able to use tcsetattr, then give openpty a try. In particular, Darwin 10.7 dnl has a more functional openpty than posix_openpt. dnl dnl There is no configure run-test for openpty, since its implementations do dnl not always run properly as a non-root user. if test "x$ac_cv_func_grantpt" != "xyes" || test -z "$cf_grantpt_opts" ; then AC_CHECK_LIB(util, openpty, [cf_have_openpty=yes],[cf_have_openpty=no]) if test "$cf_have_openpty" = yes ; then ac_cv_func_grantpt=no LIBS="-lutil $LIBS" AC_DEFINE(HAVE_OPENPTY) AC_CHECK_HEADERS( \ util.h \ libutil.h \ pty.h \ ) fi fi dnl If we did not settle on using openpty, fill in the definitions for grantpt. if test "x$ac_cv_func_grantpt" != xno then AC_DEFINE(HAVE_WORKING_GRANTPT) for cf_feature in $cf_grantpt_opts do cf_feature=`echo "$cf_feature" | sed -e 's/ //g'` CF_UPPER(cf_FEATURE,$cf_feature) AC_DEFINE_UNQUOTED(HAVE_GRANTPT_$cf_FEATURE) done elif test "x$cf_have_openpty" = xno then CF_VERBOSE(will rely upon BSD-pseudoterminals) fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_FUNC_MEMMOVE version: 7 updated: 2006/12/16 12:33:30 dnl --------------- dnl Check for memmove, or a bcopy that can handle overlapping copy. If neither dnl is found, add our own version of memmove to the list of objects. AC_DEFUN([CF_FUNC_MEMMOVE], [ AC_CHECK_FUNC(memmove,,[ AC_CHECK_FUNC(bcopy,[ AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[ AC_TRY_RUN([ int main() { static char data[] = "abcdefghijklmnopqrstuwwxyz"; char temp[40]; bcopy(data, temp, sizeof(data)); bcopy(temp+10, temp, 15); bcopy(temp+5, temp+15, 10); ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz")); } ], [cf_cv_good_bcopy=yes], [cf_cv_good_bcopy=no], [cf_cv_good_bcopy=unknown]) ]) ],[cf_cv_good_bcopy=no]) if test "$cf_cv_good_bcopy" = yes ; then AC_DEFINE(USE_OK_BCOPY) else AC_DEFINE(USE_MY_MEMMOVE) fi ])])dnl dnl --------------------------------------------------------------------------- dnl CF_FUNC_TGETENT version: 18 updated: 2011/08/09 21:06:37 dnl --------------- dnl Check for tgetent function in termcap library. If we cannot find this, dnl we'll use the $LINES and $COLUMNS environment variables to pass screen dnl size information to subprocesses. (We cannot use terminfo's compatibility dnl function, since it cannot provide the termcap-format data). dnl dnl If the --disable-full-tgetent option is given, we'll settle for the first dnl tgetent function we find. Since the search list in that case does not dnl include the termcap library, that allows us to default to terminfo. AC_DEFUN([CF_FUNC_TGETENT], [ # compute a reasonable value for $TERM to give tgetent(), since we may be # running in 'screen', which sets $TERMCAP to a specific entry that is not # necessarily in /etc/termcap - unsetenv is not portable, so we cannot simply # discard $TERMCAP. cf_TERMVAR=vt100 if test -n "$TERMCAP" then cf_TERMCAP=`echo "$TERMCAP" | tr '\n' ' ' | sed -e 's/^..|//' -e 's/|.*//'` case "$cf_TERMCAP" in #(vi screen*.*) #(vi ;; *) cf_TERMVAR="$cf_TERMCAP" ;; esac fi test -z "$cf_TERMVAR" && cf_TERMVAR=vt100 AC_MSG_CHECKING(if we want full tgetent function) CF_ARG_DISABLE(full-tgetent, [ --disable-full-tgetent disable check for full tgetent function], cf_full_tgetent=no, cf_full_tgetent=yes,yes) AC_MSG_RESULT($cf_full_tgetent) if test "$cf_full_tgetent" = yes ; then cf_test_message="full tgetent" else cf_test_message="tgetent" fi AC_CACHE_CHECK(for $cf_test_message function,cf_cv_lib_tgetent,[ cf_save_LIBS="$LIBS" cf_cv_lib_tgetent=no if test "$cf_full_tgetent" = yes ; then cf_TERMLIB="otermcap termcap termlib ncurses curses" cf_TERMTST="buffer[[0]] == 0" else cf_TERMLIB="termlib ncurses curses" cf_TERMTST="0" fi for cf_termlib in '' $cf_TERMLIB ; do LIBS="$cf_save_LIBS" test -n "$cf_termlib" && CF_ADD_LIB($cf_termlib) AC_TRY_RUN([ /* terminfo implementations ignore the buffer argument, making it useless for * the xterm application, which uses this information to make a new TERMCAP * environment variable. */ int main() { char buffer[1024]; buffer[0] = 0; tgetent(buffer, "$cf_TERMVAR"); ${cf_cv_main_return:-return} ($cf_TERMTST); }], [echo "yes, there is a termcap/tgetent in $cf_termlib" 1>&AC_FD_CC if test -n "$cf_termlib" ; then cf_cv_lib_tgetent="-l$cf_termlib" else cf_cv_lib_tgetent=yes fi break], [echo "no, there is no termcap/tgetent in $cf_termlib" 1>&AC_FD_CC], [echo "cross-compiling, cannot verify if a termcap/tgetent is present in $cf_termlib" 1>&AC_FD_CC]) done LIBS="$cf_save_LIBS" ]) # If we found a working tgetent(), set LIBS and check for termcap.h. # (LIBS cannot be set inside AC_CACHE_CHECK; the commands there should # not have side effects other than setting the cache variable, because # they are not executed when a cached value exists.) if test "x$cf_cv_lib_tgetent" != xno ; then test "x$cf_cv_lib_tgetent" != xyes && CF_ADD_LIBS($cf_cv_lib_tgetent) AC_DEFINE(USE_TERMCAP) if test "$cf_full_tgetent" = no ; then AC_TRY_COMPILE([ #include ],[ #ifdef NCURSES_VERSION make an error #endif],[AC_DEFINE(HAVE_TERMCAP_H)]) else AC_CHECK_HEADERS(termcap.h) fi else # If we didn't find a tgetent() that supports the buffer # argument, look again to see whether we can find even # a crippled one. A crippled tgetent() is still useful to # validate values for the TERM environment variable given to # child processes. AC_CACHE_CHECK(for partial tgetent function,cf_cv_lib_part_tgetent,[ cf_cv_lib_part_tgetent=no for cf_termlib in $cf_TERMLIB ; do LIBS="$cf_save_LIBS -l$cf_termlib" AC_TRY_LINK([],[tgetent(0, "$cf_TERMVAR")], [echo "there is a terminfo/tgetent in $cf_termlib" 1>&AC_FD_CC cf_cv_lib_part_tgetent="-l$cf_termlib" break]) done LIBS="$cf_save_LIBS" ]) if test "$cf_cv_lib_part_tgetent" != no ; then CF_ADD_LIBS($cf_cv_lib_part_tgetent) AC_CHECK_HEADERS(termcap.h) # If this is linking against ncurses, we'll trigger the # ifdef in resize.c that turns the termcap stuff back off. AC_DEFINE(USE_TERMINFO) fi fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_GCC_ATTRIBUTES version: 14 updated: 2010/10/23 15:52:32 dnl ----------------- dnl Test for availability of useful gcc __attribute__ directives to quiet dnl compiler warnings. Though useful, not all are supported -- and contrary dnl to documentation, unrecognized directives cause older compilers to barf. AC_DEFUN([CF_GCC_ATTRIBUTES], [ if test "$GCC" = yes then cat > conftest.i < conftest.$ac_ext <&AC_FD_CC case $cf_attribute in #(vi printf) #(vi cf_printf_attribute=yes cat >conftest.h <conftest.h <conftest.h <>confdefs.h case $cf_attribute in #(vi printf) #(vi if test "$cf_printf_attribute" = no ; then cat >>confdefs.h <>confdefs.h <>confdefs.h <>confdefs.h <>confdefs.h fi rm -rf conftest* fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_GCC_VERSION version: 5 updated: 2010/04/24 11:02:31 dnl -------------- dnl Find version of gcc AC_DEFUN([CF_GCC_VERSION],[ AC_REQUIRE([AC_PROG_CC]) GCC_VERSION=none if test "$GCC" = yes ; then AC_MSG_CHECKING(version of $CC) GCC_VERSION="`${CC} --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`" test -z "$GCC_VERSION" && GCC_VERSION=unknown AC_MSG_RESULT($GCC_VERSION) fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_GCC_WARNINGS version: 29 updated: 2012/06/16 14:55:39 dnl --------------- dnl Check if the compiler supports useful warning options. There's a few that dnl we don't use, simply because they're too noisy: dnl dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x) dnl -Wredundant-decls (system headers make this too noisy) dnl -Wtraditional (combines too many unrelated messages, only a few useful) dnl -Wwrite-strings (too noisy, but should review occasionally). This dnl is enabled for ncurses using "--enable-const". dnl -pedantic dnl dnl Parameter: dnl $1 is an optional list of gcc warning flags that a particular dnl application might want to use, e.g., "no-unused" for dnl -Wno-unused dnl Special: dnl If $with_ext_const is "yes", add a check for -Wwrite-strings dnl AC_DEFUN([CF_GCC_WARNINGS], [ AC_REQUIRE([CF_GCC_VERSION]) CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS) CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS) cat > conftest.$ac_ext <],[ #ifndef _XOPEN_SOURCE make an error #endif], [cf_cv_gnu_source=no], [cf_save="$CPPFLAGS" CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE" AC_TRY_COMPILE([#include ],[ #ifdef _XOPEN_SOURCE make an error #endif], [cf_cv_gnu_source=no], [cf_cv_gnu_source=yes]) CPPFLAGS="$cf_save" ]) ]) test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE" ])dnl dnl --------------------------------------------------------------------------- dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23 dnl --------------- dnl Insert text into the help-message, for readability, from AC_ARG_WITH. AC_DEFUN([CF_HELP_MESSAGE], [AC_DIVERT_HELP([$1])dnl ])dnl dnl --------------------------------------------------------------------------- dnl CF_IMAKE_CFLAGS version: 31 updated: 2010/05/26 05:38:42 dnl --------------- dnl Use imake to obtain compiler flags. We could, in principle, write tests to dnl get these, but if imake is properly configured there is no point in doing dnl this. dnl dnl Parameters (used in constructing a sample Imakefile): dnl $1 = optional value to append to $IMAKE_CFLAGS dnl $2 = optional value to append to $IMAKE_LOADFLAGS AC_DEFUN([CF_IMAKE_CFLAGS], [ AC_PATH_PROGS(IMAKE,xmkmf imake) if test -n "$IMAKE" ; then case $IMAKE in # (vi */imake) cf_imake_opts="-DUseInstalled=YES" # (vi ;; */util/xmkmf) # A single parameter tells xmkmf where the config-files are: cf_imake_opts="`echo $IMAKE|sed -e s,/config/util/xmkmf,,`" # (vi ;; *) cf_imake_opts= ;; esac # If it's installed properly, imake (or its wrapper, xmkmf) will point to the # config directory. if mkdir conftestdir; then CDPATH=; export CDPATH cf_makefile=`cd $srcdir;pwd`/Imakefile cd conftestdir cat >fix_cflags.sed <<'CF_EOF' s/\\//g s/[[ ]][[ ]]*/ /g s/"//g :pack s/\(=[[^ ]][[^ ]]*\) \([[^-]]\)/\1 \2/g t pack s/\(-D[[a-zA-Z0-9_]][[a-zA-Z0-9_]]*\)=\([[^\'0-9 ]][[^ ]]*\)/\1='\\"\2\\"'/g s/^IMAKE[[ ]]/IMAKE_CFLAGS="/ s/ / /g s/$/"/ CF_EOF cat >fix_lflags.sed <<'CF_EOF' s/^IMAKE[[ ]]*/IMAKE_LOADFLAGS="/ s/$/"/ CF_EOF echo >./Imakefile test -f $cf_makefile && cat $cf_makefile >>./Imakefile cat >> ./Imakefile <<'CF_EOF' findstddefs: @echo IMAKE ${ALLDEFINES}ifelse([$1],,,[ $1]) | sed -f fix_cflags.sed @echo IMAKE ${EXTRA_LOAD_FLAGS}ifelse([$2],,,[ $2]) | sed -f fix_lflags.sed CF_EOF if ( $IMAKE $cf_imake_opts 1>/dev/null 2>&AC_FD_CC && test -f Makefile) then CF_VERBOSE(Using $IMAKE $cf_imake_opts) else # sometimes imake doesn't have the config path compiled in. Find it. cf_config= for cf_libpath in $X_LIBS $LIBS ; do case $cf_libpath in # (vi -L*) cf_libpath=`echo .$cf_libpath | sed -e 's/^...//'` cf_libpath=$cf_libpath/X11/config if test -d $cf_libpath ; then cf_config=$cf_libpath break fi ;; esac done if test -z "$cf_config" ; then AC_MSG_WARN(Could not find imake config-directory) else cf_imake_opts="$cf_imake_opts -I$cf_config" if ( $IMAKE -v $cf_imake_opts 2>&AC_FD_CC) then CF_VERBOSE(Using $IMAKE $cf_config) else AC_MSG_WARN(Cannot run $IMAKE) fi fi fi # GNU make sometimes prints "make[1]: Entering...", which # would confuse us. eval `make findstddefs 2>/dev/null | grep -v make` cd .. rm -rf conftestdir # We use ${ALLDEFINES} rather than ${STD_DEFINES} because the former # declares XTFUNCPROTO there. However, some vendors (e.g., SGI) have # modified it to support site.cf, adding a kludge for the /usr/include # directory. Try to filter that out, otherwise gcc won't find its # headers. if test -n "$GCC" ; then if test -n "$IMAKE_CFLAGS" ; then cf_nostdinc="" cf_std_incl="" cf_cpp_opts="" for cf_opt in $IMAKE_CFLAGS do case "$cf_opt" in -nostdinc) #(vi cf_nostdinc="$cf_opt" ;; -I/usr/include) #(vi cf_std_incl="$cf_opt" ;; *) #(vi cf_cpp_opts="$cf_cpp_opts $cf_opt" ;; esac done if test -z "$cf_nostdinc" ; then IMAKE_CFLAGS="$cf_cpp_opts $cf_std_incl" elif test -z "$cf_std_incl" ; then IMAKE_CFLAGS="$cf_cpp_opts $cf_nostdinc" else CF_VERBOSE(suppressed \"$cf_nostdinc\" and \"$cf_std_incl\") IMAKE_CFLAGS="$cf_cpp_opts" fi fi fi fi # Some imake configurations define PROJECTROOT with an empty value. Remove # the empty definition. case $IMAKE_CFLAGS in *-DPROJECTROOT=/*) ;; *) IMAKE_CFLAGS=`echo "$IMAKE_CFLAGS" |sed -e "s,-DPROJECTROOT=[[ ]], ,"` ;; esac fi CF_VERBOSE(IMAKE_CFLAGS $IMAKE_CFLAGS) CF_VERBOSE(IMAKE_LOADFLAGS $IMAKE_LOADFLAGS) AC_SUBST(IMAKE_CFLAGS) AC_SUBST(IMAKE_LOADFLAGS) ])dnl dnl --------------------------------------------------------------------------- dnl CF_INPUT_METHOD version: 3 updated: 2000/04/11 23:46:57 dnl --------------- dnl Check if the X libraries support input-method AC_DEFUN([CF_INPUT_METHOD], [ AC_CACHE_CHECK([if X libraries support input-method],cf_cv_input_method,[ AC_TRY_LINK([ #include #include #include #include #include #include ],[ { XIM xim; XIMStyles *xim_styles = 0; XIMStyle input_style; Widget w = 0; XSetLocaleModifiers("@im=none"); xim = XOpenIM(XtDisplay(w), NULL, NULL, NULL); XGetIMValues(xim, XNQueryInputStyle, &xim_styles, NULL); XCloseIM(xim); input_style = (XIMPreeditNothing | XIMStatusNothing); } ], [cf_cv_input_method=yes], [cf_cv_input_method=no])]) ])dnl dnl --------------------------------------------------------------------------- dnl CF_INTEL_COMPILER version: 4 updated: 2010/05/26 05:38:42 dnl ----------------- dnl Check if the given compiler is really the Intel compiler for Linux. It dnl tries to imitate gcc, but does not return an error when it finds a mismatch dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK. dnl dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from dnl the wrappers for gcc and g++ warnings. dnl dnl $1 = GCC (default) or GXX dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS dnl $3 = CFLAGS (default) or CXXFLAGS AC_DEFUN([CF_INTEL_COMPILER],[ ifelse([$2],,INTEL_COMPILER,[$2])=no if test "$ifelse([$1],,[$1],GCC)" = yes ; then case $host_os in linux*|gnu*) AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler) cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])" ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc" AC_TRY_COMPILE([],[ #ifdef __INTEL_COMPILER #else make an error #endif ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc" ],[]) ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS" AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2])) ;; esac fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_LASTLOG version: 4 updated: 2002/10/27 23:21:42 dnl ---------- dnl Check for header defining _PATH_LASTLOG, or failing that, see if the lastlog dnl file exists. AC_DEFUN([CF_LASTLOG], [ AC_CHECK_HEADERS(lastlog.h paths.h) AC_CACHE_CHECK(for lastlog path,cf_cv_path_lastlog,[ AC_TRY_COMPILE([ #include #ifdef HAVE_LASTLOG_H #include #else #ifdef HAVE_PATHS_H #include #endif #endif],[char *path = _PATH_LASTLOG], [cf_cv_path_lastlog="_PATH_LASTLOG"], [if test -f /usr/adm/lastlog ; then cf_cv_path_lastlog=/usr/adm/lastlog else cf_cv_path_lastlog=no fi]) ]) test $cf_cv_path_lastlog != no && AC_DEFINE(USE_LASTLOG) ])dnl dnl --------------------------------------------------------------------------- dnl CF_LD_RPATH_OPT version: 5 updated: 2011/07/17 14:48:41 dnl --------------- dnl For the given system and compiler, find the compiler flags to pass to the dnl loader to use the "rpath" feature. AC_DEFUN([CF_LD_RPATH_OPT], [ AC_REQUIRE([CF_CHECK_CACHE]) LD_RPATH_OPT= AC_MSG_CHECKING(for an rpath option) case $cf_cv_system_name in #(vi irix*) #(vi if test "$GCC" = yes; then LD_RPATH_OPT="-Wl,-rpath," else LD_RPATH_OPT="-rpath " fi ;; linux*|gnu*|k*bsd*-gnu) #(vi LD_RPATH_OPT="-Wl,-rpath," ;; openbsd[[2-9]].*|mirbsd*) #(vi LD_RPATH_OPT="-Wl,-rpath," ;; dragonfly*|freebsd*) #(vi LD_RPATH_OPT="-rpath " ;; netbsd*) #(vi LD_RPATH_OPT="-Wl,-rpath," ;; osf*|mls+*) #(vi LD_RPATH_OPT="-rpath " ;; solaris2*) #(vi LD_RPATH_OPT="-R" ;; *) ;; esac AC_MSG_RESULT($LD_RPATH_OPT) case "x$LD_RPATH_OPT" in #(vi x-R*) AC_MSG_CHECKING(if we need a space after rpath option) cf_save_LIBS="$LIBS" CF_ADD_LIBS(${LD_RPATH_OPT}$libdir) AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes) LIBS="$cf_save_LIBS" AC_MSG_RESULT($cf_rpath_space) test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT " ;; esac ])dnl dnl --------------------------------------------------------------------------- dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32 dnl ------------ dnl Generate tags/TAGS targets for makefiles. Do not generate TAGS if we have dnl a monocase filesystem. AC_DEFUN([CF_MAKE_TAGS],[ AC_REQUIRE([CF_MIXEDCASE_FILENAMES]) AC_CHECK_PROGS(CTAGS, exctags ctags) AC_CHECK_PROGS(ETAGS, exetags etags) AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no) if test "$cf_cv_mixedcase" = yes ; then AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no) else MAKE_UPPER_TAGS=no fi if test "$MAKE_UPPER_TAGS" = yes ; then MAKE_UPPER_TAGS= else MAKE_UPPER_TAGS="#" fi if test "$MAKE_LOWER_TAGS" = yes ; then MAKE_LOWER_TAGS= else MAKE_LOWER_TAGS="#" fi AC_SUBST(CTAGS) AC_SUBST(ETAGS) AC_SUBST(MAKE_UPPER_TAGS) AC_SUBST(MAKE_LOWER_TAGS) ])dnl dnl --------------------------------------------------------------------------- dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55 dnl ---------------------- dnl Check if the file-system supports mixed-case filenames. If we're able to dnl create a lowercase name and see it as uppercase, it doesn't support that. AC_DEFUN([CF_MIXEDCASE_FILENAMES], [ AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[ if test "$cross_compiling" = yes ; then case $target_alias in #(vi *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi cf_cv_mixedcase=no ;; *) cf_cv_mixedcase=yes ;; esac else rm -f conftest CONFTEST echo test >conftest if test -f CONFTEST ; then cf_cv_mixedcase=no else cf_cv_mixedcase=yes fi rm -f conftest CONFTEST fi ]) test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES) ])dnl dnl --------------------------------------------------------------------------- dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32 dnl ---------- dnl Write a debug message to config.log, along with the line number in the dnl configure script. AC_DEFUN([CF_MSG_LOG],[ echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC ])dnl dnl --------------------------------------------------------------------------- dnl CF_PATHSEP version: 5 updated: 2010/05/26 05:38:42 dnl ---------- dnl Provide a value for the $PATH and similar separator AC_DEFUN([CF_PATHSEP], [ case $cf_cv_system_name in os2*) PATH_SEPARATOR=';' ;; *) PATH_SEPARATOR=':' ;; esac ifelse([$1],,,[$1=$PATH_SEPARATOR]) AC_SUBST(PATH_SEPARATOR) ])dnl dnl --------------------------------------------------------------------------- dnl CF_PATH_PROG version: 8 updated: 2010/10/23 16:12:25 dnl ------------ dnl Check for a given program, defining corresponding symbol. dnl $1 = environment variable, which is suffixed by "_PATH" in the #define. dnl $2 = program name to find. dnl $3 = optional list of additional program names to test. dnl dnl If there is more than one token in the result, #define the remaining tokens dnl to $1_ARGS. We need this for 'install' in particular. dnl dnl FIXME: we should allow this to be overridden by environment variables dnl AC_DEFUN([CF_PATH_PROG],[ AC_REQUIRE([CF_PATHSEP]) test -z "[$]$1" && $1=$2 AC_PATH_PROGS($1,[$]$1 $2 $3,[$]$1) cf_path_prog="" cf_path_args="" IFS="${IFS:- }"; cf_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR" for cf_temp in $ac_cv_path_$1 do if test -z "$cf_path_prog" ; then if test "$with_full_paths" = yes ; then CF_PATH_SYNTAX(cf_temp,break) cf_path_prog="$cf_temp" else cf_path_prog="`basename $cf_temp`" fi elif test -z "$cf_path_args" ; then cf_path_args="$cf_temp" else cf_path_args="$cf_path_args $cf_temp" fi done IFS="$cf_save_ifs" if test -n "$cf_path_prog" ; then CF_MSG_LOG(defining path for ${cf_path_prog}) AC_DEFINE_UNQUOTED($1_PATH,"$cf_path_prog") test -n "$cf_path_args" && AC_DEFINE_UNQUOTED($1_ARGS,"$cf_path_args") fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_PATH_SYNTAX version: 14 updated: 2012/06/19 20:58:54 dnl -------------- dnl Check the argument to see that it looks like a pathname. Rewrite it if it dnl begins with one of the prefix/exec_prefix variables, and then again if the dnl result begins with 'NONE'. This is necessary to work around autoconf's dnl delayed evaluation of those symbols. AC_DEFUN([CF_PATH_SYNTAX],[ if test "x$prefix" != xNONE; then cf_path_syntax="$prefix" else cf_path_syntax="$ac_default_prefix" fi case ".[$]$1" in #(vi .\[$]\(*\)*|.\'*\'*) #(vi ;; ..|./*|.\\*) #(vi ;; .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX ;; .\[$]{*prefix}*|.\[$]{*dir}*) #(vi eval $1="[$]$1" case ".[$]$1" in #(vi .NONE/*) $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%` ;; esac ;; #(vi .no|.NONE/*) $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%` ;; *) ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2) ;; esac ])dnl dnl --------------------------------------------------------------------------- dnl CF_PKG_CONFIG version: 7 updated: 2011/04/29 04:53:22 dnl ------------- dnl Check for the package-config program, unless disabled by command-line. AC_DEFUN([CF_PKG_CONFIG], [ AC_MSG_CHECKING(if you want to use pkg-config) AC_ARG_WITH(pkg-config, [ --with-pkg-config{=path} enable/disable use of pkg-config], [cf_pkg_config=$withval], [cf_pkg_config=yes]) AC_MSG_RESULT($cf_pkg_config) case $cf_pkg_config in #(vi no) #(vi PKG_CONFIG=none ;; yes) #(vi CF_ACVERSION_CHECK(2.52, [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)], [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)]) ;; *) PKG_CONFIG=$withval ;; esac test -z "$PKG_CONFIG" && PKG_CONFIG=none if test "$PKG_CONFIG" != none ; then CF_PATH_SYNTAX(PKG_CONFIG) fi AC_SUBST(PKG_CONFIG) ])dnl dnl --------------------------------------------------------------------------- dnl CF_POSIX_C_SOURCE version: 8 updated: 2010/05/26 05:38:42 dnl ----------------- dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed. dnl dnl POSIX.1-1990 _POSIX_SOURCE dnl POSIX.1-1990 and _POSIX_SOURCE and dnl POSIX.2-1992 C-Language _POSIX_C_SOURCE=2 dnl Bindings Option dnl POSIX.1b-1993 _POSIX_C_SOURCE=199309L dnl POSIX.1c-1996 _POSIX_C_SOURCE=199506L dnl X/Open 2000 _POSIX_C_SOURCE=200112L dnl dnl Parameters: dnl $1 is the nominal value for _POSIX_C_SOURCE AC_DEFUN([CF_POSIX_C_SOURCE], [ cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1]) cf_save_CFLAGS="$CFLAGS" cf_save_CPPFLAGS="$CPPFLAGS" CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE) CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE) AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[ CF_MSG_LOG(if the symbol is already defined go no further) AC_TRY_COMPILE([#include ],[ #ifndef _POSIX_C_SOURCE make an error #endif], [cf_cv_posix_c_source=no], [cf_want_posix_source=no case .$cf_POSIX_C_SOURCE in #(vi .[[12]]??*) #(vi cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE" ;; .2) #(vi cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE" cf_want_posix_source=yes ;; .*) cf_want_posix_source=yes ;; esac if test "$cf_want_posix_source" = yes ; then AC_TRY_COMPILE([#include ],[ #ifdef _POSIX_SOURCE make an error #endif],[], cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE") fi CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE) CFLAGS="$cf_trim_CFLAGS" CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source" CF_MSG_LOG(if the second compile does not leave our definition intact error) AC_TRY_COMPILE([#include ],[ #ifndef _POSIX_C_SOURCE make an error #endif],, [cf_cv_posix_c_source=no]) CFLAGS="$cf_save_CFLAGS" CPPFLAGS="$cf_save_CPPFLAGS" ]) ]) if test "$cf_cv_posix_c_source" != no ; then CFLAGS="$cf_trim_CFLAGS" CPPFLAGS="$cf_trim_CPPFLAGS" CF_ADD_CFLAGS($cf_cv_posix_c_source) fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_POSIX_SAVED_IDS version: 7 updated: 2007/03/14 16:43:53 dnl ------------------ dnl dnl Check first if saved-ids are always supported. Some systems dnl may require runtime checks. AC_DEFUN([CF_POSIX_SAVED_IDS], [ AC_CHECK_HEADERS( \ sys/param.h \ ) AC_CACHE_CHECK(if POSIX saved-ids are supported,cf_cv_posix_saved_ids,[ AC_TRY_LINK( [ #include #ifdef HAVE_SYS_PARAM_H #include /* this may define "BSD" */ #endif ],[ #if defined(_POSIX_SAVED_IDS) && (_POSIX_SAVED_IDS > 0) void *p = (void *) seteuid; int x = seteuid(geteuid()); #elif defined(BSD) && (BSD >= 199103) /* The BSD's may implement the runtime check - and it fails. * However, saved-ids work almost like POSIX (close enough for most uses). */ #else make an error #endif ],[cf_cv_posix_saved_ids=yes ],[ AC_TRY_RUN([ #ifdef HAVE_STDLIB_H #include #endif #include int main() { void *p = (void *) seteuid; long code = sysconf(_SC_SAVED_IDS); ${cf_cv_main_return:-return} ((code > 0) ? 0 : 1); }], cf_cv_posix_saved_ids=yes, cf_cv_posix_saved_ids=no, cf_cv_posix_saved_ids=unknown) ]) ]) test "$cf_cv_posix_saved_ids" = yes && AC_DEFINE(HAVE_POSIX_SAVED_IDS) ]) dnl --------------------------------------------------------------------------- dnl CF_POSIX_WAIT version: 2 updated: 2000/05/29 16:16:04 dnl ------------- dnl Check for POSIX wait support AC_DEFUN([CF_POSIX_WAIT], [ AC_REQUIRE([AC_HEADER_SYS_WAIT]) AC_CACHE_CHECK(for POSIX wait functions,cf_cv_posix_wait,[ AC_TRY_LINK([ #include #include #include #ifdef HAVE_SYS_WAIT_H #include #endif ],[ int stat_loc; pid_t pid = waitpid(-1, &stat_loc, WNOHANG|WUNTRACED); pid_t pid2 = wait(&stat_loc); ], [cf_cv_posix_wait=yes], [cf_cv_posix_wait=no]) ]) test "$cf_cv_posix_wait" = yes && AC_DEFINE(USE_POSIX_WAIT) ])dnl dnl --------------------------------------------------------------------------- dnl CF_PROCFS_CWD version: 2 updated: 2007/03/12 20:39:04 dnl ------------- dnl Find /proc tree (may be in a different place) which implements the "cwd" dnl link. AC_DEFUN([CF_PROCFS_CWD],[ AC_CACHE_CHECK(for proc tree with cwd-support,cf_cv_procfs_cwd,[ cf_cv_procfs_cwd=no for cf_path in /proc /compat/linux/proc /usr/compat/linux/proc do if test -d $cf_path && \ test -d $cf_path/$$ && \ ( test -d $cf_path/$$/cwd || \ test -L $cf_path/$$/cwd ); then cf_cv_procfs_cwd=$cf_path break fi done ]) ])dnl dnl --------------------------------------------------------------------------- dnl CF_PROG_CC_U_D version: 1 updated: 2005/07/14 16:59:30 dnl -------------- dnl Check if C (preprocessor) -U and -D options are processed in the order dnl given rather than by type of option. Some compilers insist on apply all dnl of the -U options after all of the -D options. Others allow mixing them, dnl and may predefine symbols that conflict with those we define. AC_DEFUN([CF_PROG_CC_U_D], [ AC_CACHE_CHECK(if $CC -U and -D options work together,cf_cv_cc_u_d_options,[ cf_save_CPPFLAGS="$CPPFLAGS" CPPFLAGS="-UU_D_OPTIONS -DU_D_OPTIONS -DD_U_OPTIONS -UD_U_OPTIONS" AC_TRY_COMPILE([],[ #ifndef U_D_OPTIONS make an undefined-error #endif #ifdef D_U_OPTIONS make a defined-error #endif ],[ cf_cv_cc_u_d_options=yes],[ cf_cv_cc_u_d_options=no]) CPPFLAGS="$cf_save_CPPFLAGS" ]) ])dnl dnl --------------------------------------------------------------------------- dnl CF_PROG_EXT version: 10 updated: 2004/01/03 19:28:18 dnl ----------- dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX. AC_DEFUN([CF_PROG_EXT], [ AC_REQUIRE([CF_CHECK_CACHE]) case $cf_cv_system_name in os2*) CFLAGS="$CFLAGS -Zmt" CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__" CXXFLAGS="$CXXFLAGS -Zmt" # autoconf's macro sets -Zexe and suffix both, which conflict:w LDFLAGS="$LDFLAGS -Zmt -Zcrtdll" ac_cv_exeext=.exe ;; esac AC_EXEEXT AC_OBJEXT PROG_EXT="$EXEEXT" AC_SUBST(PROG_EXT) test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT") ])dnl dnl --------------------------------------------------------------------------- dnl CF_REGEX version: 9 updated: 2012/01/07 15:08:24 dnl -------- dnl Attempt to determine if we've got one of the flavors of regular-expression dnl code that we can support. AC_DEFUN([CF_REGEX], [ cf_regex_func=no cf_regex_libs="regex re" case $host_os in #(vi mingw*) cf_regex_libs="gnurx $cf_regex_libs" ;; esac AC_CHECK_FUNC(regcomp,[cf_regex_func=regcomp],[ for cf_regex_lib in $cf_regex_libs do AC_CHECK_LIB($cf_regex_lib,regcomp,[ CF_ADD_LIB($cf_regex_lib) cf_regex_func=regcomp break]) done ]) if test "$cf_regex_func" = no ; then AC_CHECK_FUNC(compile,[cf_regex_func=compile],[ AC_CHECK_LIB(gen,compile,[ CF_ADD_LIB(gen) cf_regex_func=compile])]) fi if test "$cf_regex_func" = no ; then AC_MSG_WARN(cannot find regular expression library) fi AC_CACHE_CHECK(for regular-expression headers,cf_cv_regex_hdrs,[ cf_cv_regex_hdrs=no case $cf_regex_func in #(vi compile) #(vi for cf_regex_hdr in regexp.h regexpr.h do AC_TRY_LINK([#include <$cf_regex_hdr>],[ char *p = compile("", "", "", 0); int x = step("", ""); ],[ cf_cv_regex_hdrs=$cf_regex_hdr break ]) done ;; *) for cf_regex_hdr in regex.h do AC_TRY_LINK([#include #include <$cf_regex_hdr>],[ regex_t *p; int x = regcomp(p, "", 0); int y = regexec(p, "", 0, 0, 0); regfree(p); ],[ cf_cv_regex_hdrs=$cf_regex_hdr break ]) done ;; esac ]) case $cf_cv_regex_hdrs in #(vi no) AC_MSG_WARN(no regular expression header found) ;; #(vi regex.h) AC_DEFINE(HAVE_REGEX_H_FUNCS) ;; #(vi regexp.h) AC_DEFINE(HAVE_REGEXP_H_FUNCS) ;; #(vi regexpr.h) AC_DEFINE(HAVE_REGEXPR_H_FUNCS) ;; esac ])dnl dnl --------------------------------------------------------------------------- dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50 dnl ---------------- dnl Remove all -U and -D options that refer to the given symbol from a list dnl of C compiler options. This works around the problem that not all dnl compilers process -U and -D options from left-to-right, so a -U option dnl cannot be used to cancel the effect of a preceding -D option. dnl dnl $1 = target (which could be the same as the source variable) dnl $2 = source (including '$') dnl $3 = symbol to remove define([CF_REMOVE_DEFINE], [ $1=`echo "$2" | \ sed -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[[ ]]/ /g' \ -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[$]//g'` ])dnl dnl --------------------------------------------------------------------------- dnl CF_RPATH_HACK version: 9 updated: 2011/02/13 13:31:33 dnl ------------- AC_DEFUN([CF_RPATH_HACK], [ AC_REQUIRE([CF_LD_RPATH_OPT]) AC_MSG_CHECKING(for updated LDFLAGS) if test -n "$LD_RPATH_OPT" ; then AC_MSG_RESULT(maybe) AC_CHECK_PROGS(cf_ldd_prog,ldd,no) cf_rpath_list="/usr/lib /lib" if test "$cf_ldd_prog" != no then cf_rpath_oops= AC_TRY_LINK([#include ], [printf("Hello");], [cf_rpath_oops=`$cf_ldd_prog conftest$ac_exeext | fgrep ' not found' | sed -e 's% =>.*$%%' |sort -u` cf_rpath_list=`$cf_ldd_prog conftest$ac_exeext | fgrep / | sed -e 's%^.*[[ ]]/%/%' -e 's%/[[^/]][[^/]]*$%%' |sort -u`]) # If we passed the link-test, but get a "not found" on a given library, # this could be due to inept reconfiguration of gcc to make it only # partly honor /usr/local/lib (or whatever). Sometimes this behavior # is intentional, e.g., installing gcc in /usr/bin and suppressing the # /usr/local libraries. if test -n "$cf_rpath_oops" then for cf_rpath_src in $cf_rpath_oops do for cf_rpath_dir in \ /usr/local \ /usr/pkg \ /opt/sfw do if test -f $cf_rpath_dir/lib/$cf_rpath_src then CF_VERBOSE(...adding -L$cf_rpath_dir/lib to LDFLAGS for $cf_rpath_src) LDFLAGS="$LDFLAGS -L$cf_rpath_dir/lib" break fi done done fi fi CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS) CF_RPATH_HACK_2(LDFLAGS) CF_RPATH_HACK_2(LIBS) CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS) fi AC_SUBST(EXTRA_LDFLAGS) ])dnl dnl --------------------------------------------------------------------------- dnl CF_RPATH_HACK_2 version: 6 updated: 2010/04/17 16:31:24 dnl --------------- dnl Do one set of substitutions for CF_RPATH_HACK, adding an rpath option to dnl EXTRA_LDFLAGS for each -L option found. dnl dnl $cf_rpath_list contains a list of directories to ignore. dnl dnl $1 = variable name to update. The LDFLAGS variable should be the only one, dnl but LIBS often has misplaced -L options. AC_DEFUN([CF_RPATH_HACK_2], [ CF_VERBOSE(...checking $1 [$]$1) cf_rpath_dst= for cf_rpath_src in [$]$1 do case $cf_rpath_src in #(vi -L*) #(vi # check if this refers to a directory which we will ignore cf_rpath_skip=no if test -n "$cf_rpath_list" then for cf_rpath_item in $cf_rpath_list do if test "x$cf_rpath_src" = "x-L$cf_rpath_item" then cf_rpath_skip=yes break fi done fi if test "$cf_rpath_skip" = no then # transform the option if test "$LD_RPATH_OPT" = "-R " ; then cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%-R %"` else cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%$LD_RPATH_OPT%"` fi # if we have not already added this, add it now cf_rpath_tst=`echo "$EXTRA_LDFLAGS" | sed -e "s%$cf_rpath_tmp %%"` if test "x$cf_rpath_tst" = "x$EXTRA_LDFLAGS" then CF_VERBOSE(...Filter $cf_rpath_src ->$cf_rpath_tmp) EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS" fi fi ;; esac cf_rpath_dst="$cf_rpath_dst $cf_rpath_src" done $1=$cf_rpath_dst CF_VERBOSE(...checked $1 [$]$1) AC_SUBST(EXTRA_LDFLAGS) ])dnl dnl --------------------------------------------------------------------------- dnl CF_SIGWINCH version: 1 updated: 2006/04/02 16:41:09 dnl ----------- dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all dnl programs need this test). dnl dnl This is really a MacOS X 10.4.3 workaround. Defining _POSIX_C_SOURCE dnl forces SIGWINCH to be undefined (breaks xterm, ncurses). Oddly, the struct dnl winsize declaration is left alone - we may revisit this if Apple choose to dnl break that part of the interface as well. AC_DEFUN([CF_SIGWINCH], [ AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[ AC_TRY_COMPILE([ #include #include ],[int x = SIGWINCH], [cf_cv_define_sigwinch=yes], [AC_TRY_COMPILE([ #undef _XOPEN_SOURCE #undef _POSIX_SOURCE #undef _POSIX_C_SOURCE #include #include ],[int x = SIGWINCH], [cf_cv_define_sigwinch=maybe], [cf_cv_define_sigwinch=no]) ]) ]) if test "$cf_cv_define_sigwinch" = maybe ; then AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[ cf_cv_fixup_sigwinch=unknown cf_sigwinch=32 while test $cf_sigwinch != 1 do AC_TRY_COMPILE([ #undef _XOPEN_SOURCE #undef _POSIX_SOURCE #undef _POSIX_C_SOURCE #include #include ],[ #if SIGWINCH != $cf_sigwinch make an error #endif int x = SIGWINCH], [cf_cv_fixup_sigwinch=$cf_sigwinch break]) cf_sigwinch=`expr $cf_sigwinch - 1` done ]) if test "$cf_cv_fixup_sigwinch" != unknown ; then CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch" fi fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_SIG_ATOMIC_T version: 2 updated: 2005/09/18 17:27:12 dnl --------------- dnl signal handler, but there are some gcc depedencies in that recommendation. dnl Try anyway. AC_DEFUN([CF_SIG_ATOMIC_T], [ AC_MSG_CHECKING(for signal global datatype) AC_CACHE_VAL(cf_cv_sig_atomic_t,[ for cf_type in \ "volatile sig_atomic_t" \ "sig_atomic_t" \ "int" do AC_TRY_COMPILE([ #include #include #include extern $cf_type x; $cf_type x; static void handler(int sig) { x = 5; }], [signal(SIGINT, handler); x = 1], [cf_cv_sig_atomic_t=$cf_type], [cf_cv_sig_atomic_t=no]) test "$cf_cv_sig_atomic_t" != no && break done ]) AC_MSG_RESULT($cf_cv_sig_atomic_t) test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t) ])dnl dnl --------------------------------------------------------------------------- dnl CF_SIZE_T version: 4 updated: 2000/01/22 00:19:54 dnl --------- dnl On both Ultrix and CLIX, I find size_t defined in AC_DEFUN([CF_SIZE_T], [ AC_MSG_CHECKING(for size_t in or ) AC_CACHE_VAL(cf_cv_type_size_t,[ AC_TRY_COMPILE([ #include #ifdef STDC_HEADERS #include #include #endif #include ], [size_t x], [cf_cv_type_size_t=yes], [cf_cv_type_size_t=no]) ]) AC_MSG_RESULT($cf_cv_type_size_t) test $cf_cv_type_size_t = no && AC_DEFINE(size_t, unsigned) ])dnl dnl --------------------------------------------------------------------------- dnl CF_STRUCT_LASTLOG version: 1 updated: 2006/03/12 17:46:43 dnl ----------------- dnl Check for header defining struct lastlog, ensure that its .ll_time member dnl is compatible with time(). AC_DEFUN([CF_STRUCT_LASTLOG], [ AC_CHECK_HEADERS(lastlog.h) AC_CACHE_CHECK(for struct lastlog,cf_cv_struct_lastlog,[ AC_TRY_RUN([ #include #include #include int main() { struct lastlog data; return (sizeof(data.ll_time) != sizeof(time_t)); }],[ cf_cv_struct_lastlog=yes],[ cf_cv_struct_lastlog=no],[ cf_cv_struct_lastlog=unknown])]) test $cf_cv_struct_lastlog != no && AC_DEFINE(USE_STRUCT_LASTLOG) ])dnl dnl --------------------------------------------------------------------------- dnl CF_SVR4 version: 4 updated: 2011/09/04 17:17:53 dnl ------- dnl Check if this is an SVR4 system. We need the definition for xterm AC_DEFUN([CF_SVR4], [ AC_CHECK_LIB(elf, elf_begin,[ AC_CACHE_CHECK(if this is an SVR4 system, cf_cv_svr4,[ AC_TRY_COMPILE([ #if defined(__CYGWIN__) make an error #endif #include #include ],[ static struct termio d_tio; d_tio.c_cc[VINTR] = 0; d_tio.c_cc[VQUIT] = 0; d_tio.c_cc[VERASE] = 0; d_tio.c_cc[VKILL] = 0; d_tio.c_cc[VEOF] = 0; d_tio.c_cc[VEOL] = 0; d_tio.c_cc[VMIN] = 0; d_tio.c_cc[VTIME] = 0; d_tio.c_cc[VLNEXT] = 0; ], [cf_cv_svr4=yes], [cf_cv_svr4=no]) ]) ]) test "$cf_cv_svr4" = yes && AC_DEFINE(SVR4) ])dnl dnl --------------------------------------------------------------------------- dnl CF_SYSV version: 14 updated: 2012/06/11 17:37:05 dnl ------- dnl Check if this is a SYSV platform, e.g., as used in , and whether dnl defining it will be helpful. The following features are used to check: dnl dnl a) bona-fide SVSV doesn't use const for sys_errlist[]. Since this is a dnl legacy (pre-ANSI) feature, const should not apply. Modern systems only dnl declare strerror(). Xos.h declares the legacy form of str_errlist[], and dnl a compile-time error will result from trying to assign to a const array. dnl dnl b) compile with headers that exist on SYSV hosts. dnl dnl c) compile with type definitions that differ on SYSV hosts from standard C. AC_DEFUN([CF_SYSV], [ AC_CHECK_HEADERS( \ termios.h \ stdlib.h \ X11/Intrinsic.h \ ) AC_REQUIRE([CF_SYS_ERRLIST]) AC_CACHE_CHECK(if we should define SYSV,cf_cv_sysv,[ AC_TRY_COMPILE([ #undef SYSV #define SYSV 1 /* get Xos.h to declare sys_errlist[] */ #ifdef HAVE_STDLIB_H #include /* look for wchar_t */ #endif #ifdef HAVE_X11_INTRINSIC_H #include /* Intrinsic.h has other traps... */ #endif #ifdef HAVE_TERMIOS_H /* needed for HPUX 10.20 */ #include #define STRUCT_TERMIOS struct termios #else #define STRUCT_TERMIOS struct termio #endif #include #include /* eliminate most BSD hacks */ #include /* declare sys_errlist on older systems */ #include /* eliminate most of the remaining ones */ ],[ static STRUCT_TERMIOS d_tio; d_tio.c_cc[VINTR] = 0; d_tio.c_cc[VQUIT] = 0; d_tio.c_cc[VERASE] = 0; d_tio.c_cc[VKILL] = 0; d_tio.c_cc[VEOF] = 0; d_tio.c_cc[VEOL] = 0; d_tio.c_cc[VMIN] = 0; d_tio.c_cc[VTIME] = 0; #if defined(HAVE_SYS_ERRLIST) && !defined(DECL_SYS_ERRLIST) sys_errlist[0] = ""; /* Cygwin mis-declares this */ #endif ], [cf_cv_sysv=yes], [cf_cv_sysv=no]) ]) test "$cf_cv_sysv" = yes && AC_DEFINE(SYSV) ])dnl dnl --------------------------------------------------------------------------- dnl CF_SYSV_UTMP version: 5 updated: 2001/12/27 12:55:07 dnl ------------ dnl Check if this is a SYSV flavor of UTMP AC_DEFUN([CF_SYSV_UTMP], [ AC_CACHE_CHECK(if $cf_cv_have_utmp is SYSV flavor,cf_cv_sysv_utmp,[ test "$cf_cv_have_utmp" = "utmp" && cf_prefix="ut" || cf_prefix="utx" AC_TRY_LINK([ #include #include <${cf_cv_have_utmp}.h>],[ struct $cf_cv_have_utmp x; set${cf_prefix}ent (); get${cf_prefix}id(&x); put${cf_prefix}line(&x); end${cf_prefix}ent();], [cf_cv_sysv_utmp=yes], [cf_cv_sysv_utmp=no]) ]) test $cf_cv_sysv_utmp = yes && AC_DEFINE(USE_SYSV_UTMP) ])dnl dnl --------------------------------------------------------------------------- dnl CF_SYS_ERRLIST version: 6 updated: 2001/12/30 13:03:23 dnl -------------- dnl Check for declaration of sys_nerr and sys_errlist in one of stdio.h and dnl errno.h. Declaration of sys_errlist on BSD4.4 interferes with our dnl declaration. Reported by Keith Bostic. AC_DEFUN([CF_SYS_ERRLIST], [ CF_CHECK_ERRNO(sys_nerr) CF_CHECK_ERRNO(sys_errlist) ])dnl dnl --------------------------------------------------------------------------- dnl CF_TERMIO_C_ISPEED version: 2 updated: 2000/05/29 16:16:04 dnl ------------------ dnl Check for SGI's broken redefinition of baud rates introduced in IRIX 6.5 dnl (there doesn't appear to be a useful predefined symbol). AC_DEFUN([CF_TERMIO_C_ISPEED], [ AC_CACHE_CHECK(for IRIX 6.5 baud-rate redefinitions,cf_cv_termio_c_ispeed,[ AC_TRY_COMPILE([ #include #include ],[ struct termio foo; foo.c_ispeed = B38400; foo.c_ospeed = B9600; ],[cf_cv_termio_c_ispeed=yes ],[cf_cv_termio_c_ispeed=no]) ]) test "$cf_cv_termio_c_ispeed" = yes && AC_DEFINE(HAVE_TERMIO_C_ISPEED) ])dnl dnl --------------------------------------------------------------------------- dnl CF_TRY_PKG_CONFIG version: 4 updated: 2010/06/14 17:42:30 dnl ----------------- dnl This is a simple wrapper to use for pkg-config, for libraries which may be dnl available in that form. dnl dnl $1 = package name dnl $2 = extra logic to use, if any, after updating CFLAGS and LIBS dnl $3 = logic to use if pkg-config does not have the package AC_DEFUN([CF_TRY_PKG_CONFIG],[ AC_REQUIRE([CF_PKG_CONFIG]) if test "$PKG_CONFIG" != none && "$PKG_CONFIG" --exists $1; then CF_VERBOSE(found package $1) cf_pkgconfig_incs="`$PKG_CONFIG --cflags $1 2>/dev/null`" cf_pkgconfig_libs="`$PKG_CONFIG --libs $1 2>/dev/null`" CF_VERBOSE(package $1 CFLAGS: $cf_pkgconfig_incs) CF_VERBOSE(package $1 LIBS: $cf_pkgconfig_libs) CF_ADD_CFLAGS($cf_pkgconfig_incs) CF_ADD_LIBS($cf_pkgconfig_libs) ifelse([$2],,:,[$2]) else ifelse([$3],,:,[$3]) fi ]) dnl --------------------------------------------------------------------------- dnl CF_TRY_XOPEN_SOURCE version: 1 updated: 2011/10/30 17:09:50 dnl ------------------- dnl If _XOPEN_SOURCE is not defined in the compile environment, check if we dnl can define it successfully. AC_DEFUN([CF_TRY_XOPEN_SOURCE],[ AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[ AC_TRY_COMPILE([ #include #include #include ],[ #ifndef _XOPEN_SOURCE make an error #endif], [cf_cv_xopen_source=no], [cf_save="$CPPFLAGS" CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE" AC_TRY_COMPILE([ #include #include #include ],[ #ifdef _XOPEN_SOURCE make an error #endif], [cf_cv_xopen_source=no], [cf_cv_xopen_source=$cf_XOPEN_SOURCE]) CPPFLAGS="$cf_save" ]) ]) if test "$cf_cv_xopen_source" != no ; then CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE) CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE) cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source" CF_ADD_CFLAGS($cf_temp_xopen_source) fi ]) dnl --------------------------------------------------------------------------- dnl CF_TTY_GROUP version: 7 updated: 2007/03/14 16:43:59 dnl ------------ dnl Check if the system has a tty-group defined. This is used in xterm when dnl setting pty ownership. AC_DEFUN([CF_TTY_GROUP], [ AC_MSG_CHECKING(for explicit tty group name) AC_ARG_WITH(tty-group, [ --with-tty-group=XXX use XXX for the tty-group], [cf_tty_group=$withval], [cf_tty_group=auto...]) test -z "$cf_tty_group" && cf_tty_group=auto... test "$cf_tty_group" = yes && cf_tty_group=auto... AC_MSG_RESULT($cf_tty_group) if test "$cf_tty_group" = "auto..." ; then AC_CACHE_CHECK(for tty group name,cf_cv_tty_group_name,[ # If we are configuring as root, it is hard to get a clue about the tty group. # But we'll guess based on how our connection is set up - assuming it is done # properly. cf_uid=`id | sed -e 's/^[^=]*=//' -e 's/(.*$//'` # )vi if test "$cf_uid" != 0 ; then cf_cv_tty_group_name= cf_tty_name=`tty` test "$cf_tty_name" = "not a tty" && cf_tty_name=/dev/tty test -z "$cf_tty_name" && cf_tty_name=/dev/tty if test -c "$cf_tty_name" then cf_option="-l -L" # Expect listing to have fields like this: #-rwxrwxrwx 1 user group 34293 Jul 18 16:29 pathname ls $cf_option $cf_tty_name >conftest.out read cf_mode cf_links cf_usr cf_grp cf_size cf_date1 cf_date2 cf_date3 cf_rest conftest.out read cf_mode cf_links cf_usr cf_grp cf_size cf_date1 cf_date2 cf_date3 cf_rest /dev/null 1>/dev/null ) then cf_cv_tty_group_name="tty" fi ;; esac fi ]) cf_tty_group="$cf_cv_tty_group_name" else # if configure option, always do this AC_DEFINE(USE_TTY_GROUP) fi AC_DEFINE_UNQUOTED(TTY_GROUP_NAME,"$cf_tty_group") # This is only a double-check that the group-name we obtained above really # does apply to the device. We cannot perform this test if we are in batch # mode, or if we are cross-compiling. AC_CACHE_CHECK(if we may use the $cf_tty_group group,cf_cv_tty_group,[ cf_tty_name=`tty` if test "$cf_tty_name" != "not a tty" then AC_TRY_RUN([ #include #include #include #include int main() { struct stat sb; struct group *ttygrp = getgrnam(TTY_GROUP_NAME); char *name = ttyname(0); endgrent(); if (ttygrp != 0 && name != 0 && stat(name, &sb) == 0 && sb.st_gid != getgid() && sb.st_gid == ttygrp->gr_gid) { ${cf_cv_main_return:-return} (0); } ${cf_cv_main_return:-return} (1); } ], [cf_cv_tty_group=yes], [cf_cv_tty_group=no], [cf_cv_tty_group=unknown]) elif test "$cross_compiling" = yes; then cf_cv_tty_group=unknown else cf_cv_tty_group=yes fi ]) if test $cf_cv_tty_group = no ; then AC_MSG_WARN(Cannot use $cf_tty_group group) else AC_DEFINE(USE_TTY_GROUP) fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_TYPE_CC_T version: 1 updated: 2011/12/12 20:54:48 dnl ------------ dnl Check for cc_t type, used in termio. AC_DEFUN([CF_TYPE_CC_T], [ AC_MSG_CHECKING(for cc_t in or ) AC_CACHE_VAL(cf_cv_type_cc_t,[ AC_TRY_COMPILE([ #include #if defined(HAVE_TERMIOS_H) #include #else #include #include #endif ], [cc_t x], [cf_cv_type_cc_t=yes], [cf_cv_type_cc_t=no]) ]) AC_MSG_RESULT($cf_cv_type_cc_t) test $cf_cv_type_cc_t = no && AC_DEFINE(cc_t, unsigned char) ])dnl dnl --------------------------------------------------------------------------- dnl CF_TYPE_FD_MASK version: 2 updated: 2008/03/25 20:59:57 dnl --------------- dnl Check for the declaration of fd_mask, which is like fd_set, associated dnl with select(). The check for fd_set should have pulled in this as well, dnl but there is a special case for Mac OS X, possibly other BSD-derived dnl platforms. AC_DEFUN([CF_TYPE_FD_MASK], [ AC_REQUIRE([CF_TYPE_FD_SET]) AC_CACHE_CHECK(for declaration of fd_mask,cf_cv_type_fd_mask,[ if test x$cf_cv_type_fd_set = xX11/Xpoll.h ; then AC_TRY_COMPILE([ #include ],[fd_mask x],, [CF_MSG_LOG(if we must define CSRG_BASED) # Xosdefs.h on Mac OS X may not define this (but it should). AC_TRY_COMPILE([ #define CSRG_BASED #include ],[fd_mask x], cf_cv_type_fd_mask=CSRG_BASED)]) else cf_cv_type_fd_mask=$cf_cv_type_fd_set fi ]) if test x$cf_cv_type_fd_mask = xCSRG_BASED ; then AC_DEFINE(CSRG_BASED) fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_TYPE_FD_SET version: 4 updated: 2008/03/25 20:56:03 dnl -------------- dnl Check for the declaration of fd_set. Some platforms declare it in dnl , and some in , which requires . dnl Finally, if we are using this for an X application, Xpoll.h may include dnl , so we don't want to do it twice. AC_DEFUN([CF_TYPE_FD_SET], [ AC_CHECK_HEADERS(X11/Xpoll.h) AC_CACHE_CHECK(for declaration of fd_set,cf_cv_type_fd_set, [CF_MSG_LOG(sys/types alone) AC_TRY_COMPILE([ #include ], [fd_set x], [cf_cv_type_fd_set=sys/types.h], [CF_MSG_LOG(X11/Xpoll.h) AC_TRY_COMPILE([ #ifdef HAVE_X11_XPOLL_H #include #endif], [fd_set x], [cf_cv_type_fd_set=X11/Xpoll.h], [CF_MSG_LOG(sys/select.h) AC_TRY_COMPILE([ #include #include ], [fd_set x], [cf_cv_type_fd_set=sys/select.h], [cf_cv_type_fd_set=unknown])])])]) if test $cf_cv_type_fd_set = sys/select.h ; then AC_DEFINE(USE_SYS_SELECT_H) fi ]) dnl --------------------------------------------------------------------------- dnl CF_UNDO_CFLAGS version: 1 updated: 2011/07/02 09:27:51 dnl -------------- dnl Remove flags from $CFLAGS or similar shell variable using sed. dnl $1 = variable dnl $2 = message dnl $3 = pattern to remove AC_DEFUN([CF_UNDO_CFLAGS], [ CF_VERBOSE(removing $2 flags from $1) $1=`echo "[$]$1" | sed -e 's/$3//'` CF_VERBOSE(...result [$]$1) ])dnl dnl --------------------------------------------------------------------------- dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59 dnl -------- dnl Make an uppercase version of a variable dnl $1=uppercase($2) AC_DEFUN([CF_UPPER], [ $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%` ])dnl dnl --------------------------------------------------------------------------- dnl CF_UTEMPTER version: 3 updated: 2010/06/02 05:03:05 dnl ----------- dnl Try to link with utempter library AC_DEFUN([CF_UTEMPTER], [ AC_CACHE_CHECK(if we can link with utempter library,cf_cv_have_utempter,[ cf_save_LIBS="$LIBS" CF_ADD_LIB(utempter) AC_TRY_LINK([ #include ],[ addToUtmp("/dev/tty", 0, 1); removeFromUtmp(); ],[ cf_cv_have_utempter=yes],[ cf_cv_have_utempter=no]) LIBS="$cf_save_LIBS" ]) if test "$cf_cv_have_utempter" = yes ; then AC_DEFINE(USE_UTEMPTER) CF_ADD_LIB(utempter) fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_UTMP version: 9 updated: 2008/01/25 17:18:00 dnl ------- dnl Check for UTMP/UTMPX headers AC_DEFUN([CF_UTMP], [ AC_REQUIRE([CF_LASTLOG]) AC_CACHE_CHECK(for utmp implementation,cf_cv_have_utmp,[ cf_cv_have_utmp=no for cf_header in utmpx utmp ; do cf_utmp_includes=" #include #include <${cf_header}.h> #define getutent getutxent #ifdef USE_LASTLOG #include /* may conflict with utmpx.h on Linux */ #endif " AC_TRY_COMPILE([$cf_utmp_includes], [struct $cf_header x; char *name = x.ut_name; /* utmp.h and compatible definitions */ ], [cf_cv_have_utmp=$cf_header break], [ AC_TRY_COMPILE([$cf_utmp_includes], [struct $cf_header x; char *name = x.ut_user; /* utmpx.h must declare this */ ], [cf_cv_have_utmp=$cf_header break ])]) done ]) if test $cf_cv_have_utmp != no ; then AC_DEFINE(HAVE_UTMP) test $cf_cv_have_utmp = utmpx && AC_DEFINE(UTMPX_FOR_UTMP) CF_UTMP_UT_HOST CF_UTMP_UT_SYSLEN CF_UTMP_UT_NAME CF_UTMP_UT_XSTATUS CF_UTMP_UT_XTIME CF_UTMP_UT_SESSION CF_SYSV_UTMP fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_UTMP_GROUP version: 1 updated: 2005/10/06 20:29:29 dnl ------------- dnl Find the utmp/utmpx file and determine its group to allow setgid programs dnl to manipulate it, e.g., when there is no intermediary. AC_DEFUN([CF_UTMP_GROUP],[ AC_REQUIRE([CF_UTMP]) if test $cf_cv_have_utmp != no ; then AC_CACHE_CHECK(for utmp/utmpx group,cf_cv_utmp_group,[ for cf_utmp_path in /var/adm /var/run do for cf_utmp_file in utmpx utmp do if test -f $cf_utmp_path/$cf_utmp_file then cf_cv_utmp_group=root cf_option="-l -L" # Expect listing to have fields like this: #-r--r--r-- 1 user group 34293 Jul 18 16:29 pathname ls $cf_option $cf_utmp_path/$cf_utmp_file >conftest read cf_mode cf_links cf_usr cf_grp cf_size cf_date1 cf_date2 cf_date3 cf_rest conftest read cf_mode cf_links cf_usr cf_grp cf_size cf_date1 cf_date2 cf_date3 cf_rest #include <${cf_cv_have_utmp}.h>], [struct $cf_cv_have_utmp x; char *y = &x.ut_host[0]], [cf_cv_have_utmp_ut_host=yes], [cf_cv_have_utmp_ut_host=no]) ]) AC_MSG_RESULT($cf_cv_have_utmp_ut_host) test $cf_cv_have_utmp_ut_host != no && AC_DEFINE(HAVE_UTMP_UT_HOST) fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_UTMP_UT_NAME version: 4 updated: 2007/03/13 19:17:11 dnl --------------- dnl Check if UTMP/UTMPX struct defines ut_name member AC_DEFUN([CF_UTMP_UT_NAME], [ if test $cf_cv_have_utmp != no ; then AC_CACHE_CHECK(if ${cf_cv_have_utmp}.ut_name is declared,cf_cv_have_utmp_ut_name,[ cf_cv_have_utmp_ut_name=no cf_utmp_includes=" #include #include <${cf_cv_have_utmp}.h> #define getutent getutxent #ifdef USE_LASTLOG #include /* may conflict with utmpx.h on Linux */ #endif " for cf_header in ut_name ut_user ; do AC_TRY_COMPILE([$cf_utmp_includes], [struct $cf_cv_have_utmp x; char *name = x.$cf_header; ], [cf_cv_have_utmp_ut_name=$cf_header break]) done ]) case $cf_cv_have_utmp_ut_name in #(vi no) #(vi AC_MSG_ERROR(Cannot find declaration for ut.ut_name) ;; ut_user) AC_DEFINE(ut_name,ut_user) ;; esac fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_UTMP_UT_SESSION version: 5 updated: 2007/03/13 19:17:11 dnl ------------------ dnl Check if UTMP/UTMPX struct defines ut_session member AC_DEFUN([CF_UTMP_UT_SESSION], [ if test $cf_cv_have_utmp != no ; then AC_CACHE_CHECK(if ${cf_cv_have_utmp}.ut_session is declared, cf_cv_have_utmp_ut_session,[ AC_TRY_COMPILE([ #include #include <${cf_cv_have_utmp}.h>], [struct $cf_cv_have_utmp x; long y = x.ut_session], [cf_cv_have_utmp_ut_session=yes], [cf_cv_have_utmp_ut_session=no]) ]) if test $cf_cv_have_utmp_ut_session != no ; then AC_DEFINE(HAVE_UTMP_UT_SESSION) fi fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_UTMP_UT_SYSLEN version: 1 updated: 2008/01/25 17:18:00 dnl ----------------- dnl Check if UTMP/UTMPX struct defines ut_syslen member AC_DEFUN([CF_UTMP_UT_SYSLEN], [ if test $cf_cv_have_utmp != no ; then AC_MSG_CHECKING(if ${cf_cv_have_utmp}.ut_syslen is declared) AC_CACHE_VAL(cf_cv_have_utmp_ut_syslen,[ AC_TRY_COMPILE([ #include #include <${cf_cv_have_utmp}.h>], [struct $cf_cv_have_utmp x; int y = x.ut_syslen], [cf_cv_have_utmp_ut_syslen=yes], [cf_cv_have_utmp_ut_syslen=no]) ]) AC_MSG_RESULT($cf_cv_have_utmp_ut_syslen) test $cf_cv_have_utmp_ut_syslen != no && AC_DEFINE(HAVE_UTMP_UT_SYSLEN) fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_UTMP_UT_XSTATUS version: 3 updated: 2001/12/27 12:55:07 dnl ------------------ dnl Check for known variants on the UTMP/UTMPX struct's exit-status as reported dnl by various people: dnl dnl ut_exit.__e_exit (HPUX 11 - David Ellement, also in glibc2) dnl ut_exit.e_exit (SVR4) dnl ut_exit.ut_e_exit (os390 - Greg Smith) dnl ut_exit.ut_exit (Tru64 4.0f - Jeremie Petit, 4.0e - Tomas Vanhala) dnl dnl Note: utmp_xstatus is not a conventional compatibility definition in the dnl system header files. AC_DEFUN([CF_UTMP_UT_XSTATUS], [ if test $cf_cv_have_utmp != no ; then AC_CACHE_CHECK(for exit-status in $cf_cv_have_utmp,cf_cv_have_utmp_ut_xstatus,[ for cf_result in \ ut_exit.__e_exit \ ut_exit.e_exit \ ut_exit.ut_e_exit \ ut_exit.ut_exit do AC_TRY_COMPILE([ #include #include <${cf_cv_have_utmp}.h>], [struct $cf_cv_have_utmp x; long y = x.$cf_result = 0], [cf_cv_have_utmp_ut_xstatus=$cf_result break], [cf_cv_have_utmp_ut_xstatus=no]) done ]) if test $cf_cv_have_utmp_ut_xstatus != no ; then AC_DEFINE(HAVE_UTMP_UT_XSTATUS) AC_DEFINE_UNQUOTED(ut_xstatus,$cf_cv_have_utmp_ut_xstatus) fi fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_UTMP_UT_XTIME version: 7 updated: 2007/03/13 19:17:11 dnl ---------------- dnl Check if UTMP/UTMPX struct defines ut_xtime member AC_DEFUN([CF_UTMP_UT_XTIME], [ if test $cf_cv_have_utmp != no ; then AC_CACHE_CHECK(if ${cf_cv_have_utmp}.ut_xtime is declared, cf_cv_have_utmp_ut_xtime,[ AC_TRY_COMPILE([ #include #include <${cf_cv_have_utmp}.h>], [struct $cf_cv_have_utmp x; long y = x.ut_xtime = 0], [cf_cv_have_utmp_ut_xtime=yes], [AC_TRY_COMPILE([ #include #include <${cf_cv_have_utmp}.h>], [struct $cf_cv_have_utmp x; long y = x.ut_tv.tv_sec], [cf_cv_have_utmp_ut_xtime=define], [cf_cv_have_utmp_ut_xtime=no]) ]) ]) if test $cf_cv_have_utmp_ut_xtime != no ; then AC_DEFINE(HAVE_UTMP_UT_XTIME) if test $cf_cv_have_utmp_ut_xtime = define ; then AC_DEFINE(ut_xtime,ut_tv.tv_sec) fi fi fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12 dnl ---------- dnl Use AC_VERBOSE w/o the warnings AC_DEFUN([CF_VERBOSE], [test -n "$verbose" && echo " $1" 1>&AC_FD_MSG CF_MSG_LOG([$1]) ])dnl dnl --------------------------------------------------------------------------- dnl CF_WITH_APP_CLASS version: 1 updated: 2011/07/08 04:54:40 dnl ----------------- dnl Handle configure option "--with-app-class", setting the $APP_CLASS dnl variable, used for X resources. dnl dnl $1 = default value. AC_DEFUN(CF_WITH_APP_CLASS,[ AC_MSG_CHECKING(for X applications class) AC_ARG_WITH(app-class, [ --with-app-class=XXX override X applications class (default $1)], [APP_CLASS=$withval], [APP_CLASS=$1]) case x$APP_CLASS in #(vi *[[/@,%]]*) #(vi AC_MSG_WARN(X applications class cannot contain punctuation) APP_CLASS=$1 ;; x[[A-Z]]*) #(vi ;; *) AC_MSG_WARN([X applications class must start with capital, ignoring $APP_CLASS]) APP_CLASS=$1 ;; esac AC_MSG_RESULT($APP_CLASS) AC_SUBST(APP_CLASS) ])dnl dnl --------------------------------------------------------------------------- dnl CF_WITH_APP_DEFAULTS version: 3 updated: 2012/06/19 20:58:54 dnl -------------------- dnl Handle configure option "--with-app-defaults", setting these shell dnl variables: dnl dnl $APPSDIR is the option value, used for installing app-defaults files. dnl $no_appsdir is a "#" (comment) if "--without-app-defaults" is given. dnl dnl Most Linux's use this: dnl /usr/share/X11/app-defaults dnl Debian uses this: dnl /etc/X11/app-defaults dnl DragonFlyBSD ports uses this: dnl /usr/pkg/lib/X11/app-defaults dnl FreeBSD ports use these: dnl /usr/local/lib/X11/app-defaults dnl /usr/local/share/X11/app-defaults dnl Mandriva has these: dnl /usr/lib/X11/app-defaults dnl /usr/lib64/X11/app-defaults dnl NetBSD has these dnl /usr/X11R7/lib/X11/app-defaults dnl OpenSolaris uses dnl 32-bit: dnl /usr/X11/etc/X11/app-defaults dnl /usr/X11/share/X11/app-defaults dnl /usr/X11/lib/X11/app-defaults dnl 64-bit: dnl /usr/X11/etc/X11/app-defaults dnl /usr/X11/share/X11/app-defaults (I mkdir'd this) dnl /usr/X11/lib/amd64/X11/app-defaults dnl Solaris10 uses (in this order): dnl /usr/openwin/lib/X11/app-defaults dnl /usr/X11/lib/X11/app-defaults AC_DEFUN(CF_WITH_APP_DEFAULTS,[ AC_MSG_CHECKING(for directory to install resource files) AC_ARG_WITH(app-defaults, [ --with-app-defaults=DIR directory in which to install resource files (EPREFIX/lib/X11/app-defaults)], [APPSDIR=$withval], [APPSDIR='${exec_prefix}/lib/X11/app-defaults']) if test "x[$]APPSDIR" = xauto then APPSDIR='${exec_prefix}/lib/X11/app-defaults' for cf_path in \ /usr/share/X11/app-defaults \ /usr/X11/share/X11/app-defaults \ /usr/X11/lib/X11/app-defaults \ /usr/lib/X11/app-defaults \ /etc/X11/app-defaults \ /usr/pkg/lib/X11/app-defaults \ /usr/X11R7/lib/X11/app-defaults \ /usr/X11R6/lib/X11/app-defaults \ /usr/X11R5/lib/X11/app-defaults \ /usr/X11R4/lib/X11/app-defaults \ /usr/local/lib/X11/app-defaults \ /usr/local/share/X11/app-defaults \ /usr/lib64/X11/app-defaults do if test -d "$cf_path" ; then APPSDIR="$cf_path" break fi done else cf_path=$APPSDIR CF_PATH_SYNTAX(cf_path) fi AC_MSG_RESULT($APPSDIR) AC_SUBST(APPSDIR) no_appsdir= test "$APPSDIR" = no && no_appsdir="#" AC_SUBST(no_appsdir) ])dnl dnl --------------------------------------------------------------------------- dnl CF_WITH_DESKTOP_CATEGORY version: 2 updated: 2011/07/02 10:22:07 dnl ------------------------ dnl Taking into account the absence of standardization of desktop categories dnl take a look to see whether other applications on the current system are dnl assigned any/all of a set of suggested categories. dnl dnl $1 = program name dnl $2 = case-pattern to match comparable desktop files to obtain category dnl This pattern may contain wildcards. dnl $3 = suggested categories, also a case-pattern but without wildcards, dnl since it doubles as a default value. dnl dnl The macro tells the configure script to substitute the $DESKTOP_CATEGORY dnl value. AC_DEFUN([CF_WITH_DESKTOP_CATEGORY],[ AC_REQUIRE([CF_DISABLE_DESKTOP]) if test -z "$desktop_utils" then AC_MSG_CHECKING(for requested desktop-category) AC_ARG_WITH(desktop-category, [ --with-desktop-category=XXX one or more desktop catgories or auto], [cf_desktop_want=$withval], [cf_desktop_want=auto]) AC_MSG_RESULT($cf_desktop_want) if test "$cf_desktop_want" = auto then rm -rf conftest* cf_desktop_also= for cf_desktop_dir in \ /usr/share/app-install \ /usr/share/applications do if test -d $cf_desktop_dir then find $cf_desktop_dir -name '*.desktop' | \ while true do read cf_desktop_path test -z "$cf_desktop_path" && break cf_desktop_name=`basename $cf_desktop_path .desktop` case $cf_desktop_name in #(vi $1|*-$1|$2) CF_VERBOSE(inspect $cf_desktop_path) egrep '^Categories=' $cf_desktop_path | \ tr ';' '\n' | \ sed -e 's%^.*=%%' -e '/^$/d' >>conftest.1 ;; esac done fi done if test -s conftest.1 then cf_desktop_last= sort conftest.1 | \ while true do read cf_desktop_this test -z "$cf_desktop_this" && break case $cf_desktop_this in #(vi Qt*|GTK*|KDE*|GNOME*|*XFCE*|*Xfce*) #(vi ;; $3) test "x$cf_desktop_last" != "x$cf_desktop_this" && echo $cf_desktop_this >>conftest.2 ;; esac cf_desktop_last=$cf_desktop_this done cf_desktop_want=`cat conftest.2 | tr '\n' ';'` fi fi DESKTOP_CATEGORY=`echo "$cf_desktop_want" | sed -e 's/[[ ,]]/;/g'` CF_VERBOSE(resulting category=$DESKTOP_CATEGORY) AC_SUBST(DESKTOP_CATEGORY) fi ]) dnl --------------------------------------------------------------------------- dnl CF_WITH_ICONDIR version: 4 updated: 2012/06/21 21:03:13 dnl --------------- dnl Handle configure option "--with-icondir", setting these shell variables: dnl dnl $ICONDIR is the option value, used for installing icon files. dnl $no_icondir is a "#" (comment) if "--without-icondir" is given. AC_DEFUN([CF_WITH_ICONDIR],[ AC_MSG_CHECKING(for directory to install icons) AC_ARG_WITH(icondir, [ --with-icondir=DIR directory in which to install icons for desktop], [ICONDIR=$withval], [test -z "$ICONDIR" && ICONDIR=no]) if test "x[$]ICONDIR" = xauto then ICONDIR='${datadir}/icons' for cf_path in \ /usr/share/icons \ /usr/X11R6/share/icons do if test -d "$cf_path" ; then ICONDIR="$cf_path" break fi done else cf_path=$ICONDIR CF_PATH_SYNTAX(cf_path) fi AC_MSG_RESULT($ICONDIR) AC_SUBST(ICONDIR) no_icondir= test "$ICONDIR" = no && no_icondir="#" AC_SUBST(no_icondir) ])dnl dnl --------------------------------------------------------------------------- dnl CF_WITH_ICON_THEME version: 5 updated: 2012/06/26 05:55:35 dnl ------------------ dnl If asked, check for prerequisites and setup symbols to permit installing dnl one or more application icons in the Red Hat icon-theme directory dnl hierarchy. dnl dnl If the prerequisites are missing, give a warning and revert to the long- dnl standing pixmaps directory. dnl dnl Parameters: dnl dnl $1 = application icon. This can be a list, and is not optional. dnl $2 = default theme (defaults to hicolor) dnl $3 = formats (defaults to list [.svg .png .xpm]) dnl $4 = alternate icon if no theme is used (defaults to $1). dnl dnl Result: dnl ICON_NAME = basename of first item in $1 dnl ICON_LIST = reprocessed $1 dnl ICON_THEME = reprocessed $2 dnl ICON_FORMAT = reprocessed $3 AC_DEFUN([CF_WITH_ICON_THEME], [ ifelse([$1],,[ AC_MSG_ERROR([macro [CF_WITH_ICON_THEME] requires application-icon name]) ],[ CF_WITH_PIXMAPDIR CF_WITH_ICONDIR AC_MSG_CHECKING(if icon theme should be used) AC_ARG_WITH(icon-theme, [ --with-icon-theme=XXX install icons into desktop theme (hicolor)], [ICON_THEME=$withval], [ICON_THEME=no]) case "x$ICON_THEME" in #(vi xno) #(vi ;; x|xyes) ICON_THEME=ifelse([$2],,hicolor,$2) ;; esac AC_MSG_RESULT($ICON_THEME) if test "x$ICON_THEME" = xno then if test "x$ICONDIR" != xno then AC_MSG_WARN(ignoring icondir without theme) no_icondir="#" fi else if test "x$ICONDIR" = xno then AC_MSG_ERROR(icondir must be set for icon theme) fi fi : ${ICON_FORMAT:=ifelse([$3],,[.svg .png .xpm],[$3])} ICON_NAME= ICON_LIST= ifelse([$4],,[cf_icon_list=$1],[ if test "x$ICON_THEME" != xno then cf_icon_list=$1 else cf_icon_list=$4 fi ]) AC_MSG_CHECKING([for icon(s) to install]) for cf_name in $cf_icon_list do for cf_suffix in $ICON_FORMAT do cf_icon="${cf_name}${cf_suffix}" cf_left=`echo "$cf_icon" | sed -e 's/:.*//'` if test ! -f "${cf_left}" then if test "x$srcdir" != "x." then cf_icon="${srcdir}/${cf_left}" cf_left=`echo "$cf_icon" | sed -e 's/:.*//'` if test ! -f "${cf_left}" then continue fi else continue fi fi if test "x$ICON_THEME" != xno then cf_base=`basename $cf_left` case "x${cf_icon}" in #(vi *:*) #(vi # user-defined mapping ;; *_[[0-9]][[0-9]]*x[[0-9]][[0-9]]*.*) #(vi cf_size=`echo "$cf_left"|sed -e 's/^.*_\([[0-9]][[0-9]]*x[[0-9]][[0-9]]*\)\..*$/\1/'` cf_left=`echo "$cf_left"|sed -e 's/^\(.*\)_\([[0-9]][[0-9]]*x[[0-9]][[0-9]]*\)\(\..*\)$/\1\3/'` cf_icon="${cf_icon}:$cf_size/apps/$cf_base" ;; *.png) #(vi cf_size=`file "$cf_left"|sed -e 's/^[[^:]]*://' -e 's/^.*[[^0-9]]\([[0-9]][[0-9]]* x [[0-9]][[0-9]]*\)[[^0-9]].*$/\1/' -e 's/ //g'` if test -z "$cf_size" then AC_MSG_WARN(cannot determine size of $cf_left) continue fi cf_icon="${cf_icon}:$cf_size/apps/$cf_base" ;; *.svg) #(vi cf_icon="${cf_icon}:scalable/apps/`basename $cf_icon`" ;; *.xpm) AC_MSG_WARN(ignored XPM file in icon theme) continue ;; esac fi test -n "$ICON_LIST" && ICON_LIST="$ICON_LIST " ICON_LIST="$ICON_LIST${cf_icon}" if test -z "$ICON_NAME" then ICON_NAME=`basename $cf_icon | sed -e 's/[[.:]].*//'` fi done done AC_MSG_RESULT($ICON_LIST) if test -z "$ICON_LIST" then AC_MSG_ERROR(no icons found) fi ]) AC_MSG_CHECKING(for icon name) AC_MSG_RESULT($ICON_NAME) AC_SUBST(ICON_FORMAT) AC_SUBST(ICON_THEME) AC_SUBST(ICON_LIST) AC_SUBST(ICON_NAME) ])dnl dnl --------------------------------------------------------------------------- dnl CF_WITH_IMAKE_CFLAGS version: 9 updated: 2010/05/26 05:38:42 dnl -------------------- dnl xterm and similar programs build more readily when propped up with imake's dnl hand-tuned definitions. If we do not use imake, provide fallbacks for the dnl most common definitions that we're not likely to do by autoconf tests. AC_DEFUN([CF_WITH_IMAKE_CFLAGS],[ AC_REQUIRE([CF_ENABLE_NARROWPROTO]) AC_MSG_CHECKING(if we should use imake to help) CF_ARG_DISABLE(imake, [ --disable-imake disable use of imake for definitions], [enable_imake=no], [enable_imake=yes]) AC_MSG_RESULT($enable_imake) if test "$enable_imake" = yes ; then CF_IMAKE_CFLAGS(ifelse([$1],,,[$1])) fi if test -n "$IMAKE" && test -n "$IMAKE_CFLAGS" ; then CF_ADD_CFLAGS($IMAKE_CFLAGS) else IMAKE_CFLAGS= IMAKE_LOADFLAGS= CF_VERBOSE(make fallback definitions) # We prefer config.guess' values when we can get them, to avoid # inconsistent results with uname (AIX for instance). However, # config.guess is not always consistent either. case $host_os in *[[0-9]].[[0-9]]*) UNAME_RELEASE="$host_os" ;; *) UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown ;; esac case .$UNAME_RELEASE in *[[0-9]].[[0-9]]*) OSMAJORVERSION=`echo "$UNAME_RELEASE" |sed -e 's/^[[^0-9]]*//' -e 's/\..*//'` OSMINORVERSION=`echo "$UNAME_RELEASE" |sed -e 's/^[[^0-9]]*//' -e 's/^[[^.]]*\.//' -e 's/\..*//' -e 's/[[^0-9]].*//' ` test -z "$OSMAJORVERSION" && OSMAJORVERSION=1 test -z "$OSMINORVERSION" && OSMINORVERSION=0 IMAKE_CFLAGS="-DOSMAJORVERSION=$OSMAJORVERSION -DOSMINORVERSION=$OSMINORVERSION $IMAKE_CFLAGS" ;; esac # FUNCPROTO is standard with X11R6, but XFree86 drops it, leaving some # fallback/fragments for NeedPrototypes, etc. IMAKE_CFLAGS="-DFUNCPROTO=15 $IMAKE_CFLAGS" # If this is not set properly, Xaw's scrollbars will not work if test "$enable_narrowproto" = yes ; then IMAKE_CFLAGS="-DNARROWPROTO=1 $IMAKE_CFLAGS" fi # Other special definitions: case $host_os in aix*) # imake on AIX 5.1 defines AIXV3. really. IMAKE_CFLAGS="-DAIXV3 -DAIXV4 $IMAKE_CFLAGS" ;; irix[[56]].*) #(vi # these are needed to make SIGWINCH work in xterm IMAKE_CFLAGS="-DSYSV -DSVR4 $IMAKE_CFLAGS" ;; esac CF_ADD_CFLAGS($IMAKE_CFLAGS) AC_SUBST(IMAKE_CFLAGS) AC_SUBST(IMAKE_LOADFLAGS) fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_WITH_PATH version: 10 updated: 2010/10/23 15:44:18 dnl ------------ dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just dnl defaulting to yes/no. dnl dnl $1 = option name dnl $2 = help-text dnl $3 = environment variable to set dnl $4 = default value, shown in the help-message, must be a constant dnl $5 = default value, if it's an expression & cannot be in the help-message dnl AC_DEFUN([CF_WITH_PATH], [AC_ARG_WITH($1,[$2 ](default: ifelse([$4],,empty,[$4])),, ifelse([$4],,[withval="${$3}"],[withval="${$3:-ifelse([$5],,[$4],[$5])}"]))dnl if ifelse([$5],,true,[test -n "$5"]) ; then CF_PATH_SYNTAX(withval) fi $3="$withval" AC_SUBST($3)dnl ])dnl dnl --------------------------------------------------------------------------- dnl CF_WITH_PCRE version: 8 updated: 2010/06/05 11:30:21 dnl ------------ dnl Add PCRE (Perl-compatible regular expressions) to the build if it is dnl available and the user requests it. Assume the application will otherwise dnl use the POSIX interface. dnl dnl TODO allow $withval to specify package location AC_DEFUN([CF_WITH_PCRE], [ AC_REQUIRE([CF_PKG_CONFIG]) AC_MSG_CHECKING(if you want to use PCRE for regular-expressions) AC_ARG_WITH(pcre, [ --with-pcre use PCRE for regular-expressions]) test -z "$with_pcre" && with_pcre=no AC_MSG_RESULT($with_pcre) if test "$with_pcre" != no ; then CF_TRY_PKG_CONFIG(libpcre,,[ AC_CHECK_LIB(pcre,pcre_compile,, AC_MSG_ERROR(Cannot find PCRE library))]) AC_DEFINE(HAVE_LIB_PCRE) case $LIBS in #(vi *pcreposix*) #(vi ;; *) AC_CHECK_LIB(pcreposix,pcreposix_regcomp, [AC_DEFINE(HAVE_PCREPOSIX_H) CF_ADD_LIB(pcreposix)], [AC_CHECK_LIB(pcreposix,regcomp,[ AC_DEFINE(HAVE_PCREPOSIX_H) CF_ADD_LIB(pcreposix)], AC_MSG_ERROR(Cannot find PCRE POSIX library)])) ;; esac fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_WITH_PIXMAPDIR version: 2 updated: 2012/06/21 21:03:13 dnl ----------------- dnl Handle configure option "--with-pixmapdir", setting these shell variables: dnl dnl $PIXMAPDIR is the option value, used for installing pixmap files. dnl $no_pixmapdir is a "#" (comment) if "--without-pixmapdir" is given. AC_DEFUN([CF_WITH_PIXMAPDIR],[ AC_MSG_CHECKING(for directory to install pixmaps) AC_ARG_WITH(pixmapdir, [ --with-pixmapdir=DIR directory in which to install pixmaps (DATADIR/pixmaps)], [PIXMAPDIR=$withval], [test -z "$PIXMAPDIR" && PIXMAPDIR='${datadir}/pixmaps']) if test "x[$]PIXMAPDIR" = xauto then PIXMAPDIR='${datadir}/pixmaps' for cf_path in \ /usr/share/pixmaps \ /usr/X11R6/share/pixmaps do if test -d "$cf_path" ; then PIXMAPDIR="$cf_path" break fi done else cf_path=$PIXMAPDIR CF_PATH_SYNTAX(cf_path) fi AC_MSG_RESULT($PIXMAPDIR) AC_SUBST(PIXMAPDIR) no_pixmapdir= test "$PIXMAPDIR" = no && no_pixmapdir="#" AC_SUBST(no_pixmapdir) ])dnl dnl --------------------------------------------------------------------------- dnl CF_XBOOL_RESULT version: 1 updated: 2012/06/04 20:23:25 dnl --------------- dnl Translate an autoconf boolean yes/no into X11's booleans, e.g., True/False. dnl Allow for more than two values, e.g., "maybe", still using the same leading dnl capital convention. dnl dnl $1 = symbol to define dnl $2 = symbol holding value define([CF_XBOOL_RESULT],[ AC_MSG_RESULT([$]$2) case [$]$2 in #(vi yes) #(vi $2=true ;; no) #(vi $2=false ;; esac cf_xbool1=`echo "[$]$2"|sed -e 's/^\(.\).*/\1/'` CF_UPPER(cf_xbool1,$cf_xbool1) cf_xbool2=`echo "[$]$2"|sed -e 's/^.//'` $2=${cf_xbool1}${cf_xbool2} AC_DEFINE_UNQUOTED($1,[$]$2) AC_SUBST($2) ]) dnl --------------------------------------------------------------------------- dnl CF_XKB_BELL_EXT version: 3 updated: 2009/02/13 16:00:39 dnl --------------- dnl Check for XKB bell extension AC_DEFUN([CF_XKB_BELL_EXT],[ AC_CACHE_CHECK(for XKB Bell extension, cf_cv_xkb_bell_ext,[ AC_TRY_LINK([ #include #include /* has the prototype */ #include /* has the XkbBI_xxx definitions */ ],[ int x = (XkbBI_Info |XkbBI_MinorError |XkbBI_MajorError |XkbBI_TerminalBell |XkbBI_MarginBell); Atom y; XkbBell((Display *)0, (Widget)0, 0, y); ],[cf_cv_xkb_bell_ext=yes],[cf_cv_xkb_bell_ext=no]) ]) test "$cf_cv_xkb_bell_ext" = yes && AC_DEFINE(HAVE_XKB_BELL_EXT) ]) dnl --------------------------------------------------------------------------- dnl CF_XOPEN_SOURCE version: 42 updated: 2012/01/07 08:26:49 dnl --------------- dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions, dnl or adapt to the vendor's definitions to get equivalent functionality, dnl without losing the common non-POSIX features. dnl dnl Parameters: dnl $1 is the nominal value for _XOPEN_SOURCE dnl $2 is the nominal value for _POSIX_C_SOURCE AC_DEFUN([CF_XOPEN_SOURCE],[ cf_XOPEN_SOURCE=ifelse([$1],,500,[$1]) cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2]) cf_xopen_source= case $host_os in #(vi aix[[4-7]]*) #(vi cf_xopen_source="-D_ALL_SOURCE" ;; cygwin) #(vi cf_XOPEN_SOURCE=600 ;; darwin[[0-8]].*) #(vi cf_xopen_source="-D_APPLE_C_SOURCE" ;; darwin*) #(vi cf_xopen_source="-D_DARWIN_C_SOURCE" cf_XOPEN_SOURCE= ;; freebsd*|dragonfly*) #(vi # 5.x headers associate # _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L # _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L cf_POSIX_C_SOURCE=200112L cf_XOPEN_SOURCE=600 cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE" ;; hpux11*) #(vi cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500" ;; hpux*) #(vi cf_xopen_source="-D_HPUX_SOURCE" ;; irix[[56]].*) #(vi cf_xopen_source="-D_SGI_SOURCE" cf_XOPEN_SOURCE= ;; linux*|gnu*|mint*|k*bsd*-gnu) #(vi CF_GNU_SOURCE ;; mirbsd*) #(vi # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks and other headers which use u_int / u_short types cf_XOPEN_SOURCE= CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE) ;; netbsd*) #(vi cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw ;; openbsd[[4-9]]*) #(vi # setting _XOPEN_SOURCE lower than 500 breaks g++ compile with wchar.h, needed for ncursesw cf_xopen_source="-D_BSD_SOURCE" cf_XOPEN_SOURCE=600 ;; openbsd*) #(vi # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw ;; osf[[45]]*) #(vi cf_xopen_source="-D_OSF_SOURCE" ;; nto-qnx*) #(vi cf_xopen_source="-D_QNX_SOURCE" ;; sco*) #(vi # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer ;; solaris2.*) #(vi cf_xopen_source="-D__EXTENSIONS__" ;; *) CF_TRY_XOPEN_SOURCE CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE) ;; esac if test -n "$cf_xopen_source" ; then CF_ADD_CFLAGS($cf_xopen_source) fi dnl In anything but the default case, we may have system-specific setting dnl which is still not guaranteed to provide all of the entrypoints that dnl _XOPEN_SOURCE would yield. if test -n "$cf_XOPEN_SOURCE" && test -z "$cf_cv_xopen_source" ; then AC_MSG_CHECKING(if _XOPEN_SOURCE really is set) AC_TRY_COMPILE([#include ],[ #ifndef _XOPEN_SOURCE make an error #endif], [cf_XOPEN_SOURCE_set=yes], [cf_XOPEN_SOURCE_set=no]) AC_MSG_RESULT($cf_XOPEN_SOURCE_set) if test $cf_XOPEN_SOURCE_set = yes then AC_TRY_COMPILE([#include ],[ #if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE make an error #endif], [cf_XOPEN_SOURCE_set_ok=yes], [cf_XOPEN_SOURCE_set_ok=no]) if test $cf_XOPEN_SOURCE_set_ok = no then AC_MSG_WARN(_XOPEN_SOURCE is lower than requested) fi else CF_TRY_XOPEN_SOURCE fi fi ]) dnl --------------------------------------------------------------------------- dnl CF_X_ATHENA version: 20 updated: 2010/11/09 05:18:02 dnl ----------- dnl Check for Xaw (Athena) libraries dnl dnl Sets $cf_x_athena according to the flavor of Xaw which is used. AC_DEFUN([CF_X_ATHENA], [ cf_x_athena=${cf_x_athena:-Xaw} AC_MSG_CHECKING(if you want to link with Xaw 3d library) withval= AC_ARG_WITH(Xaw3d, [ --with-Xaw3d link with Xaw 3d library]) if test "$withval" = yes ; then cf_x_athena=Xaw3d AC_MSG_RESULT(yes) else AC_MSG_RESULT(no) fi AC_MSG_CHECKING(if you want to link with neXT Athena library) withval= AC_ARG_WITH(neXtaw, [ --with-neXtaw link with neXT Athena library]) if test "$withval" = yes ; then cf_x_athena=neXtaw AC_MSG_RESULT(yes) else AC_MSG_RESULT(no) fi AC_MSG_CHECKING(if you want to link with Athena-Plus library) withval= AC_ARG_WITH(XawPlus, [ --with-XawPlus link with Athena-Plus library]) if test "$withval" = yes ; then cf_x_athena=XawPlus AC_MSG_RESULT(yes) else AC_MSG_RESULT(no) fi cf_x_athena_lib="" if test "$PKG_CONFIG" != none ; then cf_athena_list= test "$cf_x_athena" = Xaw && cf_athena_list="xaw8 xaw7 xaw6" for cf_athena_pkg in \ $cf_athena_list \ ${cf_x_athena} \ ${cf_x_athena}-devel \ lib${cf_x_athena} \ lib${cf_x_athena}-devel do CF_TRY_PKG_CONFIG($cf_athena_pkg,[ cf_x_athena_lib="$cf_pkgconfig_libs" CF_UPPER(cf_x_athena_LIBS,HAVE_LIB_$cf_x_athena) AC_DEFINE_UNQUOTED($cf_x_athena_LIBS) AC_CACHE_CHECK(for usable $cf_x_athena/Xmu package,cf_cv_xaw_compat,[ AC_TRY_LINK([ #include ],[ int check = XmuCompareISOLatin1("big", "small") ],[cf_cv_xaw_compat=yes],[cf_cv_xaw_compat=no])]) if test "$cf_cv_xaw_compat" = no then # workaround for broken ".pc" files... case "$cf_x_athena_lib" in #(vi *-lXmu*) #(vi ;; *) CF_VERBOSE(work around broken package) CF_TRY_PKG_CONFIG(xmu,,[CF_ADD_LIB_AFTER(-lXt,-lXmu)]) ;; esac fi break]) done fi if test -z "$cf_x_athena_lib" ; then CF_X_EXT CF_X_TOOLKIT CF_X_ATHENA_CPPFLAGS($cf_x_athena) CF_X_ATHENA_LIBS($cf_x_athena) fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_X_ATHENA_CPPFLAGS version: 5 updated: 2010/05/26 17:35:30 dnl -------------------- dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw. AC_DEFUN([CF_X_ATHENA_CPPFLAGS], [ cf_x_athena_root=ifelse([$1],,Xaw,[$1]) cf_x_athena_inc="" for cf_path in default \ /usr/contrib/X11R6 \ /usr/contrib/X11R5 \ /usr/lib/X11R5 \ /usr/local do if test -z "$cf_x_athena_inc" ; then cf_save="$CPPFLAGS" cf_test=X11/$cf_x_athena_root/SimpleMenu.h if test $cf_path != default ; then CPPFLAGS="$cf_save -I$cf_path/include" AC_MSG_CHECKING(for $cf_test in $cf_path) else AC_MSG_CHECKING(for $cf_test) fi AC_TRY_COMPILE([ #include #include <$cf_test>],[], [cf_result=yes], [cf_result=no]) AC_MSG_RESULT($cf_result) if test "$cf_result" = yes ; then cf_x_athena_inc=$cf_path break else CPPFLAGS="$cf_save" fi fi done if test -z "$cf_x_athena_inc" ; then AC_MSG_WARN( [Unable to successfully find Athena header files with test program]) elif test "$cf_x_athena_inc" != default ; then CPPFLAGS="$CPPFLAGS -I$cf_x_athena_inc" fi ]) dnl --------------------------------------------------------------------------- dnl CF_X_ATHENA_LIBS version: 12 updated: 2011/07/17 19:55:02 dnl ---------------- dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw. AC_DEFUN([CF_X_ATHENA_LIBS], [AC_REQUIRE([CF_X_TOOLKIT]) cf_x_athena_root=ifelse([$1],,Xaw,[$1]) cf_x_athena_lib="" for cf_path in default \ /usr/contrib/X11R6 \ /usr/contrib/X11R5 \ /usr/lib/X11R5 \ /usr/local do for cf_lib in \ ${cf_x_athena_root} \ ${cf_x_athena_root}7 \ ${cf_x_athena_root}6 do for cf_libs in \ "-l$cf_lib -lXmu" \ "-l$cf_lib -lXpm -lXmu" \ "-l${cf_lib}_s -lXmu_s" do if test -z "$cf_x_athena_lib" ; then cf_save="$LIBS" cf_test=XawSimpleMenuAddGlobalActions if test $cf_path != default ; then CF_ADD_LIBS(-L$cf_path/lib $cf_libs) AC_MSG_CHECKING(for $cf_libs in $cf_path) else CF_ADD_LIBS($cf_libs) AC_MSG_CHECKING(for $cf_test in $cf_libs) fi AC_TRY_LINK([ #include #include ],[ $cf_test((XtAppContext) 0)], [cf_result=yes], [cf_result=no]) AC_MSG_RESULT($cf_result) if test "$cf_result" = yes ; then cf_x_athena_lib="$cf_libs" break fi LIBS="$cf_save" fi done # cf_libs test -n "$cf_x_athena_lib" && break done # cf_lib done if test -z "$cf_x_athena_lib" ; then AC_MSG_ERROR( [Unable to successfully link Athena library (-l$cf_x_athena_root) with test program]) fi CF_UPPER(cf_x_athena_LIBS,HAVE_LIB_$cf_x_athena) AC_DEFINE_UNQUOTED($cf_x_athena_LIBS) ]) dnl --------------------------------------------------------------------------- dnl CF_X_EXT version: 3 updated: 2010/06/02 05:03:05 dnl -------- AC_DEFUN([CF_X_EXT],[ CF_TRY_PKG_CONFIG(Xext,,[ AC_CHECK_LIB(Xext,XextCreateExtension, [CF_ADD_LIB(Xext)])]) ])dnl dnl --------------------------------------------------------------------------- dnl CF_X_FONTCONFIG version: 4 updated: 2011/07/04 10:01:31 dnl --------------- dnl Check for fontconfig library, a dependency of the X FreeType library. AC_DEFUN([CF_X_FONTCONFIG], [ AC_REQUIRE([CF_X_FREETYPE]) if test "$cf_cv_found_freetype" = yes ; then AC_CACHE_CHECK(for usable Xft/fontconfig package,cf_cv_xft_compat,[ AC_TRY_LINK([ #include ],[ XftPattern *pat; XftPatternBuild(pat, XFT_FAMILY, XftTypeString, "mono", (void *) 0); ],[cf_cv_xft_compat=yes],[cf_cv_xft_compat=no]) ]) if test "$cf_cv_xft_compat" = no then # workaround for broken ".pc" files used for Xft. case "$cf_cv_x_freetype_libs" in #(vi *-lfontconfig*) #(vi ;; *) CF_VERBOSE(work around broken package) CF_TRY_PKG_CONFIG(fontconfig,,[CF_ADD_LIB_AFTER(-lXft,-lfontconfig)]) ;; esac fi fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_X_FREETYPE version: 25 updated: 2012/06/11 17:37:05 dnl ------------- dnl Check for X FreeType headers and libraries (XFree86 4.x, etc). dnl dnl First check for the appropriate config program, since the developers for dnl these libraries change their configuration (and config program) more or dnl less randomly. If we cannot find the config program, do not bother trying dnl to guess the latest variation of include/lib directories. dnl dnl If either or both of these configure-script options are not given, rely on dnl the output of the config program to provide the cflags/libs options: dnl --with-freetype-cflags dnl --with-freetype-libs AC_DEFUN([CF_X_FREETYPE], [ AC_REQUIRE([CF_PKG_CONFIG]) cf_cv_x_freetype_incs=no cf_cv_x_freetype_libs=no cf_extra_freetype_libs= FREETYPE_CONFIG=none FREETYPE_PARAMS= AC_MSG_CHECKING(for FreeType configuration script) AC_ARG_WITH(freetype-config, [ --with-freetype-config configure script to use for FreeType], [cf_cv_x_freetype_cfgs="$withval"], [cf_cv_x_freetype_cfgs=auto]) test -z $cf_cv_x_freetype_cfgs && cf_cv_x_freetype_cfgs=auto test $cf_cv_x_freetype_cfgs = no && cf_cv_x_freetype_cfgs=none AC_MSG_RESULT($cf_cv_x_freetype_cfgs) case $cf_cv_x_freetype_cfgs in none) #(vi AC_MSG_CHECKING(if you specified -D/-I options for FreeType) AC_ARG_WITH(freetype-cflags, [ --with-freetype-cflags -D/-I options for compiling with FreeType], [cf_cv_x_freetype_incs="$with_freetype_cflags"], [cf_cv_x_freetype_incs=no]) AC_MSG_RESULT($cf_cv_x_freetype_incs) AC_MSG_CHECKING(if you specified -L/-l options for FreeType) AC_ARG_WITH(freetype-libs, [ --with-freetype-libs -L/-l options to link FreeType], [cf_cv_x_freetype_libs="$with_freetype_libs"], [cf_cv_x_freetype_libs=no]) AC_MSG_RESULT($cf_cv_x_freetype_libs) ;; auto) #(vi if test "$PKG_CONFIG" != none && "$PKG_CONFIG" --exists xft; then FREETYPE_CONFIG=$PKG_CONFIG FREETYPE_PARAMS=xft else AC_PATH_PROG(FREETYPE_CONFIG, freetype-config, none) if test "$FREETYPE_CONFIG" != none; then FREETYPE_CONFIG=$FREETYPE_CONFIG cf_extra_freetype_libs="-lXft" else AC_PATH_PROG(FREETYPE_OLD_CONFIG, xft-config, none) if test "$FREETYPE_OLD_CONFIG" != none; then FREETYPE_CONFIG=$FREETYPE_OLD_CONFIG fi fi fi ;; pkg*) #(vi if test "$PKG_CONFIG" != none && "$PKG_CONFIG" --exists xft; then FREETYPE_CONFIG=$cf_cv_x_freetype_cfgs FREETYPE_PARAMS=xft else AC_MSG_WARN(cannot find pkg-config for Xft) fi ;; *) #(vi AC_PATH_PROG(FREETYPE_XFT_CONFIG, $cf_cv_x_freetype_cfgs, none) if test "$FREETYPE_XFT_CONFIG" != none; then FREETYPE_CONFIG=$FREETYPE_XFT_CONFIG else AC_MSG_WARN(cannot find config script for Xft) fi ;; esac if test "$FREETYPE_CONFIG" != none ; then AC_MSG_CHECKING(for FreeType config) AC_MSG_RESULT($FREETYPE_CONFIG $FREETYPE_PARAMS) if test "$cf_cv_x_freetype_incs" = no ; then AC_MSG_CHECKING(for $FREETYPE_CONFIG cflags) cf_cv_x_freetype_incs="`$FREETYPE_CONFIG $FREETYPE_PARAMS --cflags 2>/dev/null`" AC_MSG_RESULT($cf_cv_x_freetype_incs) fi if test "$cf_cv_x_freetype_libs" = no ; then AC_MSG_CHECKING(for $FREETYPE_CONFIG libs) cf_cv_x_freetype_libs="$cf_extra_freetype_libs `$FREETYPE_CONFIG $FREETYPE_PARAMS --libs 2>/dev/null`" AC_MSG_RESULT($cf_cv_x_freetype_libs) fi fi if test "$cf_cv_x_freetype_incs" = no ; then cf_cv_x_freetype_incs= fi if test "$cf_cv_x_freetype_libs" = no ; then cf_cv_x_freetype_libs=-lXft fi AC_MSG_CHECKING(if we can link with FreeType libraries) cf_save_LIBS="$LIBS" cf_save_INCS="$CPPFLAGS" CF_ADD_LIBS($cf_cv_x_freetype_libs) CPPFLAGS="$CPPFLAGS $cf_cv_x_freetype_incs" AC_TRY_LINK([ #include #include #include ],[ XftPattern *pat = XftNameParse ("name");], [cf_cv_found_freetype=yes], [cf_cv_found_freetype=no]) AC_MSG_RESULT($cf_cv_found_freetype) LIBS="$cf_save_LIBS" CPPFLAGS="$cf_save_INCS" if test "$cf_cv_found_freetype" = yes ; then CF_ADD_LIBS($cf_cv_x_freetype_libs) CF_ADD_CFLAGS($cf_cv_x_freetype_incs) AC_DEFINE(XRENDERFONT) AC_CHECK_FUNCS( \ XftDrawCharSpec \ XftDrawSetClip \ XftDrawSetClipRectangles \ ) else AC_MSG_WARN(No libraries found for FreeType) CPPFLAGS=`echo "$CPPFLAGS" | sed -e s/-DXRENDERFONT//` fi # FIXME: revisit this if needed AC_SUBST(HAVE_TYPE_FCCHAR32) AC_SUBST(HAVE_TYPE_XFTCHARSPEC) ]) dnl --------------------------------------------------------------------------- dnl CF_X_TOOLKIT version: 20 updated: 2010/11/19 05:43:04 dnl ------------ dnl Check for X Toolkit libraries dnl AC_DEFUN([CF_X_TOOLKIT], [ AC_REQUIRE([AC_PATH_XTRA]) AC_REQUIRE([CF_CHECK_CACHE]) cf_have_X_LIBS=no CF_TRY_PKG_CONFIG(xt,[ case "x$LIBS" in #(vi *-lX11*) #(vi ;; *) # we have an "xt" package, but it may omit Xt's dependency on X11 AC_CACHE_CHECK(for usable X dependency,cf_cv_xt_x11_compat,[ AC_TRY_LINK([ #include ],[ int rc1 = XDrawLine((Display*) 0, (Drawable) 0, (GC) 0, 0, 0, 0, 0); int rc2 = XClearWindow((Display*) 0, (Window) 0); int rc3 = XMoveWindow((Display*) 0, (Window) 0, 0, 0); int rc4 = XMoveResizeWindow((Display*)0, (Window)0, 0, 0, 0, 0); ],[cf_cv_xt_x11_compat=yes],[cf_cv_xt_x11_compat=no])]) if test "$cf_cv_xt_x11_compat" = no then CF_VERBOSE(work around broken X11 dependency) # 2010/11/19 - good enough until a working Xt on Xcb is delivered. CF_TRY_PKG_CONFIG(x11,,[CF_ADD_LIB_AFTER(-lXt,-lX11)]) fi ;; esac AC_CACHE_CHECK(for usable X Toolkit package,cf_cv_xt_ice_compat,[ AC_TRY_LINK([ #include ],[int num = IceConnectionNumber(0) ],[cf_cv_xt_ice_compat=yes],[cf_cv_xt_ice_compat=no])]) if test "$cf_cv_xt_ice_compat" = no then # workaround for broken ".pc" files used for X Toolkit. case "x$X_PRE_LIBS" in #(vi *-lICE*) case "x$LIBS" in #(vi *-lICE*) #(vi ;; *) CF_VERBOSE(work around broken ICE dependency) CF_TRY_PKG_CONFIG(ice, [CF_TRY_PKG_CONFIG(sm)], [CF_ADD_LIB_AFTER(-lXt,$X_PRE_LIBS)]) ;; esac ;; esac fi cf_have_X_LIBS=yes ],[ LDFLAGS="$X_LIBS $LDFLAGS" CF_CHECK_CFLAGS($X_CFLAGS) AC_CHECK_FUNC(XOpenDisplay,,[ AC_CHECK_LIB(X11,XOpenDisplay, [CF_ADD_LIB(X11)],, [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS])]) AC_CHECK_FUNC(XtAppInitialize,,[ AC_CHECK_LIB(Xt, XtAppInitialize, [AC_DEFINE(HAVE_LIBXT) cf_have_X_LIBS=Xt LIBS="-lXt $X_PRE_LIBS $LIBS $X_EXTRA_LIBS"],, [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS])]) ]) if test $cf_have_X_LIBS = no ; then AC_MSG_WARN( [Unable to successfully link X Toolkit library (-lXt) with test program. You will have to check and add the proper libraries by hand to makefile.]) fi ])dnl dnl --------------------------------------------------------------------------- dnl CF__GRANTPT_BODY version: 4 updated: 2012/05/07 19:39:45 dnl ---------------- dnl Body for workability check of grantpt. define([CF__GRANTPT_BODY],[ int code = 0; int rc; int pty; int tty; char *slave; struct termios tio; signal(SIGALRM, my_timeout); if (alarm(2) == 9) failed(9); else if ((pty = posix_openpt(O_RDWR)) < 0) failed(1); else if ((rc = grantpt(pty)) < 0) failed(2); else if ((rc = unlockpt(pty)) < 0) failed(3); else if ((slave = ptsname(pty)) == 0) failed(4); #if (CONFTEST == 3) || defined(CONFTEST_isatty) else if (!isatty(pty)) failed(4); #endif #if CONFTEST >= 4 else if ((rc = tcgetattr(pty, &tio)) < 0) failed(20); else if ((rc = tcsetattr(pty, TCSAFLUSH, &tio)) < 0) failed(21); #endif /* BSD posix_openpt does not treat pty as a terminal until slave is opened. * Linux does treat it that way. */ else if ((tty = open(slave, O_RDWR)) < 0) failed(5); #ifdef CONFTEST #ifdef I_PUSH #if (CONFTEST == 0) || defined(CONFTEST_ptem) else if ((rc = ioctl(tty, I_PUSH, "ptem")) < 0) failed(10); #endif #if (CONFTEST == 1) || defined(CONFTEST_ldterm) else if ((rc = ioctl(tty, I_PUSH, "ldterm")) < 0) failed(11); #endif #if (CONFTEST == 2) || defined(CONFTEST_ttcompat) else if ((rc = ioctl(tty, I_PUSH, "ttcompat")) < 0) failed(12); #endif #endif /* I_PUSH */ #if CONFTEST >= 5 else if ((rc = tcgetattr(tty, &tio)) < 0) failed(30); else if ((rc = tcsetattr(tty, TCSAFLUSH, &tio)) < 0) failed(31); #endif #endif /* CONFTEST */ ${cf_cv_main_return:-return}(code); ]) dnl --------------------------------------------------------------------------- dnl CF__GRANTPT_HEAD version: 3 updated: 2012/01/29 17:13:14 dnl ---------------- dnl Headers for workability check of grantpt. define([CF__GRANTPT_HEAD],[ #include #include #include #include #include #include #ifndef HAVE_POSIX_OPENPT #undef posix_openpt #define posix_openpt(mode) open("/dev/ptmx", mode) #endif #ifdef HAVE_STROPTS_H #include #endif static void failed(int code) { perror("conftest"); exit(code); } static void my_timeout(int sig) { exit(99); } ])