mirror of
git://git.sv.gnu.org/coreutils.git
synced 2026-04-13 15:26:48 +02:00
e0190a9d1b
$ yes abcdefghijklmnopqrstuvwxyz | head -n 200000000 > input
$ time ./src/wc-prev -l input
200000000 input
real 0m1.240s
user 0m0.456s
sys 0m0.784s
$ time ./src/wc -l input
200000000 input
real 0m0.936s
user 0m0.141s
sys 0m0.795s
* configure.ac: Use unsigned char for the buffer to avoid potential
compiler warnings. Check for the functions being used in src/wc_neon.c
after this patch.
* src/wc_neon.c (wc_lines_neon): Use vreinterpretq_s8_u8 to convert 0xff
into -1 instead of bitwise AND instructions into convert it into 1.
Perform the pairwise addition and lane extraction once every 8192 bytes
instead of once every 64 bytes.
Thanks to Lasse Collin for spotting this and reviewing a draft of this
patch.
972 lines
33 KiB
Plaintext
972 lines
33 KiB
Plaintext
# -*- autoconf -*-
|
|
# Process this file with autoconf to produce a configure script.
|
|
|
|
# Copyright (C) 1991-2026 Free Software Foundation, Inc.
|
|
|
|
# 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.
|
|
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
dnl Written by Jim Meyering.
|
|
|
|
AC_PREREQ([2.69])
|
|
|
|
# Make inter-release version strings look like, e.g., v6.9-219-g58ddd, which
|
|
# indicates that it is built from the 219th delta (in _some_ repository)
|
|
# following the v6.9 tag, and that 58ddd is a prefix of the commit SHA1.
|
|
# The explicit URL can be removed when autoconf > 2.69 is released.
|
|
AC_INIT([GNU coreutils],
|
|
m4_esyscmd([build-aux/git-version-gen .tarball-version]),
|
|
[bug-coreutils@gnu.org],
|
|
[coreutils],
|
|
[https://www.gnu.org/software/coreutils/])
|
|
|
|
AC_CONFIG_SRCDIR([src/ls.c])
|
|
|
|
AC_CONFIG_AUX_DIR([build-aux])
|
|
AC_CONFIG_HEADERS([lib/config.h:lib/config.hin])
|
|
|
|
AM_INIT_AUTOMAKE([1.11.2 dist-xz color-tests parallel-tests subdir-objects])
|
|
AM_SILENT_RULES([yes]) # make --enable-silent-rules the default.
|
|
|
|
dnl POSIXCHECK is worthwhile for maintainers, but adds several seconds
|
|
dnl (more than 10% execution time) to ./configure, with no benefit for
|
|
dnl most users. Using it to look for bugs requires:
|
|
dnl GNULIB_POSIXCHECK=1 autoreconf -f
|
|
dnl ./configure
|
|
dnl make
|
|
dnl make -C src clean
|
|
dnl make CFLAGS=-DGNULIB_POSIXCHECK=1
|
|
dnl FIXME: Once we figure out how to avoid false positives, we should
|
|
dnl have 'make my-distcheck' in dist-check.mk exercise this.
|
|
m4_syscmd([test "${GNULIB_POSIXCHECK+set}" = set])
|
|
m4_if(m4_sysval, [0], [], [dnl
|
|
gl_ASSERT_NO_GNULIB_POSIXCHECK])
|
|
|
|
AC_PROG_CC
|
|
AM_PROG_CC_C_O
|
|
AC_PROG_CPP
|
|
AC_PROG_RANLIB
|
|
AC_PROG_EGREP
|
|
AC_PROG_LN_S
|
|
gl_EARLY
|
|
gl_SET_CRYPTO_CHECK_DEFAULT([auto-gpl-compat])
|
|
gl_INIT
|
|
coreutils_MACROS
|
|
|
|
# These are safe, since 'sort', coreutils's only multithreaded app,
|
|
# does not use the relevant modules.
|
|
AC_DEFINE([GNULIB_EXCLUDE_SINGLE_THREAD], [1],
|
|
[Define to 1 if apps call 'exclude' functions from a single thread.])
|
|
AC_DEFINE([GNULIB_REGEX_SINGLE_THREAD], [1],
|
|
[Define to 1 if apps call 'regex' functions from a single thread.])
|
|
# Although 'sort' is multithreaded and can use these functions,
|
|
# it uses them only from the main thread.
|
|
AC_DEFINE([GNULIB_MBRTOWC_SINGLE_THREAD], [1],
|
|
[Define to 1 if apps call mbrtowc, mbrtoc32, and 'regex' functions
|
|
from a single thread.])
|
|
# This is safe, since all apps set locale early.
|
|
AC_DEFINE([GNULIB_WCHAR_SINGLE_LOCALE], [1],
|
|
[Define to 1 if apps don't set the locale after calling
|
|
locale-sensitive functions like mbrtowc and wcwidth.])
|
|
|
|
AC_DEFINE([GNULIB_MBRTOC32_REGULAR], [1],
|
|
[Do not worry about rare encodings like CP864, EBCDIC, Johab, and Shift JIS
|
|
that glibc does not support.])
|
|
|
|
# The test suite needs to know if we have a working perl.
|
|
AM_CONDITIONAL([HAVE_PERL], [test "$gl_cv_prog_perl" != no])
|
|
|
|
# gl_GCC_VERSION_IFELSE([major], [minor], [run-if-found], [run-if-not-found])
|
|
# ------------------------------------------------
|
|
# If $CPP is gcc-MAJOR.MINOR or newer, then run RUN-IF-FOUND.
|
|
# Otherwise, run RUN-IF-NOT-FOUND.
|
|
AC_DEFUN([gl_GCC_VERSION_IFELSE],
|
|
[AC_PREPROC_IFELSE(
|
|
[AC_LANG_PROGRAM(
|
|
[[
|
|
#if ($1) < __GNUC__ || (($1) == __GNUC__ && ($2) <= __GNUC_MINOR__)
|
|
/* ok */
|
|
#else
|
|
# error "your version of gcc is older than $1.$2"
|
|
#endif
|
|
]]),
|
|
], [$3], [$4])
|
|
]
|
|
)
|
|
|
|
AC_ARG_ENABLE([single-binary],
|
|
[AS_HELP_STRING([--enable-single-binary=[shebangs|symlinks|hardlinks]],
|
|
[Compile all the tools in a single binary, reducing the overall size.
|
|
When compiled this way, shebangs (default when enabled), symlinks, or
|
|
hardlinks are installed for each tool, which point to a single binary])],
|
|
[gl_single_binary=no ;
|
|
case $enableval in
|
|
yes) gl_single_binary=shebangs ;;
|
|
no|shebangs|symlinks|hardlinks) gl_single_binary=$enableval ;;
|
|
*) AC_MSG_ERROR([bad value $enableval for single-binary option.
|
|
Options are: hardlinks, symlinks, shebangs, no.]) ;;
|
|
esac],
|
|
[gl_single_binary=no]
|
|
)
|
|
AC_ARG_ENABLE([single-binary-exceptions],
|
|
[AS_HELP_STRING([--enable-single-binary-exceptions=PROG_LIST],
|
|
[When used with --enable-single-binary, exclude the PROG_LIST from
|
|
it, so these programs are compiled as separated files
|
|
(comma-separated, default none))])],
|
|
[gl_single_binary_exceptions=$enableval],
|
|
[gl_single_binary_exceptions=]
|
|
)
|
|
if test "$gl_single_binary" = 'symlinks' ||
|
|
test "$gl_single_binary" = 'hardlinks'; then
|
|
if ! test "`echo ls | sed \"$program_transform_name\"`" = 'ls'; then
|
|
AC_MSG_ERROR([program name transformations are not currently supported
|
|
with --enable-single-binary=$gl_single_binary.])
|
|
fi
|
|
fi
|
|
AM_CONDITIONAL([SINGLE_BINARY], [test "$gl_single_binary" != no])
|
|
AM_CONDITIONAL([SINGLE_BINARY_HARD], [test "$gl_single_binary" = hardlinks])
|
|
|
|
AC_ARG_ENABLE([bold-man-page-references],
|
|
[AS_HELP_STRING([--disable-bold-man-page-references],
|
|
[When generating man pages, or displaying --help, do not apply bold style
|
|
around any references like name(1) or --option references etc.])],
|
|
[gl_bold_manpages=yes ;
|
|
case $enableval in
|
|
no|yes) gl_bold_manpages=$enableval ;;
|
|
*) AC_MSG_ERROR([bad value $enableval for bold-man-page-references.
|
|
Options are: yes, no.]) ;;
|
|
esac],
|
|
[gl_bold_manpages=yes]
|
|
)
|
|
if test "$gl_bold_manpages" != no; then
|
|
AC_DEFINE([BOLD_MAN_REFS], [1], [Whether to markup references as bold])
|
|
fi
|
|
AM_CONDITIONAL([BOLD_MAN_REFS], [test "$gl_bold_manpages" != no])
|
|
|
|
AC_ARG_ENABLE([manual-url],
|
|
[AS_HELP_STRING([--enable-manual-url@<:@=<url>@:>@],
|
|
[When generating man pages, or displaying --help, generate hyperlinks
|
|
from each "--option" to <url>@%:@command-option. A local file is
|
|
supported through a file:// URL. The default URL used is:
|
|
$PACKAGE_URL/manual/$PACKAGE.html.])],
|
|
[case $enableval in
|
|
yes) gl_manual_url=default ;;
|
|
no) gl_manual_url='' ;;
|
|
*) gl_manual_url="$enableval" ;;
|
|
esac],
|
|
[gl_manual_url=default]
|
|
)
|
|
if test x"$gl_manual_url" != x; then
|
|
if test "$gl_manual_url" = default; then
|
|
gl_manual_url=${PACKAGE_URL}manual/$PACKAGE.html
|
|
fi
|
|
AC_DEFINE_UNQUOTED([MANUAL_URL], ["$gl_manual_url"], [URL for full manual])
|
|
fi
|
|
|
|
AC_ARG_ENABLE([gcc-warnings],
|
|
[AS_HELP_STRING([--enable-gcc-warnings@<:@=TYPE@:>@],
|
|
[control generation of GCC warnings. The TYPE 'no' disables
|
|
warnings (default for non-developer builds); 'yes' generates
|
|
cheap warnings if available (default for developer builds);
|
|
'expensive' in addition generates expensive-to-compute warnings
|
|
if available.])],
|
|
[case $enableval in
|
|
no|yes|expensive) ;;
|
|
*) AC_MSG_ERROR([bad value $enableval for gcc-warnings option]) ;;
|
|
esac
|
|
gl_gcc_warnings=$enableval],
|
|
[
|
|
# GCC provides fine-grained control over diagnostics which
|
|
# is used in gnulib for example to suppress warnings from
|
|
# certain sections of code. So if this is available and
|
|
# we're running from a git repo, then auto enable the warnings.
|
|
gl_gcc_warnings=no
|
|
gl_GCC_VERSION_IFELSE([4], [6],
|
|
[test -d "$srcdir"/.git \
|
|
&& ! test -f "$srcdir"/.tarball-version \
|
|
&& gl_gcc_warnings=yes])]
|
|
)
|
|
|
|
# clang is unduly picky about some things, even by default.
|
|
if test "$gl_cv_compiler_clang" = yes; then
|
|
gl_WARN_ADD([-Wno-format-extra-args])
|
|
gl_WARN_ADD([-Wno-implicit-const-int-float-conversion])
|
|
gl_WARN_ADD([-Wno-tautological-constant-out-of-range-compare])
|
|
fi
|
|
|
|
if test $gl_gcc_warnings != no; then
|
|
gl_WARN_ADD([-Werror], [WERROR_CFLAGS])
|
|
AC_SUBST([WERROR_CFLAGS])
|
|
|
|
ew=
|
|
AS_IF([test $gl_gcc_warnings != expensive],
|
|
[# -fanalyzer and related options slow GCC considerably.
|
|
ew="$ew -fanalyzer -Wno-analyzer-malloc-leak"])
|
|
|
|
# This, $nw, is the list of warnings we disable.
|
|
nw=$ew
|
|
nw="$nw -Wstack-protector" # not worth working around for pre GCC 15
|
|
nw="$nw -Wformat-overflow=2" # False alarms due to GCC bug 110333
|
|
nw="$nw -Wformat-truncation=2" # False alarm in ls.c, probably related
|
|
nw="$nw -Winline" # system.h's readdir_ignoring_dot_and_dotdot
|
|
|
|
# Suppress noreturn warnings with single binaries; otherwise
|
|
# GCC complains about the renamed 'main' not being declared noreturn
|
|
# because 'main_exit' calls 'exit' when linting.
|
|
if test "$gl_single_binary" != no; then
|
|
nw="$nw -Wsuggest-attribute=noreturn"
|
|
fi
|
|
|
|
# Using -Wstrict-overflow is a pain, but the alternative is worse.
|
|
# For an example, see the code that provoked this report:
|
|
# https://gcc.gnu.org/PR33498
|
|
# Code like that still infloops with gcc-4.6.0 and -O2. Scary indeed.
|
|
|
|
gl_MANYWARN_ALL_GCC([ws])
|
|
AS_VAR_APPEND([ws], [' -Wswitch-enum'])
|
|
AS_VAR_APPEND([ws], [' -Wtrailing-whitespace'])
|
|
gl_MANYWARN_COMPLEMENT([ws], [$ws], [$nw])
|
|
for w in $ws; do
|
|
gl_WARN_ADD([$w])
|
|
done
|
|
gl_WARN_ADD([-Wno-sign-compare]) # Too many warnings for now
|
|
gl_WARN_ADD([-Wno-format-nonliteral])
|
|
|
|
AC_SUBST([WARN_CFLAGS])
|
|
|
|
AC_DEFINE([lint], [1], [Define to 1 if the compiler is checking for lint.])
|
|
AH_VERBATIM([FORTIFY_SOURCE],
|
|
[/* Enable compile-time and run-time bounds-checking, and some warnings,
|
|
without upsetting glibc 2.15+. */
|
|
#if !defined _FORTIFY_SOURCE && defined __OPTIMIZE__ && __OPTIMIZE__
|
|
# define _FORTIFY_SOURCE 2
|
|
#endif
|
|
])
|
|
AC_DEFINE([GNULIB_PORTCHECK], [1], [enable some gnulib portability checks])
|
|
|
|
# We use a slightly smaller set of warning options for lib/.
|
|
# Remove the following and save the result in GNULIB_WARN_CFLAGS.
|
|
nw=$ew
|
|
nw="$nw -Wduplicated-branches" # Too many false alarms
|
|
nw="$nw -Wformat-truncation=2"
|
|
nw="$nw -Wunused-macros"
|
|
|
|
gl_MANYWARN_COMPLEMENT([GNULIB_WARN_CFLAGS], [$WARN_CFLAGS], [$nw])
|
|
AC_SUBST([GNULIB_WARN_CFLAGS])
|
|
|
|
# For gnulib-tests, the set is slightly smaller still.
|
|
nw=
|
|
# It's not worth being this picky about test programs.
|
|
nw="$nw -Wmissing-variable-declarations"
|
|
nw="$nw -Wsuggest-attribute=cold"
|
|
nw="$nw -Wsuggest-attribute=const"
|
|
nw="$nw -Wsuggest-attribute=format"
|
|
nw="$nw -Wsuggest-attribute=pure"
|
|
gl_MANYWARN_COMPLEMENT([GNULIB_TEST_WARN_CFLAGS],
|
|
[$GNULIB_WARN_CFLAGS], [$nw])
|
|
AC_SUBST([GNULIB_TEST_WARN_CFLAGS])
|
|
fi
|
|
|
|
AC_FUNC_FORK
|
|
|
|
optional_bin_progs=
|
|
AC_CHECK_FUNCS([chroot],
|
|
gl_ADD_PROG([optional_bin_progs], [chroot]))
|
|
AC_CHECK_FUNCS([gethostid],
|
|
gl_ADD_PROG([optional_bin_progs], [hostid]))
|
|
AC_CHECK_FUNCS([sigsuspend],
|
|
gl_ADD_PROG([optional_bin_progs], [timeout]))
|
|
|
|
gl_WINSIZE_IN_PTEM
|
|
|
|
AC_MSG_CHECKING([whether localtime caches TZ])
|
|
AC_CACHE_VAL([utils_cv_localtime_cache],
|
|
[if test x$ac_cv_func_tzset = xyes; then
|
|
AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <time.h>
|
|
#if STDC_HEADERS
|
|
# include <stdlib.h>
|
|
#endif
|
|
extern char **environ;
|
|
void unset_TZ (void)
|
|
{
|
|
char **from, **to;
|
|
for (to = from = environ; (*to = *from); from++)
|
|
if (! (to[0][0] == 'T' && to[0][1] == 'Z' && to[0][2] == '='))
|
|
to++;
|
|
}
|
|
int
|
|
main ()
|
|
{
|
|
time_t now = time ((time_t *) 0);
|
|
int hour_GMT0, hour_unset;
|
|
if (putenv ("TZ=GMT0") != 0)
|
|
return 1;
|
|
hour_GMT0 = localtime (&now)->tm_hour;
|
|
unset_TZ ();
|
|
hour_unset = localtime (&now)->tm_hour;
|
|
if (putenv ("TZ=PST8") != 0)
|
|
return 1;
|
|
if (localtime (&now)->tm_hour == hour_GMT0)
|
|
return 1;
|
|
unset_TZ ();
|
|
if (localtime (&now)->tm_hour != hour_unset)
|
|
return 1;
|
|
return 0;
|
|
}]])],
|
|
[utils_cv_localtime_cache=no],
|
|
[utils_cv_localtime_cache=yes],
|
|
[# If we have tzset, assume the worst when cross-compiling.
|
|
utils_cv_localtime_cache=yes])
|
|
else
|
|
# If we lack tzset, report that localtime does not cache TZ,
|
|
# since we can't invalidate the cache if we don't have tzset.
|
|
utils_cv_localtime_cache=no
|
|
fi])dnl
|
|
AC_MSG_RESULT([$utils_cv_localtime_cache])
|
|
if test $utils_cv_localtime_cache = yes; then
|
|
AC_DEFINE([LOCALTIME_CACHE], [1], [FIXME])
|
|
fi
|
|
|
|
# Find the library for dynamic loading of shared libraries.
|
|
AC_SEARCH_LIBS([dlopen], [dl])
|
|
AS_CASE([$ac_cv_search_dlopen],
|
|
[no | 'none required'],
|
|
[LIB_DL=],
|
|
[*],
|
|
[LIB_DL="$ac_cv_search_dlopen"])
|
|
AC_SUBST([LIB_DL])
|
|
|
|
# Should 'sort' link libcrypto dynamically?
|
|
AS_CASE([$LIB_CRYPTO],
|
|
[-lcrypto],
|
|
[# Check for dlopen and libcrypto dynamic linking in one program,
|
|
# as there's little point to checking them separately.
|
|
AC_CACHE_CHECK([for dlopen and whether libcrypto is linked dynamically],
|
|
[utils_cv_libcrypto_soname],
|
|
[utils_cv_libcrypto_soname=no
|
|
saved_LIBS=$LIBS
|
|
LIBS="$LIBS $LIB_DL $LIB_CRYPTO"
|
|
AC_LINK_IFELSE(
|
|
[AC_LANG_PROGRAM(
|
|
[[#include <dlfcn.h>
|
|
#include <openssl/sha.h>
|
|
/* Use SHA512 rather than MD5 here to avoid deprecation warnings.
|
|
So need to check HAVE_OPENSSL_MD5.. with DLOPEN_LIBCRYPTO. */
|
|
]],
|
|
[[return !(dlopen ("libcrypto.so", RTLD_LAZY | RTLD_GLOBAL)
|
|
&& SHA512 (0, 0, 0));]])],
|
|
[# readelf works with cross-builds; ldd works on more platforms.
|
|
LIBCRYPTO_SONAME="`(readelf -d conftest$EXEEXT || ldd conftest$EXEEXT
|
|
) 2>/dev/null |
|
|
sed -n 's/.*\(libcrypto\.so\.[[.0-9]]*\).*/\1/p'`"
|
|
AS_CASE([$LIBCRYPTO_SONAME],
|
|
[*libcrypto*],
|
|
[utils_cv_libcrypto_soname=$LIBCRYPTO_SONAME])])
|
|
LIBS=$saved_LIBS])
|
|
AS_CASE([$utils_cv_libcrypto_soname],
|
|
[*libcrypto*],
|
|
[AC_DEFINE([DLOPEN_LIBCRYPTO], [1],
|
|
[Define to 1 if dlopen exists and libcrypto is
|
|
linked dynamically.])
|
|
AC_DEFINE_UNQUOTED([LIBCRYPTO_SONAME], ["$utils_cv_libcrypto_soname"],
|
|
[versioned libcrypto])
|
|
])])
|
|
|
|
# macOS >= 10.12
|
|
AC_CHECK_FUNCS([fclonefileat])
|
|
|
|
# Assume that if getattrat exists, it's compatible with Solaris 11.
|
|
AC_CHECK_FUNCS([getattrat])
|
|
if test $ac_cv_func_getattrat = yes; then
|
|
LIB_NVPAIR=-lnvpair
|
|
AC_SUBST([LIB_NVPAIR])
|
|
fi
|
|
|
|
# glibc >= 2.28 and linux kernel >= 4.11, Android API level 30.
|
|
gl_CHECK_FUNCS_ANDROID([statx], [[#include <sys/stat.h>]])
|
|
|
|
# SCO-ODT-3.0 is reported to need -los to link programs using initgroups
|
|
AC_CHECK_FUNCS([initgroups])
|
|
if test $ac_cv_func_initgroups = no; then
|
|
AC_CHECK_LIB([os], [initgroups])
|
|
fi
|
|
|
|
AC_CHECK_FUNCS([syslog])
|
|
if test $ac_cv_func_syslog = no; then
|
|
# syslog is not in the default libraries. See if it's in some other.
|
|
for lib in bsd socket inet; do
|
|
AC_CHECK_LIB([$lib], [syslog], [AC_DEFINE([HAVE_SYSLOG], [1], [FIXME])
|
|
LIBS="$LIBS -l$lib"; break])
|
|
done
|
|
fi
|
|
|
|
AC_CACHE_CHECK([for 3-argument setpriority function],
|
|
[utils_cv_func_setpriority],
|
|
[AC_LINK_IFELSE(
|
|
[AC_LANG_PROGRAM(
|
|
[[#include <sys/time.h>
|
|
#include <sys/resource.h>
|
|
]],
|
|
[[setpriority (0, 0, 0);]])],
|
|
[utils_cv_func_setpriority=yes],
|
|
[utils_cv_func_setpriority=no])])
|
|
if test $utils_cv_func_setpriority = no; then
|
|
AC_CHECK_FUNCS([nice])
|
|
fi
|
|
case $utils_cv_func_setpriority,$ac_cv_func_nice in
|
|
*yes*)
|
|
gl_ADD_PROG([optional_bin_progs], [nice])
|
|
esac
|
|
|
|
if test "$cross_compiling" = yes || test -c /dev/stdin <.; then
|
|
AC_DEFINE([DEV_FD_MIGHT_BE_CHR], [1],
|
|
[Define to 1 if /dev/std{in,out,err} and /dev/fd/N, if they exist, might be
|
|
character-special devices whose minor device number is the file
|
|
descriptor number, such as on Solaris. Leave undefined if they are
|
|
definitely the actual files. This determination should be done after any
|
|
symbolic links are followed.])
|
|
fi
|
|
|
|
AC_DEFUN([coreutils_DUMMY_1],
|
|
[
|
|
AC_REQUIRE([gl_READUTMP])
|
|
if test $ac_cv_header_utmp_h = yes || test $ac_cv_header_utmpx_h = yes; then
|
|
gl_ADD_PROG([optional_bin_progs], [who])
|
|
gl_ADD_PROG([optional_bin_progs], [users])
|
|
gl_ADD_PROG([optional_bin_progs], [pinky])
|
|
fi
|
|
])
|
|
coreutils_DUMMY_1
|
|
|
|
AC_SYS_POSIX_TERMIOS()
|
|
gl_HEADER_TIOCGWINSZ_NEEDS_SYS_IOCTL
|
|
|
|
if test $ac_cv_sys_posix_termios = yes; then
|
|
gl_ADD_PROG([optional_bin_progs], [stty])
|
|
|
|
AC_MSG_CHECKING([whether termios.h needs _XOPEN_SOURCE])
|
|
AC_CACHE_VAL([su_cv_sys_termios_needs_xopen_source],
|
|
[AC_EGREP_CPP([yes], [#include <termios.h>
|
|
#ifdef IUCLC
|
|
yes
|
|
#endif], su_cv_sys_termios_needs_xopen_source=no,
|
|
AC_EGREP_CPP([yes], [#define _XOPEN_SOURCE
|
|
#include <termios.h>
|
|
#ifdef IUCLC
|
|
yes
|
|
#endif], su_cv_sys_termios_needs_xopen_source=yes,
|
|
su_cv_sys_termios_needs_xopen_source=no))])
|
|
AC_MSG_RESULT([$su_cv_sys_termios_needs_xopen_source])
|
|
test $su_cv_sys_termios_needs_xopen_source = yes &&
|
|
AC_DEFINE([TERMIOS_NEEDS_XOPEN_SOURCE], [1], [FIXME])
|
|
|
|
AC_MSG_CHECKING([c_line in struct termios])
|
|
AC_CACHE_VAL([su_cv_sys_c_line_in_termios],
|
|
[AC_LINK_IFELSE([AC_LANG_PROGRAM([[#if TERMIOS_NEEDS_XOPEN_SOURCE
|
|
#define _XOPEN_SOURCE
|
|
#endif
|
|
#include <sys/types.h>
|
|
#include <termios.h>
|
|
struct termios t;
|
|
int s = sizeof t.c_line;]])],
|
|
[su_cv_sys_c_line_in_termios=yes],
|
|
[su_cv_sys_c_line_in_termios=no])])
|
|
AC_MSG_RESULT([$su_cv_sys_c_line_in_termios])
|
|
test $su_cv_sys_c_line_in_termios = yes \
|
|
&& AC_DEFINE([HAVE_C_LINE], [1], [FIXME])
|
|
fi
|
|
|
|
# FIXME: note that this macro appears above, too.
|
|
# I'm leaving it here for now. This whole thing needs to be modernized...
|
|
gl_WINSIZE_IN_PTEM
|
|
|
|
gl_HEADER_TIOCGWINSZ_IN_TERMIOS_H
|
|
|
|
if test $gl_cv_sys_tiocgwinsz_needs_termios_h = no && \
|
|
test $gl_cv_sys_tiocgwinsz_needs_sys_ioctl_h = no; then
|
|
AC_MSG_CHECKING([TIOCGWINSZ in sys/pty.h])
|
|
AC_CACHE_VAL([su_cv_sys_tiocgwinsz_in_sys_pty_h],
|
|
[AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <sys/types.h>
|
|
#ifdef WINSIZE_IN_PTEM
|
|
# include <sys/stream.h>
|
|
# include <sys/ptem.h>
|
|
#endif
|
|
#include <sys/ioctl.h>
|
|
#include <sys/tty.h>
|
|
#include <sys/pty.h>]], [[int x = TIOCGWINSZ;]])],
|
|
[su_cv_sys_tiocgwinsz_in_sys_pty_h=yes],
|
|
[su_cv_sys_tiocgwinsz_in_sys_pty_h=no])])
|
|
AC_MSG_RESULT([$su_cv_sys_tiocgwinsz_in_sys_pty_h])
|
|
|
|
test $su_cv_sys_tiocgwinsz_in_sys_pty_h = yes \
|
|
&& AC_DEFINE([GWINSZ_IN_SYS_PTY], [1],
|
|
[Define if your system defines TIOCGWINSZ in sys/pty.h.])
|
|
fi
|
|
|
|
# Build df only if there's a point to it.
|
|
if test $gl_cv_list_mounted_fs = yes && test $gl_cv_fs_space = yes; then
|
|
gl_ADD_PROG([optional_bin_progs], [df])
|
|
fi
|
|
|
|
# Build stdbuf only if supported
|
|
ac_save_CFLAGS=$CFLAGS
|
|
ac_save_LDFLAGS=$LDFLAGS
|
|
cu_save_c_werror_flag=$ac_c_werror_flag
|
|
AC_LANG_WERROR
|
|
# Detect warnings about ignored "constructor" attributes.
|
|
gl_WARN_ADD([-Werror], [CFLAGS])
|
|
gl_WARN_ADD([-errwarn], [CFLAGS])
|
|
# Put this message here, after gl_WARN_ADD's chatter.
|
|
AC_MSG_CHECKING([whether this system supports stdbuf])
|
|
CFLAGS="-fPIC $CFLAGS"
|
|
LDFLAGS="-shared $LDFLAGS"
|
|
AC_CACHE_VAL([utils_cv_stdbuf_supported],[
|
|
utils_cv_stdbuf_supported=no
|
|
# Note we only LINK here rather than RUN to support cross compilation
|
|
AC_LINK_IFELSE(
|
|
[AC_LANG_PROGRAM([[
|
|
static int stdbuf = 0;
|
|
|
|
void __attribute__ ((constructor))
|
|
stdbuf_init (void)
|
|
{
|
|
stdbuf = 1;
|
|
}]],[[
|
|
if (stdbuf != 1)
|
|
return 1;]])
|
|
],
|
|
[utils_cv_stdbuf_supported=yes])])
|
|
AC_MSG_RESULT([$utils_cv_stdbuf_supported])
|
|
if test "$utils_cv_stdbuf_supported" = "yes" && test -z "$EXEEXT"; then
|
|
gl_ADD_PROG([optional_bin_progs], [stdbuf])
|
|
fi
|
|
CFLAGS=$ac_save_CFLAGS
|
|
LDFLAGS=$ac_save_LDFLAGS
|
|
ac_c_werror_flag=$cu_save_c_werror_flag
|
|
|
|
# Don't build chcon and runcon if only have gnulib stubs
|
|
# Honor --without-selinux to force disable
|
|
# and --with-selinux to force enable.
|
|
if test "$with_selinux" != no &&
|
|
{ test "$with_selinux" = yes ||
|
|
test "$ac_cv_header_selinux_selinux_h" = yes; }; then
|
|
gl_ADD_PROG([optional_bin_progs], [chcon])
|
|
gl_ADD_PROG([optional_bin_progs], [runcon])
|
|
fi
|
|
|
|
# Test compiler support for half precision floating point types (for od)
|
|
AC_MSG_CHECKING([IEEE 16 bit floating point])
|
|
AC_CACHE_VAL([utils_cv_ieee_16_bit_supported],[
|
|
AC_RUN_IFELSE(
|
|
[AC_LANG_SOURCE([[
|
|
int
|
|
main (void)
|
|
{
|
|
volatile _Float16 hf = 1;
|
|
float f = hf; /* Ensure compiler can promote to float. */
|
|
return !(f == 1.0f);
|
|
}
|
|
]])
|
|
],[
|
|
utils_cv_ieee_16_bit_supported=yes
|
|
],[
|
|
utils_cv_ieee_16_bit_supported=no
|
|
],[
|
|
utils_cv_ieee_16_bit_supported=no
|
|
])])
|
|
AC_MSG_RESULT([$utils_cv_ieee_16_bit_supported])
|
|
if test $utils_cv_ieee_16_bit_supported = yes; then
|
|
AC_DEFINE([FLOAT16_SUPPORTED], [1], [IEEE 16 bit float supported])
|
|
fi
|
|
|
|
AC_MSG_CHECKING([Brain 16 bit floating point])
|
|
AC_CACHE_VAL([utils_cv_brain_16_bit_supported],[
|
|
AC_RUN_IFELSE(
|
|
[AC_LANG_SOURCE([[
|
|
int
|
|
main (void)
|
|
{
|
|
volatile __bf16 hf = 1;
|
|
float f = hf; /* Ensure compiler can promote to float. */
|
|
return !(f == 1.0f);
|
|
}
|
|
]])
|
|
],[
|
|
utils_cv_brain_16_bit_supported=yes
|
|
],[
|
|
utils_cv_brain_16_bit_supported=no
|
|
],[
|
|
utils_cv_brain_16_bit_supported=no
|
|
])])
|
|
AC_MSG_RESULT([$utils_cv_brain_16_bit_supported])
|
|
if test $utils_cv_brain_16_bit_supported = yes; then
|
|
AC_DEFINE([BF16_SUPPORTED], [1], [Brain 16 bit float supported])
|
|
fi
|
|
|
|
ac_save_CFLAGS=$CFLAGS
|
|
CFLAGS="-march=armv8-a+crypto $CFLAGS"
|
|
AC_MSG_CHECKING([if vmull intrinsic exists])
|
|
AC_CACHE_VAL([utils_cv_vmull_intrinsic_exists],[
|
|
AC_LINK_IFELSE(
|
|
[AC_LANG_SOURCE([[
|
|
#include <stdio.h>
|
|
#include <sys/auxv.h>
|
|
#include <asm/hwcap.h>
|
|
#include <arm_neon.h>
|
|
|
|
int
|
|
main (void)
|
|
{
|
|
uint64x2_t a;
|
|
poly64_t shift64 = vget_lane_p64(vcreate_p64(0xB8BC6765), 0);
|
|
a = vreinterpretq_u64_p128(vmull_p64(shift64, vreinterpretq_p128_u64(a)));
|
|
return (getauxval(AT_HWCAP) & HWCAP_PMULL) > 0;
|
|
}
|
|
]])
|
|
],[
|
|
utils_cv_vmull_intrinsic_exists=yes
|
|
],[
|
|
utils_cv_vmull_intrinsic_exists=no
|
|
])])
|
|
AC_MSG_RESULT([$utils_cv_vmull_intrinsic_exists])
|
|
if test $utils_cv_vmull_intrinsic_exists = yes; then
|
|
AC_DEFINE([USE_VMULL_CRC32], [1],
|
|
[CRC32 calculation by vmull hardware instruction enabled])
|
|
fi
|
|
AM_CONDITIONAL([USE_VMULL_CRC32],
|
|
[test $utils_cv_vmull_intrinsic_exists = yes])
|
|
CFLAGS=$ac_save_CFLAGS
|
|
|
|
ac_save_CFLAGS=$CFLAGS
|
|
CFLAGS="-mavx -mpclmul $CFLAGS"
|
|
AC_MSG_CHECKING([if pclmul intrinsic exists])
|
|
AC_CACHE_VAL([utils_cv_pclmul_intrinsic_exists],[
|
|
AC_LINK_IFELSE(
|
|
[AC_LANG_SOURCE([[
|
|
#include <x86intrin.h>
|
|
|
|
int
|
|
main (void)
|
|
{
|
|
__m128i a, b;
|
|
a = _mm_clmulepi64_si128 (a, b, 0x00);
|
|
a = _mm_shuffle_epi8 (a, b);
|
|
return __builtin_cpu_supports ("pclmul");
|
|
}
|
|
]])
|
|
],[
|
|
utils_cv_pclmul_intrinsic_exists=yes
|
|
],[
|
|
utils_cv_pclmul_intrinsic_exists=no
|
|
])])
|
|
AC_MSG_RESULT([$utils_cv_pclmul_intrinsic_exists])
|
|
if test $utils_cv_pclmul_intrinsic_exists = yes; then
|
|
AC_DEFINE([USE_PCLMUL_CRC32], [1],
|
|
[CRC32 calculation by pclmul hardware instruction enabled])
|
|
fi
|
|
AM_CONDITIONAL([USE_PCLMUL_CRC32],
|
|
[test $utils_cv_pclmul_intrinsic_exists = yes])
|
|
CFLAGS=$ac_save_CFLAGS
|
|
|
|
ac_save_CFLAGS=$CFLAGS
|
|
CFLAGS=" -mavx2 -mvpclmulqdq $CFLAGS"
|
|
AC_MSG_CHECKING([if avx2 pclmul intrinsic exists])
|
|
AC_CACHE_VAL([utils_cv_avx2_pclmul_intrinsic_exists],[
|
|
AC_LINK_IFELSE(
|
|
[AC_LANG_SOURCE([[
|
|
#include <x86intrin.h>
|
|
|
|
int
|
|
main (void)
|
|
{
|
|
__m256i a, b;
|
|
a = _mm256_clmulepi64_epi128 (a, b, 0x00);
|
|
a = _mm256_shuffle_epi8 (a, b);
|
|
return __builtin_cpu_supports ("avx2") &&
|
|
__builtin_cpu_supports ("vpclmulqdq");
|
|
}
|
|
]])
|
|
],[
|
|
utils_cv_avx2_pclmul_intrinsic_exists=yes
|
|
],[
|
|
utils_cv_avx2_pclmul_intrinsic_exists=no
|
|
])])
|
|
AC_MSG_RESULT([$utils_cv_avx2_pclmul_intrinsic_exists])
|
|
if test $utils_cv_avx2_pclmul_intrinsic_exists = yes; then
|
|
AC_DEFINE([USE_AVX2_CRC32], [1],
|
|
[CRC32 calculation by avx2 hardware instructions enabled])
|
|
fi
|
|
AM_CONDITIONAL([USE_AVX2_CRC32],
|
|
[test $utils_cv_avx2_pclmul_intrinsic_exists = yes])
|
|
CFLAGS=$ac_save_CFLAGS
|
|
|
|
ac_save_CFLAGS=$CFLAGS
|
|
CFLAGS=" -mavx512bw -mavx512f -mvpclmulqdq $CFLAGS"
|
|
AC_MSG_CHECKING([if avx512 pclmul intrinsic exists])
|
|
AC_CACHE_VAL([utils_cv_avx512_pclmul_intrinsic_exists],[
|
|
AC_LINK_IFELSE(
|
|
[AC_LANG_SOURCE([[
|
|
#include <x86intrin.h>
|
|
|
|
int
|
|
main (void)
|
|
{
|
|
__m512i a, b;
|
|
a = _mm512_set_epi8 (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
|
|
a = _mm512_clmulepi64_epi128 (a, b, 0x00);
|
|
a = _mm512_shuffle_epi8 (a, b);
|
|
return (__builtin_cpu_supports ("avx512bw")
|
|
&& __builtin_cpu_supports ("avx512f")
|
|
&& __builtin_cpu_supports ("vpclmulqdq"));
|
|
}
|
|
]])
|
|
],[
|
|
utils_cv_avx512_pclmul_intrinsic_exists=yes
|
|
],[
|
|
utils_cv_avx512_pclmul_intrinsic_exists=no
|
|
])])
|
|
AC_MSG_RESULT([$utils_cv_avx512_pclmul_intrinsic_exists])
|
|
if test $utils_cv_avx512_pclmul_intrinsic_exists = yes; then
|
|
AC_DEFINE([USE_AVX512_CRC32], [1],
|
|
[CRC32 calculation by avx512 hardware instructions enabled])
|
|
fi
|
|
AM_CONDITIONAL([USE_AVX512_CRC32],
|
|
[test $utils_cv_avx512_pclmul_intrinsic_exists = yes])
|
|
CFLAGS=$ac_save_CFLAGS
|
|
|
|
CFLAGS="-mavx2 $CFLAGS"
|
|
AC_MSG_CHECKING([for avx2 intrinsics])
|
|
AC_CACHE_VAL([utils_cv_avx2_intrinsic_exists],[
|
|
AC_LINK_IFELSE(
|
|
[AC_LANG_SOURCE([[
|
|
#include <x86intrin.h>
|
|
|
|
int
|
|
main (void)
|
|
{
|
|
__m256i matches = _mm256_setzero_si256 ();
|
|
int mask = _mm256_movemask_epi8 (matches);
|
|
int lines = __builtin_popcount (mask);
|
|
return __builtin_cpu_supports ("avx2");
|
|
}
|
|
]])
|
|
],[
|
|
utils_cv_avx2_intrinsic_exists=yes
|
|
],[
|
|
utils_cv_avx2_intrinsic_exists=no
|
|
])])
|
|
AC_MSG_RESULT([$utils_cv_avx2_intrinsic_exists])
|
|
if test $utils_cv_avx2_intrinsic_exists = yes; then
|
|
AC_DEFINE([USE_AVX2_WC_LINECOUNT], [1], [Counting lines with AVX2 enabled])
|
|
fi
|
|
AM_CONDITIONAL([USE_AVX2_WC_LINECOUNT],
|
|
[test $utils_cv_avx2_intrinsic_exists = yes])
|
|
|
|
CFLAGS=$ac_save_CFLAGS
|
|
|
|
CFLAGS="-mavx512bw -mavx512f $CFLAGS"
|
|
AC_MSG_CHECKING([for avx512 intrinsics])
|
|
AC_CACHE_VAL([utils_cv_avx512_intrinsic_exists],[
|
|
AC_LINK_IFELSE(
|
|
[AC_LANG_SOURCE([[
|
|
#include <x86intrin.h>
|
|
|
|
int
|
|
main (void)
|
|
{
|
|
__m512i matches = _mm512_setzero_si512 ();
|
|
long long mask = _mm512_movepi8_mask (matches);
|
|
int lines = __builtin_popcountll (mask);
|
|
return (__builtin_cpu_supports ("avx512bw")
|
|
&& __builtin_cpu_supports ("avx512f"));
|
|
}
|
|
]])
|
|
],[
|
|
utils_cv_avx512_intrinsic_exists=yes
|
|
],[
|
|
utils_cv_avx512_intrinsic_exists=no
|
|
])])
|
|
AC_MSG_RESULT([$utils_cv_avx512_intrinsic_exists])
|
|
if test $utils_cv_avx512_intrinsic_exists = yes; then
|
|
AC_DEFINE([USE_AVX512_WC_LINECOUNT], [1],
|
|
[Counting lines with AVX512 enabled])
|
|
fi
|
|
AM_CONDITIONAL([USE_AVX512_WC_LINECOUNT],
|
|
[test $utils_cv_avx512_intrinsic_exists = yes])
|
|
|
|
CFLAGS=$ac_save_CFLAGS
|
|
|
|
CFLAGS="-march=armv8-a+simd $CFLAGS"
|
|
AC_MSG_CHECKING([for neon intrinsics])
|
|
AC_CACHE_VAL([utils_cv_neon_intrinsic_exists],[
|
|
AC_LINK_IFELSE(
|
|
[AC_LANG_SOURCE([[
|
|
#include <sys/auxv.h>
|
|
#include <asm/hwcap.h>
|
|
#include <arm_neon.h>
|
|
|
|
int
|
|
main (void)
|
|
{
|
|
unsigned char buffer[128] = {0};
|
|
const uint8x16_t endlines = vdupq_n_u8 ('\n');
|
|
int8x16_t acc0 = vdupq_n_s8 (0);
|
|
uint8x16_t v0 = vld1q_u8 (buffer);
|
|
int8x16_t c0 = vreinterpretq_s8_u8 (vceqq_u8 (v0, endlines));
|
|
acc0 = vaddq_s8 (acc0, c0);
|
|
int16x8_t a0 = vpaddlq_s8 (acc0);
|
|
int32x4_t b0 = vpaddlq_s16 (a0);
|
|
int64x2_t c1 = vpaddlq_s32 (b0);
|
|
int lines = vgetq_lane_s64 (c1, 0) + vgetq_lane_s64 (c1, 1);
|
|
return lines && 0 < (getauxval (AT_HWCAP) & HWCAP_ASIMD);
|
|
}
|
|
]])
|
|
],[
|
|
utils_cv_neon_intrinsic_exists=yes
|
|
],[
|
|
utils_cv_neon_intrinsic_exists=no
|
|
])])
|
|
AC_MSG_RESULT([$utils_cv_neon_intrinsic_exists])
|
|
if test $utils_cv_neon_intrinsic_exists = yes; then
|
|
AC_DEFINE([USE_NEON_WC_LINECOUNT], [1], [Counting lines with Neon enabled])
|
|
fi
|
|
AM_CONDITIONAL([USE_NEON_WC_LINECOUNT],
|
|
[test $utils_cv_neon_intrinsic_exists = yes])
|
|
|
|
CFLAGS=$ac_save_CFLAGS
|
|
############################################################################
|
|
|
|
dnl Autogenerated by the 'gen-lists-of-programs.sh' auxiliary script.
|
|
dnl Issue proper calls to the macros gl_INCLUDE_EXCLUDE_PROG and
|
|
dnl gl_ADD_PROG (updating $optional_bin_progs), and generate the list
|
|
dnl of coreutils programs to be built only upon explicit user request,
|
|
dnl saving that list in the $no_install_progs_default shell variable.
|
|
m4_include([m4/cu-progs.m4])
|
|
|
|
# Now that we know which programs will actually be built, determine
|
|
# which optional helper progs should be compiled.
|
|
# Note it adding to pkglibexec_PROGRAMS, $(transform) in src/local.mk
|
|
# may need to be updated accordingly.
|
|
case " $optional_bin_progs " in
|
|
*' stdbuf '*) pkglibexec_PROGRAMS='src/libstdbuf.so';;
|
|
*) pkglibexec_PROGRAMS='';;
|
|
esac
|
|
|
|
man1_MANS=`
|
|
for p in $optional_bin_progs; do
|
|
# Change "ginstall.1" to "install.1".
|
|
test $p = ginstall && p=install
|
|
# Ignore the "[" program, since writing a portable make rule to
|
|
# generate its manpage is not practical.
|
|
dnl Use the autoconf-provided quadrigraph to represent "[",
|
|
dnl otherwise we will incur in dreadful quoting issues.
|
|
test x$p = x'@<:@' && continue
|
|
echo "man/$p.1"
|
|
done`
|
|
|
|
# Not installed by "make install", but must be built when creating
|
|
# a distribution tarball.
|
|
EXTRA_MANS=`for p in $no_install_progs_default $gl_no_install_prog; do
|
|
echo man/$p.1
|
|
done`
|
|
|
|
# Replace all the programs by the single binary and symlinks if specified.
|
|
single_binary_progs=
|
|
single_binary_libs=
|
|
single_binary_deps=
|
|
single_binary_install_type=
|
|
if test "$gl_single_binary" != no; then
|
|
man1_MANS="$man1_MANS man/coreutils.1"
|
|
# Convert the list to a space separated list
|
|
gl_single_binary_exceptions=`echo $gl_single_binary_exceptions | tr ',' ' '`
|
|
|
|
single_binary_progs=`echo $optional_bin_progs`
|
|
optional_bin_progs="coreutils"
|
|
for prog in $gl_single_binary_exceptions; do
|
|
# Fail if requested to exclude a program than was not part of coreutils.
|
|
case " $single_binary_progs " in
|
|
*" $prog "*)
|
|
gl_REMOVE_PROG([single_binary_progs], [$prog]) ;
|
|
gl_ADD_PROG([optional_bin_progs], [$prog]) ;;
|
|
*) AC_MSG_ERROR(['$prog' is not being compiled.]) ;;
|
|
esac
|
|
done
|
|
|
|
# single_binary_libs holds the list of libs required by the selected
|
|
# programs, such as for example -lrt.
|
|
single_binary_libs=`
|
|
for p in $single_binary_progs; do
|
|
# Convert '[' to '_'
|
|
test x"$p" = x'@<:@' && p='_'
|
|
printf '$(src_libsinglebin_%s_a_ldadd) ' "$p"
|
|
done`
|
|
# single_binary_deps holds the list of libsinglebin_*.a files that have the
|
|
# compiled code of each selected program in a "library" format.
|
|
single_binary_deps=`
|
|
for p in $single_binary_progs; do
|
|
# Convert '[' to '_'
|
|
test x"$p" = x'@<:@' && p='_'
|
|
printf 'src/libsinglebin_%s.a ' "$p"
|
|
done`
|
|
single_binary_install_type="$gl_single_binary"
|
|
fi
|
|
AC_SUBST([single_binary_progs], [$single_binary_progs])
|
|
AC_SUBST([single_binary_libs], [$single_binary_libs])
|
|
AC_SUBST([single_binary_deps], [$single_binary_deps])
|
|
AC_SUBST([single_binary_install_type], [$single_binary_install_type])
|
|
|
|
|
|
# The programs built and installed by "make && make install".
|
|
# Since this is AC_SUBST'd, Automake won't be able to perform rewrite
|
|
# with $(EXEEXT) appending on it, so we have to do it ourselves -- in
|
|
# this case, only for $(bin_PROGRAMS).
|
|
bin_PROGRAMS=`
|
|
for p in $optional_bin_progs; do echo src/"$p"'$(EXEEXT)'; done`
|
|
|
|
# Normalize whitespace.
|
|
man1_MANS=`echo $man1_MANS`
|
|
EXTRA_MANS=`echo $EXTRA_MANS`
|
|
bin_PROGRAMS=`echo $bin_PROGRAMS`
|
|
pkglibexec_PROGS=`echo $pkglibexec_PROGRAMS`
|
|
|
|
AC_SUBST([bin_PROGRAMS]) AM_SUBST_NOTMAKE([bin_PROGRAMS])
|
|
AC_SUBST([pkglibexec_PROGRAMS]) AM_SUBST_NOTMAKE([pkglibexec_PROGRAMS])
|
|
AC_SUBST([man1_MANS]) AM_SUBST_NOTMAKE([man1_MANS])
|
|
AC_SUBST([EXTRA_MANS]) AM_SUBST_NOTMAKE([EXTRA_MANS])
|
|
|
|
AC_SUBST([built_programs], [$optional_bin_progs])
|
|
|
|
AM_CONDITIONAL([CROSS_COMPILING], [test "$cross_compiling" = yes])
|
|
############################################################################
|
|
|
|
# As long as "grep 'PRI[diouxX]' po/*.pot" reports matches in
|
|
# translatable strings, we must use need-formatstring-macros here.
|
|
AM_GNU_GETTEXT([external], [need-formatstring-macros])
|
|
AM_GNU_GETTEXT_VERSION([0.19.2])
|
|
AM_CONDITIONAL([USE_NLS], [test "$USE_NLS" = yes])
|
|
|
|
# For a test of uniq: it uses the $LOCALE_FR envvar.
|
|
gt_LOCALE_FR
|
|
|
|
AC_CONFIG_FILES(
|
|
Makefile
|
|
po/Makefile.in
|
|
gnulib-tests/Makefile
|
|
)
|
|
AC_CONFIG_FILES([build-aux/makeinfo-wrapper.sh],
|
|
[chmod +x build-aux/makeinfo-wrapper.sh])
|
|
AC_OUTPUT
|