Edit: programs.m4
# This file is part of Autoconf. -*- Autoconf -*- # Checking for programs. # Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc. # This file is part of Autoconf. This program is free # software; you can redistribute it and/or modify it under the # terms of the GNU General Public License as published by the # Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # Under Section 7 of GPL version 3, you are granted additional # permissions described in the Autoconf Configure Script Exception, # version 3.0, as published by the Free Software Foundation. # # You should have received a copy of the GNU General Public License # and a copy of the Autoconf Configure Script Exception along with # this program; see the files COPYINGv3 and COPYING.EXCEPTION # respectively. If not, see <http://www.gnu.org/licenses/>. # Written by David MacKenzie, with help from # Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor, # Roland McGrath, Noah Friedman, david d zuhn, and many others. ## ----------------------------- ## ## Generic checks for programs. ## ## ----------------------------- ## # _AC_CHECK_PROG(VARIABLE, PROG-TO-CHECK-FOR, # [VALUE-IF-FOUND], [VALUE-IF-NOT-FOUND], # [PATH], [REJECT]) # ----------------------------------------------------- AC_DEFUN([_AC_CHECK_PROG], [# Extract the first word of "$2", so it can be a program name with args. set dummy $2; ac_word=$[2] AC_MSG_CHECKING([for $ac_word]) AC_CACHE_VAL(ac_cv_prog_$1, [if test -n "$$1"; then ac_cv_prog_$1="$$1" # Let the user override the test. else m4_ifvaln([$6], [ ac_prog_rejected=no])dnl _AS_PATH_WALK([$5], [for ac_exec_ext in '' $ac_executable_extensions; do if AS_EXECUTABLE_P(["$as_dir/$ac_word$ac_exec_ext"]); then m4_ifvaln([$6], [ if test "$as_dir/$ac_word$ac_exec_ext" = "$6"; then ac_prog_rejected=yes continue fi])dnl ac_cv_prog_$1="$3" _AS_ECHO_LOG([found $as_dir/$ac_word$ac_exec_ext]) break 2 fi done]) m4_ifvaln([$6], [if test $ac_prog_rejected = yes; then # We found a bogon in the path, so make sure we never use it. set dummy $ac_cv_prog_$1 shift if test $[@%:@] != 0; then # We chose a different compiler from the bogus one. # However, it has the same basename, so the bogon will be chosen # first if we set $1 to just the basename; use the full file name. shift ac_cv_prog_$1="$as_dir/$ac_word${1+' '}$[@]" m4_if([$2], [$4], [ else # Default is a loser. AC_MSG_ERROR([$1=$6 unacceptable, but no other $4 found in dnl m4_default([$5], [\$PATH])]) ])dnl fi fi])dnl dnl If no 4th arg is given, leave the cache variable unset, dnl so AC_CHECK_PROGS will keep looking. m4_ifvaln([$4], [ test -z "$ac_cv_prog_$1" && ac_cv_prog_$1="$4"])dnl fi])dnl $1=$ac_cv_prog_$1 if test -n "$$1"; then AC_MSG_RESULT([$$1]) else AC_MSG_RESULT([no]) fi ])# _AC_CHECK_PROG # AC_CHECK_PROG(VARIABLE, PROG-TO-CHECK-FOR, # [VALUE-IF-FOUND], [VALUE-IF-NOT-FOUND], # [PATH], [REJECT]) # ----------------------------------------------------- AC_DEFUN([AC_CHECK_PROG], [_AC_CHECK_PROG($@) AC_SUBST([$1])dnl ]) # AC_CHECK_PROGS(VARIABLE, PROGS-TO-CHECK-FOR, [VALUE-IF-NOT-FOUND], # [PATH]) # ------------------------------------------------------------------ AC_DEFUN([AC_CHECK_PROGS], [for ac_prog in $2 do AC_CHECK_PROG([$1], [$ac_prog], [$ac_prog], , [$4]) test -n "$$1" && break done m4_ifvaln([$3], [test -n "$$1" || $1="$3"])]) # _AC_PATH_PROG(VARIABLE, PROG-TO-CHECK-FOR, [VALUE-IF-NOT-FOUND], [PATH]) # ------------------------------------------------------------------------ AC_DEFUN([_AC_PATH_PROG], [# Extract the first word of "$2", so it can be a program name with args. set dummy $2; ac_word=$[2] AC_MSG_CHECKING([for $ac_word]) AC_CACHE_VAL([ac_cv_path_$1], [case $$1 in [[\\/]]* | ?:[[\\/]]*) ac_cv_path_$1="$$1" # Let the user override the test with a path. ;; *) _AS_PATH_WALK([$4], [for ac_exec_ext in '' $ac_executable_extensions; do if AS_EXECUTABLE_P(["$as_dir/$ac_word$ac_exec_ext"]); then ac_cv_path_$1="$as_dir/$ac_word$ac_exec_ext" _AS_ECHO_LOG([found $as_dir/$ac_word$ac_exec_ext]) break 2 fi done]) dnl If no 3rd arg is given, leave the cache variable unset, dnl so AC_PATH_PROGS will keep looking. m4_ifvaln([$3], [ test -z "$ac_cv_path_$1" && ac_cv_path_$1="$3"])dnl ;; esac])dnl $1=$ac_cv_path_$1 if test -n "$$1"; then AC_MSG_RESULT([$$1]) else AC_MSG_RESULT([no]) fi ])# _AC_PATH_PROG # AC_PATH_PROG(VARIABLE, PROG-TO-CHECK-FOR, [VALUE-IF-NOT-FOUND], [PATH]) # ----------------------------------------------------------------------- AC_DEFUN([AC_PATH_PROG], [_AC_PATH_PROG($@) AC_SUBST([$1])dnl ]) # AC_PATH_PROGS(VARIABLE, PROGS-TO-CHECK-FOR, [VALUE-IF-NOT-FOUND], # [PATH]) # ----------------------------------------------------------------- AC_DEFUN([AC_PATH_PROGS], [for ac_prog in $2 do AC_PATH_PROG([$1], [$ac_prog], , [$4]) test -n "$$1" && break done m4_ifvaln([$3], [test -n "$$1" || $1="$3"])dnl ]) ## -------------------------- ## ## Generic checks for tools. ## ## -------------------------- ## # AC_CHECK_TOOL_PREFIX # -------------------- AU_DEFUN([AC_CHECK_TOOL_PREFIX]) # _AC_TOOL_WARN # ------------- AC_DEFUN([_AC_TOOL_WARN], [case $cross_compiling:$ac_tool_warned in yes:) AC_MSG_WARN([using cross tools not prefixed with host triplet]) ac_tool_warned=yes ;; esac]) # AC_PATH_TOOL(VARIABLE, PROG-TO-CHECK-FOR, [VALUE-IF-NOT-FOUND], [PATH]) # ----------------------------------------------------------------------- # (Use different variables $1 and ac_pt_$1 so that cache vars don't conflict.) AC_DEFUN([AC_PATH_TOOL], [if test -n "$ac_tool_prefix"; then AC_PATH_PROG([$1], [${ac_tool_prefix}$2], , [$4]) fi if test -z "$ac_cv_path_$1"; then ac_pt_$1=$$1 _AC_PATH_PROG([ac_pt_$1], [$2], [], [$4]) if test "x$ac_pt_$1" = x; then $1="$3" else _AC_TOOL_WARN $1=$ac_pt_$1 fi else $1="$ac_cv_path_$1" fi ])# AC_PATH_TOOL # AC_CHECK_TOOL(VARIABLE, PROG-TO-CHECK-FOR, [VALUE-IF-NOT-FOUND], [PATH]) # ------------------------------------------------------------------------ # (Use different variables $1 and ac_ct_$1 so that cache vars don't conflict.) AC_DEFUN([AC_CHECK_TOOL], [if test -n "$ac_tool_prefix"; then AC_CHECK_PROG([$1], [${ac_tool_prefix}$2], [${ac_tool_prefix}$2], , [$4]) fi if test -z "$ac_cv_prog_$1"; then ac_ct_$1=$$1 _AC_CHECK_PROG([ac_ct_$1], [$2], [$2], [], [$4]) if test "x$ac_ct_$1" = x; then $1="$3" else _AC_TOOL_WARN $1=$ac_ct_$1 fi else $1="$ac_cv_prog_$1" fi ])# AC_CHECK_TOOL # AC_CHECK_TOOLS(VARIABLE, PROGS-TO-CHECK-FOR, [VALUE-IF-NOT-FOUND], # [PATH]) # ------------------------------------------------------------------ # Check for each tool in PROGS-TO-CHECK-FOR with the cross prefix. If # none can be found with a cross prefix, then use the first one that # was found without the cross prefix. AC_DEFUN([AC_CHECK_TOOLS], [if test -n "$ac_tool_prefix"; then for ac_prog in $2 do AC_CHECK_PROG([$1], [$ac_tool_prefix$ac_prog], [$ac_tool_prefix$ac_prog],, [$4]) test -n "$$1" && break done fi if test -z "$$1"; then ac_ct_$1=$$1 AC_CHECK_PROGS([ac_ct_$1], [$2], [], [$4]) if test "x$ac_ct_$1" = x; then $1="$3" else _AC_TOOL_WARN $1=$ac_ct_$1 fi fi ])# AC_CHECK_TOOLS # AC_PATH_TARGET_TOOL(VARIABLE, PROG-TO-CHECK-FOR, [VALUE-IF-NOT-FOUND], [PATH]) # ------------------------------------------------------------------------------ # (Use different variables $1 and ac_pt_$1 so that cache vars don't conflict.) AC_DEFUN([AC_PATH_TARGET_TOOL], [AC_REQUIRE([AC_CANONICAL_TARGET])dnl AC_PATH_PROG([$1], [$target_alias-$2], , [$4]) if test -z "$ac_cv_path_$1"; then if test "$build" = "$target"; then ac_pt_$1=$$1 _AC_PATH_PROG([ac_pt_$1], [$2], [$3], [$4]) $1=$ac_pt_$1 else $1="$3" fi else $1="$ac_cv_path_$1" fi ])# AC_PATH_TARGET_TOOL # AC_CHECK_TARGET_TOOL(VARIABLE, PROG-TO-CHECK-FOR, [VALUE-IF-NOT-FOUND], [PATH]) # ------------------------------------------------------------------------------- # (Use different variables $1 and ac_ct_$1 so that cache vars don't conflict.) AC_DEFUN([AC_CHECK_TARGET_TOOL], [AC_REQUIRE([AC_CANONICAL_TARGET])dnl AC_CHECK_PROG([$1], [$target_alias-$2], [$target_alias-$2], , [$4]) if test -z "$ac_cv_prog_$1"; then if test "$build" = "$target"; then ac_ct_$1=$$1 _AC_CHECK_PROG([ac_ct_$1], [$2], [$2], [$3], [$4]) $1=$ac_ct_$1 else $1="$3" fi else $1="$ac_cv_prog_$1" fi ])# AC_CHECK_TARGET_TOOL # AC_CHECK_TARGET_TOOLS(VARIABLE, PROGS-TO-CHECK-FOR, [VALUE-IF-NOT-FOUND], # [PATH]) # ------------------------------------------------------------------------- # Check for each tool in PROGS-TO-CHECK-FOR with the cross prefix. If # none can be found with a cross prefix, then use the first one that # was found without the cross prefix. AC_DEFUN([AC_CHECK_TARGET_TOOLS], [AC_REQUIRE([AC_CANONICAL_TARGET])dnl for ac_prog in $2 do AC_CHECK_PROG([$1], [$target_alias-$ac_prog], [$target_alias-$ac_prog],, [$4]) test -n "$$1" && break done if test -z "$$1"; then if test "$build" = "$target"; then ac_ct_$1=$$1 AC_CHECK_PROGS([ac_ct_$1], [$2], [$3], [$4]) $1=$ac_ct_$1 else $1="$3" fi fi ])# AC_CHECK_TARGET_TOOLS ## ---------------- ## ## Specific tests. ## ## ---------------- ## # Please, keep this section sorted. # (But of course when keeping related things together). # Check for gawk first since it's generally better. AN_MAKEVAR([AWK], [AC_PROG_AWK]) AN_PROGRAM([awk], [AC_PROG_AWK]) AN_PROGRAM([gawk], [AC_PROG_AWK]) AN_PROGRAM([mawk], [AC_PROG_AWK]) AN_PROGRAM([nawk], [AC_PROG_AWK]) AC_DEFUN([AC_PROG_AWK], [AC_CHECK_PROGS(AWK, gawk mawk nawk awk, )]) # AC_PROG_EGREP # ------------- AC_DEFUN([AC_PROG_EGREP], [AC_REQUIRE([AC_PROG_GREP])dnl AC_CACHE_CHECK([for egrep], ac_cv_path_EGREP, [if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 then ac_cv_path_EGREP="$GREP -E" else _AC_PROG_GREP(EGREP, egrep, ['EGREP$']) fi]) EGREP="$ac_cv_path_EGREP" AC_SUBST([EGREP]) ])# AC_PROG_EGREP # AC_PROG_FGREP # ------------- AC_DEFUN([AC_PROG_FGREP], [AC_REQUIRE([AC_PROG_GREP])dnl AC_CACHE_CHECK([for fgrep], ac_cv_path_FGREP, [if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1 then ac_cv_path_FGREP="$GREP -F" else _AC_PROG_GREP(FGREP, fgrep, [FGREP]) fi]) FGREP="$ac_cv_path_FGREP" AC_SUBST([FGREP]) ])# AC_PROG_FGREP # AC_PROG_GREP # ------------ # Check for a fully functional grep program that handles # the longest lines possible and which respects multiple -e options. # Prefer GNU grep if found. AC_DEFUN([AC_PROG_GREP], [AC_CACHE_CHECK([for grep that handles long lines and -e], ac_cv_path_GREP, [_$0(GREP, [grep ggrep], [-e 'GREP$' -e '-(cannot match)-'])]) GREP="$ac_cv_path_GREP" AC_SUBST([GREP]) ]) # _AC_PROG_GREP(VARIABLE, PROGNAME-LIST, PROG-ARGUMENTS) # ------------------------------------------------------ # Solaris 9 /usr/xpg4/bin/*grep is suitable, but /usr/bin/*grep lacks -e. # AIX silently truncates long lines before matching. # NeXT understands only one -e and truncates long lines. m4_define([_AC_PROG_GREP], [_AC_PATH_PROGS_FEATURE_CHECK([$1], [$2], [_AC_FEATURE_CHECK_LENGTH([ac_path_$1], [ac_cv_path_$1], ["$ac_path_$1" $3], [$1])], [], [$PATH$PATH_SEPARATOR/usr/xpg4/bin])dnl ]) # _AC_PATH_PROGS_FEATURE_CHECK(VARIABLE, PROGNAME-LIST, FEATURE-TEST, # [ACTION-IF-NOT-FOUND], [PATH=$PATH]) # ------------------------------------------------------------------- # FEATURE-TEST is called repeatedly with $ac_path_VARIABLE set to the # name of a program in PROGNAME-LIST found in PATH. FEATURE-TEST must set # $ac_cv_path_VARIABLE to the path of an acceptable program, or else # ACTION-IF-NOT-FOUND is executed; the default action (for internal use # only) issues a fatal error message. If a suitable $ac_path_VARIABLE is # found in the FEATURE-TEST macro, it can set $ac_path_VARIABLE_found=':' # to accept that value without any further checks. m4_define([_AC_PATH_PROGS_FEATURE_CHECK], [if test -z "$$1"; then ac_path_$1_found=false # Loop through the user's path and test for each of PROGNAME-LIST _AS_PATH_WALK([$5], [for ac_prog in $2; do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_$1="$as_dir/$ac_prog$ac_exec_ext" AS_EXECUTABLE_P(["$ac_path_$1"]) || continue $3 $ac_path_$1_found && break 3 done done])dnl if test -z "$ac_cv_path_$1"; then m4_default([$4], [AC_MSG_ERROR([no acceptable m4_bpatsubst([$2], [ .*]) could be dnl found in m4_default([$5], [\$PATH])])]) fi else ac_cv_path_$1=$$1 fi ]) # AC_PATH_PROGS_FEATURE_CHECK(VARIABLE, PROGNAME-LIST, # FEATURE-TEST, [ACTION-IF-NOT-FOUND=:], # [PATH=$PATH]) # ------------------------------------------------------------------ # Designed to be used inside AC_CACHE_VAL. It is recommended, # but not required, that the user also use AC_ARG_VAR([VARIABLE]). # If VARIABLE is not empty, set the cache variable # $ac_cv_path_VARIABLE to VARIABLE without any further tests. # Otherwise, call FEATURE_TEST repeatedly with $ac_path_VARIABLE # set to the name of a program in PROGNAME-LIST found in PATH. If # no invocation of FEATURE-TEST sets $ac_cv_path_VARIABLE to the # path of an acceptable program, ACTION-IF-NOT-FOUND is executed. # FEATURE-TEST is invoked even when $ac_cv_path_VARIABLE is set, # in case a better candidate occurs later in PATH; to accept the # current setting and bypass further checks, FEATURE-TEST can set # $ac_path_VARIABLE_found=':'. Note that, unlike AC_CHECK_PROGS, # this macro does not have any side effect on the current value # of VARIABLE. m4_define([AC_PATH_PROGS_FEATURE_CHECK], [_$0([$1], [$2], [$3], m4_default([$4], [:]), [$5])dnl ]) # _AC_FEATURE_CHECK_LENGTH(PROGPATH, CACHE-VAR, CHECK-CMD, [MATCH-STRING]) # ------------------------------------------------------------------------ # For use as the FEATURE-TEST argument to _AC_PATH_PROGS_FEATURE_TEST. # On each iteration run CHECK-CMD on an input file, storing the value # of PROGPATH in CACHE-VAR if the CHECK-CMD succeeds. The input file # is always one line, starting with only 10 characters, and doubling # in length at each iteration until approx 10000 characters or the # feature check succeeds. The feature check is called at each # iteration by appending (optionally, MATCH-STRING and) a newline # to the file, and using the result as input to CHECK-CMD. m4_define([_AC_FEATURE_CHECK_LENGTH], [# Check for GNU $1 and select it if it is found. _AC_PATH_PROG_FLAVOR_GNU([$$1], [$2="$$1" $1_found=:], [ac_count=0 AS_ECHO_N([0123456789]) >"conftest.in" while : do cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" AS_ECHO(['$4']) >> "conftest.nl" $3 < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break AS_VAR_ARITH([ac_count], [$ac_count + 1]) if test $ac_count -gt ${$1_max-0}; then # Best one so far, save it but keep looking for a better one $2="$$1" dnl # Using $1_max so that each tool feature checked gets its dnl # own variable. Don't reset it otherwise the implied search dnl # for best performing tool in a list breaks down. $1_max=$ac_count fi # 10*(2^10) chars as input seems more than enough test $ac_count -gt 10 && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out])dnl ]) # _AC_PATH_PROG_FLAVOR_GNU(PROGRAM-PATH, IF-SUCCESS, [IF-FAILURE]) # ---------------------------------------------------------------- m4_define([_AC_PATH_PROG_FLAVOR_GNU], [# Check for GNU $1 case `"$1" --version 2>&1` in *GNU*) $2;; m4_ifval([$3], [*) $3;; ])esac ])# _AC_PATH_PROG_FLAVOR_GNU # AC_PROG_INSTALL # --------------- AN_MAKEVAR([INSTALL], [AC_PROG_INSTALL]) AN_PROGRAM([install], [AC_PROG_INSTALL]) AC_DEFUN_ONCE([AC_PROG_INSTALL], [AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl AC_REQUIRE_AUX_FILE([install-sh])dnl # Find a good install program. We prefer a C program (faster), # so one script is as good as another. But avoid the broken or # incompatible versions: # SysV /etc/install, /usr/sbin/install # SunOS /usr/etc/install # IRIX /sbin/install # AIX /bin/install # AmigaOS /C/install, which installs bootblocks on floppy discs # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag # AFS /usr/afsws/bin/install, which mishandles nonexistent args # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" # OS/2's system install, which has a completely different semantic # ./install, which can be erroneously created by make from ./install.sh. # Reject install programs that cannot install multiple files. AC_MSG_CHECKING([for a BSD-compatible install]) if test -z "$INSTALL"; then AC_CACHE_VAL(ac_cv_path_install, [_AS_PATH_WALK([$PATH], [[# Account for people who put trailing slashes in PATH elements. case $as_dir/ in @%:@(( ./ | .// | /[cC]/* | \ /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \ ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \ /usr/ucb/* ) ;; *)] # OSF1 and SCO ODT 3.0 have their own names for install. # Don't use installbsd from OSF since it installs stuff as root # by default. for ac_prog in ginstall scoinst install; do for ac_exec_ext in '' $ac_executable_extensions; do if AS_EXECUTABLE_P(["$as_dir/$ac_prog$ac_exec_ext"]); then if test $ac_prog = install && grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then # AIX install. It has an incompatible calling convention. : elif test $ac_prog = install && grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then # program-specific install script used by HP pwplus--don't use. : else rm -rf conftest.one conftest.two conftest.dir echo one > conftest.one echo two > conftest.two mkdir conftest.dir if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" && test -s conftest.one && test -s conftest.two && test -s conftest.dir/conftest.one && test -s conftest.dir/conftest.two then ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c" break 3 fi fi fi done done ;; esac ]) rm -rf conftest.one conftest.two conftest.dir ])dnl if test "${ac_cv_path_install+set}" = set; then INSTALL=$ac_cv_path_install else # As a last resort, use the slow shell script. Don't cache a # value for INSTALL within a source directory, because that will # break other packages using the cache if that directory is # removed, or if the value is a relative name. INSTALL=$ac_install_sh fi fi dnl Do special magic for INSTALL instead of AC_SUBST, to get dnl relative names right. AC_MSG_RESULT([$INSTALL]) # Use test -z because SunOS4 sh mishandles braces in ${var-val}. # It thinks the first close brace ends the variable substitution. test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}' AC_SUBST(INSTALL_PROGRAM)dnl test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}' AC_SUBST(INSTALL_SCRIPT)dnl test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' AC_SUBST(INSTALL_DATA)dnl ])# AC_PROG_INSTALL # AC_PROG_MKDIR_P # --------------- # Check whether `mkdir -p' is known to be thread-safe, and fall back to # install-sh -d otherwise. # # Automake 1.8 used `mkdir -m 0755 -p --' to ensure that directories # created by `make install' are always world readable, even if the # installer happens to have an overly restrictive umask (e.g. 077). # This was a mistake. There are at least two reasons why we must not # use `-m 0755': # - it causes special bits like SGID to be ignored, # - it may be too restrictive (some setups expect 775 directories). # # Do not use -m 0755 and let people choose whatever they expect by # setting umask. # # We cannot accept any implementation of `mkdir' that recognizes `-p'. # Some implementations (such as Solaris 8's) are vulnerable to race conditions: # if a parallel make tries to run `mkdir -p a/b' and `mkdir -p a/c' # concurrently, both version can detect that a/ is missing, but only # one can create it and the other will error out. Consequently we # restrict ourselves to known race-free implementations. # # Automake used to define mkdir_p as `mkdir -p .', in order to # allow $(mkdir_p) to be used without argument. As in # $(mkdir_p) $(somedir) # where $(somedir) is conditionally defined. However we don't do # that for MKDIR_P. # 1. before we restricted the check to GNU mkdir, `mkdir -p .' was # reported to fail in read-only directories. The system where this # happened has been forgotten. # 2. in practice we call $(MKDIR_P) on directories such as # $(MKDIR_P) "$(DESTDIR)$(somedir)" # and we don't want to create $(DESTDIR) if $(somedir) is empty. # To support the latter case, we have to write # test -z "$(somedir)" || $(MKDIR_P) "$(DESTDIR)$(somedir)" # so $(MKDIR_P) always has an argument. # We will have better chances of detecting a missing test if # $(MKDIR_P) complains about missing arguments. # 3. $(MKDIR_P) is named after `mkdir -p' and we don't expect this # to accept no argument. # 4. having something like `mkdir .' in the output is unsightly. # # On NextStep and OpenStep, the `mkdir' command does not # recognize any option. It will interpret all options as # directories to create. AN_MAKEVAR([MKDIR_P], [AC_PROG_MKDIR_P]) AC_DEFUN_ONCE([AC_PROG_MKDIR_P], [AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl AC_REQUIRE_AUX_FILE([install-sh])dnl AC_MSG_CHECKING([for a thread-safe mkdir -p]) if test -z "$MKDIR_P"; then AC_CACHE_VAL([ac_cv_path_mkdir], [_AS_PATH_WALK([$PATH$PATH_SEPARATOR/opt/sfw/bin], [for ac_prog in mkdir gmkdir; do for ac_exec_ext in '' $ac_executable_extensions; do AS_EXECUTABLE_P(["$as_dir/$ac_prog$ac_exec_ext"]) || continue case `"$as_dir/$ac_prog$ac_exec_ext" --version 2>&1` in #( 'mkdir (GNU coreutils) '* | \ 'mkdir (coreutils) '* | \ 'mkdir (fileutils) '4.1*) ac_cv_path_mkdir=$as_dir/$ac_prog$ac_exec_ext break 3;; esac done done])]) test -d ./--version && rmdir ./--version if test "${ac_cv_path_mkdir+set}" = set; then MKDIR_P="$ac_cv_path_mkdir -p" else # As a last resort, use the slow shell script. Don't cache a # value for MKDIR_P within a source directory, because that will # break other packages using the cache if that directory is # removed, or if the value is a relative name. MKDIR_P="$ac_install_sh -d" fi fi dnl status.m4 does special magic for MKDIR_P instead of AC_SUBST, dnl to get relative names right. However, also AC_SUBST here so dnl that Automake versions before 1.10 will pick it up (they do not dnl trace AC_SUBST_TRACE). dnl FIXME: Remove this once we drop support for Automake < 1.10. AC_SUBST([MKDIR_P])dnl AC_MSG_RESULT([$MKDIR_P]) ])# AC_PROG_MKDIR_P # AC_PROG_LEX # ----------- # Look for flex or lex. Set its associated library to LEXLIB. # Check if lex declares yytext as a char * by default, not a char[]. AN_MAKEVAR([LEX], [AC_PROG_LEX]) AN_PROGRAM([lex], [AC_PROG_LEX]) AN_PROGRAM([flex], [AC_PROG_LEX]) AC_DEFUN_ONCE([AC_PROG_LEX], [AC_CHECK_PROGS(LEX, flex lex, :) if test "x$LEX" != "x:"; then _AC_PROG_LEX_YYTEXT_DECL fi]) # _AC_PROG_LEX_YYTEXT_DECL # ------------------------ # Check for the Lex output root, the Lex library, and whether Lex # declares yytext as a char * by default. m4_define([_AC_PROG_LEX_YYTEXT_DECL], [cat >conftest.l <<_ACEOF[ %% a { ECHO; } b { REJECT; } c { yymore (); } d { yyless (1); } e { /* IRIX 6.5 flex 2.5.4 underquotes its yyless argument. */ yyless ((input () != 0)); } f { unput (yytext[0]); } . { BEGIN INITIAL; } %% #ifdef YYTEXT_POINTER extern char *yytext; #endif int main (void) { return ! yylex () + ! yywrap (); } ]_ACEOF _AC_DO_VAR(LEX conftest.l) AC_CACHE_CHECK([lex output file root], [ac_cv_prog_lex_root], [ if test -f lex.yy.c; then ac_cv_prog_lex_root=lex.yy elif test -f lexyy.c; then ac_cv_prog_lex_root=lexyy else AC_MSG_ERROR([cannot find output from $LEX; giving up]) fi]) AC_SUBST([LEX_OUTPUT_ROOT], [$ac_cv_prog_lex_root])dnl if test -z "${LEXLIB+set}"; then AC_CACHE_CHECK([lex library], [ac_cv_lib_lex], [ ac_save_LIBS=$LIBS ac_cv_lib_lex='none needed' for ac_lib in '' -lfl -ll; do LIBS="$ac_lib $ac_save_LIBS" AC_LINK_IFELSE([AC_LANG_DEFINES_PROVIDED[`cat $LEX_OUTPUT_ROOT.c`]], [ac_cv_lib_lex=$ac_lib]) test "$ac_cv_lib_lex" != 'none needed' && break done LIBS=$ac_save_LIBS ]) test "$ac_cv_lib_lex" != 'none needed' && LEXLIB=$ac_cv_lib_lex fi AC_SUBST(LEXLIB) AC_CACHE_CHECK(whether yytext is a pointer, ac_cv_prog_lex_yytext_pointer, [# POSIX says lex can declare yytext either as a pointer or an array; the # default is implementation-dependent. Figure out which it is, since # not all implementations provide the %pointer and %array declarations. ac_cv_prog_lex_yytext_pointer=no ac_save_LIBS=$LIBS LIBS="$LEXLIB $ac_save_LIBS" AC_LINK_IFELSE([AC_LANG_DEFINES_PROVIDED [#define YYTEXT_POINTER 1 `cat $LEX_OUTPUT_ROOT.c`]], [ac_cv_prog_lex_yytext_pointer=yes]) LIBS=$ac_save_LIBS ]) dnl if test $ac_cv_prog_lex_yytext_pointer = yes; then AC_DEFINE(YYTEXT_POINTER, 1, [Define to 1 if `lex' declares `yytext' as a `char *' by default, not a `char[]'.]) fi rm -f conftest.l $LEX_OUTPUT_ROOT.c ])# _AC_PROG_LEX_YYTEXT_DECL # Require AC_PROG_LEX in case some people were just calling this macro. AU_DEFUN([AC_DECL_YYTEXT], [AC_PROG_LEX]) # AC_PROG_LN_S # ------------ AN_MAKEVAR([LN], [AC_PROG_LN_S]) AN_PROGRAM([ln], [AC_PROG_LN_S]) AC_DEFUN([AC_PROG_LN_S], [AC_MSG_CHECKING([whether ln -s works]) AC_SUBST([LN_S], [$as_ln_s])dnl if test "$LN_S" = "ln -s"; then AC_MSG_RESULT([yes]) else AC_MSG_RESULT([no, using $LN_S]) fi ])# AC_PROG_LN_S # AC_PROG_MAKE_SET # ---------------- # Define SET_MAKE to set ${MAKE} if Make does not do so automatically. If Make # does not run the test Makefile, we assume that the Make program the user will # invoke does set $(MAKE). This is typical, and emitting `MAKE=foomake' is # always wrong if `foomake' is not available or does not work. AN_MAKEVAR([MAKE], [AC_PROG_MAKE_SET]) AN_PROGRAM([make], [AC_PROG_MAKE_SET]) AC_DEFUN([AC_PROG_MAKE_SET], [AC_MSG_CHECKING([whether ${MAKE-make} sets \$(MAKE)]) set x ${MAKE-make} ac_make=`AS_ECHO(["$[2]"]) | sed 's/+/p/g; s/[[^a-zA-Z0-9_]]/_/g'` AC_CACHE_VAL(ac_cv_prog_make_${ac_make}_set, [cat >conftest.make <<\_ACEOF SHELL = /bin/sh all: @echo '@@@%%%=$(MAKE)=@@@%%%' _ACEOF # GNU make sometimes prints "make[1]: Entering ...", which would confuse us. case `${MAKE-make} -f conftest.make 2>/dev/null` in *@@@%%%=?*=@@@%%%*) eval ac_cv_prog_make_${ac_make}_set=yes;; *) eval ac_cv_prog_make_${ac_make}_set=no;; esac rm -f conftest.make])dnl if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then AC_MSG_RESULT([yes]) SET_MAKE= else AC_MSG_RESULT([no]) SET_MAKE="MAKE=${MAKE-make}" fi AC_SUBST([SET_MAKE])dnl ])# AC_PROG_MAKE_SET # AC_PROG_RANLIB # -------------- AN_MAKEVAR([RANLIB], [AC_PROG_RANLIB]) AN_PROGRAM([ranlib], [AC_PROG_RANLIB]) AC_DEFUN([AC_PROG_RANLIB], [AC_CHECK_TOOL(RANLIB, ranlib, :)]) # AC_RSH # ------ # I don't know what it used to do, but it no longer does. AU_DEFUN([AC_RSH], [], [$0 is no longer supported. Remove this warning when you adjust the code.]) # AC_PROG_SED # ----------- # Check for a fully functional sed program that truncates # as few characters as possible. Prefer GNU sed if found. AC_DEFUN([AC_PROG_SED], [AC_CACHE_CHECK([for a sed that does not truncate output], ac_cv_path_SED, [dnl ac_script should not contain more than 99 commands (for HP-UX sed), dnl but more than about 7000 bytes, to catch a limit in Solaris 8 /usr/ucb/sed. ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/ for ac_i in 1 2 3 4 5 6 7; do ac_script="$ac_script$as_nl$ac_script" done echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed AS_UNSET([ac_script]) _AC_PATH_PROGS_FEATURE_CHECK(SED, [sed gsed], [_AC_FEATURE_CHECK_LENGTH([ac_path_SED], [ac_cv_path_SED], ["$ac_path_SED" -f conftest.sed])])]) SED="$ac_cv_path_SED" AC_SUBST([SED])dnl rm -f conftest.sed ])# AC_PROG_SED # AC_PROG_YACC # ------------ AN_MAKEVAR([BISON], [AC_PROG_YACC]) AN_MAKEVAR([YACC], [AC_PROG_YACC]) AN_MAKEVAR([YFLAGS], [AC_PROG_YACC]) AN_PROGRAM([yacc], [AC_PROG_YACC]) AN_PROGRAM([byacc], [AC_PROG_YACC]) AN_PROGRAM([bison], [AC_PROG_YACC]) AC_DEFUN([AC_PROG_YACC], [AC_CHECK_PROGS(YACC, 'bison -y' byacc, yacc)dnl AC_ARG_VAR(YACC, [The `Yet Another Compiler Compiler' implementation to use. Defaults to the first program found out of: `bison -y', `byacc', `yacc'.])dnl AC_ARG_VAR(YFLAGS, [The list of arguments that will be passed by default to $YACC. This script will default YFLAGS to the empty string to avoid a default value of `-d' given by some make applications.])])
Cancel