mirror of
https://git.savannah.gnu.org/git/emacs.git
synced 2024-09-02 09:45:31 +00:00
* build-aux/ndk-build-helper-1.mk: * build-aux/ndk-build-helper-2.mk: * build-aux/ndk-build-helper.mk: Do not generate file names with redundant directory separators, to port to systems where the semantics of this are undefined. * configure.ac: Provide a cache file to the recursive invocation of configure if one is specified for the initial. * cross/ndk-build/Makefile.in (my-dir): Better conform to the original ndk-build by generating directory names with no trailing separator. * m4/ndk-build.m4 (ndk_resolve_import_module, ndk_SEARCH_MODULE): Cache the names of Android.mk files and the commands produced from them.
8039 lines
268 KiB
Text
8039 lines
268 KiB
Text
dnl Autoconf script for GNU Emacs
|
||
dnl To rebuild the 'configure' script from this, execute the command
|
||
dnl autoconf
|
||
dnl in the directory containing this script.
|
||
dnl If you changed any AC_DEFINES, also run autoheader.
|
||
dnl
|
||
dnl Copyright (C) 1994-1996, 1999-2024 Free Software Foundation, Inc.
|
||
dnl
|
||
dnl This file is part of GNU Emacs.
|
||
dnl
|
||
dnl GNU Emacs is free software: you can redistribute it and/or modify
|
||
dnl it under the terms of the GNU General Public License as published by
|
||
dnl the Free Software Foundation, either version 3 of the License, or
|
||
dnl (at your option) any later version.
|
||
dnl
|
||
dnl GNU Emacs is distributed in the hope that it will be useful,
|
||
dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
dnl GNU General Public License for more details.
|
||
dnl
|
||
dnl You should have received a copy of the GNU General Public License
|
||
dnl along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
|
||
|
||
AC_PREREQ([2.65])
|
||
dnl Note this is parsed by (at least) make-dist and lisp/cedet/ede/emacs.el.
|
||
AC_INIT([GNU Emacs], [31.0.50], [bug-gnu-emacs@gnu.org], [],
|
||
[https://www.gnu.org/software/emacs/])
|
||
|
||
if test "$XCONFIGURE" = "android"; then
|
||
# configure is being called recursively to configure Emacs for
|
||
# Android!
|
||
AC_MSG_NOTICE([called to recursively configure Emacs for Android.])
|
||
# Set CC to ANDROID_CC and CFLAGS to ANDROID_CFLAGS.
|
||
CC=$ANDROID_CC
|
||
# Set -Wno-implicit-function-declaration. Building Emacs for older
|
||
# versions of Android requires configure tests to fail if the
|
||
# functions are not defined, as the Android library in the NDK
|
||
# defines subroutines that are not available in the headers being
|
||
# used.
|
||
CFLAGS="$ANDROID_CFLAGS -Werror=implicit-function-declaration"
|
||
# Don't explicitly enable support for large files unless Emacs is
|
||
# being built for API 21 or later. Otherwise, mmap does not work.
|
||
#
|
||
# Moreover, 64-bit variants of file IO functions in the C library are
|
||
# liable to fail with ENOSYS or EINVAL on earlier API versions, and as
|
||
# such their definitions must be explicitly disabled on NDK releases
|
||
# that enable them by default.
|
||
AS_IF([test "$ANDROID_SDK" -lt "21"], [
|
||
CFLAGS="$CFLAGS -D_FILE_OFFSET_BITS=32"
|
||
enable_largefile=no
|
||
enable_year2038=no])
|
||
fi
|
||
|
||
dnl Set emacs_config_options to the options of 'configure', quoted for the shell,
|
||
dnl and then quoted again for a C string. Separate options with spaces.
|
||
dnl Add some environment variables, if they were passed via the environment
|
||
dnl rather than on the command-line.
|
||
emacs_config_options=
|
||
optsep=
|
||
dnl This is the documented way to record the args passed to configure,
|
||
dnl rather than $ac_configure_args.
|
||
for opt in "$@" CFLAGS CPPFLAGS LDFLAGS; do
|
||
case $opt in
|
||
-n | --no-create | --no-recursion)
|
||
continue ;;
|
||
CFLAGS | CPPFLAGS | LDFLAGS)
|
||
eval 'test "${'$opt'+set}" = set' || continue
|
||
case " $*" in
|
||
*" $opt="*) continue ;;
|
||
esac
|
||
eval opt=$opt=\$$opt ;;
|
||
esac
|
||
|
||
emacs_shell_specials=$IFS\''"#$&()*;<>?@<:@\\`{|~'
|
||
case $opt in
|
||
*[["$emacs_shell_specials"]]*)
|
||
case $opt in
|
||
*\'*)
|
||
emacs_quote_apostrophes="s/'/'\\\\''/g"
|
||
opt=`AS_ECHO(["$opt"]) | sed "$emacs_quote_apostrophes"` ;;
|
||
esac
|
||
opt="'$opt'"
|
||
case $opt in
|
||
*[['"\\']]*)
|
||
emacs_quote_for_c='s/[["\\]]/\\&/g; $!s/$/\\n\\/'
|
||
opt=`AS_ECHO(["$opt"]) | sed "$emacs_quote_for_c"` ;;
|
||
esac ;;
|
||
esac
|
||
AS_VAR_APPEND([emacs_config_options], ["$optsep$opt"])
|
||
optsep=' '
|
||
done
|
||
|
||
AC_CONFIG_HEADERS([src/config.h:src/config.in])
|
||
AC_CONFIG_SRCDIR([src/lisp.h])
|
||
AC_CONFIG_AUX_DIR([build-aux])
|
||
AC_CONFIG_MACRO_DIR([m4])
|
||
|
||
xcsdkdir=
|
||
AC_CHECK_PROGS([XCRUN], [xcrun])
|
||
if test -n "$XCRUN"; then
|
||
if test -z "$MAKE"; then
|
||
dnl Call the variable MAKE_PROG, not MAKE, to avoid confusion with
|
||
dnl the usual MAKE variable that 'make' itself uses.
|
||
AC_CHECK_PROG([MAKE_PROG], [make], [yes])
|
||
if test -z "$MAKE_PROG"; then
|
||
MAKE="$XCRUN MAKE"
|
||
export MAKE
|
||
xcsdkdir=`$XCRUN --show-sdk-path 2>/dev/null`
|
||
fi
|
||
fi
|
||
fi
|
||
|
||
dnl Check for GNU Make and possibly set MAKE.
|
||
[emacs_check_gnu_make ()
|
||
{
|
||
emacs_makeout=`($1 --version) 2>/dev/null` &&
|
||
case $emacs_makeout in
|
||
'GNU Make '3.8[1-9]* | 'GNU Make '3.9[0-9]* | \
|
||
'GNU Make '3.[1-9][0-9][0-9]* | 'GNU Make '[4-9]* | 'GNU Make '[1-9][0-9]* )
|
||
ac_path_MAKE_found=:;;
|
||
esac
|
||
}]
|
||
AC_CACHE_CHECK([for GNU Make], [ac_cv_path_MAKE],
|
||
[ac_path_MAKE_found=false
|
||
if test -n "$MAKE"; then
|
||
emacs_check_gnu_make "$MAKE"
|
||
ac_cv_path_MAKE=$MAKE
|
||
else
|
||
emacs_tried_make=false
|
||
emacs_tried_gmake=false
|
||
emacs_tried_gnumake=false
|
||
AC_PATH_PROGS_FEATURE_CHECK([MAKE], [make gmake gnumake],
|
||
[[emacs_check_gnu_make "$ac_path_MAKE"
|
||
if $ac_path_MAKE_found; then
|
||
# Use the fully-qualified program name only if the basename
|
||
# would not resolve to it.
|
||
if eval \$emacs_tried_$ac_prog; then
|
||
ac_cv_path_MAKE=$ac_path_MAKE
|
||
else
|
||
ac_cv_path_MAKE=$ac_prog
|
||
fi
|
||
fi
|
||
eval emacs_tried_$ac_prog=:]])
|
||
fi])
|
||
$ac_path_MAKE_found || {
|
||
AC_MSG_ERROR([[Building Emacs requires GNU Make, at least version 3.81.
|
||
If you have it installed under another name, configure with 'MAKE=...'.
|
||
For example, run '$0 MAKE=gnu-make'.]])
|
||
}
|
||
MAKE=$ac_cv_path_MAKE
|
||
export MAKE
|
||
|
||
dnl Canonicalize the configuration name.
|
||
if test "$XCONFIGURE" = "android"; then
|
||
dnl Set host to whatever Android system Emacs is being configured
|
||
dnl for. Determine this by looking at the output of ANDROID_CC.
|
||
|
||
AC_MSG_CHECKING([the cross-compiler's target])
|
||
cc_target=`${CC} -v 2>&1 | sed -n 's/Target: //p'`
|
||
case "$cc_target" in
|
||
*android*) host_alias=$cc_target
|
||
;;
|
||
*) AC_MSG_ERROR([The cross compiler does not compile for Android.
|
||
Please verify that you specified the correct compiler in the ANDROID_CC
|
||
variable when you ran configure.])
|
||
;;
|
||
esac
|
||
AC_MSG_RESULT([$host_alias])
|
||
fi
|
||
|
||
AC_CANONICAL_HOST
|
||
AC_CANONICAL_BUILD
|
||
|
||
AS_IF([test "$XCONFIGURE" = "android"],[
|
||
# Initialize the Android NDK build system. Make sure to use the
|
||
# passed through NDK path.
|
||
# Make sure to pass through the CFLAGS, as older versions of the
|
||
# NDK require them to be able to find system includes.
|
||
with_ndk_path="$android_ndk_path"
|
||
with_ndk_cxx="$android_ndk_cxx"
|
||
ndk_INIT([$android_abi], [$ANDROID_SDK], [cross/ndk-build],
|
||
[$ANDROID_CFLAGS])
|
||
|
||
# At the same time, configure libexec with the build directory
|
||
# set to `exec'.
|
||
AS_MKDIR_P([exec])
|
||
|
||
# Enter exec and configure it, using the C compiler as both the
|
||
# assembler and the linker. Determine the absolute name of the
|
||
# source directory.
|
||
# N.B. that the linker is actually cc, so pass -nostdlib, lest
|
||
# the crt be linked in. Likewise for as.
|
||
|
||
AS_CASE([$srcdir], [.], [emacs_srcdir=`pwd`],
|
||
[[[\\/]* | ?:[\\/]*]], [emacs_srcdir=$srcdir],
|
||
[*], [emacs_srcdir=`pwd`/$srcdir])
|
||
|
||
AC_MSG_NOTICE([configuring in `exec'])
|
||
|
||
OLDCWD=`pwd`
|
||
cd exec
|
||
$CONFIG_SHELL $emacs_srcdir/exec/configure \
|
||
--host=$host "CC=$CC" "LD=$CC" "AS=$CC" \
|
||
"AR=$AR" "CFLAGS=$CFLAGS"
|
||
emacs_val=$?
|
||
cd $OLDCWD
|
||
|
||
AS_IF([test "$emacs_val" != "0"],
|
||
[AC_MSG_ERROR([failed to configure in `exec'])])
|
||
])
|
||
|
||
case $host in
|
||
*-mingw*)
|
||
|
||
if test -z "$host_alias"; then
|
||
|
||
# No --host argument was given to 'configure'; therefore $host
|
||
# was set to a default value based on the build platform. But
|
||
# this default value may be wrong if we are building from a
|
||
# 64-bit MSYS[2] pre-configured to build 32-bit MinGW programs.
|
||
# Therefore, we'll try to get the right host platform from the
|
||
# compiler's target.
|
||
|
||
AC_MSG_CHECKING([the compiler's target])
|
||
if test -z "$CC"; then
|
||
cc=gcc
|
||
else
|
||
cc=$CC
|
||
fi
|
||
cc_target=`$cc -v 2>&1 | sed -n 's/Target: //p'`
|
||
case "$cc_target" in
|
||
*-*) host=$cc_target
|
||
;;
|
||
"") AC_MSG_ERROR([Impossible to obtain $cc compiler target.
|
||
Please explicitly provide --host.])
|
||
;;
|
||
*) AC_MSG_WARN([Compiler reported non-standard target.
|
||
Defaulting to $host.])
|
||
;;
|
||
esac
|
||
AC_MSG_RESULT([$host])
|
||
fi
|
||
|
||
. $srcdir/nt/mingw-cfg.site
|
||
|
||
case $srcdir in
|
||
/* | ?:*)
|
||
# srcdir is an absolute path. In this case, force the format
|
||
# "/c/foo/bar", to simplify later conversions to native Windows
|
||
# format ("c:/foo/bar").
|
||
srcdir=`cd "${srcdir}" && pwd -W`
|
||
# 'eval' pacifies strict POSIX non-MinGW shells (Bug#18612).
|
||
# We downcase the drive letter to avoid warnings when
|
||
# generating autoloads.
|
||
eval 'srcdir=/`echo ${srcdir:0:1} | sed "y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/"`"${srcdir:2}"'
|
||
;;
|
||
esac;;
|
||
esac
|
||
|
||
canonical=$host
|
||
configuration=${host_alias-${build_alias-$host}}
|
||
emacs_uname_r=`uname -r`
|
||
|
||
dnl Support for --program-prefix, --program-suffix and
|
||
dnl --program-transform-name options
|
||
AC_ARG_PROGRAM
|
||
|
||
dnl It is important that variables on the RHS not be expanded here,
|
||
dnl hence the single quotes. This is per the GNU coding standards, see
|
||
dnl (autoconf) Installation Directory Variables
|
||
dnl See also epaths.h below.
|
||
lispdirrel='${version}/lisp'
|
||
lispdir='${datadir}/emacs/'${lispdirrel}
|
||
standardlisppath='${lispdir}'
|
||
locallisppath='${datadir}/emacs/${version}/site-lisp:'\
|
||
'${datadir}/emacs/site-lisp'
|
||
lisppath='${locallisppath}:${standardlisppath}'
|
||
etcdir='${datadir}/emacs/${version}/etc'
|
||
archlibdir='${libexecdir}/emacs/${version}/${configuration}'
|
||
etcdocdir='${datadir}/emacs/${version}/etc'
|
||
gamedir='${localstatedir}/games/emacs'
|
||
|
||
dnl Special option to disable the most of other options.
|
||
AC_ARG_WITH([all],
|
||
[AS_HELP_STRING([--without-all],
|
||
[omit almost all features and build
|
||
small executable with minimal dependencies])],
|
||
[with_features=$withval],
|
||
[with_features=yes])
|
||
|
||
dnl ARCH_INDEPENDENT_CONFIG_FILES(FILE...)
|
||
dnl Like AC_CONFIG_FILES(FILE). However, do not generate this
|
||
dnl if configure is being called recursively in preparation
|
||
dnl for cross-compilation.
|
||
AC_DEFUN([ARCH_INDEPENDENT_CONFIG_FILES], [
|
||
AS_IF([test "$XCONFIGURE" != "android"], [AC_CONFIG_FILES([$1])])])
|
||
|
||
dnl OPTION_DEFAULT_OFF(NAME, HELP-STRING)
|
||
dnl Create a new --with option that defaults to being disabled.
|
||
dnl NAME is the base name of the option. The shell variable with_NAME
|
||
dnl will be set to either the user's value (if the option is
|
||
dnl specified; 'yes' for a plain --with-NAME) or to 'no' (if the
|
||
dnl option is not specified). Note that the shell variable name is
|
||
dnl constructed as autoconf does, by replacing non-alphanumeric
|
||
dnl characters with "_".
|
||
dnl HELP-STRING is the help text for the option.
|
||
AC_DEFUN([OPTION_DEFAULT_OFF], [dnl
|
||
AC_ARG_WITH([$1],[AS_HELP_STRING([--with-$1],[$2])],[],[dnl
|
||
m4_bpatsubst([with_$1], [[^0-9a-z]], [_])=no])dnl
|
||
])dnl
|
||
|
||
dnl OPTION_DEFAULT_IFAVAILABLE(NAME, HELP-STRING)
|
||
dnl Create a new --with option that defaults to 'ifavailable',
|
||
dnl unless it is overridden by $with_features being equal to 'no'.
|
||
dnl NAME is the base name of the option. The shell variable with_NAME
|
||
dnl will be set to either the user's value (if the option is
|
||
dnl specified; 'yes' for a plain --with-NAME) or to 'ifavailable' (if the
|
||
dnl option is not specified). Note that the shell variable name is
|
||
dnl constructed as autoconf does, by replacing non-alphanumeric
|
||
dnl characters with "_".
|
||
dnl HELP-STRING is the help text for the option.
|
||
AC_DEFUN([OPTION_DEFAULT_IFAVAILABLE], [dnl
|
||
AC_ARG_WITH([$1],[AS_HELP_STRING([--with-$1],[$2])],[],[dnl
|
||
AS_IF([test "$with_features" != no],
|
||
[m4_bpatsubst([with_$1], [[^0-9a-z]], [_])=ifavailable],
|
||
[m4_bpatsubst([with_$1], [[^0-9a-z]], [_])=no])dnl
|
||
])dnl
|
||
])dnl
|
||
|
||
dnl OPTION_DEFAULT_ON(NAME, HELP-STRING)
|
||
dnl Create a new --with option that defaults to $with_features.
|
||
dnl NAME is the base name of the option. The shell variable with_NAME
|
||
dnl will be set either to 'no' (for a plain --without-NAME) or to
|
||
dnl 'yes' (if the option is not specified). Note that the shell
|
||
dnl variable name is constructed as autoconf does, by replacing
|
||
dnl non-alphanumeric characters with "_".
|
||
dnl HELP-STRING is the help text for the option.
|
||
AC_DEFUN([OPTION_DEFAULT_ON], [dnl
|
||
AC_ARG_WITH([$1],[AS_HELP_STRING([--without-$1],[$2])],[],[dnl
|
||
m4_bpatsubst([with_$1], [[^0-9a-z]], [_])=$with_features])dnl
|
||
])dnl
|
||
|
||
# For retrieving mail, unencrypted network connections are the default
|
||
# only on native MS-Windows platforms. (FIXME: These platforms should
|
||
# also be secure by default.)
|
||
|
||
AC_ARG_WITH([mailutils],
|
||
[AS_HELP_STRING([--with-mailutils],
|
||
[rely on GNU Mailutils, so that the --without-pop through --with-mailhost
|
||
options are irrelevant; this is the default if GNU Mailutils is
|
||
installed])],
|
||
[],
|
||
[AS_IF([test "$with_features" != "no"],
|
||
[with_mailutils=yes-unless-android
|
||
AS_IF([test "x$XCONFIGURE" != "xandroid"],
|
||
[(movemail --version) >/dev/null 2>&1 || with_mailutils=no],
|
||
[dnl Don't check for movemail if cross-compiling.
|
||
dnl instead, default to false.
|
||
with_mailutils=no])])])
|
||
|
||
AC_ARG_WITH([pop],
|
||
[AS_HELP_STRING([--with-pop],
|
||
[Support POP mail retrieval if Emacs movemail is used (not recommended,
|
||
as Emacs movemail POP is insecure). This is the default only on
|
||
native MS-Windows and Android.])],
|
||
[],
|
||
dnl Enable movemail POP support on Android as GNU Mailutils is
|
||
dnl normally unavailable on that platform.
|
||
[AS_CASE([$host],
|
||
[*-mingw*|*android*], [with_pop=yes],
|
||
[with_pop=no-by-default])])
|
||
if test "$with_pop" = yes; then
|
||
AC_DEFINE([MAIL_USE_POP])
|
||
fi
|
||
AH_TEMPLATE([MAIL_USE_POP], [Define to support POP mail retrieval.])dnl
|
||
|
||
OPTION_DEFAULT_OFF([kerberos],[support Kerberos-authenticated POP])
|
||
if test "$with_kerberos" != no; then
|
||
AC_DEFINE([KERBEROS])
|
||
fi
|
||
AH_TEMPLATE([KERBEROS],
|
||
[Define to support Kerberos-authenticated POP mail retrieval.])dnl
|
||
|
||
OPTION_DEFAULT_OFF([kerberos5],[support Kerberos version 5 authenticated POP])
|
||
if test "${with_kerberos5}" != no; then
|
||
if test "${with_kerberos}" = no; then
|
||
with_kerberos=yes
|
||
AC_DEFINE([KERBEROS])
|
||
fi
|
||
AC_DEFINE([KERBEROS5], [1],
|
||
[Define to use Kerberos 5 instead of Kerberos 4.])
|
||
fi
|
||
|
||
OPTION_DEFAULT_OFF([hesiod],[support Hesiod to get the POP server host])
|
||
dnl FIXME hesiod support may not be present, so it seems like an error
|
||
dnl to define, or at least use, this unconditionally.
|
||
if test "$with_hesiod" != no; then
|
||
AC_DEFINE([HESIOD], [1],
|
||
[Define to support using a Hesiod database to find the POP server.])
|
||
fi
|
||
|
||
OPTION_DEFAULT_OFF([mail-unlink],[unlink, rather than empty, mail spool after reading])
|
||
if test "$with_mail_unlink" != no; then
|
||
AC_DEFINE([MAIL_UNLINK_SPOOL], [1],
|
||
[Define to unlink, rather than empty, mail spool after reading.])
|
||
fi
|
||
|
||
AC_ARG_WITH([mailhost],[AS_HELP_STRING([--with-mailhost=HOSTNAME],
|
||
[string giving default POP mail host])],
|
||
AC_DEFINE_UNQUOTED([MAILHOST], ["$withval"],
|
||
[String giving fallback POP mail host.]))
|
||
|
||
AC_ARG_WITH([sound],[AS_HELP_STRING([--with-sound=VALUE],
|
||
[compile with sound support (VALUE one of: yes, alsa, oss, bsd-ossaudio, no;
|
||
default yes). Only for GNU/Linux, FreeBSD, NetBSD, MinGW, Cygwin.])],
|
||
[ case "${withval}" in
|
||
yes|no|alsa|oss|bsd-ossaudio) val=$withval ;;
|
||
*) AC_MSG_ERROR(['--with-sound=$withval' is invalid;
|
||
this option's value should be 'yes', 'no', 'alsa', 'oss', or 'bsd-ossaudio'.])
|
||
;;
|
||
esac
|
||
with_sound=$val
|
||
],
|
||
[with_sound=$with_features])
|
||
|
||
AC_ARG_WITH([pdumper],
|
||
AS_HELP_STRING(
|
||
[--with-pdumper=VALUE],
|
||
[enable pdumper support unconditionally
|
||
('yes', 'no', or 'auto': default 'auto')]),
|
||
[ case "${withval}" in
|
||
yes|no|auto) val=$withval ;;
|
||
*) AC_MSG_ERROR(
|
||
['--with-pdumper=$withval' is invalid;
|
||
this option's value should be 'yes' or 'no'.]) ;;
|
||
esac
|
||
with_pdumper=$val
|
||
],
|
||
[with_pdumper=auto])
|
||
|
||
AC_ARG_WITH([unexec],
|
||
AS_HELP_STRING(
|
||
[--with-unexec=VALUE],
|
||
[enable unexec support unconditionally
|
||
('yes', 'no', or 'auto': default 'auto')]),
|
||
[ case "${withval}" in
|
||
yes|no|auto) val=$withval ;;
|
||
*) AC_MSG_ERROR(
|
||
['--with-unexec=$withval' is invalid;
|
||
this option's value should be 'yes' or 'no'.]) ;;
|
||
esac
|
||
with_unexec=$val
|
||
],
|
||
[with_unexec=auto])
|
||
|
||
AC_ARG_WITH([dumping],[AS_HELP_STRING([--with-dumping=VALUE],
|
||
[kind of dumping to use for initial Emacs build
|
||
(VALUE one of: pdumper, unexec, none; default pdumper)])],
|
||
[ case "${withval}" in
|
||
pdumper|unexec|none) val=$withval ;;
|
||
*) AC_MSG_ERROR(['--with-dumping=$withval is invalid;
|
||
this option's value should be 'pdumper', 'unexec', or 'none'.])
|
||
;;
|
||
esac
|
||
with_dumping=$val
|
||
],
|
||
[with_dumping=pdumper])
|
||
|
||
if test "$with_pdumper" = "auto"; then
|
||
if test "$with_dumping" = "pdumper"; then
|
||
with_pdumper=yes
|
||
else
|
||
with_pdumper=no
|
||
fi
|
||
fi
|
||
|
||
if test "$with_unexec" = "auto"; then
|
||
if test "$with_dumping" = "unexec"; then
|
||
with_unexec=yes
|
||
else
|
||
with_unexec=no
|
||
fi
|
||
fi
|
||
|
||
if test "$with_dumping" = "pdumper" && test "$with_pdumper" = "no"; then
|
||
AC_MSG_ERROR(['--with-dumping=pdumper' requires pdumper support])
|
||
fi
|
||
|
||
if test "$with_dumping" = "unexec" && test "$with_unexec" = "no"; then
|
||
AC_MSG_ERROR(['--with-dumping=unexec' requires unexec support])
|
||
fi
|
||
|
||
if test "$with_pdumper" = "yes"; then
|
||
AC_DEFINE([HAVE_PDUMPER], [1],
|
||
[Define to build with portable dumper support])
|
||
HAVE_PDUMPER=yes
|
||
else
|
||
HAVE_PDUMPER=no
|
||
fi
|
||
AC_SUBST([HAVE_PDUMPER])
|
||
|
||
DUMPING=$with_dumping
|
||
AC_SUBST([DUMPING])
|
||
|
||
dnl FIXME currently it is not the last.
|
||
dnl This should be the last --with option, because --with-x is
|
||
dnl added later on when we find the file name of X, and it's best to
|
||
dnl keep them together visually.
|
||
AC_ARG_WITH([x-toolkit],[AS_HELP_STRING([--with-x-toolkit=KIT],
|
||
[use an X toolkit (KIT one of: yes or gtk, gtk2, gtk3, lucid or athena, motif, no)])],
|
||
[ case "${withval}" in
|
||
y | ye | yes ) val=gtk ;;
|
||
n | no ) val=no ;;
|
||
l | lu | luc | luci | lucid ) val=lucid ;;
|
||
a | at | ath | athe | athen | athena ) val=athena ;;
|
||
m | mo | mot | moti | motif ) val=motif ;;
|
||
g | gt | gtk ) val=gtk ;;
|
||
gtk2 ) val=gtk2 ;;
|
||
gtk3 ) val=gtk3 ;;
|
||
* )
|
||
AC_MSG_ERROR(['--with-x-toolkit=$withval' is invalid;
|
||
this option's value should be 'yes', 'no', 'lucid', 'athena', 'motif', 'gtk',
|
||
'gtk2' or 'gtk3'. 'yes' and 'gtk' are synonyms.
|
||
'athena' and 'lucid' are synonyms.])
|
||
;;
|
||
esac
|
||
with_x_toolkit=$val
|
||
])
|
||
|
||
OPTION_DEFAULT_OFF([wide-int],
|
||
[prefer wide Emacs integers (typically 62-bit);
|
||
on 32-bit hosts, this allows buffer and string size up to 2GB,
|
||
at the cost of 10% to 30% slowdown of Lisp interpreter
|
||
and larger memory footprint])
|
||
if test "$with_wide_int" = yes; then
|
||
AC_DEFINE([WIDE_EMACS_INT], [1], [Use long long for EMACS_INT if available.])
|
||
fi
|
||
|
||
dnl _ON results in a '--without' option in the --help output, so
|
||
dnl the help text should refer to "don't compile", etc.
|
||
with_xpm_set=${with_xpm+set}
|
||
OPTION_DEFAULT_ON([xpm],[don't compile with XPM image support])
|
||
OPTION_DEFAULT_ON([jpeg],[don't compile with JPEG image support])
|
||
OPTION_DEFAULT_ON([tiff],[don't compile with TIFF image support])
|
||
OPTION_DEFAULT_ON([gif],[don't compile with GIF image support])
|
||
OPTION_DEFAULT_ON([png],[don't compile with PNG image support])
|
||
OPTION_DEFAULT_ON([rsvg],[don't compile with SVG image support])
|
||
OPTION_DEFAULT_ON([webp],[don't compile with WebP image support])
|
||
OPTION_DEFAULT_ON([sqlite3],[don't compile with sqlite3 support])
|
||
OPTION_DEFAULT_ON([lcms2],[don't compile with Little CMS support])
|
||
OPTION_DEFAULT_ON([libsystemd],[don't compile with libsystemd support])
|
||
OPTION_DEFAULT_ON([cairo],[don't compile with Cairo drawing])
|
||
OPTION_DEFAULT_OFF([cairo-xcb], [use XCB surfaces for Cairo support])
|
||
OPTION_DEFAULT_ON([xml2],[don't compile with XML parsing support])
|
||
OPTION_DEFAULT_OFF([imagemagick],[compile with ImageMagick image support])
|
||
OPTION_DEFAULT_ON([native-image-api], [don't use native image APIs (GDI+ on Windows)])
|
||
OPTION_DEFAULT_IFAVAILABLE([tree-sitter], [compile with tree-sitter])
|
||
|
||
OPTION_DEFAULT_ON([xft],[don't use XFT for anti aliased fonts])
|
||
OPTION_DEFAULT_ON([harfbuzz],[don't use HarfBuzz for text shaping])
|
||
OPTION_DEFAULT_ON([libotf],[don't use libotf for OpenType font support])
|
||
OPTION_DEFAULT_ON([m17n-flt],[don't use m17n-flt for text shaping])
|
||
|
||
OPTION_DEFAULT_ON([toolkit-scroll-bars],[don't use Motif/Xaw3d/GTK toolkit scroll bars])
|
||
OPTION_DEFAULT_ON([xaw3d],[don't use Xaw3d])
|
||
OPTION_DEFAULT_ON([xim],[at runtime, default X11 XIM to off])
|
||
OPTION_DEFAULT_ON([xdbe],[don't use X11 double buffering support])
|
||
AC_ARG_WITH([ns],[AS_HELP_STRING([--with-ns],
|
||
[use Nextstep (macOS Cocoa or GNUstep) windowing system.
|
||
On by default on macOS.])],[],[with_ns=maybe])
|
||
OPTION_DEFAULT_OFF([w32], [use native MS Windows GUI in a Cygwin build])
|
||
OPTION_DEFAULT_OFF([pgtk], [use GTK to support window systems other than X])
|
||
|
||
OPTION_DEFAULT_ON([gpm],[don't use -lgpm for mouse support on a GNU/Linux console])
|
||
OPTION_DEFAULT_ON([dbus],[don't compile with D-Bus support])
|
||
AC_ARG_WITH([gconf],[AS_HELP_STRING([--with-gconf],
|
||
[compile with Gconf support (Gsettings replaces this)])],[],
|
||
[if test $with_features = yes; then
|
||
with_gconf=maybe
|
||
else
|
||
with_gconf=no
|
||
fi])
|
||
OPTION_DEFAULT_ON([gsettings],[don't compile with GSettings support])
|
||
OPTION_DEFAULT_ON([selinux],[don't compile with SELinux support])
|
||
OPTION_DEFAULT_ON([gnutls],[don't use -lgnutls for SSL/TLS support])
|
||
OPTION_DEFAULT_ON([zlib],[don't compile with zlib decompression support])
|
||
OPTION_DEFAULT_ON([modules],[don't compile with dynamic modules support])
|
||
OPTION_DEFAULT_ON([threads],[don't compile with elisp threading support])
|
||
OPTION_DEFAULT_OFF([cygwin32-native-compilation],[use native compilation on 32-bit Cygwin])
|
||
OPTION_DEFAULT_ON([xinput2],[don't use version 2 of the X Input Extension for input])
|
||
OPTION_DEFAULT_OFF([small-ja-dic],[generate a smaller-size Japanese dictionary])
|
||
OPTION_DEFAULT_OFF([android],[cross-compile Android application package])
|
||
OPTION_DEFAULT_ON([android-debug],[don't build Emacs as a debug package on Android])
|
||
|
||
# Find out of Android support is enabled and mailutils has defaulted
|
||
# to `yes-unless-android'. Disable it if so.
|
||
|
||
AS_IF([test "x$with_mailutils" = "xyes-unless-android"],
|
||
[AS_IF([test "x$with_android" != "xno"],
|
||
[with_mailutils=no],
|
||
[with_mailutils=yes])])
|
||
|
||
# Clear with_mailutils if it's set to no.
|
||
|
||
AS_IF([test "$with_mailutils" = no],
|
||
[with_mailutils=])
|
||
|
||
AS_IF([test x"$with_mailutils" = xyes],
|
||
[AC_DEFINE([HAVE_MAILUTILS], [1],
|
||
[Define to 1 if Emacs was configured with mailutils])])
|
||
|
||
AC_SUBST([with_mailutils])
|
||
|
||
AC_ARG_WITH([shared-user-id],
|
||
[AS_HELP_STRING([--with-shared-user-id=ID],
|
||
[use the given shared user ID in Android builds])])
|
||
|
||
AC_ARG_WITH([file-notification],[AS_HELP_STRING([--with-file-notification=LIB],
|
||
[use a file notification library (LIB one of: yes, inotify, kqueue, gfile, w32, no)])],
|
||
[ case "${withval}" in
|
||
y | ye | yes ) val=yes ;;
|
||
n | no ) val=no ;;
|
||
i | in | ino | inot | inoti | inotif | inotify ) val=inotify ;;
|
||
k | kq | kqu | kque | kqueu | kqueue ) val=kqueue ;;
|
||
g | gf | gfi | gfil | gfile ) val=gfile ;;
|
||
w | w3 | w32 ) val=w32 ;;
|
||
* ) AC_MSG_ERROR(['--with-file-notification=$withval' is invalid;
|
||
this option's value should be 'yes', 'no', 'inotify', 'kqueue', 'gfile' or 'w32'.
|
||
'yes' is a synonym for 'w32' on MS-Windows, for 'no' on Nextstep,
|
||
otherwise for the first of 'inotify', 'kqueue' or 'gfile' that is usable.])
|
||
;;
|
||
esac
|
||
with_file_notification=$val
|
||
],
|
||
[with_file_notification=$with_features])
|
||
|
||
OPTION_DEFAULT_OFF([xwidgets],
|
||
[enable use of xwidgets in Emacs buffers (requires gtk3 or macOS Cocoa)])
|
||
|
||
OPTION_DEFAULT_OFF([be-app],
|
||
[enable use of Haiku's Application Kit as a window system])
|
||
|
||
OPTION_DEFAULT_OFF([be-cairo],
|
||
[enable use of cairo under Haiku's Application Kit])
|
||
|
||
## Makefile.in needs the cache file name.
|
||
AC_SUBST([cache_file])
|
||
|
||
## This is an option because I do not know if all info/man support
|
||
## compressed files, nor how to test if they do so.
|
||
OPTION_DEFAULT_ON([compress-install],
|
||
[don't compress some files (.el, .info, etc.) when installing. Equivalent to:
|
||
make GZIP_PROG= install])
|
||
|
||
AC_ARG_WITH([gameuser],
|
||
[AS_HELP_STRING([--with-gameuser=USER_OR_GROUP],
|
||
[user for shared game score files.
|
||
An argument prefixed by ':' specifies a group instead.])])
|
||
gameuser=
|
||
gamegroup=
|
||
case ${with_gameuser} in
|
||
'' | no) ;;
|
||
yes) gamegroup=games ;;
|
||
:*) gamegroup=${with_gameuser#:} ;;
|
||
*) gameuser=${with_gameuser} ;;
|
||
esac
|
||
|
||
AC_ARG_WITH([gnustep-conf],
|
||
[AS_HELP_STRING([--with-gnustep-conf=FILENAME],
|
||
[name of GNUstep configuration file to use on systems where the command
|
||
'gnustep-config' does not work; default $GNUSTEP_CONFIG_FILE, or
|
||
/etc/GNUstep/GNUstep.conf])])
|
||
test "X${with_gnustep_conf}" != X && test "${with_gnustep_conf}" != yes && \
|
||
GNUSTEP_CONFIG_FILE="${with_gnustep_conf}"
|
||
test "X$GNUSTEP_CONFIG_FILE" = "X" && \
|
||
GNUSTEP_CONFIG_FILE=/etc/GNUstep/GNUstep.conf
|
||
|
||
AC_ARG_ENABLE([ns-self-contained],
|
||
[AS_HELP_STRING([--disable-ns-self-contained],
|
||
[disable self contained build under NeXTstep])],
|
||
[EN_NS_SELF_CONTAINED=$enableval],
|
||
[EN_NS_SELF_CONTAINED=yes])
|
||
|
||
locallisppathset=no
|
||
AC_ARG_ENABLE([locallisppath],
|
||
[AS_HELP_STRING([--enable-locallisppath=PATH],
|
||
[directories Emacs should search for lisp files specific
|
||
to this site])],
|
||
[if test "${enableval}" = "no"; then
|
||
locallisppath=
|
||
elif test "${enableval}" != "yes"; then
|
||
locallisppath=${enableval} locallisppathset=yes
|
||
fi])
|
||
|
||
AC_ARG_ENABLE([checking],
|
||
[AS_HELP_STRING([--enable-checking@<:@=LIST@:>@],
|
||
[enable expensive checks. With LIST,
|
||
enable only specific categories of checks.
|
||
Categories are: all,yes,no.
|
||
Flags are: stringbytes, stringoverrun, stringfreelist,
|
||
structs, glyphs])],
|
||
[ac_checking_flags="${enableval}"],[])
|
||
IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="$IFS,"
|
||
CHECK_STRUCTS=false
|
||
for check in $ac_checking_flags
|
||
do
|
||
case $check in
|
||
# these set all the flags to specific states
|
||
yes) ac_enable_checking=1 ;;
|
||
no) ac_enable_checking= ;
|
||
CHECK_STRUCTS=false
|
||
ac_gc_check_stringbytes= ;
|
||
ac_gc_check_string_overrun= ;
|
||
ac_gc_check_string_free_list= ;
|
||
ac_glyphs_debug= ;;
|
||
all) ac_enable_checking=1 ;
|
||
CHECK_STRUCTS=true
|
||
ac_gc_check_stringbytes=1 ;
|
||
ac_gc_check_string_overrun=1 ;
|
||
ac_gc_check_string_free_list=1 ;
|
||
ac_glyphs_debug=1 ;;
|
||
# these enable particular checks
|
||
stringbytes) ac_gc_check_stringbytes=1 ;;
|
||
stringoverrun) ac_gc_check_string_overrun=1 ;;
|
||
stringfreelist) ac_gc_check_string_free_list=1 ;;
|
||
structs) CHECK_STRUCTS=true ;;
|
||
glyphs) ac_glyphs_debug=1 ;;
|
||
*) AC_MSG_ERROR([unknown check category $check]) ;;
|
||
esac
|
||
done
|
||
IFS="$ac_save_IFS"
|
||
|
||
# This environment variable is used to signal that checking should be
|
||
# enabled on Android. When that happens, simply enable checking for
|
||
# the cross-compiled Android binary.
|
||
|
||
AS_IF([test "x$XCONFIGURE" = "xandroid" \
|
||
&& test "x$android_enable_checking" = "xyes"],
|
||
[ac_enable_checking=yes])
|
||
|
||
# There is little point in enabling checking in the build machine if
|
||
# cross-compiling for Android.
|
||
AS_IF([test "$with_android" = no || test -n "$XCONFIGURE"],[
|
||
if test x$ac_enable_checking != x ; then
|
||
AC_DEFINE([ENABLE_CHECKING], [1],
|
||
[Define to 1 if expensive run-time data type and consistency checks are enabled.])
|
||
fi
|
||
if $CHECK_STRUCTS; then
|
||
AC_DEFINE([CHECK_STRUCTS], [1],
|
||
[Define this to check whether someone updated the portable dumper
|
||
code after changing the layout of a structure that it uses.
|
||
If you change one of these structures, check that the pdumper.c
|
||
code is still valid, and update the pertinent hash in pdumper.c
|
||
by manually copying the hash from the newly-generated dmpstruct.h.])
|
||
fi
|
||
AC_SUBST([CHECK_STRUCTS])
|
||
if test x$ac_gc_check_stringbytes != x ; then
|
||
AC_DEFINE([GC_CHECK_STRING_BYTES], [1],
|
||
[Define this temporarily to hunt a bug. If defined, the size of
|
||
strings is redundantly recorded in sdata structures so that it can
|
||
be compared to the sizes recorded in Lisp strings.])
|
||
fi
|
||
if test x$ac_gc_check_string_overrun != x ; then
|
||
AC_DEFINE([GC_CHECK_STRING_OVERRUN], [1],
|
||
[Define this to check for short string overrun.])
|
||
fi
|
||
if test x$ac_gc_check_string_free_list != x ; then
|
||
AC_DEFINE([GC_CHECK_STRING_FREE_LIST], [1],
|
||
[Define this to check the string free list.])
|
||
fi
|
||
if test x$ac_glyphs_debug != x ; then
|
||
AC_DEFINE([GLYPH_DEBUG], [1],
|
||
[Define this to enable glyphs debugging code.])
|
||
fi
|
||
],[AS_IF([test "x$ac_enable_checking" != x],
|
||
[android_enable_checking=yes
|
||
export android_enable_checking])])
|
||
|
||
dnl The name of this option is unfortunate. It predates, and has no
|
||
dnl relation to, the "sampling-based elisp profiler" added in 24.3.
|
||
dnl Actually, it stops it working.
|
||
dnl https://lists.gnu.org/r/emacs-devel/2012-11/msg00393.html
|
||
AC_ARG_ENABLE([profiling],
|
||
[AS_HELP_STRING([--enable-profiling],
|
||
[build emacs with low-level, gprof profiling support.
|
||
Mainly useful for debugging Emacs itself. May not work on
|
||
all platforms. Stops profiler.el working.])],
|
||
[ac_enable_profiling="${enableval}"],[])
|
||
if test x$ac_enable_profiling != x ; then
|
||
PROFILING_CFLAGS="-DPROFILING=1 -pg"
|
||
else
|
||
PROFILING_CFLAGS=
|
||
fi
|
||
AC_SUBST([PROFILING_CFLAGS])
|
||
|
||
AC_ARG_ENABLE([autodepend],
|
||
[AS_HELP_STRING([--enable-autodepend],
|
||
[automatically generate dependencies to .h-files.
|
||
Requires gcc, enabled if found.])],
|
||
[ac_enable_autodepend="${enableval}"],[ac_enable_autodepend=yes])
|
||
|
||
AC_ARG_ENABLE([gtk-deprecation-warnings],
|
||
[AS_HELP_STRING([--enable-gtk-deprecation-warnings],
|
||
[Show Gtk+/Gdk deprecation warnings for Gtk+ >= 3.0])],
|
||
[ac_enable_gtk_deprecation_warnings="${enableval}"],[])
|
||
|
||
BUILD_DETAILS=
|
||
AC_ARG_ENABLE([build-details],
|
||
[AS_HELP_STRING([--disable-build-details],
|
||
[Make the build more deterministic by omitting host
|
||
names, time stamps, etc. from the output.])],
|
||
[test "$enableval" = no && BUILD_DETAILS=--no-build-details])
|
||
AC_SUBST([BUILD_DETAILS])
|
||
|
||
# JAVA_PUSH_LINT(OPT)
|
||
# -------------------
|
||
# Check if javac supports the diagnostic flag -Xlint:OPT.
|
||
# If it does, add it to WARN_JAVAFLAGS.
|
||
|
||
AC_DEFUN([JAVA_PUSH_LINT],
|
||
[
|
||
AC_CACHE_CHECK([whether Java compiler accepts -Xlint:$1],
|
||
[emacs_cv_javac_knows_lint_$1],
|
||
AS_IF([rm -f conftest.class
|
||
cat << EOF > conftest.java
|
||
|
||
class conftest
|
||
{
|
||
|
||
}
|
||
|
||
EOF
|
||
("$JAVAC" -Xlint:$1 conftest.java 2>&AS_MESSAGE_LOG_FD) \
|
||
&& rm -f conftest.class], [emacs_cv_javac_knows_lint_$1=yes],
|
||
[emacs_cv_javac_knows_lint_$1=no]))
|
||
|
||
AS_IF([test "$emacs_cv_javac_knows_lint_$1" = "yes"],
|
||
[WARN_JAVAFLAGS="$WARN_JAVAFLAGS -Xlint:$1"])
|
||
])
|
||
|
||
# Start Android configuration. This is done in three steps:
|
||
|
||
# First, the SDK tools needed to build the Android package on the host
|
||
# are found.
|
||
|
||
# Then, configure is called inside itself with the NDK C and C++
|
||
# compilers, and the Makefiles generated, along with config.h, are
|
||
# renamed to end with .android.
|
||
|
||
# Finally, configure continues to configure the Emacs binary that will
|
||
# run on the host.
|
||
|
||
ANDROID=
|
||
JAVAC=
|
||
AAPT=
|
||
JARSIGNER=
|
||
APKSIGNER=
|
||
ZIPALIGN=
|
||
DX=
|
||
ANDROID_JAR=
|
||
ANDROID_ABI=
|
||
WARN_JAVAFLAGS=
|
||
ANDROID_SHARED_USER_ID=
|
||
ANDROID_SHARED_USER_NAME=
|
||
IS_D8_R8=
|
||
|
||
# This is a list of Makefiles that have alternative versions for
|
||
# Android.
|
||
android_makefiles="lib/Makefile lib/gnulib.mk lib-src/Makefile src/Makefile"
|
||
|
||
# This is whether or not to package mailutils into the executable.
|
||
emacs_use_mailutils=
|
||
|
||
AC_ARG_VAR([ANDROID_CC], [The Android C cross-compiler.])
|
||
AC_ARG_VAR([SDK_BUILD_TOOLS], [Name of directory holding Android SDK build-tools.])
|
||
AC_ARG_VAR([ANDROID_CFLAGS], [Flags given to the Android C cross-compiler.])
|
||
AC_ARG_VAR([JAVAC], [Java compiler path. Used for Android.])
|
||
AC_ARG_VAR([JARSIGNER], [Java package signer path. Used for Android.])
|
||
AC_ARG_VAR([APKSIGNER], [Android package signer path. Used for Android.])
|
||
AC_ARG_VAR([SDK_BUILD_TOOLS], [Path to the Android SDK build tools.])
|
||
AC_ARG_VAR([ZIP], [Path to the `zip' utility.])
|
||
|
||
if test "$with_android" = "yes"; then
|
||
AC_MSG_ERROR([Please specify the path to the Android.jar file, like so:
|
||
|
||
./configure --with-android=/path/to/android.jar
|
||
|
||
along with the path to the SDK build-tools (this is the directory with
|
||
tools such as aapt, dx, and aidl):
|
||
|
||
SDK_BUILD_TOOLS=/path/to/sdk-build-tools
|
||
|
||
The cross-compiler should then be specified:
|
||
|
||
ANDROID_CC=/path/to/armv7a-linux-androideabi19-clang
|
||
|
||
In addition, you may pass any special arguments to the cross-compiler
|
||
via the ANDROID_CFLAGS environment variable.])
|
||
elif test "$with_android" = "no" || test "$with_android" = ""; then
|
||
ANDROID=no
|
||
else
|
||
AC_CHECK_PROGS([JAVAC], [javac])
|
||
if test "$JAVAC" = ""; then
|
||
AC_MSG_ERROR([The Java compiler required to build Emacs was not found.
|
||
Please make sure `javac' can be found on your path, or alternatively specify
|
||
the path to your Java compiler before configuring Emacs, like so:
|
||
|
||
JAVAC=/opt/jdk/bin/javac ./configure --with-android])
|
||
fi
|
||
|
||
AC_CHECK_PROGS([JARSIGNER], [jarsigner])
|
||
if test "$JARSIGNER" = ""; then
|
||
AC_MSG_ERROR([The Java package signing utility was not found.
|
||
Please make sure `jarsigner' can be found on your path, or alternatively
|
||
specify its location before configuring Emacs, like so:
|
||
|
||
JARSIGNER=/opt/jdk/bin/jarsigner ./configure --with-android])
|
||
fi
|
||
|
||
AC_CACHE_CHECK([whether the Java compiler works],
|
||
[emacs_cv_working_javac],
|
||
AS_IF([rm -f conftest.class
|
||
cat << EOF > conftest.java
|
||
|
||
import android.app.Activity;
|
||
import android.os.Bundle;
|
||
|
||
class conftest extends Activity
|
||
{
|
||
@Override
|
||
public void
|
||
onCreate (Bundle savedInstanceState)
|
||
{
|
||
super.onCreate (savedInstanceState);
|
||
}
|
||
}
|
||
|
||
EOF
|
||
("$JAVAC" -classpath "$with_android" -target 1.7 -source 1.7 conftest.java \
|
||
-d . >&AS_MESSAGE_LOG_FD 2>&1) && test -s conftest.class && rm -f conftest.class],
|
||
[emacs_cv_working_javac=yes],
|
||
[emacs_cv_working_javac=no]))
|
||
|
||
if test "$emacs_cv_working_javac" = "no"; then
|
||
AC_MSG_ERROR([The Java compiler does not work, or you did not specify
|
||
a valid path to android.jar. See config.log for more details.])
|
||
fi
|
||
|
||
AC_CACHE_CHECK([whether android.jar is new enough],
|
||
[emacs_cv_android_u_or_later],
|
||
AS_IF([rm -f conftest.class
|
||
cat << EOF > conftest.java
|
||
|
||
import android.os.Build;
|
||
|
||
class conftest
|
||
{
|
||
private static int test = Build.VERSION_CODES.UPSIDE_DOWN_CAKE;
|
||
}
|
||
|
||
EOF
|
||
("$JAVAC" -classpath "$with_android" -target 1.7 -source 1.7 conftest.java \
|
||
-d . >&AS_MESSAGE_LOG_FD 2>&1) && test -s conftest.class && rm -f conftest.class],
|
||
[emacs_cv_android_u_or_later=yes],
|
||
[emacs_cv_android_u_or_later=no]))
|
||
|
||
if test "$emacs_cv_android_u_or_later" = "no"; then
|
||
AC_MSG_ERROR([Emacs must be built with an android.jar file produced for \
|
||
Android 14 (Upside Down Cake) or later.])
|
||
fi
|
||
|
||
dnl See if the Java compiler supports the `--release' option which
|
||
dnl makes it check for and prevent using features introduced after
|
||
dnl Java 1.7.
|
||
|
||
AC_CACHE_CHECK([whether javac accepts --release 7],
|
||
[emacs_cv_javac_release_7], AS_IF([rm -f conftest.class
|
||
cat << EOF > conftest.java
|
||
|
||
class conftest
|
||
{
|
||
|
||
}
|
||
|
||
EOF
|
||
("$JAVAC" --release 7 conftest.java 2>&AS_MESSAGE_LOG_FD) \
|
||
&& rm -f conftest.class],
|
||
[emacs_cv_javac_release_7=yes],
|
||
[emacs_cv_javac_release_7=no]))
|
||
|
||
if test "$emacs_cv_javac_release_7" = "yes"; then
|
||
WARN_JAVAFLAGS="$WARN_JAVAFLAGS --release 7"
|
||
else
|
||
dnl If not, just make sure the generated bytecode is correct.
|
||
WARN_JAVAFLAGS="$WARN_JAVAFLAGS -target 1.7 -source 1.7"
|
||
fi
|
||
|
||
dnl Enable some useful Java linting options.
|
||
JAVA_PUSH_LINT([deprecation])
|
||
JAVA_PUSH_LINT([cast])
|
||
JAVA_PUSH_LINT([divzero])
|
||
JAVA_PUSH_LINT([nonempty])
|
||
JAVA_PUSH_LINT([empty])
|
||
JAVA_PUSH_LINT([finally])
|
||
JAVA_PUSH_LINT([overrides])
|
||
JAVA_PUSH_LINT([path])
|
||
JAVA_PUSH_LINT([serial])
|
||
JAVA_PUSH_LINT([unchecked])
|
||
|
||
# Get the name of the android.jar file.
|
||
ANDROID_JAR="$with_android"
|
||
|
||
# Substitute this into java/Makefile.
|
||
AC_SUBST([WARN_JAVAFLAGS])
|
||
|
||
AC_PATH_PROGS([AAPT], [aapt], [], "${SDK_BUILD_TOOLS}:$PATH")
|
||
if test "$AAPT" = ""; then
|
||
AC_MSG_ERROR([The Android asset packaging tool was not found.
|
||
Please verify that the path to the SDK build tools you specified is correct])
|
||
fi
|
||
|
||
AC_PATH_PROGS([APKSIGNER], [apksigner], [], "${SDK_BUILD_TOOLS}:$PATH")
|
||
if test "$APKSIGNER" = ""; then
|
||
AC_MSG_ERROR([The Android package signing tool was not found.
|
||
Please verify that the path to the SDK build tools you specified is correct])
|
||
fi
|
||
|
||
AC_PATH_PROGS([D8], [d8], [], "${SDK_BUILD_TOOLS}:$PATH")
|
||
if test "D8" = ""; then
|
||
AC_MSG_ERROR([The Android dexer was not found.
|
||
Please verify that the path to the SDK build tools you specified is correct])
|
||
fi
|
||
|
||
# Locate any d8.jar within the SDK build tools directory. The R8
|
||
# optimizing compiler is also present in this bundle, and it generates
|
||
# far superior code.
|
||
emacs_val=`which $D8`
|
||
emacs_val=`AS_DIRNAME([$emacs_val])`/lib/d8.jar
|
||
AS_IF([test -f "$emacs_val"],
|
||
[AC_CACHE_CHECK([whether d8.jar coresident with d8 binary provides r8],
|
||
[emacs_cv_d8_provides_r8],
|
||
[AS_IF([java -cp "$emacs_val" com.android.tools.r8.R8 --help &>/dev/null],
|
||
[emacs_cv_d8_provides_r8=yes], [emacs_cv_d8_provides_r8=no])])])
|
||
AS_IF([test "$emacs_cv_d8_provides_r8" = "yes"],
|
||
# And substitute it for D8 if present.
|
||
[D8="java -cp $emacs_val com.android.tools.r8.R8"
|
||
IS_D8_R8=yes])
|
||
|
||
AC_PATH_PROGS([ZIPALIGN], [zipalign], [], "${SDK_BUILD_TOOLS}:$PATH")
|
||
if test "ZIPALIGN" = ""; then
|
||
AC_MSG_ERROR([The Android ZIP archive alignment utility was not found.
|
||
Please verify that the path to the SDK build tools you specified is correct]);
|
||
fi
|
||
|
||
dnl Now configure Emacs to generate binaries for Android. After the
|
||
dnl configuration completes, move the generated Makefiles.
|
||
|
||
if test "$ANDROID_CC" = ""; then
|
||
AC_MSG_ERROR([Please specify the path to the Android cross-compiler
|
||
for your machine. For example:
|
||
|
||
ANDROID_CC=/path/to/armv7a-linux-androideabi19-clang \\
|
||
./configure --with-android])
|
||
fi
|
||
|
||
dnl Obtain the cross compiler's target to find out where binaries go
|
||
dnl in the resulting package.
|
||
|
||
AC_MSG_CHECKING([for the kind of Android system Emacs is being built for])
|
||
cc_target=`${ANDROID_CC} -v 2>&1 | sed -n 's/Target: //p'`
|
||
case "$cc_target" in
|
||
[
|
||
*i[3-6]86*) android_abi=x86
|
||
;;
|
||
*x86_64*) android_abi=x86_64
|
||
;;
|
||
*aarch64*) android_abi=arm64-v8a
|
||
;;
|
||
*arm*v7a*) android_abi=armeabi-v7a
|
||
;;
|
||
*mips64*) android_abi=mips64
|
||
;;
|
||
*mips*) android_abi=mips
|
||
;;
|
||
*arm*) android_abi=armeabi
|
||
;;
|
||
]
|
||
*) AC_MSG_ERROR([configure could not determine the type of Android \
|
||
binary Emacs is being configured for. Please port this configure script \
|
||
to your Android system, or verify that you specified the correct compiler \
|
||
in the ANDROID_CC variable when you ran configure.
|
||
|
||
The compiler target is: $cc_target])
|
||
;;
|
||
esac
|
||
AC_MSG_RESULT([$android_abi])
|
||
|
||
ANDROID_ABI=$android_abi
|
||
|
||
dnl Obtain the minimum SDK version of the resulting Emacs binary
|
||
dnl built with this NDK.
|
||
|
||
ANDROID_MIN_SDK=8
|
||
AC_MSG_CHECKING([for the lowest Android version Emacs can run on])
|
||
[android_sdk=`echo "$cc_target" | grep -oE 'android([0-9][0-9]?)'`]
|
||
|
||
if test -n "$android_sdk"; then
|
||
android_sdk=`echo "$android_sdk" | sed -n 's/android//p'`
|
||
AC_MSG_RESULT([$android_sdk])
|
||
ANDROID_MIN_SDK=$android_sdk
|
||
else
|
||
# This is probably GCC.
|
||
[ cat << EOF > conftest.c
|
||
#include <android/api-level.h>
|
||
extern const char *foo;
|
||
|
||
int
|
||
main (void)
|
||
{
|
||
#if __ANDROID_API__ < 7
|
||
foo = "emacs_api_6";
|
||
#elif __ANDROID_API__ < 8
|
||
foo = "emacs_api_7";
|
||
#elif __ANDROID_API__ < 9
|
||
foo = "emacs_api_8";
|
||
#elif __ANDROID_API__ < 10
|
||
foo = "emacs_api_9";
|
||
#elif __ANDROID_API__ < 11
|
||
foo = "emacs_api_10";
|
||
#elif __ANDROID_API__ < 12
|
||
foo = "emacs_api_11";
|
||
#elif __ANDROID_API__ < 13
|
||
foo = "emacs_api_12";
|
||
#elif __ANDROID_API__ < 14
|
||
foo = "emacs_api_13";
|
||
#elif __ANDROID_API__ < 15
|
||
foo = "emacs_api_14";
|
||
#elif __ANDROID_API__ < 16
|
||
foo = "emacs_api_15";
|
||
#elif __ANDROID_API__ < 17
|
||
foo = "emacs_api_16";
|
||
#elif __ANDROID_API__ < 18
|
||
foo = "emacs_api_17";
|
||
#elif __ANDROID_API__ < 19
|
||
foo = "emacs_api_18";
|
||
#elif __ANDROID_API__ < 20
|
||
foo = "emacs_api_19";
|
||
#elif __ANDROID_API__ < 21
|
||
foo = "emacs_api_20";
|
||
#elif __ANDROID_API__ < 22
|
||
foo = "emacs_api_21";
|
||
#elif __ANDROID_API__ < 23
|
||
foo = "emacs_api_22";
|
||
#elif __ANDROID_API__ < 24
|
||
foo = "emacs_api_23";
|
||
#elif __ANDROID_API__ < 25
|
||
foo = "emacs_api_24";
|
||
#elif __ANDROID_API__ < 26
|
||
foo = "emacs_api_25";
|
||
#elif __ANDROID_API__ < 27
|
||
foo = "emacs_api_26";
|
||
#elif __ANDROID_API__ < 28
|
||
foo = "emacs_api_27";
|
||
#elif __ANDROID_API__ < 29
|
||
foo = "emacs_api_28";
|
||
#elif __ANDROID_API__ < 30
|
||
foo = "emacs_api_29";
|
||
#elif __ANDROID_API__ < 31
|
||
foo = "emacs_api_30";
|
||
#elif __ANDROID_API__ < 32
|
||
foo = "emacs_api_31";
|
||
#elif __ANDROID_API__ < 33
|
||
foo = "emacs_api_32";
|
||
#elif __ANDROID_API__ < 34
|
||
foo = "emacs_api_33";
|
||
#elif __ANDROID_API__ < 35
|
||
foo = "emacs_api_34";
|
||
#else
|
||
foo = "emacs_api_future";
|
||
#endif
|
||
}
|
||
EOF]
|
||
|
||
AC_CACHE_VAL([emacs_cv_android_api],
|
||
[$ANDROID_CC $ANDROID_CFLAGS -c conftest.c -o conftest.o \
|
||
&& emacs_cv_android_api=`grep -ao -E \
|
||
"emacs_api_([[0-9][0-9]]?|future)" conftest.o`])
|
||
android_sdk="$emacs_cv_android_api"
|
||
rm -rf conftest.c conftest.o
|
||
|
||
# If this version of the NDK requires __ANDROID_API__ to be
|
||
# specified, then complain to the user.
|
||
if test "$android_sdk" = "emacs_api_future"; then
|
||
AC_MSG_ERROR([The version of Android to build for was not specified.
|
||
You must tell the Android compiler what version of Android to build for,
|
||
by defining the __ANDROID_API__ preprocessor macro in ANDROID_CC, like so:
|
||
|
||
ANDROID_CC="/path/to/ndk/arm-linux-android-gcc -D__ANDROID_API__=8"])
|
||
fi
|
||
|
||
if test -n "$android_sdk"; then
|
||
android_sdk=`echo $android_sdk | sed -n 's/emacs_api_//p'`
|
||
AC_MSG_RESULT([$android_sdk])
|
||
ANDROID_MIN_SDK=$android_sdk
|
||
else
|
||
AC_MSG_RESULT([unknown ($cc_target); assuming 8])
|
||
AC_MSG_ERROR([configure could not determine the versions of Android \
|
||
a binary built with this compiler will run on. The generated application \
|
||
package will likely install on older systems but crash on startup.])
|
||
android_sdk=8
|
||
fi
|
||
fi
|
||
AC_SUBST([ANDROID_MIN_SDK])
|
||
|
||
# Now tell java/Makefile if Emacs is being built for Android 4.3 or
|
||
# earlier.
|
||
ANDROID_SDK_18_OR_EARLIER=
|
||
if test "$android_sdk" -le "18"; then
|
||
ANDROID_SDK_18_OR_EARLIER=yes
|
||
fi
|
||
AC_SUBST([ANDROID_SDK_18_OR_EARLIER])
|
||
|
||
# Likewise for Android 2.2.
|
||
ANDROID_SDK_8_OR_EARLIER=
|
||
if test "$android_sdk" -le "8"; then
|
||
ANDROID_SDK_8_OR_EARLIER=yes
|
||
AC_CHECK_PROGS([ZIP], [zip])
|
||
AS_IF([test -z "$ZIP"],
|
||
[AC_MSG_ERROR([The `zip' utility is required for generating \
|
||
packages targeting Android 2.2.])])
|
||
fi
|
||
AC_SUBST([ANDROID_SDK_8_OR_EARLIER])
|
||
AC_SUBST([ZIP])
|
||
|
||
# Save confdefs.h and config.log for now.
|
||
mv -f confdefs.h _confdefs.h
|
||
mv -f config.log _config.log
|
||
|
||
# Make sure these files are removed upon exit.
|
||
trap "rm -rf _confdefs.h _config.log" 0
|
||
|
||
# Figure out what --with-FOO options to pass through.
|
||
passthrough="$passthrough --with-png=$with_png"
|
||
passthrough="$passthrough --with-webp=$with_webp"
|
||
passthrough="$passthrough --with-gif=$with_gif"
|
||
passthrough="$passthrough --with-jpeg=$with_jpeg"
|
||
passthrough="$passthrough --with-xml2=$with_xml2"
|
||
passthrough="$passthrough --with-sqlite3=$with_sqlite3"
|
||
passthrough="$passthrough --with-gnutls=$with_gnutls"
|
||
passthrough="$passthrough --with-tiff=$with_tiff"
|
||
passthrough="$passthrough --with-selinux=$with_selinux"
|
||
passthrough="$passthrough --with-modules=$with_modules"
|
||
passthrough="$passthrough --with-tree-sitter=$with_tree_sitter"
|
||
passthrough="$passthrough --with-imagemagick=$with_imagemagick"
|
||
passthrough="$passthrough --with-lcms2=$with_lcms2"
|
||
passthrough="$passthrough --with-mailutils=$with_mailutils"
|
||
passthrough="$passthrough --with-pop=$with_pop"
|
||
passthrough="$passthrough --with-harfbuzz=$with_harfbuzz"
|
||
passthrough="$passthrough --with-threads=$with_threads"
|
||
passthrough="$passthrough --with-rsvg=$with_rsvg"
|
||
|
||
# Now pass through some checking-related options.
|
||
emacs_val="--enable-check-lisp-object-type=$enable_check_lisp_object_type"
|
||
passthrough="$passthrough $emacs_val"
|
||
|
||
# And derive a name for the recursive configure invocation's cache
|
||
# file if one should be specified for this.
|
||
AS_IF([test -n "$cache_file"],
|
||
[passthrough="$passthrough --cache-file=$cache_file.1"])
|
||
|
||
AS_IF([test "x$with_mailutils" = "xyes"], [emacs_use_mailutils=yes])
|
||
AC_SUBST([emacs_use_mailutils])
|
||
|
||
AS_IF([XCONFIGURE=android ANDROID_CC="$ANDROID_CC" \
|
||
ANDROID_SDK="$android_sdk" android_abi=$android_abi \
|
||
android_ndk_path="$with_ndk_path" \
|
||
android_ndk_cxx="$android_ndk_cxx" \
|
||
$CONFIG_SHELL $0 $passthrough], [],
|
||
[AC_MSG_ERROR([Failed to cross-configure Emacs for android.])])
|
||
|
||
# Now set ANDROID to yes.
|
||
ANDROID=yes
|
||
|
||
for makefile in $android_makefiles; do
|
||
AC_MSG_NOTICE([Generating $makefile.android])
|
||
mv -f "$makefile" "$makefile.android"
|
||
done
|
||
|
||
AC_MSG_NOTICE([Generating src/config.h.android])
|
||
mv -f src/config.h src/config.h.android
|
||
|
||
# Tell AndroidManifest.xml whether or not Emacs should be built
|
||
# debug.
|
||
ANDROID_DEBUGGABLE=false
|
||
if test "$with_android_debug" = "yes"; then
|
||
ANDROID_DEBUGGABLE=true
|
||
fi
|
||
AC_SUBST([ANDROID_DEBUGGABLE])
|
||
|
||
# Move confdefs.h back now that the recursive call to configure is
|
||
# complete.
|
||
mv -f _confdefs.h confdefs.h
|
||
|
||
# Move the Android config.log to config.log.android. */
|
||
mv -f config.log config.log.android
|
||
|
||
# And _config.log back.
|
||
mv -f _config.log config.log
|
||
fi
|
||
|
||
AC_SUBST([ANDROID])
|
||
AC_SUBST([JAVAC])
|
||
AC_SUBST([AAPT])
|
||
AC_SUBST([D8])
|
||
AC_SUBST([ZIPALIGN])
|
||
AC_SUBST([ANDROID_JAR])
|
||
AC_SUBST([ANDROID_ABI])
|
||
AC_SUBST([IS_D8_R8])
|
||
|
||
if test "$XCONFIGURE" = "android"; then
|
||
ANDROID=yes
|
||
|
||
# Enable cross compiling.
|
||
cross_compiling=yes
|
||
fi
|
||
|
||
AC_SUBST([XCONFIGURE])
|
||
|
||
if test "$ANDROID" = "yes"; then
|
||
# When --with-android is specified, almost all build options must be
|
||
# disabled, both within the recursive invocation of configure and
|
||
# outside.
|
||
with_xpm=no
|
||
|
||
# Some of these dependencies are now supported within Android, so
|
||
# they can be enabled.
|
||
if test "$XCONFIGURE" != "android"; then
|
||
with_png=no
|
||
with_webp=no
|
||
with_gif=no
|
||
with_jpeg=no
|
||
with_xml2=no
|
||
with_sqlite3=no
|
||
with_gnutls=no
|
||
with_tiff=no
|
||
with_selinux=no
|
||
with_modules=no
|
||
with_tree_sitter=no
|
||
with_imagemagick=no
|
||
with_lcms2=no
|
||
with_mailutils=no
|
||
with_pop=no
|
||
with_harfbuzz=no
|
||
with_native_compilation=no
|
||
with_threads=no
|
||
with_rsvg=no
|
||
fi
|
||
|
||
with_libsystemd=no
|
||
with_cairo=no
|
||
with_xft=no
|
||
with_libotf=no
|
||
with_gpm=no
|
||
with_dbus=no
|
||
with_gsettings=no
|
||
with_ns=no
|
||
|
||
# zlib is available in android.
|
||
fi
|
||
|
||
dnl This used to use changequote, but, apart from 'changequote is evil'
|
||
dnl per the autoconf manual, we can speed up autoconf somewhat by quoting
|
||
dnl the great gob of text. Thus it's not processed for possible expansion.
|
||
dnl Just make sure the brackets remain balanced.
|
||
dnl
|
||
dnl Since Emacs can't find matching pairs of quotes, boundaries are
|
||
dnl indicated by comments.
|
||
dnl quotation begins
|
||
[
|
||
|
||
### If you add support for a new configuration, add code to this
|
||
### switch statement to recognize your configuration name and select
|
||
### the appropriate opsys.
|
||
|
||
### As far as handling version numbers on operating systems is
|
||
### concerned, make sure things will fail in a fixable way. If
|
||
### /etc/MACHINES doesn't say anything about version numbers, be
|
||
### prepared to handle anything reasonably. If version numbers
|
||
### matter, be sure /etc/MACHINES says something about it.
|
||
|
||
opsys='' unported=no
|
||
case "${canonical}" in
|
||
|
||
## Android
|
||
*linux-android* )
|
||
opsys=android
|
||
;;
|
||
|
||
## GNU/Linux and similar ports
|
||
*-*-linux* )
|
||
opsys=gnu-linux
|
||
;;
|
||
|
||
## FreeBSD ports
|
||
*-*-freebsd* )
|
||
opsys=freebsd
|
||
;;
|
||
|
||
## DragonFly ports
|
||
*-*-dragonfly* )
|
||
opsys=dragonfly
|
||
;;
|
||
|
||
## FreeBSD kernel + glibc based userland
|
||
*-*-kfreebsd*gnu* )
|
||
opsys=gnu-kfreebsd
|
||
;;
|
||
|
||
## NetBSD ports
|
||
*-*-netbsd* )
|
||
opsys=netbsd
|
||
;;
|
||
|
||
## OpenBSD ports
|
||
*-*-openbsd* | *-*-mirbsd* )
|
||
opsys=openbsd
|
||
;;
|
||
|
||
## Apple Darwin / macOS
|
||
*-apple-darwin* )
|
||
case "${canonical}" in
|
||
*-apple-darwin[0-9].*) unported=yes ;;
|
||
i[3456]86-* | x86_64-* | arm-* | aarch64-* ) ;;
|
||
* ) unported=yes ;;
|
||
esac
|
||
opsys=darwin
|
||
## FIXME: Find a way to use Fink if available (Bug#11507).
|
||
;;
|
||
|
||
## Chromium Native Client
|
||
*-nacl )
|
||
opsys=nacl
|
||
;;
|
||
|
||
## Cygwin ports
|
||
*-*-cygwin )
|
||
opsys=cygwin
|
||
;;
|
||
|
||
## HP 9000 series 700 and 800, running HP/UX
|
||
hppa*-hp-hpux10.2* )
|
||
opsys=hpux10-20
|
||
;;
|
||
hppa*-hp-hpux1[1-9]* )
|
||
opsys=hpux11
|
||
CFLAGS="-D_INCLUDE__STDC_A1_SOURCE $CFLAGS"
|
||
;;
|
||
|
||
## IBM machines
|
||
rs6000-ibm-aix4.[23]* )
|
||
opsys=aix4-2
|
||
;;
|
||
powerpc-ibm-aix4.[23]* )
|
||
opsys=aix4-2
|
||
;;
|
||
rs6000-ibm-aix[56]* )
|
||
opsys=aix4-2
|
||
;;
|
||
powerpc-ibm-aix[5-9]* | powerpc-ibm-aix[1-9][0-9]* )
|
||
opsys=aix4-2
|
||
;;
|
||
|
||
## Solaris
|
||
*-*-solaris* | *-*-sunos*)
|
||
case "${canonical}" in
|
||
i[3456]86-*-* ) ;;
|
||
amd64-*-*|x86_64-*-*) ;;
|
||
sparc* ) ;;
|
||
* ) unported=yes ;;
|
||
esac
|
||
opsys=solaris
|
||
## Watch out for a compiler that we know will not work.
|
||
if [ "$CC" = /usr/ucb/cc ]; then
|
||
## /usr/ucb/cc doesn't work;
|
||
## we should find some other compiler that does work.
|
||
unset CC
|
||
fi
|
||
;;
|
||
|
||
## QNX Neutrino
|
||
*-nto-qnx* )
|
||
opsys=qnxnto
|
||
test -z "$CC" && CC=qcc
|
||
LDFLAGS="-N2M $LDFLAGS"
|
||
;;
|
||
|
||
*-haiku )
|
||
opsys=haiku
|
||
;;
|
||
|
||
## Intel 386 machines where we don't care about the manufacturer.
|
||
i[3456]86-*-* )
|
||
case "${canonical}" in
|
||
*-darwin* ) opsys=darwin ;;
|
||
*-mingw* )
|
||
opsys=mingw32
|
||
# MinGW overrides and adds some system headers in nt/inc.
|
||
# Also, GCC 14 turns on implicit-function-declaration
|
||
# error by default, which fails configure tests where our
|
||
# emulation of Posix headers defines only the minimal
|
||
# stuff we actually need.
|
||
GCC_TEST_OPTIONS="-I $srcdir/nt/inc -Wno-error=implicit-function-declaration"
|
||
;;
|
||
*-sysv4.2uw* ) opsys=unixware ;;
|
||
*-sysv5uw* ) opsys=unixware ;;
|
||
*-sysv5OpenUNIX* ) opsys=unixware ;;
|
||
## Otherwise, we'll fall through to the generic opsys code at the bottom.
|
||
esac
|
||
;;
|
||
|
||
# MinGW64
|
||
x86_64-*-* )
|
||
case "${canonical}" in
|
||
*-mingw* )
|
||
opsys=mingw32
|
||
# MinGW overrides and adds some system headers in nt/inc.
|
||
GCC_TEST_OPTIONS="-I $srcdir/nt/inc -Wno-error=implicit-function-declaration"
|
||
;;
|
||
## Otherwise, we'll fall through to the generic opsys code at the bottom.
|
||
esac
|
||
;;
|
||
|
||
* )
|
||
unported=yes
|
||
;;
|
||
esac
|
||
|
||
### If the code above didn't choose an operating system, just choose
|
||
### an operating system based on the configuration name. You really
|
||
### only want to use this when you have no idea what the right
|
||
### operating system is; if you know what operating systems a machine
|
||
### runs, it's cleaner to make it explicit in the case statement
|
||
### above.
|
||
if test x"${opsys}" = x; then
|
||
case "${canonical}" in
|
||
*-gnu* ) opsys=gnu ;;
|
||
* )
|
||
unported=yes
|
||
;;
|
||
esac
|
||
fi
|
||
|
||
]
|
||
dnl quotation ends
|
||
|
||
if test $unported = yes; then
|
||
AC_MSG_ERROR([Emacs does not support '${canonical}' systems.
|
||
If you think it should, please send a report to ${PACKAGE_BUGREPORT}.
|
||
Check 'etc/MACHINES' for recognized configuration names.])
|
||
fi
|
||
|
||
#### Choose a compiler.
|
||
|
||
dnl Don't bother to test for C89.
|
||
AC_DEFUN([_AC_PROG_CC_C89], [$2])
|
||
|
||
dnl Sets GCC=yes if using gcc.
|
||
AC_PROG_CC([gcc cc cl clang "$XCRUN gcc" "$XCRUN clang"])
|
||
|
||
if test -n "$XCRUN"; then
|
||
AC_CHECK_PROGS([AR], [ar "$XCRUN ar"])
|
||
test -n "$AR" && export AR
|
||
fi
|
||
|
||
dnl Emacs needs C99 or later.
|
||
gl_PROG_CC_C99
|
||
|
||
AC_PROG_CC_C_O
|
||
|
||
if test x$GCC = xyes; then
|
||
test "x$GCC_TEST_OPTIONS" != x && CC="$CC $GCC_TEST_OPTIONS"
|
||
fi
|
||
|
||
# Avoid gnulib's tests for -lcrypto, so that there's no static dependency on it.
|
||
AC_DEFUN([gl_CRYPTO_CHECK])
|
||
# Avoid gnulib's tests for HAVE_WORKING_O_NOATIME and HAVE_WORKING_O_NOFOLLOW,
|
||
# as we don't use them.
|
||
AC_DEFUN([gl_FCNTL_O_FLAGS])
|
||
# Avoid gnulib's test for pthread_sigmask.
|
||
funcs=
|
||
for func in $ac_func_list; do
|
||
test $func = pthread_sigmask || AS_VAR_APPEND([funcs], [" $func"])
|
||
done
|
||
ac_func_list=$funcs
|
||
# Emacs does not use the wchar or wctype-h modules.
|
||
AC_DEFUN([gt_TYPE_WINT_T],
|
||
[GNULIBHEADERS_OVERRIDE_WINT_T=0
|
||
AC_SUBST([GNULIBHEADERS_OVERRIDE_WINT_T])])
|
||
# Emacs does not need precise checks for the Solaris 10 MB_CUR_MAX bug.
|
||
AC_DEFUN_ONCE([gl_STDLIB_H],
|
||
[AC_REQUIRE([gl_STDLIB_H_DEFAULTS])
|
||
gl_NEXT_HEADERS([stdlib.h])])
|
||
# Emacs does not need to check for off64_t.
|
||
AC_DEFUN([gl_TYPE_OFF64_T],
|
||
[HAVE_OFF64_T=1
|
||
AC_SUBST([HAVE_OFF64_T])])
|
||
|
||
# Initialize gnulib right after choosing the compiler.
|
||
dnl Amongst other things, this sets AR and ARFLAGS.
|
||
gl_EARLY
|
||
|
||
# ndk_LATE must be enclosed in this conditional to prevent the
|
||
# AC_PROG_CXX it indirectly requires from being expanded at top level.
|
||
if test "$ndk_INITIALIZED" = "yes"; then
|
||
ndk_LATE_EARLY
|
||
ndk_LATE
|
||
fi
|
||
|
||
if test "$ac_test_CFLAGS" != set; then
|
||
# It's helpful to have C macros available to GDB, so prefer -g3 to -g
|
||
# if -g3 works and the user does not specify CFLAGS.
|
||
# This test must follow gl_EARLY; otherwise AC_LINK_IFELSE complains.
|
||
case $CFLAGS in
|
||
'-g')
|
||
emacs_g3_CFLAGS='-g3';;
|
||
'-g -O2')
|
||
emacs_g3_CFLAGS='-g3 -O2';;
|
||
*)
|
||
emacs_g3_CFLAGS='';;
|
||
esac
|
||
if test -n "$emacs_g3_CFLAGS"; then
|
||
emacs_save_CFLAGS=$CFLAGS
|
||
CFLAGS=$emacs_g3_CFLAGS
|
||
AC_CACHE_CHECK([whether $CC accepts $emacs_g3_CFLAGS],
|
||
[emacs_cv_prog_cc_g3],
|
||
[AC_LINK_IFELSE([AC_LANG_PROGRAM()],
|
||
[emacs_cv_prog_cc_g3=yes],
|
||
[emacs_cv_prog_cc_g3=no])])
|
||
if test $emacs_cv_prog_cc_g3 != yes; then
|
||
CFLAGS=$emacs_save_CFLAGS
|
||
fi
|
||
# Haiku also needs -gdwarf-2 because its GDB is too old
|
||
# to understand newer formats.
|
||
if test $opsys = mingw32 || test $opsys = haiku; then
|
||
CFLAGS="$CFLAGS -gdwarf-2"
|
||
fi
|
||
fi
|
||
|
||
case $CFLAGS in
|
||
*-O*) ;;
|
||
*)
|
||
# No optimization flag was inferred for this non-GCC compiler.
|
||
# Try -O. This is needed for xlc on AIX; see Bug#14258.
|
||
emacs_save_CFLAGS=$CFLAGS
|
||
test -z "$CFLAGS" || CFLAGS="$CFLAGS "
|
||
CFLAGS=${CFLAGS}-O
|
||
AC_CACHE_CHECK([whether $CC accepts -O],
|
||
[emacs_cv_prog_cc_o],
|
||
[AC_LINK_IFELSE([AC_LANG_PROGRAM()],
|
||
[emacs_cv_prog_cc_o=yes],
|
||
[emacs_cv_prog_cc_o=no])])
|
||
if test $emacs_cv_prog_cc_o != yes; then
|
||
CFLAGS=$emacs_save_CFLAGS
|
||
fi ;;
|
||
esac
|
||
fi
|
||
|
||
# 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])
|
||
]
|
||
)
|
||
|
||
# clang is unduly picky about some things.
|
||
AC_CACHE_CHECK([whether the compiler is clang], [emacs_cv_clang],
|
||
[AC_COMPILE_IFELSE(
|
||
[AC_LANG_PROGRAM([[
|
||
#ifndef __clang__
|
||
error "not clang";
|
||
#endif
|
||
]])],
|
||
[emacs_cv_clang=yes],
|
||
[emacs_cv_clang=no])])
|
||
|
||
AC_ARG_ENABLE([gcc-warnings],
|
||
[AS_HELP_STRING([--enable-gcc-warnings@<:@=TYPE@:>@],
|
||
[control generation of GCC warnings. The TYPE 'yes'
|
||
means to fail if any warnings are issued; 'warn-only'
|
||
means issue warnings without failing (default for
|
||
developer builds); 'no' means disable warnings
|
||
(default for non-developer builds).])],
|
||
[case $enableval in
|
||
yes|no|warn-only) ;;
|
||
*) AC_MSG_ERROR([bad value $enableval for gcc-warnings option]) ;;
|
||
esac
|
||
gl_gcc_warnings=$enableval],
|
||
[# By default, use 'warn-only' if it looks like the invoker of 'configure'
|
||
# is a developer as opposed to a builder. This is most likely true
|
||
# if GCC is recent enough and there is a .git directory or file;
|
||
# however, if there is also a .tarball-version file it is probably
|
||
# just a release imported into Git for patch management.
|
||
gl_gcc_warnings=no
|
||
AS_IF([test -d "$srcdir"/.git || test -f "$srcdir"/.git],
|
||
[AS_IF([test -f "$srcdir"/.tarball-version], [],
|
||
# Clang typically identifies itself as GCC 4.2 or something similar
|
||
# even if it is recent enough to accept the warnings we enable.
|
||
[AS_IF([test "$emacs_cv_clang" = yes],
|
||
[gl_gcc_warnings=warn-only],
|
||
[gl_GCC_VERSION_IFELSE([5], [3], [gl_gcc_warnings=warn-only])])])])])
|
||
|
||
NATIVE_COMPILATION_AOT=no
|
||
AC_ARG_WITH([native-compilation],
|
||
[AS_HELP_STRING([--with-native-compilation@<:@=TYPE@:>@],
|
||
[compile with Emacs Lisp native compiler support. The TYPE
|
||
'yes' (or empty) means to enable it and compile natively
|
||
preloaded Lisp files; 'no' means to disable it;
|
||
'aot' will make the build process compile all the Lisp
|
||
files in the tree natively ahead of time. (This will
|
||
usually be quite slow.)])],
|
||
[
|
||
case $withval in
|
||
aot)
|
||
withval=yes
|
||
NATIVE_COMPILATION_AOT=yes
|
||
;;
|
||
yes|no) ;;
|
||
*) AC_MSG_ERROR([bad value $withval for native-compilation option]) ;;
|
||
esac
|
||
with_native_compilation=$withval],
|
||
[with_native_compilation=default]
|
||
)
|
||
AC_SUBST([NATIVE_COMPILATION_AOT])
|
||
|
||
AC_ARG_ENABLE([check-lisp-object-type],
|
||
[AS_HELP_STRING([--enable-check-lisp-object-type],
|
||
[Enable compile time checks for the Lisp_Object data type,
|
||
which can catch some bugs during development.])])
|
||
if test "$enable_check_lisp_object_type" = yes; then
|
||
AC_DEFINE([CHECK_LISP_OBJECT_TYPE], [1],
|
||
[Define to enable compile-time checks for the Lisp_Object data type.])
|
||
fi
|
||
|
||
WERROR_CFLAGS=
|
||
# When compiling with GCC, prefer -isystem to -I when including system
|
||
# include files, to avoid generating useless diagnostics for the files.
|
||
AS_IF([test $gl_gcc_warnings = no],
|
||
[
|
||
isystem='-I'
|
||
AS_IF([test "$emacs_cv_clang" = yes],
|
||
[
|
||
# Turn off some warnings if supported.
|
||
gl_WARN_ADD([-Wno-pointer-sign])
|
||
gl_WARN_ADD([-Wno-string-plus-int])
|
||
gl_WARN_ADD([-Wno-unknown-attributes])
|
||
gl_WARN_ADD([-Wno-unknown-pragmas])
|
||
])
|
||
],[
|
||
isystem='-isystem '
|
||
|
||
# This, $nw, is the list of warnings we disable.
|
||
nw=
|
||
|
||
case $with_x_toolkit in
|
||
lucid | athena | motif)
|
||
# Old toolkits mishandle 'const'.
|
||
nw="$nw -Wwrite-strings"
|
||
;;
|
||
esac
|
||
AS_IF([test $gl_gcc_warnings = yes],
|
||
[WERROR_CFLAGS=-Werror],
|
||
[# Use -fanalyzer and related options only if --enable-gcc-warnings,
|
||
# as they slow GCC considerably.
|
||
nw="$nw -fanalyzer -Wno-analyzer-double-free -Wno-analyzer-malloc-leak"
|
||
nw="$nw -Wno-analyzer-null-dereference -Wno-analyzer-use-after-free"
|
||
# Use -Wsuggest-attribute=malloc only if --enable-gcc-warnings,
|
||
# as it doesn't flag code that is wrong in any way.
|
||
nw="$nw -Wsuggest-attribute=malloc"])
|
||
|
||
nw="$nw -Wcast-align=strict" # Emacs is tricky with pointers.
|
||
nw="$nw -Wduplicated-branches" # Too many false alarms
|
||
nw="$nw -Wformat-overflow=2" # False alarms due to GCC bug 110333
|
||
nw="$nw -Wsystem-headers" # Don't let system headers trigger warnings
|
||
nw="$nw -Woverlength-strings" # Not a problem these days
|
||
nw="$nw -Wvla" # Emacs uses <vla.h>.
|
||
nw="$nw -Wunused-const-variable=2" # lisp.h declares const objects.
|
||
nw="$nw -Winline" # OK to ignore 'inline'
|
||
nw="$nw -Wstrict-overflow" # OK to optimize assuming that
|
||
# signed overflow has undefined behavior
|
||
nw="$nw -Wsync-nand" # irrelevant here, and provokes ObjC warning
|
||
nw="$nw -Wunsafe-loop-optimizations" # OK to suppress unsafe optimizations
|
||
nw="$nw -Wbad-function-cast" # These casts are no worse than others.
|
||
|
||
# Emacs doesn't care about shadowing; see
|
||
# <https://lists.gnu.org/r/emacs-diffs/2011-11/msg00265.html>.
|
||
nw="$nw -Wshadow"
|
||
|
||
# Emacs's use of alloca inhibits protecting the stack.
|
||
nw="$nw -Wstack-protector"
|
||
|
||
# Emacs's use of __attribute__ ((cold)) causes false alarms with this option.
|
||
nw="$nw -Wsuggest-attribute=cold"
|
||
|
||
# Emacs's use of partly-const functions such as Fgnutls_available_p
|
||
# make this option problematic.
|
||
nw="$nw -Wsuggest-attribute=const"
|
||
|
||
# Emacs's use of partly-pure functions such as CHECK_TYPE make this
|
||
# option problematic.
|
||
nw="$nw -Wsuggest-attribute=pure"
|
||
|
||
# Emacs doesn't need this paranoia.
|
||
nw="$nw -Wbidi-chars=any,ucn"
|
||
|
||
if test "$emacs_cv_clang" = yes; then
|
||
nw="$nw -Wdouble-promotion"
|
||
nm="$nm -Wunknown-pragmas"
|
||
fi
|
||
|
||
# This causes too much noise in the MinGW build.
|
||
if test $opsys = mingw32; then
|
||
nw="$nw -Wsuggest-attribute=format"
|
||
fi
|
||
|
||
# If Emacs is being built for Android and many functions are
|
||
# currently stubbed out for operation on the build machine, disable
|
||
# -Wsuggest-attribute=noreturn.
|
||
|
||
AS_IF([test "$ANDROID" = "yes"],
|
||
[nw="$nw -Wsuggest-attribute=noreturn"])
|
||
|
||
gl_MANYWARN_ALL_GCC([ws])
|
||
gl_MANYWARN_COMPLEMENT([ws], [$ws], [$nw])
|
||
for w in $ws; do
|
||
gl_WARN_ADD([$w])
|
||
done
|
||
gl_WARN_ADD([-Wredundant-decls]) # Prefer this, as we don't use Bison.
|
||
gl_WARN_ADD([-Wno-missing-field-initializers]) # We need this one
|
||
gl_WARN_ADD([-Wno-override-init]) # More trouble than it is worth
|
||
gl_WARN_ADD([-Wno-sign-compare]) # Too many warnings for now
|
||
gl_WARN_ADD([-Wno-type-limits]) # Too many warnings for now
|
||
gl_WARN_ADD([-Wno-unused-parameter]) # Too many warnings for now
|
||
gl_WARN_ADD([-Wno-format-nonliteral])
|
||
gl_WARN_ADD([-Wno-bidi-chars])
|
||
AS_IF([test $gl_gcc_warnings = yes],
|
||
[gl_WARN_ADD([-Wno-analyzer-fd-leak])]) # GCC bug 109839
|
||
|
||
# clang is unduly picky about some things.
|
||
if test "$emacs_cv_clang" = yes; then
|
||
gl_WARN_ADD([-Wno-bitwise-instead-of-logical])
|
||
gl_WARN_ADD([-Wno-missing-braces])
|
||
gl_WARN_ADD([-Wno-null-pointer-arithmetic])
|
||
gl_WARN_ADD([-Wno-implicit-const-int-float-conversion])
|
||
gl_WARN_ADD([-Wno-int-in-bool-context])
|
||
gl_WARN_ADD([-Wno-shift-overflow])
|
||
fi
|
||
|
||
# This causes too much noise in the MinGW build
|
||
if test $opsys = mingw32; then
|
||
gl_WARN_ADD([-Wno-pointer-sign])
|
||
fi
|
||
|
||
AC_DEFINE([GCC_LINT], [1], [Define to 1 if --enable-gcc-warnings.])
|
||
AS_IF([test $gl_gcc_warnings = yes],
|
||
[AC_DEFINE([GNULIB_PORTCHECK], [1], [enable some gnulib portability checks])
|
||
AH_VERBATIM([GNULIB_PORTCHECK_FORTIFY_SOURCE],
|
||
[/* Enable compile-time and run-time bounds-checking, and some warnings,
|
||
without upsetting glibc 2.15+. */
|
||
#if (defined GNULIB_PORTCHECK && !defined _FORTIFY_SOURCE \
|
||
&& defined __OPTIMIZE__ && __OPTIMIZE__)
|
||
# define _FORTIFY_SOURCE 2
|
||
#endif
|
||
])])
|
||
])
|
||
|
||
# clang is picky about these regardless of whether
|
||
# --enable-gcc-warnings is specified.
|
||
if test "$emacs_cv_clang" = yes; then
|
||
gl_WARN_ADD([-Wno-initializer-overrides])
|
||
gl_WARN_ADD([-Wno-tautological-compare])
|
||
gl_WARN_ADD([-Wno-tautological-constant-out-of-range-compare])
|
||
fi
|
||
|
||
# Suppress deprecation warnings from using sprintf variants,
|
||
# starting with Xcode 14.1 on macOS 13.
|
||
# These warnings are false alarms, as Emacs usage of sprintf is safe.
|
||
if test $opsys = darwin; then
|
||
gl_WARN_ADD([-Wno-deprecated-declarations])
|
||
fi
|
||
|
||
# Use a slightly smaller set of warning options for lib/.
|
||
nw=
|
||
nw="$nw -Wunused-macros"
|
||
gl_MANYWARN_COMPLEMENT([GNULIB_WARN_CFLAGS], [$WARN_CFLAGS], [$nw])
|
||
|
||
AC_SUBST([WERROR_CFLAGS])
|
||
AC_SUBST([GNULIB_WARN_CFLAGS])
|
||
|
||
edit_cflags="
|
||
s,///*,/,g
|
||
s/^/ /
|
||
s/ -I/ $isystem/g
|
||
s/^ //
|
||
"
|
||
|
||
AC_ARG_ENABLE([link-time-optimization],
|
||
[AS_HELP_STRING([--enable-link-time-optimization],
|
||
[build with link-time optimization
|
||
(experimental; see INSTALL)])],
|
||
if test "${enableval}" != "no"; then
|
||
ac_lto_supported=no
|
||
if test "$emacs_cv_clang" = yes; then
|
||
AC_MSG_CHECKING([whether link-time optimization is supported by clang])
|
||
GOLD_PLUGIN=`$CC -print-file-name=LLVMgold.so 2>/dev/null`
|
||
if test -x "$GOLD_PLUGIN"; then
|
||
LTO="-flto"
|
||
fi
|
||
elif test x$GCC = xyes; then
|
||
AC_MSG_CHECKING([whether link-time optimization is supported by gcc])
|
||
CPUS=`getconf _NPROCESSORS_ONLN 2>/dev/null`
|
||
if test x$CPUS != x; then
|
||
LTO="-flto=$CPUS"
|
||
else
|
||
LTO="-flto"
|
||
fi
|
||
else
|
||
AC_MSG_ERROR([Link-time optimization is not supported with your compiler.])
|
||
fi
|
||
if test -z "$LTO"; then
|
||
ac_lto_supported=no
|
||
else
|
||
old_CFLAGS=$CFLAGS
|
||
CFLAGS="$CFLAGS $LTO"
|
||
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
|
||
[ac_lto_supported=yes], [ac_lto_supported=no])
|
||
CFLAGS="$old_CFLAGS"
|
||
fi
|
||
AC_MSG_RESULT([$ac_lto_supported])
|
||
if test "$ac_lto_supported" = "yes"; then
|
||
CFLAGS="$CFLAGS $LTO"
|
||
if test "$emacs_cv_clang" = yes; then
|
||
AC_MSG_WARN([Please read INSTALL before using link-time optimization with clang])
|
||
# WARNING: 'ar --plugin ...' doesn't work without
|
||
# command, so plugin name is appended to ARFLAGS.
|
||
ARFLAGS="cru --plugin $GOLD_PLUGIN"
|
||
RANLIB="$RANLIB --plugin $GOLD_PLUGIN"
|
||
else
|
||
dnl The following is needed for GCC 4.9.0. The GCC 4.9.0 release notes
|
||
dnl suggest that instead of -ffat-lto-objects we should use gcc-ar and
|
||
dnl gcc-ranlib in place of ar and ranlib, but gcc-ar makes /usr/bin/ar
|
||
dnl dump core on Fedora 20, so play it safe for now.
|
||
gl_COMPILER_OPTION_IF([-ffat-lto-objects],
|
||
[CFLAGS="$CFLAGS -ffat-lto-objects"])
|
||
fi
|
||
fi
|
||
fi)
|
||
|
||
|
||
dnl Automake replacements.
|
||
AC_DEFUN([AM_CONDITIONAL],
|
||
[$2 && $1_CONDITION=1 || $1_CONDITION=
|
||
AC_SUBST([$1_CONDITION])])
|
||
AC_DEFUN([AM_COND_IF],
|
||
[AS_IF([test "$$1_CONDITION"], [$2], [$3])])
|
||
|
||
dnl Prefer silent make output. For verbose output, use
|
||
dnl 'configure --disable-silent-rules' or 'make V=1' .
|
||
AC_ARG_ENABLE([silent-rules],
|
||
[AS_HELP_STRING(
|
||
[--disable-silent-rules],
|
||
[verbose build output (undo: "make V=0")])])
|
||
if test "$enable_silent_rules" = no; then
|
||
AM_DEFAULT_VERBOSITY=1
|
||
else
|
||
AM_DEFAULT_VERBOSITY=0
|
||
fi
|
||
AC_SUBST([AM_DEFAULT_VERBOSITY])
|
||
ARCH_INDEPENDENT_CONFIG_FILES([src/verbose.mk])
|
||
|
||
dnl Some other nice autoconf tests.
|
||
AC_PROG_INSTALL
|
||
dnl These are commented out, since gl_EARLY and/or Autoconf already does them.
|
||
dnl AC_PROG_MKDIR_P
|
||
dnl if test "x$RANLIB" = x; then
|
||
dnl AC_PROG_RANLIB
|
||
dnl fi
|
||
|
||
|
||
dnl Sadly, AC_PROG_LN_S is too restrictive. It also tests whether links
|
||
dnl can be made to directories. This is not relevant for our usage, and
|
||
dnl excludes some cases that work fine for us. Eg MS Windows or files
|
||
dnl hosted on AFS, both examples where simple links work, but links to
|
||
dnl directories fail. We use a cut-down version instead.
|
||
dnl AC_PROG_LN_S
|
||
|
||
AC_CACHE_CHECK([command to symlink files in the same directory], [emacs_cv_ln_s_fileonly],
|
||
[rm -f conf$$ conf$$.file
|
||
|
||
emacs_cv_ln_s_fileonly='cp -p'
|
||
|
||
dnl On MinGW, ensure we will call the MSYS /bin/ln.exe, not some
|
||
dnl random program in the current directory.
|
||
if (echo >conf$$.file) 2>/dev/null; then
|
||
if test "$opsys" = "mingw32"; then
|
||
emacs_cv_ln_s_fileonly=/bin/ln
|
||
elif ln -s conf$$.file conf$$ 2>/dev/null; then
|
||
emacs_cv_ln_s_fileonly='ln -s'
|
||
elif ln conf$$.file conf$$ 2>/dev/null; then
|
||
emacs_cv_ln_s_fileonly=ln
|
||
fi
|
||
fi
|
||
|
||
rm -f conf$$ conf$$.file])
|
||
LN_S_FILEONLY=$emacs_cv_ln_s_fileonly
|
||
|
||
AC_SUBST([LN_S_FILEONLY])
|
||
|
||
|
||
dnl AC_PROG_LN_S sets LN_S to 'cp -pR' for MinGW, on the premise that 'ln'
|
||
dnl doesn't support links to directories, as in "ln file dir". But that
|
||
dnl use is non-portable, and OTOH MinGW wants to use hard links for Emacs
|
||
dnl executables at "make install" time.
|
||
dnl See https://lists.gnu.org/r/emacs-devel/2013-04/msg00475.html
|
||
dnl for more details.
|
||
if test "$opsys" = "mingw32"; then
|
||
LN_S="/bin/ln"
|
||
fi
|
||
|
||
dnl On some Debian versions, "install-info" prints irritating messages
|
||
dnl "This is not dpkg install-info anymore, but GNU install-info"
|
||
dnl if called via an absolute file name.
|
||
dnl Use the entirely-identical-but-quieter ginstall-info instead if present.
|
||
dnl Sadly some people may have an old ginstall-info installed on
|
||
dnl non-Debian systems, so we can't use this.
|
||
dnl AC_PATH_PROGS([INSTALL_INFO], [ginstall-info install-info], [:],
|
||
dnl [$PATH$PATH_SEPARATOR/usr/sbin$PATH_SEPARATOR/sbin])
|
||
|
||
AC_PATH_PROG([INSTALL_INFO], [install-info], [:],
|
||
[$PATH$PATH_SEPARATOR/usr/sbin$PATH_SEPARATOR/sbin])
|
||
dnl Don't use GZIP, which is used by gzip for additional parameters.
|
||
AC_PATH_PROG([GZIP_PROG], [gzip])
|
||
|
||
test $with_compress_install != yes && test -n "$GZIP_PROG" && \
|
||
GZIP_PROG=" # $GZIP_PROG # (disabled by configure --without-compress-install)"
|
||
|
||
if test "$with_dumping" = "unexec" && test "$opsys" = "nacl"; then
|
||
AC_MSG_ERROR([nacl is not compatible with --with-dumping=unexec])
|
||
fi
|
||
|
||
AC_CACHE_CHECK([for 'find' args to delete a file],
|
||
[emacs_cv_find_delete],
|
||
[if touch conftest.tmp && find conftest.tmp -delete 2>/dev/null &&
|
||
test ! -f conftest.tmp
|
||
then emacs_cv_find_delete="-delete"
|
||
else emacs_cv_find_delete="-exec rm -f {} ';'"
|
||
fi])
|
||
FIND_DELETE=$emacs_cv_find_delete
|
||
AC_SUBST([FIND_DELETE])
|
||
|
||
PAXCTL_dumped=
|
||
PAXCTL_notdumped=
|
||
if test $with_unexec = yes && test $opsys = gnu-linux; then
|
||
if test "${SETFATTR+set}" != set; then
|
||
AC_CACHE_CHECK([for setfattr],
|
||
[emacs_cv_prog_setfattr],
|
||
[touch conftest.tmp
|
||
if (setfattr -n user.pax.flags conftest.tmp) >/dev/null 2>&1; then
|
||
emacs_cv_prog_setfattr=yes
|
||
else
|
||
emacs_cv_prog_setfattr=no
|
||
fi])
|
||
if test "$emacs_cv_prog_setfattr" = yes; then
|
||
PAXCTL_notdumped='$(SETFATTR) -n user.pax.flags -v er'
|
||
SETFATTR=setfattr
|
||
else
|
||
SETFATTR=
|
||
fi
|
||
fi
|
||
case $opsys,$PAXCTL_notdumped,$emacs_uname_r in
|
||
gnu-linux,,* | netbsd,,[0-7].*)
|
||
AC_PATH_PROG([PAXCTL], [paxctl], [],
|
||
[$PATH$PATH_SEPARATOR/sbin$PATH_SEPARATOR/usr/sbin])
|
||
if test -n "$PAXCTL"; then
|
||
if test "$opsys" = netbsd; then
|
||
PAXCTL_dumped='$(PAXCTL) +a'
|
||
PAXCTL_notdumped=$PAXCTL_dumped
|
||
else
|
||
AC_MSG_CHECKING([whether binaries have a PT_PAX_FLAGS header])
|
||
AC_LINK_IFELSE([AC_LANG_PROGRAM([], [])],
|
||
[if $PAXCTL -v conftest$EXEEXT >/dev/null 2>&1; then
|
||
AC_MSG_RESULT([yes])
|
||
else
|
||
AC_MSG_RESULT([no])
|
||
PAXCTL=
|
||
fi])
|
||
if test -n "$PAXCTL"; then
|
||
PAXCTL_dumped='$(PAXCTL) -zex'
|
||
PAXCTL_notdumped='$(PAXCTL) -r'
|
||
fi
|
||
fi
|
||
fi;;
|
||
esac
|
||
fi
|
||
AC_SUBST([PAXCTL_dumped])
|
||
AC_SUBST([PAXCTL_notdumped])
|
||
AC_SUBST([SETFATTR])
|
||
|
||
# Makeinfo on macOS is ancient, check whether there is a more recent
|
||
# version installed by Homebrew.
|
||
AC_CHECK_PROGS([BREW], [brew])
|
||
if test -n "$BREW"; then
|
||
AC_PATH_PROG([MAKEINFO], [makeinfo], [],
|
||
[`$BREW --prefix texinfo 2>/dev/null`/bin$PATH_SEPARATOR$PATH])
|
||
fi
|
||
|
||
# Check MacPorts on macOS.
|
||
if test $opsys = darwin; then
|
||
AC_PATH_PROG([HAVE_MACPORTS], [port])
|
||
fi
|
||
|
||
## Require makeinfo >= 4.13 (last of the 4.x series) to build the manuals.
|
||
: ${MAKEINFO:=makeinfo}
|
||
case `($MAKEINFO --version) 2>/dev/null` in
|
||
*' (GNU texinfo) '4.1[[3-9]]* | \
|
||
*' (GNU texinfo) '[[5-9]]* | \
|
||
*' (GNU texinfo) '[[1-9][0-9]]* ) ;;
|
||
*) MAKEINFO=no;;
|
||
esac
|
||
|
||
## Makeinfo is unusual. For a released Emacs, the manuals are
|
||
## pre-built, and not deleted by the normal clean rules. makeinfo is
|
||
## therefore in the category of "special tools" not normally required, which
|
||
## configure does not have to check for (eg autoconf itself).
|
||
## In a repository checkout on the other hand, the manuals are not included.
|
||
## So makeinfo is a requirement to build from the repository, and configure
|
||
## should test for it as it does for any other build requirement.
|
||
## We use the presence of $srcdir/info/emacs to distinguish a release,
|
||
## with pre-built manuals, from a repository checkout.
|
||
if test "$MAKEINFO" = "no"; then
|
||
MAKEINFO=makeinfo
|
||
if test ! -e "$srcdir/info/emacs" && test ! -e "$srcdir/info/emacs.info"; then
|
||
AC_MSG_ERROR( [You do not seem to have makeinfo >= 4.13, and your
|
||
source tree does not seem to have pre-built manuals in the 'info' directory.
|
||
Please install a suitable version of makeinfo.] )
|
||
else
|
||
AC_MSG_WARN( [You do not seem to have makeinfo >= 4.13.
|
||
You will not be able to rebuild the manuals if you delete them or change
|
||
their sources.] )
|
||
fi
|
||
fi
|
||
AC_SUBST([MAKEINFO])
|
||
|
||
if test $opsys = mingw32; then
|
||
DOCMISC_W32=efaq-w32
|
||
else
|
||
DOCMISC_W32=
|
||
fi
|
||
AC_SUBST([DOCMISC_W32])
|
||
|
||
dnl Add our options to ac_link now, after it is set up.
|
||
|
||
if test x$GCC = xyes; then
|
||
test "x$GCC_LINK_TEST_OPTIONS" != x && \
|
||
ac_link="$ac_link $GCC_LINK_TEST_OPTIONS"
|
||
else
|
||
test "x$NON_GCC_LINK_TEST_OPTIONS" != x && \
|
||
ac_link="$ac_link $NON_GCC_LINK_TEST_OPTIONS"
|
||
fi
|
||
|
||
dnl On some platforms using GNU ld, linking temacs needs -znocombreloc.
|
||
dnl Although this has something to do with dumping, the details are unknown.
|
||
dnl If the flag is used but not needed,
|
||
dnl Emacs should still work (albeit a bit more slowly),
|
||
dnl so use the flag everywhere that it is supported.
|
||
dnl When testing whether the flag works, treat GCC specially
|
||
dnl since it just gives a non-fatal 'unrecognized option'
|
||
dnl if not built to support GNU ld.
|
||
if test "$GCC" = yes; then
|
||
LDFLAGS_NOCOMBRELOC="-Wl,-znocombreloc"
|
||
else
|
||
LDFLAGS_NOCOMBRELOC="-znocombreloc"
|
||
fi
|
||
|
||
AC_CACHE_CHECK([for -znocombreloc], [emacs_cv_znocombreloc],
|
||
[if test $with_unexec = no; then
|
||
emacs_cv_znocombreloc='not needed'
|
||
else
|
||
save_LDFLAGS=$LDFLAGS
|
||
LDFLAGS="$LDFLAGS $LDFLAGS_NOCOMBRELOC"
|
||
AC_LINK_IFELSE([AC_LANG_PROGRAM([], [])],
|
||
[emacs_cv_znocombreloc=yes], [emacs_cv_znocombreloc=no])
|
||
LDFLAGS=$save_LDFLAGS
|
||
fi])
|
||
|
||
case $emacs_cv_znocombreloc in
|
||
no*)
|
||
LDFLAGS_NOCOMBRELOC= ;;
|
||
esac
|
||
|
||
|
||
AC_CACHE_CHECK([whether addresses are sanitized],
|
||
[emacs_cv_sanitize_address],
|
||
[AC_COMPILE_IFELSE(
|
||
[AC_LANG_PROGRAM(
|
||
[[#ifndef __has_feature
|
||
#define __has_feature(f) 0
|
||
#endif
|
||
#if defined __SANITIZE_ADDRESS__ || __has_feature (address_sanitizer)
|
||
#else
|
||
error "Addresses are not sanitized.";
|
||
#endif
|
||
]])],
|
||
[emacs_cv_sanitize_address=yes],
|
||
[emacs_cv_sanitize_address=no])])
|
||
|
||
if test $with_unexec = yes; then
|
||
AC_DEFINE([HAVE_UNEXEC], [1], [Define if Emacs supports unexec.])
|
||
if test "$emacs_cv_sanitize_address" = yes; then
|
||
AC_MSG_WARN([[Addresses are sanitized; suggest --without-unexec]])
|
||
fi
|
||
fi
|
||
|
||
|
||
UNEXEC_OBJ=
|
||
test $with_unexec = yes &&
|
||
case "$opsys" in
|
||
# MSDOS uses unexcoff.o
|
||
aix4-2)
|
||
UNEXEC_OBJ=unexaix.o
|
||
;;
|
||
cygwin)
|
||
UNEXEC_OBJ=unexcw.o
|
||
;;
|
||
darwin)
|
||
UNEXEC_OBJ=unexmacosx.o
|
||
;;
|
||
hpux10-20 | hpux11)
|
||
UNEXEC_OBJ=unexhp9k800.o
|
||
;;
|
||
mingw32)
|
||
UNEXEC_OBJ=unexw32.o
|
||
;;
|
||
solaris)
|
||
# Use the Solaris dldump() function, called from unexsol.c, to dump
|
||
# emacs, instead of the generic ELF dump code found in unexelf.c.
|
||
# The resulting binary has a complete symbol table, and is better
|
||
# for debugging and other observability tools (debuggers, pstack, etc).
|
||
UNEXEC_OBJ=unexsol.o
|
||
;;
|
||
*)
|
||
UNEXEC_OBJ=unexelf.o
|
||
;;
|
||
esac
|
||
AC_SUBST([UNEXEC_OBJ])
|
||
|
||
LD_SWITCH_SYSTEM=
|
||
test "$with_unexec" = no || case "$opsys" in
|
||
freebsd|dragonfly)
|
||
## Let 'ld' find image libs and similar things in /usr/local/lib.
|
||
## The system compiler, GCC, has apparently been modified to not
|
||
## look there, contrary to what a stock GCC would do.
|
||
### It's not our place to do this. See bug#10313#17.
|
||
### LD_SWITCH_SYSTEM=-L/usr/local/lib
|
||
:
|
||
;;
|
||
|
||
gnu-linux)
|
||
## cpp test was "ifdef __mips__", but presumably this is equivalent...
|
||
case $host_cpu in mips*) LD_SWITCH_SYSTEM="-G 0";; esac
|
||
;;
|
||
|
||
netbsd)
|
||
### It's not our place to do this. See bug#10313#17.
|
||
### LD_SWITCH_SYSTEM="-Wl,-rpath,/usr/pkg/lib -L/usr/pkg/lib -Wl,-rpath,/usr/local/lib -L/usr/local/lib"
|
||
:
|
||
;;
|
||
|
||
openbsd)
|
||
## Han Boetes <han@boetes.org> says this is necessary,
|
||
## otherwise Emacs dumps core on elf systems.
|
||
LD_SWITCH_SYSTEM="-Z"
|
||
;;
|
||
esac
|
||
AC_SUBST([LD_SWITCH_SYSTEM])
|
||
|
||
ac_link="$ac_link $LD_SWITCH_SYSTEM"
|
||
|
||
## This setting of LD_SWITCH_SYSTEM references LD_SWITCH_X_SITE_RPATH,
|
||
## which has not been defined yet. When this was handled with cpp,
|
||
## it was expanded to null when configure sourced the s/*.h file.
|
||
## Thus LD_SWITCH_SYSTEM had different values in configure and the Makefiles.
|
||
## FIXME it would be cleaner to put this in LD_SWITCH_SYSTEM_TEMACS
|
||
## (or somesuch), but because it is supposed to go at the _front_
|
||
## of LD_SWITCH_SYSTEM, we cannot do that in exactly the same way.
|
||
## Compare with the gnu-linux case below, which added to the end
|
||
## of LD_SWITCH_SYSTEM, and so can instead go at the front of
|
||
## LD_SWITCH_SYSTEM_TEMACS.
|
||
case "$opsys" in
|
||
netbsd|openbsd)
|
||
LD_SWITCH_SYSTEM="\$(LD_SWITCH_X_SITE_RPATH) $LD_SWITCH_SYSTEM" ;;
|
||
esac
|
||
|
||
C_SWITCH_MACHINE=
|
||
|
||
test $with_unexec = yes &&
|
||
case $canonical in
|
||
alpha*)
|
||
## With ELF, make sure that all common symbols get allocated to in the
|
||
## data section. Otherwise, the dump of temacs may miss variables in
|
||
## the shared library that have been initialized. For example, with
|
||
## GNU libc, __malloc_initialized would normally be resolved to the
|
||
## shared library's .bss section, which is fatal.
|
||
if test "x$GCC" = "xyes"; then
|
||
C_SWITCH_MACHINE="-fno-common"
|
||
else
|
||
AC_MSG_ERROR([Non-GCC compilers are not supported.])
|
||
fi
|
||
;;
|
||
esac
|
||
AC_SUBST([C_SWITCH_MACHINE])
|
||
|
||
C_SWITCH_SYSTEM=
|
||
## Some programs in src produce warnings saying certain subprograms
|
||
## are too complex and need a MAXMEM value greater than 2000 for
|
||
## additional optimization. --nils@exp-math.uni-essen.de
|
||
test "$opsys" = "aix4.2" && test "x$GCC" != "xyes" && \
|
||
C_SWITCH_SYSTEM="-ma -qmaxmem=4000"
|
||
if test "$opsys" = "mingw32"; then
|
||
case "$canonical" in
|
||
x86_64-*-mingw*) C_SWITCH_SYSTEM="-mtune=generic" ;;
|
||
*) C_SWITCH_SYSTEM="-mtune=pentium4" ;;
|
||
esac
|
||
fi
|
||
## gnu-linux might need -D_BSD_SOURCE on old libc5 systems.
|
||
## It is redundant in glibc2, since we define _GNU_SOURCE.
|
||
AC_SUBST([C_SWITCH_SYSTEM])
|
||
|
||
|
||
LIBS_SYSTEM=
|
||
case "$opsys" in
|
||
## IBM's X11R5 uses -lIM and -liconv in AIX 3.2.2.
|
||
aix4-2) LIBS_SYSTEM="-lrts -lIM -liconv" ;;
|
||
|
||
freebsd|dragonfly) LIBS_SYSTEM="-lutil" ;;
|
||
|
||
hpux*) LIBS_SYSTEM="-l:libdld.sl" ;;
|
||
|
||
qnxnto) LIBS_SYSTEM="-lsocket" ;;
|
||
|
||
solaris) LIBS_SYSTEM="-lsocket -lnsl" ;;
|
||
|
||
## Motif needs -lgen.
|
||
unixware) LIBS_SYSTEM="-lsocket -lnsl -lelf -lgen" ;;
|
||
|
||
# Haiku needs -lbsd for cfsetspeed.
|
||
haiku) LIBS_SYSTEM="-lnetwork -lbsd" ;;
|
||
esac
|
||
|
||
AC_SUBST([LIBS_SYSTEM])
|
||
|
||
### Make sure subsequent tests use flags consistent with the build flags.
|
||
|
||
if test x"${OVERRIDE_CPPFLAGS}" != x; then
|
||
CPPFLAGS="${OVERRIDE_CPPFLAGS}"
|
||
else
|
||
CPPFLAGS="$C_SWITCH_SYSTEM $C_SWITCH_MACHINE $CPPFLAGS"
|
||
fi
|
||
|
||
# Suppress obsolescent Autoconf test for size_t; Emacs assumes C99 or better.
|
||
AC_DEFUN([AC_TYPE_SIZE_T])
|
||
# Likewise for obsolescent test for uid_t, gid_t; Emacs assumes them.
|
||
AC_DEFUN([AC_TYPE_UID_T])
|
||
ac_cv_type_gid_t=yes # AC_TYPE_GETGROUPS needs this in Autoconf 2.72.
|
||
|
||
# Check for all math.h functions that Emacs uses; on some platforms,
|
||
# -lm is needed for some of these functions.
|
||
AC_CACHE_CHECK([for math library],
|
||
[emacs_cv_lib_math],
|
||
[OLD_LIBS=$LIBS
|
||
AC_LINK_IFELSE(
|
||
[AC_LANG_SOURCE([[
|
||
#include <math.h>
|
||
int
|
||
main (int argc, char **argv)
|
||
{
|
||
double d = argc;
|
||
float f = argc;
|
||
int i = argc;
|
||
long l = argc;
|
||
d = acos (d);
|
||
d = asin (d);
|
||
d = atan (d);
|
||
d = atan2 (d, d);
|
||
d = ceil (d);
|
||
d = copysign (d, d);
|
||
d = cos (d);
|
||
d = exp (d);
|
||
d = fabs (d);
|
||
d = floor (d);
|
||
d = fmod (d, d);
|
||
d = frexp (d, &i);
|
||
d = ldexp (d, i);
|
||
d = log (d);
|
||
d = log10 (d);
|
||
d = pow (d, d);
|
||
d = rint (d);
|
||
d = scalbn (d, l);
|
||
d = sin (d);
|
||
d = sqrt (d);
|
||
d = tan (d);
|
||
d = trunc (d);
|
||
f = fabsf (f);
|
||
f = powf (f, f);
|
||
i = ilogb (d);
|
||
i = signbit (d);
|
||
l = lrint (d);
|
||
l = lround (d);
|
||
return d == f && i == l;
|
||
}
|
||
]])],
|
||
[emacs_cv_lib_math='none required'],
|
||
[LIBS="-lm $LIBS"
|
||
AC_LINK_IFELSE([],
|
||
[emacs_cv_lib_math=-lm],
|
||
[AC_MSG_ERROR([Math library (-lm) not found])])])
|
||
LIBS=$OLD_LIBS])
|
||
case $emacs_cv_lib_math in
|
||
-*) LIB_MATH=$emacs_cv_lib_math;;
|
||
*) LIB_MATH=;;
|
||
esac
|
||
|
||
dnl Current possibilities handled by sed (aix4-2 -> aix,
|
||
dnl gnu-linux -> gnu/linux, etc.):
|
||
dnl gnu, gnu/linux, gnu/kfreebsd, aix, cygwin, darwin, hpux.
|
||
dnl And special cases: berkeley-unix, usg-unix-v, ms-dos, windows-nt.
|
||
SYSTEM_TYPE=`echo $opsys | sed -e 's/[[0-9]].*//' -e 's|-|/|'`
|
||
|
||
case $opsys in
|
||
cygwin )
|
||
LIB_MATH=
|
||
;;
|
||
darwin )
|
||
## Adding -lm confuses the dynamic linker, so omit it.
|
||
LIB_MATH=
|
||
;;
|
||
freebsd | dragonfly )
|
||
SYSTEM_TYPE=berkeley-unix
|
||
;;
|
||
gnu-linux | gnu-kfreebsd )
|
||
;;
|
||
hpux10-20 | hpux11 )
|
||
;;
|
||
mingw32 )
|
||
LIB_MATH=
|
||
SYSTEM_TYPE=windows-nt
|
||
;;
|
||
netbsd | openbsd )
|
||
SYSTEM_TYPE=berkeley-unix
|
||
;;
|
||
|
||
solaris | unixware )
|
||
SYSTEM_TYPE=usg-unix-v
|
||
;;
|
||
|
||
esac
|
||
|
||
AC_SUBST([LIB_MATH])
|
||
AC_DEFINE_UNQUOTED([SYSTEM_TYPE], ["$SYSTEM_TYPE"],
|
||
[The type of system you are compiling for; sets 'system-type'.])
|
||
AC_SUBST([SYSTEM_TYPE])
|
||
|
||
pre_PKG_CONFIG_CFLAGS=$CFLAGS
|
||
pre_PKG_CONFIG_LIBS=$LIBS
|
||
|
||
dnl pkg-config does not work when cross-compiling for Android.
|
||
if test "${ANDROID}" != "yes"; then
|
||
PKG_PROG_PKG_CONFIG([0.9.0])
|
||
fi
|
||
|
||
dnl EMACS_CHECK_MODULES([GSTUFF], [gtk+-2.0 >= 1.3 glib = 1.3.4])
|
||
dnl acts like PKG_CHECK_MODULES([GSTUFF], [gtk+-2.0 >= 1.3 glib = 1.3.4],
|
||
dnl [HAVE_GSTUFF=yes], [HAVE_GSTUFF=no]) -- see pkg-config man page --
|
||
dnl except that it postprocesses CFLAGS as needed for --enable-gcc-warnings.
|
||
dnl EMACS_CHECK_MODULES accepts optional 3rd and 4th arguments that
|
||
dnl can take the place of the default HAVE_GSTUFF=yes and HAVE_GSTUFF=no
|
||
dnl actions.
|
||
AC_DEFUN([EMACS_CHECK_MODULES],
|
||
[AS_IF([test -n "$ndk_INITIALIZED"],
|
||
[ndk_CHECK_MODULES([$1], [$2], m4_default([$3], [HAVE_$1=yes]),
|
||
m4_default([$4],[HAVE_$1=no]))],
|
||
[PKG_CHECK_MODULES([$1], [$2],
|
||
[$1_CFLAGS=`AS_ECHO(["$$1_CFLAGS"]) | sed -e "$edit_cflags"`
|
||
m4_default([$3], [HAVE_$1=yes])],
|
||
[m4_default([$4], [HAVE_$1=no])])])])
|
||
|
||
dnl EMACS_CHECK_LIB(NAME, FUNCTION, ACTION-IF-FOUND, ACTION-IF-NOT-FOUND,
|
||
dnl OTHER-LIBRARIES, INCLUDES)
|
||
dnl ---------------------------------------------------------------------
|
||
dnl This is like AC_CHECK_LIB; however, there is no default action, and
|
||
dnl when cross-configuring for Android, AC_CHECK_DECLS is called with NAME
|
||
dnl and INCLUDES instead, as the library being checked against will likely
|
||
dnl be built together with Emacs.
|
||
AC_DEFUN([EMACS_CHECK_LIB],
|
||
[AS_IF([test -n "$ndk_INITIALIZED"],
|
||
[AC_CHECK_DECL([$2], [$3], [$4], [$6])],
|
||
[AC_CHECK_LIB([$1], [$2], [$3], [$4], [$5])])])
|
||
|
||
HAVE_SOUND=no
|
||
if test "${with_sound}" != "no"; then
|
||
# Sound support for GNU/Linux, the free BSDs, MinGW, and Cygwin.
|
||
AC_CHECK_HEADERS([machine/soundcard.h sys/soundcard.h soundcard.h mmsystem.h],
|
||
[have_sound_header=yes], [], [
|
||
#ifdef __MINGW32__
|
||
#define WIN32_LEAN_AND_MEAN
|
||
#include <windows.h>
|
||
#endif
|
||
])
|
||
test "${with_sound}" = "oss" && test "${have_sound_header}" != "yes" && \
|
||
AC_MSG_ERROR([OSS sound support requested but not found.])
|
||
|
||
if test "${with_sound}" = "bsd-ossaudio" || test "${with_sound}" = "yes"; then
|
||
# OSS emulation library used on NetBSD and OpenBSD.
|
||
AC_CHECK_LIB([ossaudio], [_oss_ioctl], [LIBSOUND=-lossaudio], [LIBSOUND=])
|
||
test "${with_sound}" = "bsd-ossaudio" && test -z "$LIBSOUND" && \
|
||
AC_MSG_ERROR([bsd-ossaudio sound support requested but not found.])
|
||
# On {Net,Open}BSD use the system audio library instead of
|
||
# potentially switching to ALSA below, as ALSA on these appears to
|
||
# just wrap system libraries.
|
||
test "${with_sound}" = "yes" && test "$LIBSOUND" = "-lossaudio" && \
|
||
with_sound="bsd-ossaudio"
|
||
fi
|
||
AC_SUBST([LIBSOUND])
|
||
|
||
if test "${with_sound}" = "alsa" || test "${with_sound}" = "yes"; then
|
||
ALSA_REQUIRED=1.0.0
|
||
ALSA_MODULES="alsa >= $ALSA_REQUIRED"
|
||
EMACS_CHECK_MODULES([ALSA], [$ALSA_MODULES])
|
||
if test $HAVE_ALSA = yes; then
|
||
LIBSOUND="$LIBSOUND $ALSA_LIBS"
|
||
CFLAGS_SOUND="$CFLAGS_SOUND $ALSA_CFLAGS"
|
||
AC_DEFINE([HAVE_ALSA], [1], [Define to 1 if ALSA is available.])
|
||
elif test "${with_sound}" = "alsa"; then
|
||
AC_MSG_ERROR([ALSA sound support requested but not found.])
|
||
fi
|
||
fi dnl with_sound = alsa|yes
|
||
|
||
dnl Define HAVE_SOUND if we have sound support. We know it works and
|
||
dnl compiles only on the specified platforms. For others, it
|
||
dnl probably doesn't make sense to try.
|
||
dnl FIXME So surely we should bypass this whole section if not using
|
||
dnl one of these platforms?
|
||
if test x$have_sound_header = xyes || test $HAVE_ALSA = yes; then
|
||
case "$opsys" in
|
||
dnl defined __FreeBSD__ || defined __NetBSD__ || defined __linux__
|
||
dnl Adjust the --with-sound help text if you change this.
|
||
gnu-linux|freebsd|netbsd|mingw32|cygwin)
|
||
AC_DEFINE([HAVE_SOUND], [1], [Define to 1 if you have sound support.])
|
||
HAVE_SOUND=yes
|
||
;;
|
||
esac
|
||
fi
|
||
|
||
AC_SUBST([CFLAGS_SOUND])
|
||
fi
|
||
|
||
dnl checks for header files
|
||
AC_CHECK_HEADERS_ONCE(
|
||
[linux/fs.h
|
||
malloc.h
|
||
sys/systeminfo.h
|
||
sys/sysinfo.h
|
||
coff.h pty.h
|
||
sys/resource.h
|
||
sys/utsname.h pwd.h util.h
|
||
sanitizer/lsan_interface.h
|
||
sanitizer/asan_interface.h
|
||
sanitizer/common_interface_defs.h])
|
||
|
||
AC_CACHE_CHECK([for ADDR_NO_RANDOMIZE],
|
||
[emacs_cv_personality_addr_no_randomize],
|
||
[AC_COMPILE_IFELSE(
|
||
[AC_LANG_PROGRAM([[#include <sys/personality.h>]],
|
||
[[personality (personality (0xffffffff)
|
||
| ADDR_NO_RANDOMIZE)]])],
|
||
[emacs_cv_personality_addr_no_randomize=yes],
|
||
[emacs_cv_personality_addr_no_randomize=no])])
|
||
if test $emacs_cv_personality_addr_no_randomize = yes; then
|
||
AC_DEFINE([HAVE_PERSONALITY_ADDR_NO_RANDOMIZE], [1],
|
||
[Define to 1 if personality flag ADDR_NO_RANDOMIZE exists.])
|
||
fi
|
||
|
||
# Note that Solaris has sys/sysinfo.h which defines struct
|
||
# sysinfo as well. To make sure that we're using GNU/Linux
|
||
# sysinfo, we explicitly set one of its fields.
|
||
if test "$ac_cv_header_sys_sysinfo_h" = yes; then
|
||
AC_CACHE_CHECK([if Linux sysinfo may be used], [emacs_cv_linux_sysinfo],
|
||
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/sysinfo.h>]],
|
||
[[struct sysinfo si;
|
||
si.totalram = 0;
|
||
sysinfo (&si)]])],
|
||
emacs_cv_linux_sysinfo=yes, emacs_cv_linux_sysinfo=no)])
|
||
|
||
if test $emacs_cv_linux_sysinfo = yes; then
|
||
AC_DEFINE([HAVE_LINUX_SYSINFO], [1],
|
||
[Define to 1 if you have Linux sysinfo function.])
|
||
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/sysinfo.h>]],
|
||
[[struct sysinfo si; return si.mem_unit]])],
|
||
AC_DEFINE([LINUX_SYSINFO_UNIT], [1],
|
||
[Define to 1 if Linux sysinfo sizes are in multiples of mem_unit bytes.]))
|
||
fi
|
||
fi
|
||
|
||
dnl On Solaris 8 there's a compilation warning for term.h because
|
||
dnl it doesn't define 'bool'.
|
||
AC_PREPROC_IFELSE([AC_LANG_PROGRAM([[#include <term.h>]],[[]])],
|
||
[AC_DEFINE([HAVE_TERM_H], [1],
|
||
[Define to 1 if you have the <term.h> header file.])])
|
||
AC_HEADER_SYS_WAIT
|
||
|
||
AC_CHECK_HEADERS_ONCE([sys/socket.h])
|
||
AC_CHECK_HEADERS([net/if.h], [], [], [AC_INCLUDES_DEFAULT
|
||
#if HAVE_SYS_SOCKET_H
|
||
#include <sys/socket.h>
|
||
#endif])
|
||
AC_CHECK_HEADERS([ifaddrs.h], [], [], [AC_INCLUDES_DEFAULT
|
||
#if HAVE_SYS_SOCKET_H
|
||
#include <sys/socket.h>
|
||
#endif])
|
||
AC_CHECK_HEADERS([net/if_dl.h], [], [], [AC_INCLUDES_DEFAULT
|
||
#if HAVE_SYS_SOCKET_H
|
||
#include <sys/socket.h>
|
||
#endif])
|
||
|
||
dnl checks for structure members
|
||
AC_CHECK_MEMBERS([struct ifreq.ifr_flags, struct ifreq.ifr_hwaddr,
|
||
struct ifreq.ifr_netmask, struct ifreq.ifr_broadaddr,
|
||
struct ifreq.ifr_addr,
|
||
struct ifreq.ifr_addr.sa_len], [], [],
|
||
[AC_INCLUDES_DEFAULT
|
||
#if HAVE_SYS_SOCKET_H
|
||
#include <sys/socket.h>
|
||
#endif
|
||
#if HAVE_NET_IF_H
|
||
#include <net/if.h>
|
||
#endif])
|
||
|
||
dnl Check for endianness.
|
||
dnl AC_C_BIGENDIAN is done by gnulib.
|
||
|
||
dnl check for Make feature
|
||
|
||
AUTO_DEPEND=no
|
||
AUTODEPEND_PARENTS='lib src'
|
||
dnl check if we have GCC and autodepend is on.
|
||
if test "$GCC" = yes && test "$ac_enable_autodepend" = yes; then
|
||
AC_CACHE_CHECK([whether gcc understands -MMD -MF], [emacs_cv_autodepend],
|
||
[SAVE_CFLAGS="$CFLAGS"
|
||
CFLAGS="$CFLAGS -MMD -MF deps.d -MP"
|
||
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
|
||
[emacs_cv_autodepend=yes], [emacs_cv_autodepend=no])
|
||
CFLAGS="$SAVE_CFLAGS"
|
||
test -f deps.d || emacs_cv_autodepend=no
|
||
rm -rf deps.d])
|
||
if test $emacs_cv_autodepend = yes; then
|
||
AUTO_DEPEND=yes
|
||
fi
|
||
fi
|
||
AC_SUBST([AUTO_DEPEND])
|
||
|
||
#### Choose a window system.
|
||
|
||
## We leave window_system equal to none if
|
||
## we end up building without one. Any new window system should
|
||
## set window_system to an appropriate value and add objects to
|
||
## window-system-specific substs.
|
||
|
||
window_system=none
|
||
|
||
ANDROID_OBJ=
|
||
ANDROID_LIBS=
|
||
# ANDROID_CFLAGS is a precious variable used to pass information to
|
||
# the cross-compiler.
|
||
ANDROID_BUILD_CFLAGS=
|
||
REALLY_ANDROID=
|
||
CM_OBJ="cm.o"
|
||
|
||
AS_IF([test "$ANDROID" = "yes"],[
|
||
window_system=android
|
||
no_x=yes
|
||
ANDROID_OBJ="androidterm.o androidfns.o androidfont.o androidmenu.o"
|
||
ANDROID_OBJ="$ANDROID_OBJ android.o"
|
||
ANDROID_LIBS=
|
||
CM_OBJ=
|
||
|
||
AC_DEFINE([HAVE_ANDROID], [1], [Define to 1 if Emacs is being built
|
||
with Android support])
|
||
|
||
AS_IF([test "$XCONFIGURE" != "android"], [
|
||
AC_DEFINE([ANDROID_STUBIFY], [1], [Define to 1 if Emacs is being built
|
||
for Android, but all API calls need to be stubbed out])
|
||
|
||
# Now set any shared user ID that was specified.
|
||
AS_IF([test -n "$with_shared_user_id"],
|
||
[emacs_val=$with_shared_user_id
|
||
emacs_val=`AS_ECHO(["$with_shared_user_id"]) \
|
||
| sed -e 's/"/\\"/'`
|
||
emacs_val="\"$emacs_val\""
|
||
ANDROID_SHARED_USER_ID="android:sharedUserId=$emacs_val"
|
||
# `android:sharedUserName' is required for sharedUserID to work
|
||
# on recent Android releases. It does not otherwise affect the
|
||
# behavior of any code.
|
||
emacs_val="\"@string/shared_user_name\""
|
||
ANDROID_SHARED_USER_NAME="android:sharedUserLabel=$emacs_val"])],[
|
||
# Emacs will be built as a shared library, and a wrapper around it
|
||
# will also be built for the benefit of applications. This
|
||
# requires Emacs be built as a position independent executable.
|
||
ANDROID_BUILD_CFLAGS="-fPIC -fvisibility=hidden"
|
||
|
||
# Graphics code in sfntfont-android.c benefits heavily from
|
||
# vectorization.
|
||
ANDROID_BUILD_CFLAGS="$ANDROID_BUILD_CFLAGS -ftree-vectorize"
|
||
|
||
# Link with libraries required for Android support.
|
||
# API 9 and later require `-landroid' for the asset manager.
|
||
# API 8 uses an emulation via the JNI.
|
||
AS_IF([test "$ANDROID_SDK" -lt "9"],
|
||
[ANDROID_LIBS="-llog -ljnigraphics"],
|
||
[ANDROID_LIBS="-landroid -llog -ljnigraphics"])
|
||
|
||
# This is required to make the system load emacs.apk's libpng
|
||
# (among others) instead of the system's own. But it doesn't work
|
||
# on all Android versions yet, so for now just suffix shared
|
||
# libraries with _emacs.
|
||
# ANDROID_LDFLAGS="-Wl,-rpath,'\$\$ORIGIN'"
|
||
|
||
# Link with the sfnt font library and sfntfont.o, along with
|
||
# sfntfont-android.o.
|
||
ANDROID_OBJ="$ANDROID_OBJ sfnt.o sfntfont.o sfntfont-android.o"
|
||
|
||
# Build androidselect.o and androidvfs.o.
|
||
ANDROID_OBJ="$ANDROID_OBJ androidselect.o androidvfs.o"
|
||
|
||
# Check for some functions not always present in the NDK.
|
||
AC_CHECK_DECLS([android_get_device_api_level])
|
||
|
||
# Mention this build is really for Android.
|
||
REALLY_ANDROID=yes])])
|
||
|
||
AC_SUBST([ANDROID])
|
||
AC_SUBST([ANDROID_OBJ])
|
||
AC_SUBST([ANDROID_LIBS])
|
||
AC_SUBST([ANDROID_LDFLAGS])
|
||
AC_SUBST([ANDROID_BUILD_CFLAGS])
|
||
AC_SUBST([ANDROID_SHARED_USER_ID])
|
||
AC_SUBST([ANDROID_SHARED_USER_NAME])
|
||
|
||
# Check for pw_gecos in struct passwd; this is known to be missing on
|
||
# Android.
|
||
|
||
AH_TEMPLATE([USER_FULL_NAME], [How to get a user's full name.])
|
||
AC_CHECK_MEMBERS([struct passwd.pw_gecos], [], [], [#include <pwd.h>])
|
||
AS_IF([test x"$REALLY_ANDROID" = "xyes"],
|
||
[AC_DEFINE([USER_FULL_NAME], [android_user_full_name (pw)])],
|
||
[AS_IF([test x"$ac_cv_member_struct_passwd_pw_gecos" = "xyes"],
|
||
[AC_DEFINE([USER_FULL_NAME], [pw->pw_gecos])],
|
||
[AC_DEFINE([USER_FULL_NAME], [NULL])])])
|
||
|
||
if test "${with_pgtk}" = "yes"; then
|
||
window_system=pgtk
|
||
fi
|
||
|
||
if test "${ANDROID}" != "yes"; then
|
||
AC_PATH_X
|
||
if test "$no_x" != yes && test "${with_pgtk}" != "yes"; then
|
||
window_system=x11
|
||
fi
|
||
fi
|
||
|
||
LD_SWITCH_X_SITE_RPATH=
|
||
if test "${x_libraries}" != NONE; then
|
||
if test -n "${x_libraries}"; then
|
||
LD_SWITCH_X_SITE=-L`AS_ECHO(["$x_libraries"]) | sed -e 's/:/ -L/g'`
|
||
LD_SWITCH_X_SITE_RPATH=-Wl,-rpath,`
|
||
AS_ECHO(["$x_libraries"]) | sed -e 's/:/ -Wl,-rpath,/g'
|
||
`
|
||
fi
|
||
x_default_search_path=""
|
||
x_search_path=${x_libraries}
|
||
if test -z "${x_search_path}"; then
|
||
x_search_path=/usr/lib
|
||
fi
|
||
for x_library in `AS_ECHO(["$x_search_path:"]) | \
|
||
sed -e "s/:/ /g" -e p -e "s:/lib[[^ /]]* :/share :g"`; do
|
||
x_search_path="\
|
||
${x_library}/X11/%L/%T/%N%C%S:\
|
||
${x_library}/X11/%l/%T/%N%C%S:\
|
||
${x_library}/X11/%T/%N%C%S:\
|
||
${x_library}/X11/%L/%T/%N%S:\
|
||
${x_library}/X11/%l/%T/%N%S:\
|
||
${x_library}/X11/%T/%N%S"
|
||
if test x"${x_default_search_path}" = x; then
|
||
x_default_search_path=${x_search_path}
|
||
else
|
||
x_default_search_path="${x_search_path}:${x_default_search_path}"
|
||
fi
|
||
done
|
||
fi
|
||
AC_SUBST([LD_SWITCH_X_SITE_RPATH])
|
||
|
||
if test "${x_includes}" != NONE && test -n "${x_includes}"; then
|
||
C_SWITCH_X_SITE=$isystem`AS_ECHO(["$x_includes"]) | sed -e "s/:/ $isystem/g"`
|
||
fi
|
||
|
||
if test x"${x_includes}" = x; then
|
||
bitmapdir=/usr/include/X11/bitmaps
|
||
else
|
||
# accumulate include directories that have X11 bitmap subdirectories
|
||
AS_UNSET([bmd_acc])
|
||
for bmd in `AS_ECHO(["$x_includes"]) | sed -e 's/:/ /g'`; do
|
||
if test -d "${bmd}/X11/bitmaps"; then
|
||
bmd_acc="${bmd_acc+$bmd_acc:}${bmd}/X11/bitmaps"
|
||
fi
|
||
if test -d "${bmd}/bitmaps"; then
|
||
bmd_acc="${bmd_acc+$bmd_acc:}${bmd}/bitmaps"
|
||
fi
|
||
done
|
||
bitmapdir=$bmd_acc
|
||
fi
|
||
|
||
NATIVE_IMAGE_API=no
|
||
|
||
test "${with_ns}" = maybe && test "${opsys}" != darwin && with_ns=no
|
||
HAVE_NS=no
|
||
NS_GNUSTEP_CONFIG=no
|
||
NS_IMPL_COCOA=no
|
||
NS_IMPL_GNUSTEP=no
|
||
tmp_CPPFLAGS="$CPPFLAGS"
|
||
tmp_CFLAGS="$CFLAGS"
|
||
CPPFLAGS="$CPPFLAGS -x objective-c"
|
||
CFLAGS="$CFLAGS -x objective-c"
|
||
GNU_OBJC_CFLAGS=""
|
||
LIBS_GNUSTEP=
|
||
if test "${with_ns}" != no; then
|
||
# macfont.o requires macuvs.h which is absent after 'make extraclean',
|
||
# so avoid NS_IMPL_COCOA if macuvs.h is absent.
|
||
# Even a headless Emacs can build macuvs.h, so this should let you bootstrap.
|
||
if test "${opsys}" = darwin && test -f "$srcdir/src/macuvs.h"; then
|
||
NS_IMPL_COCOA=yes
|
||
ns_appdir=`pwd`/nextstep/Emacs.app
|
||
ns_appbindir=${ns_appdir}/Contents/MacOS
|
||
ns_applibexecdir=${ns_appdir}/Contents/MacOS/libexec
|
||
ns_applibdir=${ns_appdir}/Contents/Frameworks
|
||
ns_appresdir=${ns_appdir}/Contents/Resources
|
||
ns_appsrc=Cocoa/Emacs.base
|
||
ns_fontfile=macfont.o
|
||
elif flags=`(gnustep-config --objc-flags) 2>/dev/null`; then
|
||
NS_IMPL_GNUSTEP=yes
|
||
NS_GNUSTEP_CONFIG=yes
|
||
GNU_OBJC_CFLAGS="$flags"
|
||
LIBS_GNUSTEP=`gnustep-config --gui-libs || exit`
|
||
elif test -f $GNUSTEP_CONFIG_FILE; then
|
||
NS_IMPL_GNUSTEP=yes
|
||
dnl FIXME sourcing this several times in subshells seems inefficient.
|
||
GNUSTEP_SYSTEM_HEADERS=`. $GNUSTEP_CONFIG_FILE \
|
||
&& AS_ECHO(["$GNUSTEP_SYSTEM_HEADERS"])`
|
||
GNUSTEP_SYSTEM_LIBRARIES=` . $GNUSTEP_CONFIG_FILE \
|
||
&& AS_ECHO(["$GNUSTEP_SYSTEM_LIBRARIES"])`
|
||
dnl I seemed to need these as well with GNUstep-startup 0.25.
|
||
GNUSTEP_LOCAL_HEADERS=`. $GNUSTEP_CONFIG_FILE \
|
||
&& AS_ECHO(["$GNUSTEP_LOCAL_HEADERS"])`
|
||
GNUSTEP_LOCAL_LIBRARIES=`. $GNUSTEP_CONFIG_FILE \
|
||
&& AS_ECHO(["$GNUSTEP_LOCAL_LIBRARIES"])`
|
||
test "x${GNUSTEP_LOCAL_HEADERS}" != "x" && \
|
||
GNUSTEP_LOCAL_HEADERS="-I${GNUSTEP_LOCAL_HEADERS}"
|
||
test "x${GNUSTEP_LOCAL_LIBRARIES}" != "x" && \
|
||
GNUSTEP_LOCAL_LIBRARIES="-L${GNUSTEP_LOCAL_LIBRARIES}"
|
||
CPPFLAGS="$CPPFLAGS -isystem ${GNUSTEP_SYSTEM_HEADERS} ${GNUSTEP_LOCAL_HEADERS}"
|
||
CFLAGS="$CFLAGS -isystem ${GNUSTEP_SYSTEM_HEADERS} ${GNUSTEP_LOCAL_HEADERS}"
|
||
LDFLAGS="$LDFLAGS -L${GNUSTEP_SYSTEM_LIBRARIES} ${GNUSTEP_LOCAL_LIBRARIES}"
|
||
LIBS_GNUSTEP="-lgnustep-gui -lgnustep-base -lobjc -lpthread"
|
||
dnl GNUstep defines BASE_NATIVE_OBJC_EXCEPTIONS to 0 or 1.
|
||
dnl If they had chosen to either define it or not, we could have
|
||
dnl just used AC_CHECK_DECL here.
|
||
AC_CACHE_CHECK([if GNUstep defines BASE_NATIVE_OBJC_EXCEPTIONS],
|
||
[emacs_cv_objc_exceptions],
|
||
[AC_COMPILE_IFELSE(
|
||
[AC_LANG_PROGRAM([[#include <GNUstepBase/GSConfig.h>]],
|
||
[[#if defined BASE_NATIVE_OBJC_EXCEPTIONS && BASE_NATIVE_OBJC_EXCEPTIONS > 0
|
||
1;
|
||
#else
|
||
fail;
|
||
#endif]])],
|
||
[emacs_cv_objc_exceptions=yes],
|
||
[emacs_cv_objc_exceptions=no])])
|
||
if test $emacs_cv_objc_exceptions = yes; then
|
||
dnl _NATIVE_OBJC_EXCEPTIONS is used by the GNUstep headers.
|
||
AC_DEFINE([_NATIVE_OBJC_EXCEPTIONS], [1],
|
||
[Define if GNUstep uses ObjC exceptions.])
|
||
GNU_OBJC_CFLAGS="$GNU_OBJC_CFLAGS -fobjc-exceptions"
|
||
fi
|
||
fi
|
||
if test $NS_IMPL_GNUSTEP = yes; then
|
||
ns_appdir=`pwd`/nextstep/Emacs.app
|
||
ns_appbindir=${ns_appdir}
|
||
ns_applibexecdir=${ns_appdir}/libexec
|
||
ns_applibdir=${ns_appdir}/Frameworks
|
||
ns_appresdir=${ns_appdir}/Resources
|
||
ns_appsrc=GNUstep/Emacs.base
|
||
ns_fontfile=nsfont.o
|
||
fi
|
||
|
||
dnl This is only used while we test the NS headers, it gets reset below.
|
||
CPPFLAGS="$CPPFLAGS $GNU_OBJC_CFLAGS"
|
||
CFLAGS="$CFLAGS $GNU_OBJC_CFLAGS"
|
||
|
||
AC_CHECK_HEADER([AppKit/AppKit.h], [HAVE_NS=yes],
|
||
[AC_MSG_ERROR([The include files (AppKit/AppKit.h etc) that
|
||
are required for a Nextstep build are missing or cannot be compiled.
|
||
Either fix this, or re-configure with the option '--without-ns'.])])
|
||
|
||
macfont_file=""
|
||
if test "${NS_IMPL_COCOA}" = "yes"; then
|
||
AC_MSG_CHECKING([for Mac OS X 10.6 or newer])
|
||
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <AppKit/AppKit.h>],
|
||
[
|
||
#ifdef MAC_OS_X_VERSION_MAX_ALLOWED
|
||
#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1060
|
||
; /* OK */
|
||
#else
|
||
error "Mac OS X 10.6 or newer required";
|
||
#endif
|
||
#endif
|
||
])],
|
||
[ns_osx_have_106=yes],
|
||
[ns_osx_have_106=no])
|
||
AC_MSG_RESULT([$ns_osx_have_106])
|
||
|
||
if test $ns_osx_have_106 = no; then
|
||
AC_MSG_ERROR([Mac OS X 10.6 or newer is required]);
|
||
fi
|
||
fi
|
||
|
||
AC_CACHE_CHECK([for Mac OS X 12.0 or later],
|
||
[emacs_cv_macosx_12_0],
|
||
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
||
#include <AvailabilityMacros.h>
|
||
#if MAC_OS_X_VERSION_MAX_ALLOWED >= 120000
|
||
Mac OS X 12.x or later.
|
||
#endif
|
||
]])], [emacs_cv_macosx_12_0=no],
|
||
[emacs_cv_macosx_12_0=yes]))
|
||
|
||
if test "${with_native_image_api}" = yes; then
|
||
AC_DEFINE([HAVE_NATIVE_IMAGE_API], [1],
|
||
[Define to use native OS APIs for images.])
|
||
NATIVE_IMAGE_API="yes (ns)"
|
||
fi
|
||
fi
|
||
|
||
AC_SUBST([LIBS_GNUSTEP])
|
||
|
||
INSTALL_ARCH_INDEP_EXTRA=install-etc
|
||
ns_self_contained=no
|
||
NS_OBJ=
|
||
NS_OBJC_OBJ=
|
||
if test "${HAVE_NS}" = yes; then
|
||
if test "$with_toolkit_scroll_bars" = "no"; then
|
||
AC_MSG_WARN([Non-toolkit scroll bars are not implemented for Nextstep.])
|
||
fi
|
||
|
||
window_system=nextstep
|
||
# set up packaging dirs
|
||
if test "${EN_NS_SELF_CONTAINED}" = yes; then
|
||
AC_DEFINE([NS_SELF_CONTAINED], [1], [Build an NS bundled app])
|
||
ns_self_contained=yes
|
||
prefix=${ns_appresdir}
|
||
exec_prefix=${ns_appbindir}
|
||
dnl This one isn't really used, only archlibdir is.
|
||
libexecdir="\${ns_applibexecdir}"
|
||
archlibdir="\${ns_applibexecdir}"
|
||
etcdocdir="\${ns_appresdir}/etc"
|
||
etcdir="\${ns_appresdir}/etc"
|
||
dnl FIXME maybe set datarootdir instead.
|
||
dnl That would also get applications, icons, man.
|
||
infodir="\${ns_appresdir}/info"
|
||
mandir="\${ns_appresdir}/man"
|
||
lispdir="\${ns_appresdir}/lisp"
|
||
lispdirrel="\${ns_appresdir}/lisp"
|
||
test "$locallisppathset" = no && locallisppath="\${ns_appresdir}/site-lisp"
|
||
INSTALL_ARCH_INDEP_EXTRA=
|
||
fi
|
||
|
||
NS_OBJC_OBJ="nsterm.o nsfns.o nsmenu.o nsselect.o nsimage.o $ns_fontfile"
|
||
fi
|
||
CFLAGS="$tmp_CFLAGS"
|
||
CPPFLAGS="$tmp_CPPFLAGS"
|
||
AC_SUBST([INSTALL_ARCH_INDEP_EXTRA])
|
||
AC_SUBST([ns_self_contained])
|
||
AC_SUBST([NS_OBJ])
|
||
AC_SUBST([NS_OBJC_OBJ])
|
||
|
||
if test "${HAVE_NS}" = yes; then
|
||
AC_LANG_PUSH([Objective C])
|
||
AC_CACHE_CHECK(
|
||
[if the Objective C compiler supports instancetype],
|
||
[emacs_cv_objc_instancetype],
|
||
[AC_COMPILE_IFELSE(
|
||
[AC_LANG_SOURCE([[@interface Test
|
||
+ (instancetype)test;
|
||
@end]])],
|
||
[emacs_cv_objc_instancetype=yes],
|
||
[emacs_cv_objc_instancetype=no])])
|
||
|
||
if test x$emacs_cv_objc_instancetype = xyes ; then
|
||
AC_DEFINE([NATIVE_OBJC_INSTANCETYPE], [1],
|
||
[Define if ObjC compiler supports instancetype natively.])
|
||
fi
|
||
|
||
AC_CACHE_CHECK(
|
||
[if the Objective C compiler defaults to C99],
|
||
[emacs_cv_objc_c99],
|
||
[AC_COMPILE_IFELSE(
|
||
[AC_LANG_PROGRAM([], [[for (int i = 0;;);]])],
|
||
[emacs_cv_objc_c99=yes],
|
||
[emacs_cv_objc_c99=no])])
|
||
|
||
if test x$emacs_cv_objc_c99 = xno ; then
|
||
GNU_OBJC_CFLAGS="$GNU_OBJC_CFLAGS -std=c99"
|
||
fi
|
||
AC_LANG_POP([Objective C])
|
||
fi
|
||
|
||
HAVE_BE_APP=no
|
||
if test "${opsys}" = "haiku" && test "${with_be_app}" = "yes"; then
|
||
dnl Only GCC is supported. Clang might work, but it's
|
||
dnl not reliable, so don't check for it here.
|
||
AC_PROG_CXX([gcc g++])
|
||
CXXFLAGS="$CXXFLAGS $emacs_g3_CFLAGS"
|
||
AC_LANG_PUSH([C++])
|
||
AC_CHECK_HEADER([app/Application.h], [HAVE_BE_APP=yes],
|
||
[AC_MSG_ERROR([The Application Kit headers required for building
|
||
with the Application Kit were not found or cannot be compiled. Either fix this, or
|
||
re-configure with the option '--without-be-app'.])])
|
||
AC_LANG_POP([C++])
|
||
fi
|
||
|
||
AC_SUBST([HAVE_BE_APP])
|
||
|
||
HAVE_W32=no
|
||
W32_OBJ=
|
||
W32_LIBS=
|
||
EMACSRES=
|
||
CLIENTRES=
|
||
CLIENTW=
|
||
W32_RES_LINK=
|
||
EMACS_MANIFEST=
|
||
if test "${with_w32}" != no; then
|
||
case "${opsys}" in
|
||
cygwin)
|
||
AC_CHECK_HEADER([windows.h], [HAVE_W32=yes],
|
||
[AC_MSG_ERROR(['--with-w32' was specified, but windows.h
|
||
cannot be found.])])
|
||
;;
|
||
mingw32)
|
||
## Using --with-w32 with MinGW is a no-op, but we allow it.
|
||
;;
|
||
*)
|
||
AC_MSG_ERROR([Using w32 with an autotools build is only supported for Cygwin and MinGW32.])
|
||
;;
|
||
esac
|
||
fi
|
||
|
||
if test "${opsys}" = "mingw32"; then
|
||
AC_CACHE_CHECK([whether Windows API headers are recent enough], [emacs_cv_w32api],
|
||
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
||
#include <windows.h>
|
||
#include <usp10.h>]],
|
||
[[PIMAGE_NT_HEADERS pHeader;
|
||
PIMAGE_SECTION_HEADER pSection = IMAGE_FIRST_SECTION(pHeader)]])],
|
||
[emacs_cv_w32api=yes], [emacs_cv_w32api=no])])
|
||
if test "${emacs_cv_w32api}" = "no"; then
|
||
AC_MSG_ERROR([the Windows API headers are too old to support this build.])
|
||
fi
|
||
HAVE_W32=${emacs_cv_w32api}
|
||
fi
|
||
|
||
FIRSTFILE_OBJ=
|
||
NTDIR=
|
||
LIBS_ECLIENT=
|
||
LIB_WSOCK32=
|
||
NTLIB=
|
||
XARGS_LIMIT=
|
||
if test "${HAVE_W32}" = "yes"; then
|
||
AC_DEFINE([HAVE_NTGUI], [1], [Define to use native MS Windows GUI.])
|
||
if test "$with_toolkit_scroll_bars" = "no"; then
|
||
AC_MSG_ERROR([Non-toolkit scroll bars are not implemented for w32 build.])
|
||
fi
|
||
AC_CHECK_TOOL([WINDRES], [windres],
|
||
[AC_MSG_ERROR([No resource compiler found.])])
|
||
W32_OBJ="w32fns.o w32menu.o w32reg.o w32font.o w32term.o"
|
||
W32_OBJ="$W32_OBJ w32xfns.o w32select.o w32uniscribe.o w32cygwinx.o"
|
||
EMACSRES="emacs.res"
|
||
case "$canonical" in
|
||
x86_64-*-*) EMACS_MANIFEST="emacs-x64.manifest" ;;
|
||
*) EMACS_MANIFEST="emacs-x86.manifest" ;;
|
||
esac
|
||
dnl Construct something of the form "24,4,0,0" with 4 components.
|
||
comma_version=`echo "${PACKAGE_VERSION}.0.0" | sed -e 's/\./,/g' -e 's/^\([[^,]]*,[[^,]]*,[[^,]]*,[[^,]]*\).*/\1/'`
|
||
|
||
comma_space_version=`echo "$comma_version" | sed 's/,/, /g'`
|
||
AC_SUBST([comma_version])
|
||
AC_SUBST([comma_space_version])
|
||
AC_CONFIG_FILES([nt/emacs.rc nt/emacsclient.rc])
|
||
if test "${opsys}" = "cygwin"; then
|
||
W32_LIBS="$W32_LIBS -lkernel32 -luser32 -lusp10 -lgdi32"
|
||
W32_LIBS="$W32_LIBS -lole32 -lcomdlg32 -lcomctl32 -lwinspool"
|
||
# Tell the linker that emacs.res is an object (which we compile from
|
||
# the rc file), not a linker script.
|
||
W32_RES_LINK="-Wl,emacs.res"
|
||
else
|
||
W32_OBJ="$W32_OBJ w32.o w32console.o w32heap.o w32inevt.o w32proc.o"
|
||
dnl FIXME: This should probably be supported for Cygwin/w32 as
|
||
dnl well, but the Cygwin build needs to link against -lgdiplus
|
||
if test "${with_native_image_api}" = yes; then
|
||
AC_DEFINE([HAVE_NATIVE_IMAGE_API], [1],
|
||
[Define to use native OS APIs for images.])
|
||
NATIVE_IMAGE_API="yes (w32)"
|
||
W32_OBJ="$W32_OBJ w32image.o"
|
||
fi
|
||
W32_LIBS="$W32_LIBS -lwinmm -lusp10 -lgdi32 -lcomdlg32"
|
||
W32_LIBS="$W32_LIBS -lmpr -lwinspool -lole32 -lcomctl32"
|
||
W32_RES_LINK="\$(EMACSRES)"
|
||
CLIENTRES="emacsclient.res"
|
||
CLIENTW="emacsclientw\$(EXEEXT)"
|
||
FIRSTFILE_OBJ=firstfile.o
|
||
NTDIR=nt
|
||
CM_OBJ=
|
||
LIBS_ECLIENT="-lcomctl32"
|
||
LIB_WSOCK32="-lwsock32"
|
||
NTLIB="ntlib.$ac_objext"
|
||
XARGS_LIMIT="-s 10000"
|
||
fi
|
||
fi
|
||
|
||
if test "${HAVE_W32}" = "no" && test "${opsys}" = "cygwin"; then
|
||
W32_LIBS="-lkernel32"
|
||
W32_OBJ="w32cygwinx.o"
|
||
fi
|
||
|
||
AC_SUBST([W32_OBJ])
|
||
AC_SUBST([W32_LIBS])
|
||
AC_SUBST([EMACSRES])
|
||
AC_SUBST([EMACS_MANIFEST])
|
||
AC_SUBST([CLIENTRES])
|
||
AC_SUBST([CLIENTW])
|
||
AC_SUBST([W32_RES_LINK])
|
||
AC_SUBST([FIRSTFILE_OBJ])
|
||
AC_SUBST([NTDIR])
|
||
AC_SUBST([CM_OBJ])
|
||
AC_SUBST([LIBS_ECLIENT])
|
||
AC_SUBST([LIB_WSOCK32])
|
||
AC_SUBST([NTLIB])
|
||
AC_SUBST([XARGS_LIMIT])
|
||
|
||
if test "${HAVE_W32}" = "yes"; then
|
||
window_system=w32
|
||
with_xft=no
|
||
fi
|
||
|
||
HAIKU_OBJ=
|
||
HAIKU_CXX_OBJ=
|
||
HAIKU_LIBS=
|
||
HAIKU_CFLAGS=
|
||
|
||
if test "$opsys" = "haiku"; then
|
||
HAIKU_OBJ="$HAIKU_OBJ haiku.o"
|
||
fi
|
||
|
||
if test "${HAVE_BE_APP}" = "yes"; then
|
||
AC_DEFINE([HAVE_HAIKU], [1],
|
||
[Define if Emacs will be built with Haiku windowing support])
|
||
fi
|
||
|
||
if test "${HAVE_BE_APP}" = "yes"; then
|
||
window_system=haiku
|
||
with_xft=no
|
||
HAIKU_OBJ="$HAIKU_OBJ haikufns.o haikuterm.o haikumenu.o haikufont.o haikuselect.o haiku_io.o"
|
||
HAIKU_CXX_OBJ="haiku_support.o haiku_font_support.o haiku_draw_support.o haiku_select.o"
|
||
HAIKU_LIBS="-lbe -lgame -ltranslation -ltracker" # -lgame is needed for set_mouse_position.
|
||
|
||
if test "${with_native_image_api}" = yes; then
|
||
AC_DEFINE([HAVE_NATIVE_IMAGE_API], [1],
|
||
[Define to use native OS APIs for images.])
|
||
NATIVE_IMAGE_API="yes (haiku)"
|
||
HAIKU_OBJ="$HAIKU_OBJ haikuimage.o"
|
||
fi
|
||
fi
|
||
|
||
AC_SUBST([HAIKU_LIBS])
|
||
AC_SUBST([HAIKU_OBJ])
|
||
AC_SUBST([HAIKU_CXX_OBJ])
|
||
AC_SUBST([HAIKU_CFLAGS])
|
||
|
||
## $window_system is now set to the window system we will
|
||
## ultimately use.
|
||
|
||
term_header=
|
||
HAVE_X_WINDOWS=no
|
||
HAVE_X11=no
|
||
USE_X_TOOLKIT=none
|
||
HAVE_PGTK=no
|
||
|
||
case "${window_system}" in
|
||
x11 )
|
||
HAVE_X_WINDOWS=yes
|
||
HAVE_X11=yes
|
||
term_header=xterm.h
|
||
case "${with_x_toolkit}" in
|
||
athena | lucid ) USE_X_TOOLKIT=LUCID ;;
|
||
motif ) USE_X_TOOLKIT=MOTIF ;;
|
||
gtk ) with_gtk=yes
|
||
term_header=gtkutil.h
|
||
dnl Don't set this for GTK. A lot of tests below assumes Xt when
|
||
dnl USE_X_TOOLKIT is set.
|
||
USE_X_TOOLKIT=none ;;
|
||
gtk2 ) with_gtk2=yes
|
||
term_header=gtkutil.h
|
||
USE_X_TOOLKIT=none ;;
|
||
gtk3 ) with_gtk3=yes
|
||
term_header=gtkutil.h
|
||
USE_X_TOOLKIT=none ;;
|
||
no ) USE_X_TOOLKIT=none ;;
|
||
dnl If user did not say whether to use a toolkit, make this decision later:
|
||
dnl use the toolkit if we have gtk, or X11R5 or newer.
|
||
* ) USE_X_TOOLKIT=maybe ;;
|
||
esac
|
||
;;
|
||
nextstep )
|
||
term_header=nsterm.h
|
||
;;
|
||
w32 )
|
||
term_header=w32term.h
|
||
;;
|
||
pgtk )
|
||
term_header=pgtkterm.h
|
||
with_gtk3=yes
|
||
USE_X_TOOLKIT=none
|
||
HAVE_PGTK=yes
|
||
AC_DEFINE([HAVE_PGTK], [1], [Define to 1 if you have pure Gtk+-3.])
|
||
;;
|
||
haiku )
|
||
term_header=haikuterm.h
|
||
;;
|
||
android )
|
||
term_header=androidterm.h
|
||
;;
|
||
esac
|
||
|
||
AC_SUBST([HAVE_PGTK])
|
||
|
||
if test "$window_system" = none && test "X$with_x" != "Xno"; then
|
||
AC_CHECK_PROG([HAVE_XSERVER], [X], [true], [false])
|
||
if test "$HAVE_XSERVER" = true ||
|
||
test -n "$DISPLAY" ||
|
||
{
|
||
for emacs_libX11 in /usr/lib/libX11.*; do break; done
|
||
test "$emacs_libX11" != '/usr/lib/libX11.*'
|
||
}
|
||
then
|
||
AC_MSG_ERROR([You seem to be running X, but no X development libraries
|
||
were found. You should install the relevant development files for X
|
||
and for the toolkit you want, such as Gtk+ or Motif. Also make
|
||
sure you have development files for image handling, i.e.
|
||
tiff, gif, jpeg, png and xpm.
|
||
If you are sure you want Emacs compiled without X window support, pass
|
||
--without-x
|
||
to configure.])
|
||
fi
|
||
fi
|
||
|
||
# Does the opsystem file prohibit the use of the GNU malloc?
|
||
# Assume not, until told otherwise.
|
||
GNU_MALLOC=yes
|
||
|
||
AC_CACHE_CHECK(
|
||
[whether malloc is Doug Lea style],
|
||
[emacs_cv_var_doug_lea_malloc],
|
||
[emacs_cv_var_doug_lea_malloc=no
|
||
dnl Hooks do not work with address sanitization.
|
||
if test "$emacs_cv_sanitize_address" != yes; then
|
||
AC_LINK_IFELSE(
|
||
[AC_LANG_PROGRAM(
|
||
[[#include <malloc.h>
|
||
static void hook (void) {}]],
|
||
[[malloc_set_state (malloc_get_state ());
|
||
__after_morecore_hook = hook;
|
||
__malloc_initialize_hook = hook;]])],
|
||
[emacs_cv_var_doug_lea_malloc=yes])
|
||
fi])
|
||
doug_lea_malloc=$emacs_cv_var_doug_lea_malloc
|
||
|
||
hybrid_malloc=
|
||
system_malloc=yes
|
||
|
||
dnl This must be before the test of $ac_cv_func_sbrk below.
|
||
AC_CHECK_FUNCS_ONCE([sbrk])
|
||
|
||
test $with_unexec = yes &&
|
||
case "$opsys" in
|
||
## darwin ld insists on the use of malloc routines in the System framework.
|
||
darwin | mingw32 | nacl | solaris) ;;
|
||
cygwin | qnxnto | freebsd)
|
||
hybrid_malloc=yes
|
||
system_malloc= ;;
|
||
*) test "$ac_cv_func_sbrk" = yes && system_malloc=$emacs_cv_sanitize_address;;
|
||
esac
|
||
|
||
if test "${system_malloc}" != yes && test "${doug_lea_malloc}" != yes \
|
||
&& test "${UNEXEC_OBJ}" = unexelf.o; then
|
||
hybrid_malloc=yes
|
||
fi
|
||
|
||
GMALLOC_OBJ=
|
||
HYBRID_MALLOC=
|
||
if test "${system_malloc}" = "yes"; then
|
||
AC_DEFINE([SYSTEM_MALLOC], [1],
|
||
[Define to 1 to use the system memory allocator, even if it is not
|
||
Doug Lea style.])
|
||
GNU_MALLOC=no
|
||
GNU_MALLOC_reason="
|
||
(The GNU allocators don't work with this system configuration.)"
|
||
VMLIMIT_OBJ=
|
||
elif test "$hybrid_malloc" = yes; then
|
||
AC_DEFINE([HYBRID_MALLOC], [1],
|
||
[Define to use gmalloc before dumping and the system malloc after.])
|
||
HYBRID_MALLOC=1
|
||
GNU_MALLOC=no
|
||
GNU_MALLOC_reason=" (only before dumping)"
|
||
GMALLOC_OBJ=gmalloc.o
|
||
VMLIMIT_OBJ=
|
||
else
|
||
test "$doug_lea_malloc" != "yes" && GMALLOC_OBJ=gmalloc.o
|
||
VMLIMIT_OBJ=vm-limit.o
|
||
|
||
AC_CHECK_HEADERS([sys/vlimit.h])
|
||
AC_CACHE_CHECK([for data_start], [emacs_cv_data_start],
|
||
[AC_LINK_IFELSE(
|
||
[AC_LANG_PROGRAM(
|
||
[[extern char data_start[]; char ch;]],
|
||
[[return data_start < &ch;]])],
|
||
[emacs_cv_data_start=yes],
|
||
[emacs_cv_data_start=no])])
|
||
if test $emacs_cv_data_start = yes; then
|
||
AC_DEFINE([HAVE_DATA_START], [1],
|
||
[Define to 1 if data_start is the address of the start
|
||
of the main data segment.])
|
||
fi
|
||
fi
|
||
AC_SUBST([HYBRID_MALLOC])
|
||
AC_SUBST([GMALLOC_OBJ])
|
||
AC_SUBST([VMLIMIT_OBJ])
|
||
|
||
if test "$doug_lea_malloc" = "yes" && test "$hybrid_malloc" != yes; then
|
||
if test "$GNU_MALLOC" = yes ; then
|
||
GNU_MALLOC_reason="
|
||
(Using Doug Lea's new malloc from the GNU C Library.)"
|
||
fi
|
||
AC_DEFINE([DOUG_LEA_MALLOC], [1],
|
||
[Define to 1 if the system memory allocator is Doug Lea style,
|
||
with malloc hooks and malloc_set_state.])
|
||
|
||
## Use mmap directly for allocating larger buffers.
|
||
## FIXME this comes from src/s/{gnu,gnu-linux}.h:
|
||
## #ifdef DOUG_LEA_MALLOC; #undef REL_ALLOC; #endif
|
||
## Does the AC_FUNC_MMAP test below make this check unnecessary?
|
||
case "$opsys" in
|
||
mingw32|gnu*) REL_ALLOC=no ;;
|
||
esac
|
||
fi
|
||
|
||
if test x"${REL_ALLOC}" = x; then
|
||
REL_ALLOC=${GNU_MALLOC}
|
||
fi
|
||
|
||
use_mmap_for_buffers=no
|
||
case "$opsys" in
|
||
mingw32) use_mmap_for_buffers=yes ;;
|
||
esac
|
||
|
||
AC_FUNC_MMAP
|
||
if test $use_mmap_for_buffers = yes; then
|
||
AC_DEFINE([USE_MMAP_FOR_BUFFERS], [1],
|
||
[Define to use mmap to allocate buffer text.])
|
||
REL_ALLOC=no
|
||
fi
|
||
|
||
LIBS="$LIBS_SYSTEM $LIBS"
|
||
|
||
dnl FIXME replace main with a function we actually want from this library.
|
||
AC_CHECK_LIB([Xbsd], [main], [LD_SWITCH_X_SITE="$LD_SWITCH_X_SITE -lXbsd"])
|
||
|
||
dnl Check for the POSIX thread library.
|
||
LIB_PTHREAD=
|
||
AC_CHECK_HEADERS_ONCE([pthread.h])
|
||
if test "$ac_cv_header_pthread_h" && test "$opsys" != "mingw32"; then
|
||
AC_CACHE_CHECK([for pthread library],
|
||
[emacs_cv_pthread_lib],
|
||
[emacs_cv_pthread_lib=no
|
||
OLD_LIBS=$LIBS
|
||
for emacs_pthread_lib in 'none needed' -lpthread; do
|
||
case $emacs_pthread_lib in
|
||
-*) LIBS="$OLD_LIBS $emacs_pthread_lib";;
|
||
esac
|
||
AC_LINK_IFELSE(
|
||
[AC_LANG_PROGRAM(
|
||
[[#include <pthread.h>
|
||
#include <signal.h>
|
||
sigset_t old_mask, new_mask;
|
||
void noop (void) {}]],
|
||
[[pthread_t th = pthread_self ();
|
||
int status = 0;
|
||
status += pthread_create (&th, 0, 0, 0);
|
||
status += pthread_sigmask (SIG_BLOCK, &new_mask, &old_mask);
|
||
status += pthread_kill (th, 0);
|
||
#if ! (defined SYSTEM_MALLOC || defined HYBRID_MALLOC \
|
||
|| defined DOUG_LEA_MALLOC)
|
||
/* Test for pthread_atfork only if gmalloc uses it,
|
||
as older-style hosts like MirBSD 10 lack it. */
|
||
status += pthread_atfork (noop, noop, noop);
|
||
#endif
|
||
return status;]])],
|
||
[emacs_cv_pthread_lib=$emacs_pthread_lib])
|
||
LIBS=$OLD_LIBS
|
||
if test "$emacs_cv_pthread_lib" != no; then
|
||
break
|
||
fi
|
||
done])
|
||
if test "$emacs_cv_pthread_lib" != no; then
|
||
AC_DEFINE([HAVE_PTHREAD], [1], [Define to 1 if you have POSIX threads.])
|
||
case $emacs_cv_pthread_lib in
|
||
-*) LIB_PTHREAD=$emacs_cv_pthread_lib;;
|
||
esac
|
||
ac_cv_func_pthread_sigmask=yes
|
||
# Some systems optimize for single-threaded programs by default, and
|
||
# need special flags to disable these optimizations. For example, the
|
||
# definition of 'errno' in <errno.h>.
|
||
case $opsys in
|
||
hpux* | solaris)
|
||
AC_DEFINE([_REENTRANT], [1],
|
||
[Define to 1 if your system requires this in multithreaded code.]);;
|
||
aix4-2)
|
||
AC_DEFINE([_THREAD_SAFE], [1],
|
||
[Define to 1 if your system requires this in multithreaded code.]);;
|
||
esac
|
||
fi
|
||
fi
|
||
AC_SUBST([LIB_PTHREAD])
|
||
|
||
AC_MSG_CHECKING([for thread support])
|
||
threads_enabled=no
|
||
if test "$with_threads" = yes; then
|
||
if test "$emacs_cv_pthread_lib" != no; then
|
||
AC_DEFINE([THREADS_ENABLED], [1],
|
||
[Define to 1 if you want elisp thread support.])
|
||
threads_enabled=yes
|
||
elif test "${opsys}" = "mingw32"; then
|
||
dnl MinGW can do native Windows threads even without pthreads
|
||
AC_DEFINE([THREADS_ENABLED], [1],
|
||
[Define to 1 if you want elisp thread support.])
|
||
threads_enabled=yes
|
||
fi
|
||
fi
|
||
AC_MSG_RESULT([$threads_enabled])
|
||
|
||
dnl Check for need for bigtoc support on IBM AIX
|
||
|
||
case ${host_os} in
|
||
aix*)
|
||
AC_CACHE_CHECK([for -bbigtoc option], [gdb_cv_bigtoc], [
|
||
case $GCC in
|
||
yes) gdb_cv_bigtoc=-Wl,-bbigtoc ;;
|
||
*) gdb_cv_bigtoc=-bbigtoc ;;
|
||
esac
|
||
|
||
LDFLAGS=$LDFLAGS\ $gdb_cv_bigtoc
|
||
AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[int i;]])], [], [gdb_cv_bigtoc=])
|
||
])
|
||
;;
|
||
esac
|
||
|
||
# Change CFLAGS, CPPFLAGS, and LIBS temporarily so that C_SWITCH_X_SITE
|
||
# is for the tests that follow. We set them back later on.
|
||
|
||
REAL_CFLAGS="$CFLAGS"
|
||
REAL_CPPFLAGS="$CPPFLAGS"
|
||
REAL_LIBS="$LIBS"
|
||
|
||
if test "${HAVE_X11}" = "yes"; then
|
||
DEFS="$C_SWITCH_X_SITE $DEFS"
|
||
LDFLAGS="$LDFLAGS $LD_SWITCH_X_SITE"
|
||
LIBS="-lX11 $LIBS"
|
||
CFLAGS="$C_SWITCH_X_SITE $CFLAGS"
|
||
CPPFLAGS="$C_SWITCH_X_SITE $CPPFLAGS"
|
||
|
||
# On Solaris, arrange for LD_RUN_PATH to point to the X libraries for tests.
|
||
# This is handled by LD_SWITCH_X_SITE_RPATH during the real build,
|
||
# but it's more convenient here to set LD_RUN_PATH since this
|
||
# also works on hosts that don't understand LD_SWITCH_X_SITE_RPATH.
|
||
if test "${x_libraries}" != NONE && test -n "${x_libraries}"; then
|
||
LD_RUN_PATH=$x_libraries${LD_RUN_PATH+:}$LD_RUN_PATH
|
||
export LD_RUN_PATH
|
||
fi
|
||
|
||
# Reportedly, some broken Solaris systems have XKBlib.h but are missing
|
||
# header files included from there.
|
||
AC_CACHE_CHECK([for Xkb], [emacs_cv_xkb],
|
||
[AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <X11/Xlib.h>
|
||
#include <X11/XKBlib.h>]],
|
||
[[XkbDescPtr kb = XkbGetKeyboard (0, XkbAllComponentsMask, XkbUseCoreKbd);]])],
|
||
[emacs_cv_xkb=yes],
|
||
[emacs_cv_xkb=no])])
|
||
if test $emacs_cv_xkb = yes; then
|
||
AC_DEFINE([HAVE_XKB], [1], [Define to 1 if you have the Xkb extension.])
|
||
AC_CHECK_FUNCS([XkbRefreshKeyboardMapping XkbFreeNames])
|
||
fi
|
||
|
||
AC_CHECK_FUNCS([XrmSetDatabase XScreenResourceString XScreenNumberOfScreen])
|
||
AC_CHECK_FUNCS([XDisplayCells XDestroySubwindows])
|
||
fi
|
||
|
||
if test "${window_system}" = "x11"; then
|
||
AC_MSG_CHECKING([X11 version 6])
|
||
AC_CACHE_VAL([emacs_cv_x11_version_6],
|
||
[AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <X11/Xlib.h>]],
|
||
[[#if XlibSpecificationRelease < 6
|
||
fail;
|
||
#endif
|
||
]])], [emacs_cv_x11_version_6=yes],
|
||
[emacs_cv_x11_version_6=no])])
|
||
if test $emacs_cv_x11_version_6 = yes; then
|
||
AC_MSG_RESULT([6 or newer])
|
||
AC_DEFINE([HAVE_X11R6], [1],
|
||
[Define to 1 if you have the X11R6 or newer version of Xlib.])
|
||
AC_DEFINE([HAVE_X_I18N], [1], [Define if you have usable i18n support.])
|
||
AC_CHECK_MEMBERS([XICCallback.callback], [], [], [#include <X11/Xlib.h>])
|
||
## inoue@ainet.or.jp says Solaris has a bug related to X11R6-style
|
||
## XIM support.
|
||
case "$opsys" in
|
||
solaris) : ;;
|
||
*) AC_DEFINE([HAVE_X11R6_XIM], [1],
|
||
[Define if you have usable X11R6-style XIM support.])
|
||
;;
|
||
esac
|
||
else
|
||
AC_MSG_RESULT([before 6])
|
||
fi
|
||
fi
|
||
|
||
### Use -lrsvg-2 if available, unless '--with-rsvg=no' is specified.
|
||
HAVE_RSVG=no
|
||
if test "${HAVE_X11}" = "yes" || test "${HAVE_NS}" = "yes" \
|
||
|| test "${opsys}" = "mingw32" || test "${HAVE_BE_APP}" = "yes" \
|
||
|| test "${window_system}" = "pgtk" \
|
||
|| test "${REALLY_ANDROID}" = "yes"; then
|
||
if test "${with_rsvg}" != "no"; then
|
||
RSVG_REQUIRED=2.14.0
|
||
AS_IF([test "${REALLY_ANDROID}" = "yes"],
|
||
[RSVG_MODULE="librsvg"],
|
||
[RSVG_MODULE="librsvg-2.0 >= $RSVG_REQUIRED"])
|
||
|
||
EMACS_CHECK_MODULES([RSVG], [$RSVG_MODULE])
|
||
AC_SUBST([RSVG_CFLAGS])
|
||
AC_SUBST([RSVG_LIBS])
|
||
|
||
if test $HAVE_RSVG = yes; then
|
||
AC_DEFINE([HAVE_RSVG], [1], [Define to 1 if using librsvg.])
|
||
CFLAGS="$CFLAGS $RSVG_CFLAGS"
|
||
# Windows loads librsvg dynamically
|
||
if test "${opsys}" = "mingw32"; then
|
||
RSVG_LIBS=
|
||
fi
|
||
fi
|
||
fi
|
||
fi
|
||
|
||
### Use -lwebp if available, unless '--with-webp=no'
|
||
HAVE_WEBP=no
|
||
if test "${with_webp}" != "no"; then
|
||
if test "${HAVE_X11}" = "yes" || test "${opsys}" = "mingw32" \
|
||
|| test "${HAVE_W32}" = "yes" || test "${HAVE_NS}" = "yes" \
|
||
|| test "${HAVE_BE_APP}" = "yes" || test "${HAVE_PGTK}" = "yes" \
|
||
|| test "${REALLY_ANDROID}" = "yes"; then
|
||
WEBP_REQUIRED=0.6.0
|
||
WEBP_MODULE="libwebpdemux >= $WEBP_REQUIRED"
|
||
|
||
EMACS_CHECK_MODULES([WEBP], [$WEBP_MODULE])
|
||
|
||
# WebPGetInfo is sometimes not present inside libwebpdemux, so
|
||
# if it does not link, also check for libwebpdecoder.
|
||
|
||
OLD_CFLAGS=$CFLAGS
|
||
OLD_LIBS=$LIBS
|
||
CFLAGS="$CFLAGS $WEBP_CFLAGS"
|
||
LIBS="$LIBS $WEBP_LIBS"
|
||
|
||
AS_IF([test "$REALLY_ANDROID" != "yes"], [
|
||
AC_CHECK_FUNC([WebPGetInfo], [],
|
||
[WEBP_MODULE="$WEBP_MODULE libwebpdecoder >= $WEBP_REQUIRED"
|
||
HAVE_WEBP=no
|
||
AS_UNSET([WEBP_LIBS])
|
||
AS_UNSET([WEBP_CFLAGS])
|
||
EMACS_CHECK_MODULES([WEBP], [$WEBP_MODULE])])])
|
||
|
||
CFLAGS=$OLD_CFLAGS
|
||
LIBS=$OLD_LIBS
|
||
|
||
AC_SUBST([WEBP_CFLAGS])
|
||
AC_SUBST([WEBP_LIBS])
|
||
fi
|
||
if test $HAVE_WEBP = yes; then
|
||
AC_DEFINE([HAVE_WEBP], [1], [Define to 1 if using libwebp.])
|
||
# Windows loads libwebp dynamically
|
||
if test "${opsys}" = "mingw32"; then
|
||
WEBP_LIBS=
|
||
fi
|
||
fi
|
||
fi
|
||
|
||
### Use -lsqlite3 if available, unless '--with-sqlite3=no'
|
||
HAVE_SQLITE3=no
|
||
SQLITE3_LIBS=
|
||
SQLITE3_CFLAGS=
|
||
if test "${with_sqlite3}" != "no"; then
|
||
if test "${REALLY_ANDROID}" = "yes"; then
|
||
ndk_SEARCH_MODULE([sqlite3], [SQLITE3], [HAVE_SQLITE3=yes])
|
||
|
||
if test "$HAVE_SQLITE3" = "yes"; then
|
||
SAVE_CFLAGS="$CFLAGS"
|
||
CFLAGS="$CFLAGS $SQLITE3_CFLAGS"
|
||
AC_CHECK_DECL([sqlite3_open_v2], [HAVE_SQLITE=yes],
|
||
[HAVE_SQLITE3=no], [#include <sqlite3.h>])
|
||
CFLAGS="$SAVE_CFLAGS"
|
||
fi
|
||
else
|
||
AC_CHECK_LIB([sqlite3], [sqlite3_open_v2],
|
||
[HAVE_SQLITE3=yes],
|
||
[HAVE_SQLITE3=no])
|
||
if test "$HAVE_SQLITE3" = "yes"; then
|
||
SQLITE3_LIBS=-lsqlite3
|
||
LIBS="$SQLITE3_LIBS $LIBS"
|
||
# Windows loads libsqlite dynamically
|
||
if test "${opsys}" = "mingw32"; then
|
||
SQLITE3_LIBS=
|
||
fi
|
||
AC_CHECK_LIB([sqlite3], [sqlite3_load_extension],
|
||
[HAVE_SQLITE3_LOAD_EXTENSION=yes],
|
||
[HAVE_SQLITE3_LOAD_EXTENSION=no])
|
||
if test "$HAVE_SQLITE3_LOAD_EXTENSION" = "yes"; then
|
||
AC_DEFINE([HAVE_SQLITE3_LOAD_EXTENSION], [1],
|
||
[Define to 1 if sqlite3 supports loading extensions.])
|
||
fi
|
||
fi
|
||
fi
|
||
|
||
if test "$HAVE_SQLITE3" = "yes"; then
|
||
AC_DEFINE([HAVE_SQLITE3], [1],
|
||
[Define to 1 if you have the libsqlite3 library (-lsqlite).])
|
||
fi
|
||
fi
|
||
|
||
AC_SUBST([SQLITE3_LIBS])
|
||
AC_SUBST([SQLITE3_CFLAGS])
|
||
|
||
HAVE_IMAGEMAGICK=no
|
||
if test "${HAVE_X11}" = "yes" || test "${HAVE_NS}" = "yes" || test "${HAVE_W32}" = "yes" || \
|
||
test "${HAVE_BE_APP}" = "yes" || test "${window_system}" = "pgtk" || \
|
||
test "${REALLY_ANDROID}" = "yes"; then
|
||
if test "${with_imagemagick}" != "no"; then
|
||
if test -n "$BREW"; then
|
||
# Homebrew doesn't link ImageMagick 6 by default, so make sure
|
||
# pkgconfig can find it.
|
||
export PKG_CONFIG_PATH="$PKG_CONFIG_PATH$PATH_SEPARATOR`$BREW --prefix imagemagick@6 2>/dev/null`/lib/pkgconfig"
|
||
fi
|
||
|
||
EMACS_CHECK_MODULES([IMAGEMAGICK], [MagickWand >= 7])
|
||
if test $HAVE_IMAGEMAGICK = yes; then
|
||
AC_DEFINE([HAVE_IMAGEMAGICK7], [1],
|
||
[Define to 1 if using ImageMagick7.])
|
||
else
|
||
## 6.3.5 is the earliest version known to work; see Bug#17339.
|
||
## 6.8.2 makes Emacs crash; see Bug#13867.
|
||
EMACS_CHECK_MODULES([IMAGEMAGICK], [Wand >= 6.3.5 Wand != 6.8.2])
|
||
fi
|
||
|
||
if test $HAVE_IMAGEMAGICK = yes; then
|
||
OLD_CFLAGS=$CFLAGS
|
||
OLD_LIBS=$LIBS
|
||
CFLAGS="$CFLAGS $IMAGEMAGICK_CFLAGS"
|
||
LIBS="$IMAGEMAGICK_LIBS $LIBS"
|
||
if test "$REALLY_ANDROID" != "yes"; then
|
||
AC_CHECK_FUNCS([MagickRelinquishMemory MagickExportImagePixels \
|
||
MagickMergeImageLayers MagickAutoOrientImage])
|
||
else
|
||
# AC_CHECK_FUNCS doesn't work for Android dependencies because
|
||
# they are built alongside Emacs.
|
||
AC_CHECK_DECLS([MagickRelinquishMemory,MagickExportImagePixels,
|
||
MagickMergeImageLayers,MagickAutoOrientImage],
|
||
[], [], [#include <MagickWand/MagickWand.h>])
|
||
fi
|
||
CFLAGS=$OLD_CFLAGS
|
||
LIBS=$OLD_LIBS
|
||
# Check that ImageMagick links. It does not link on Fedora 25
|
||
# with './configure CC=clang', as pkg-config outputs flags like
|
||
# -lomp that work for GCC but not Clang.
|
||
if test "$ac_cv_func_MagickRelinquishMemory" != yes \
|
||
&& test "$REALLY_ANDROID" != "yes"; then
|
||
HAVE_IMAGEMAGICK=no
|
||
fi
|
||
fi
|
||
if test $HAVE_IMAGEMAGICK = yes; then
|
||
AC_DEFINE([HAVE_IMAGEMAGICK], [1], [Define to 1 if using ImageMagick.])
|
||
else
|
||
if test "${with_imagemagick}" != "no"; then
|
||
AC_MSG_ERROR([ImageMagick wanted, but it does not compile. Maybe some library files are missing?]);
|
||
fi
|
||
IMAGEMAGICK_CFLAGS=
|
||
IMAGEMAGICK_LIBS=
|
||
fi
|
||
AC_SUBST([IMAGEMAGICK_CFLAGS])
|
||
AC_SUBST([IMAGEMAGICK_LIBS])
|
||
fi
|
||
fi
|
||
|
||
AC_CHECK_LIB([anl], [getaddrinfo_a], [HAVE_GETADDRINFO_A=yes])
|
||
if test "${HAVE_GETADDRINFO_A}" = "yes"; then
|
||
AC_DEFINE([HAVE_GETADDRINFO_A], [1],
|
||
[Define to 1 if you have getaddrinfo_a for asynchronous DNS resolution.])
|
||
GETADDRINFO_A_LIBS="-lanl"
|
||
AC_SUBST([GETADDRINFO_A_LIBS])
|
||
fi
|
||
|
||
HAVE_GTK=no
|
||
GTK_OBJ=
|
||
gtk_term_header=$term_header
|
||
check_gtk2=no
|
||
gtk3_pkg_errors=
|
||
if test "${opsys}" != "mingw32"; then
|
||
if test "${with_gtk3}" = "yes" || test "${with_gtk}" = "yes" || test "$USE_X_TOOLKIT" = "maybe"; then
|
||
GLIB_REQUIRED=2.37.5
|
||
if test "${window_system}" = "x11"; then
|
||
GTK_REQUIRED=3.10
|
||
else
|
||
GTK_REQUIRED=3.22.23
|
||
fi
|
||
GTK_MODULES="gtk+-3.0 >= $GTK_REQUIRED glib-2.0 >= $GLIB_REQUIRED"
|
||
|
||
dnl Checks for libraries.
|
||
EMACS_CHECK_MODULES([GTK], [$GTK_MODULES],
|
||
[pkg_check_gtk=yes], [pkg_check_gtk=no])
|
||
if test "$pkg_check_gtk" = "no" && test "$with_gtk3" = "yes"; then
|
||
AC_MSG_ERROR([$GTK_PKG_ERRORS])
|
||
fi
|
||
if test "$pkg_check_gtk" = "yes"; then
|
||
AC_DEFINE([HAVE_GTK3], [1], [Define to 1 if using GTK 3 or later.])
|
||
GTK_OBJ=emacsgtkfixed.o
|
||
gtk_term_header=gtkutil.h
|
||
USE_GTK_TOOLKIT="GTK3"
|
||
if test "x$ac_enable_gtk_deprecation_warnings" = x; then
|
||
AC_DEFINE([GDK_DISABLE_DEPRECATION_WARNINGS], [1],
|
||
[Define to 1 to disable GTK+/GDK deprecation warnings.])
|
||
AC_DEFINE([GLIB_DISABLE_DEPRECATION_WARNINGS], [1],
|
||
[Define to 1 to disable Glib deprecation warnings.])
|
||
fi
|
||
else
|
||
check_gtk2=yes
|
||
gtk3_pkg_errors="$GTK_PKG_ERRORS "
|
||
fi
|
||
fi
|
||
|
||
if test "${with_gtk2}" = "yes" || test "$check_gtk2" = "yes"; then
|
||
GLIB_REQUIRED=2.28
|
||
GTK_REQUIRED=2.24
|
||
GTK_MODULES="gtk+-2.0 >= $GTK_REQUIRED glib-2.0 >= $GLIB_REQUIRED"
|
||
|
||
dnl Checks for libraries.
|
||
EMACS_CHECK_MODULES([GTK], [$GTK_MODULES],
|
||
[pkg_check_gtk=yes], [pkg_check_gtk=no])
|
||
if test "$pkg_check_gtk" = "no" &&
|
||
{ test "$with_gtk" = yes || test "$with_gtk2" = "yes"; }
|
||
then
|
||
AC_MSG_ERROR([$gtk3_pkg_errors$GTK_PKG_ERRORS])
|
||
fi
|
||
test "$pkg_check_gtk" = "yes" && USE_GTK_TOOLKIT="GTK2"
|
||
fi
|
||
fi
|
||
|
||
OLD_CFLAGS=$CFLAGS
|
||
OLD_LIBS=$LIBS
|
||
|
||
if test x"$pkg_check_gtk" = xyes; then
|
||
|
||
AC_SUBST([GTK_LIBS])
|
||
CFLAGS="$CFLAGS $GTK_CFLAGS"
|
||
LIBS="$GTK_LIBS $LIBS"
|
||
dnl Try to compile a simple GTK program.
|
||
AC_CACHE_CHECK([whether GTK compiles], [emacs_cv_gtk_compiles],
|
||
[AC_LINK_IFELSE(
|
||
[AC_LANG_PROGRAM(
|
||
[[/* Check the Gtk and Glib APIs. */
|
||
#include <gtk/gtk.h>
|
||
#include <glib-object.h>
|
||
static void
|
||
callback (GObject *go, GParamSpec *spec, gpointer user_data)
|
||
{}
|
||
]],
|
||
[[
|
||
GtkSettings *gs = 0;
|
||
/* Use G_CALLBACK to make sure function pointers can be cast to void *;
|
||
strict C prohibits this. Use gtk_main_iteration to test that the
|
||
libraries are there. */
|
||
if (g_signal_handler_find (G_OBJECT (gs), G_SIGNAL_MATCH_FUNC,
|
||
0, 0, 0, G_CALLBACK (callback), 0))
|
||
gtk_main_iteration ();
|
||
]])],
|
||
[emacs_cv_gtk_compiles=yes], [emacs_cv_gtk_compiles=no])])
|
||
if test "${emacs_cv_gtk_compiles}" != "yes"; then
|
||
GTK_OBJ=
|
||
if test "$USE_X_TOOLKIT" != "maybe"; then
|
||
AC_MSG_ERROR([Gtk+ wanted, but it does not compile, see config.log. Maybe some x11-devel files missing?]);
|
||
fi
|
||
else
|
||
C_SWITCH_X_SITE="$C_SWITCH_X_SITE $GTK_CFLAGS"
|
||
HAVE_GTK=yes
|
||
AC_DEFINE([USE_GTK], [1], [Define to 1 if using GTK.])
|
||
GTK_OBJ="gtkutil.o $GTK_OBJ"
|
||
term_header=$gtk_term_header
|
||
USE_X_TOOLKIT=none
|
||
AC_MSG_WARN([[Your version of Gtk+ will have problems with
|
||
closing open displays. This is no problem if you just use
|
||
one display, but if you use more than one and close one of them
|
||
Emacs may crash.
|
||
See https://gitlab.gnome.org/GNOME/gtk/issues/221]])
|
||
fi
|
||
|
||
fi
|
||
AC_SUBST([GTK_OBJ])
|
||
|
||
|
||
if test "${HAVE_GTK}" = "yes"; then
|
||
|
||
dnl GTK scrollbars resemble toolkit scrollbars a lot, so to avoid
|
||
dnl a lot if #ifdef:s, say we have toolkit scrollbars.
|
||
if test "$with_toolkit_scroll_bars" != no; then
|
||
with_toolkit_scroll_bars=yes
|
||
fi
|
||
|
||
term_header=gtkutil.h
|
||
|
||
if test "${USE_GTK_TOOLKIT}" = GTK2; then
|
||
|
||
dnl Check if we have the old file selection dialog declared and
|
||
dnl in the link library. In 2.x it may be in the library,
|
||
dnl but not declared if deprecated featured has been selected out.
|
||
dnl AC_CHECK_DECL checks for a macro, so check for GTK_TYPE_FILE_SELECTION.
|
||
HAVE_GTK_FILE_SELECTION=no
|
||
AC_CHECK_DECL([GTK_TYPE_FILE_SELECTION],
|
||
[HAVE_GTK_FILE_SELECTION=yes],
|
||
[HAVE_GTK_FILE_SELECTION=no],
|
||
[AC_INCLUDES_DEFAULT
|
||
#include <gtk/gtk.h>])
|
||
if test "$HAVE_GTK_FILE_SELECTION" = yes; then
|
||
AC_CHECK_FUNCS([gtk_file_selection_new])
|
||
fi
|
||
|
||
dnl This procedure causes a bug on certain Ubuntu GTK+2 builds
|
||
AC_CHECK_FUNCS([gtk_window_set_has_resize_grip])
|
||
fi
|
||
fi
|
||
|
||
CFLAGS=$OLD_CFLAGS
|
||
LIBS=$OLD_LIBS
|
||
|
||
PGTK_OBJ=
|
||
PGTK_LIBS=
|
||
if test "$window_system" = "pgtk"; then
|
||
PGTK_OBJ="pgtkfns.o pgtkterm.o pgtkselect.o pgtkmenu.o pgtkim.o xsettings.o"
|
||
PGTK_LIBS="$GTK_LIBS"
|
||
fi
|
||
AC_SUBST([PGTK_OBJ])
|
||
AC_SUBST([PGTK_LIBS])
|
||
|
||
AC_CHECK_FUNCS([malloc_trim])
|
||
|
||
dnl D-Bus has been tested under GNU/Linux only. Must be adapted for
|
||
dnl other platforms.
|
||
HAVE_DBUS=no
|
||
DBUS_OBJ=
|
||
if test "${with_dbus}" = "yes"; then
|
||
EMACS_CHECK_MODULES([DBUS], [dbus-1 >= 1.0])
|
||
if test "$HAVE_DBUS" = yes; then
|
||
AC_DEFINE([HAVE_DBUS], [1], [Define to 1 if using D-Bus.])
|
||
dnl dbus_watch_get_unix_fd has been introduced in D-Bus 1.1.1.
|
||
dnl dbus_type_is_valid and dbus_validate_* have been introduced in
|
||
dnl D-Bus 1.5.12.
|
||
OLD_LIBS=$LIBS
|
||
LIBS="$LIBS $DBUS_LIBS"
|
||
AC_CHECK_FUNCS([dbus_watch_get_unix_fd \
|
||
dbus_type_is_valid \
|
||
dbus_validate_bus_name \
|
||
dbus_validate_path \
|
||
dbus_validate_interface \
|
||
dbus_validate_member])
|
||
LIBS=$OLD_LIBS
|
||
DBUS_OBJ=dbusbind.o
|
||
fi
|
||
fi
|
||
AC_SUBST([DBUS_CFLAGS])
|
||
AC_SUBST([DBUS_LIBS])
|
||
AC_SUBST([DBUS_OBJ])
|
||
|
||
dnl GSettings has been tested under GNU/Linux only.
|
||
HAVE_GSETTINGS=no
|
||
if test "${HAVE_X11}" = "yes" -o "${window_system}" = "pgtk" && test "${with_gsettings}" = "yes"; then
|
||
EMACS_CHECK_MODULES([GSETTINGS], [gio-2.0 >= 2.26])
|
||
if test "$HAVE_GSETTINGS" = "yes"; then
|
||
old_CFLAGS=$CFLAGS
|
||
CFLAGS="$CFLAGS $GSETTINGS_CFLAGS"
|
||
old_LIBS=$LIBS
|
||
LIBS="$LIBS $GSETTINGS_LIBS"
|
||
AC_CACHE_CHECK([whether GSettings is in gio], [emacs_cv_gsettings_in_gio],
|
||
[AC_LINK_IFELSE(
|
||
[AC_LANG_PROGRAM(
|
||
[[/* Check that gsettings really is present. */
|
||
#include <glib-object.h>
|
||
#include <gio/gio.h>
|
||
]],
|
||
[[
|
||
GSettings *settings;
|
||
GVariant *val = g_settings_get_value (settings, "");
|
||
]])],
|
||
[emacs_cv_gsettings_in_gio=yes], [emacs_cv_gsettings_in_gio=no])])
|
||
|
||
if test "$emacs_cv_gsettings_in_gio" = "yes"; then
|
||
AC_DEFINE([HAVE_GSETTINGS], [1], [Define to 1 if using GSettings.])
|
||
SETTINGS_CFLAGS="$GSETTINGS_CFLAGS"
|
||
SETTINGS_LIBS="$GSETTINGS_LIBS"
|
||
test "$with_gconf" = "yes" || with_gconf=no
|
||
fi
|
||
CFLAGS=$old_CFLAGS
|
||
LIBS=$old_LIBS
|
||
fi
|
||
fi
|
||
AC_SUBST([HAVE_GSETTINGS])
|
||
|
||
dnl GConf has been tested under GNU/Linux only.
|
||
dnl The version is really arbitrary, it is about the same age as Gtk+ 2.6.
|
||
HAVE_GCONF=no
|
||
if test "${HAVE_X11}" = "yes" -o "${window_system}" = "pgtk" && test "${with_gconf}" != "no"; then
|
||
EMACS_CHECK_MODULES([GCONF], [gconf-2.0 >= 2.13])
|
||
if test "$HAVE_GCONF" = yes; then
|
||
AC_DEFINE([HAVE_GCONF], [1], [Define to 1 if using GConf.])
|
||
dnl Newer GConf doesn't link with g_objects, so this is not defined.
|
||
SETTINGS_CFLAGS="$SETTINGS_CFLAGS $GCONF_CFLAGS"
|
||
SETTINGS_LIBS="$SETTINGS_LIBS $GCONF_LIBS"
|
||
fi
|
||
fi
|
||
|
||
if test "$HAVE_GSETTINGS" = "yes" || test "$HAVE_GCONF" = "yes"; then
|
||
EMACS_CHECK_MODULES([GOBJECT], [gobject-2.0 >= 2.0])
|
||
if test "$HAVE_GOBJECT" = "yes"; then
|
||
SETTINGS_CFLAGS="$SETTINGS_CFLAGS $GOBJECT_CFLAGS"
|
||
SETTINGS_LIBS="$SETTINGS_LIBS $GOBJECT_LIBS"
|
||
fi
|
||
SAVE_CFLAGS="$CFLAGS"
|
||
SAVE_LIBS="$LIBS"
|
||
CFLAGS="$SETTINGS_CFLAGS $CFLAGS"
|
||
LIBS="$SETTINGS_LIBS $LIBS"
|
||
CFLAGS="$SAVE_CFLAGS"
|
||
LIBS="$SAVE_LIBS"
|
||
fi
|
||
AC_SUBST([SETTINGS_CFLAGS])
|
||
AC_SUBST([SETTINGS_LIBS])
|
||
|
||
USE_STARTUP_NOTIFICATION=no
|
||
if test "${HAVE_GTK}" = "yes"; then
|
||
USE_STARTUP_NOTIFICATION=yes
|
||
fi
|
||
AC_SUBST([USE_STARTUP_NOTIFICATION])
|
||
|
||
dnl SELinux is available for Linux kernel based systems only.
|
||
dnl These include GNU/Linux and Android.
|
||
HAVE_LIBSELINUX=no
|
||
LIBSELINUX_LIBS=
|
||
LIBSELINUX_CFLAGS=
|
||
if test "${with_selinux}" = "yes"; then
|
||
if test "$REALLY_ANDROID" = "yes"; then
|
||
ndk_SEARCH_MODULE([libselinux], [LIBSELINUX],
|
||
[HAVE_LIBSELINUX=yes])
|
||
else
|
||
AC_CHECK_LIB([selinux], [lgetfilecon],
|
||
[HAVE_LIBSELINUX=yes],
|
||
[HAVE_LIBSELINUX=no])
|
||
fi
|
||
if test "$HAVE_LIBSELINUX" = yes; then
|
||
AC_DEFINE([HAVE_LIBSELINUX], [1], [Define to 1 if using SELinux.])
|
||
if test "$REALLY_ANDROID" != "yes"; then
|
||
LIBSELINUX_LIBS=-lselinux
|
||
fi
|
||
fi
|
||
fi
|
||
AC_SUBST([LIBSELINUX_LIBS])
|
||
AC_SUBST([LIBSELINUX_CFLAGS])
|
||
|
||
HAVE_GNUTLS=no
|
||
if test "${with_gnutls}" != "no" ; then
|
||
EMACS_CHECK_MODULES([LIBGNUTLS], [gnutls >= 2.12.2],
|
||
[HAVE_GNUTLS=yes], [HAVE_GNUTLS=no])
|
||
if test "${HAVE_GNUTLS}" = "yes"; then
|
||
AC_DEFINE([HAVE_GNUTLS], [1], [Define if using GnuTLS.])
|
||
fi
|
||
|
||
# Windows loads GnuTLS dynamically
|
||
if test "${opsys}" = "mingw32"; then
|
||
LIBGNUTLS_LIBS=
|
||
fi
|
||
fi
|
||
|
||
AC_SUBST([LIBGNUTLS_LIBS])
|
||
AC_SUBST([LIBGNUTLS_CFLAGS])
|
||
|
||
HAVE_LIBSYSTEMD=no
|
||
if test "${with_libsystemd}" = "yes" ; then
|
||
dnl This code has been tested with libsystemd 222 and later.
|
||
dnl FIXME: Find the earliest version number for which Emacs should work,
|
||
dnl and change '222' to that number.
|
||
EMACS_CHECK_MODULES([LIBSYSTEMD], [libsystemd >= 222],
|
||
[HAVE_LIBSYSTEMD=yes], [HAVE_LIBSYSTEMD=no])
|
||
if test "${HAVE_LIBSYSTEMD}" = "yes"; then
|
||
AC_DEFINE([HAVE_LIBSYSTEMD], [1], [Define if using libsystemd.])
|
||
fi
|
||
fi
|
||
|
||
AC_SUBST([LIBSYSTEMD_LIBS])
|
||
AC_SUBST([LIBSYSTEMD_CFLAGS])
|
||
|
||
HAVE_TREE_SITTER=no
|
||
TREE_SITTER_OBJ=
|
||
NEED_DYNLIB=no
|
||
|
||
if test "${with_tree_sitter}" != "no"; then
|
||
dnl Tree-sitter 0.20.2 added support to change the malloc it uses
|
||
dnl at runtime, we need that feature. However, tree-sitter's
|
||
dnl Makefile has problems, until that's fixed, all tree-sitter
|
||
dnl libraries distributed are versioned 0.6.3. We try to
|
||
dnl accept a tree-sitter library that has incorrect version as long
|
||
dnl as it supports changing malloc.
|
||
EMACS_CHECK_MODULES([TREE_SITTER], [tree-sitter >= 0.20.2],
|
||
[HAVE_TREE_SITTER=yes], [HAVE_TREE_SITTER=no])
|
||
if test "${HAVE_TREE_SITTER}" = yes; then
|
||
AC_DEFINE(HAVE_TREE_SITTER, 1, [Define if using tree-sitter.])
|
||
NEED_DYNLIB=yes
|
||
else
|
||
EMACS_CHECK_MODULES([TREE_SITTER], [tree-sitter >= 0.6.3],
|
||
[HAVE_TREE_SITTER=yes], [HAVE_TREE_SITTER=no])
|
||
if test "${HAVE_TREE_SITTER}" = yes; then
|
||
OLD_CFLAGS=$CFLAGS
|
||
OLD_LIBS=$LIBS
|
||
CFLAGS="$CFLAGS $TREE_SITTER_CFLAGS"
|
||
LIBS="$TREE_SITTER_LIBS $LIBS"
|
||
AC_CHECK_FUNCS([ts_set_allocator])
|
||
CFLAGS=$OLD_CFLAGS
|
||
LIBS=$OLD_LIBS
|
||
if test "$ac_cv_func_ts_set_allocator" = yes; then
|
||
AC_DEFINE(HAVE_TREE_SITTER, 1, [Define if using tree-sitter.])
|
||
NEED_DYNLIB=yes
|
||
else
|
||
AC_MSG_ERROR([Tree-sitter library exists but its version is too old]);
|
||
TREE_SITTER_CFLAGS=
|
||
TREE_SITTER_LIBS=
|
||
fi
|
||
fi
|
||
fi
|
||
|
||
# Windows loads tree-sitter dynamically
|
||
if test "${opsys}" = "mingw32"; then
|
||
TREE_SITTER_LIBS=
|
||
fi
|
||
fi
|
||
|
||
AC_SUBST(TREE_SITTER_LIBS)
|
||
AC_SUBST(TREE_SITTER_CFLAGS)
|
||
|
||
NOTIFY_OBJ=
|
||
NOTIFY_SUMMARY=no
|
||
|
||
dnl MS Windows native file monitor is available for mingw32 only.
|
||
case $with_file_notification,$opsys in
|
||
w32,cygwin)
|
||
AC_MSG_ERROR(['--with-file-notification=w32' was specified, but
|
||
this is only supported on MS-Windows native and MinGW32 builds.
|
||
Consider using gfile instead.])
|
||
;;
|
||
w32,* | yes,mingw32)
|
||
AC_CHECK_HEADER([windows.h])
|
||
if test "$ac_cv_header_windows_h" = yes ; then
|
||
AC_DEFINE([HAVE_W32NOTIFY], [1], [Define to 1 to use w32notify.])
|
||
NOTIFY_OBJ=w32notify.o
|
||
NOTIFY_SUMMARY="yes (w32)"
|
||
fi ;;
|
||
esac
|
||
|
||
dnl inotify is available only on Linux-kernel based systems.
|
||
case $with_file_notification,$NOTIFY_OBJ in
|
||
inotify, | yes,)
|
||
AC_CHECK_HEADER([sys/inotify.h])
|
||
if test "$ac_cv_header_sys_inotify_h" = yes ; then
|
||
AC_CHECK_FUNCS([inotify_init inotify_init1])
|
||
if test "$ac_cv_func_inotify_init" = yes; then
|
||
AC_DEFINE([HAVE_INOTIFY], [1], [Define to 1 to use inotify.])
|
||
NOTIFY_OBJ=inotify.o
|
||
NOTIFY_SUMMARY="yes (inotify)"
|
||
fi
|
||
fi ;;
|
||
esac
|
||
|
||
AS_IF([test "$opsys" != "haiku"], [
|
||
dnl kqueue is available on BSD-like systems and Haiku, but Haiku's
|
||
dnl implementation cannot monitor filesystem activity.
|
||
case $with_file_notification,$NOTIFY_OBJ in
|
||
kqueue,* | yes,)
|
||
EMACS_CHECK_MODULES([KQUEUE], [libkqueue])
|
||
if test "$HAVE_KQUEUE" = "yes"; then
|
||
AC_DEFINE([HAVE_KQUEUE], [1], [Define to 1 to use kqueue.])
|
||
CPPFLAGS="$CPPFLAGS -I/usr/include/kqueue"
|
||
NOTIFY_CFLAGS=$KQUEUE_CFLAGS
|
||
NOTIFY_LIBS=$KQUEUE_LIBS
|
||
NOTIFY_OBJ=kqueue.o
|
||
NOTIFY_SUMMARY="yes -lkqueue"
|
||
else
|
||
AC_SEARCH_LIBS([kqueue], [])
|
||
if test "$ac_cv_search_kqueue" != no; then
|
||
AC_DEFINE([HAVE_KQUEUE], [1], [Define to 1 to use kqueue.])
|
||
NOTIFY_OBJ=kqueue.o
|
||
NOTIFY_SUMMARY="yes (kqueue)"
|
||
fi
|
||
fi ;;
|
||
esac])
|
||
|
||
dnl g_file_monitor exists since glib 2.18. G_FILE_MONITOR_EVENT_MOVED
|
||
dnl has been added in glib 2.24. It has been tested under
|
||
dnl GNU/Linux only.
|
||
case $with_file_notification,$NOTIFY_OBJ in
|
||
gfile,* | yes,)
|
||
if test "${HAVE_NS}" = yes; then
|
||
AC_MSG_ERROR(['--with-file-notification=gfile' is not supported in NextStep builds.
|
||
Consider kqueue instead.])
|
||
else
|
||
EMACS_CHECK_MODULES([GFILENOTIFY], [gio-2.0 >= 2.24])
|
||
if test "$HAVE_GFILENOTIFY" = "yes"; then
|
||
AC_DEFINE([HAVE_GFILENOTIFY], [1], [Define to 1 if using GFile.])
|
||
NOTIFY_CFLAGS=$GFILENOTIFY_CFLAGS
|
||
NOTIFY_LIBS=$GFILENOTIFY_LIBS
|
||
NOTIFY_OBJ=gfilenotify.o
|
||
NOTIFY_SUMMARY="yes -lgio (gfile)"
|
||
fi
|
||
fi ;;
|
||
esac
|
||
|
||
case $with_file_notification,$NOTIFY_OBJ in
|
||
yes,* | no,* | *,?*) ;;
|
||
*) AC_MSG_ERROR([File notification '$with_file_notification' requested but requirements not found.]) ;;
|
||
esac
|
||
|
||
if test -n "$NOTIFY_OBJ"; then
|
||
AC_DEFINE([USE_FILE_NOTIFY], [1],
|
||
[Define to 1 if using file notifications.])
|
||
fi
|
||
AC_SUBST([NOTIFY_CFLAGS])
|
||
AC_SUBST([NOTIFY_LIBS])
|
||
AC_SUBST([NOTIFY_OBJ])
|
||
|
||
dnl Do not put whitespace before the #include statements below.
|
||
dnl Older compilers (eg sunos4 cc) choke on it.
|
||
HAVE_XAW3D=no
|
||
LUCID_LIBW=
|
||
if test x"${USE_X_TOOLKIT}" = xmaybe || test x"${USE_X_TOOLKIT}" = xLUCID; then
|
||
if test "$with_xaw3d" != no; then
|
||
AC_CACHE_VAL([emacs_cv_xaw3d],
|
||
[AC_LINK_IFELSE([AC_LANG_PROGRAM([[
|
||
#include <X11/Intrinsic.h>
|
||
#include <X11/Xaw3d/Simple.h>]],
|
||
[[]])],
|
||
[AC_CHECK_LIB([Xaw3d], [XawScrollbarSetThumb],
|
||
[emacs_cv_xaw3d=yes],
|
||
[emacs_cv_xaw3d=no])],
|
||
[emacs_cv_xaw3d=no])])
|
||
else
|
||
emacs_cv_xaw3d=no
|
||
fi
|
||
if test $emacs_cv_xaw3d = yes; then
|
||
AC_MSG_CHECKING([for xaw3d])
|
||
AC_MSG_RESULT([yes; using Lucid toolkit])
|
||
USE_X_TOOLKIT=LUCID
|
||
HAVE_XAW3D=yes
|
||
LUCID_LIBW=-lXaw3d
|
||
AC_DEFINE([HAVE_XAW3D], [1],
|
||
[Define to 1 if you have the Xaw3d library (-lXaw3d).])
|
||
else
|
||
AC_MSG_CHECKING([for xaw3d])
|
||
AC_MSG_RESULT([no])
|
||
AC_MSG_CHECKING([for libXaw])
|
||
AC_CACHE_VAL([emacs_cv_xaw],
|
||
[AC_LINK_IFELSE([AC_LANG_PROGRAM([[
|
||
#include <X11/Intrinsic.h>
|
||
#include <X11/Xaw/Simple.h>]],
|
||
[[]])],
|
||
[emacs_cv_xaw=yes],
|
||
[emacs_cv_xaw=no])])
|
||
if test $emacs_cv_xaw = yes; then
|
||
AC_MSG_RESULT([yes; using Lucid toolkit])
|
||
USE_X_TOOLKIT=LUCID
|
||
LUCID_LIBW=-lXaw
|
||
elif test x"${USE_X_TOOLKIT}" = xLUCID; then
|
||
AC_MSG_ERROR([Lucid toolkit requires X11/Xaw include files])
|
||
else
|
||
AC_MSG_ERROR([No X toolkit could be found.
|
||
If you are sure you want Emacs compiled without an X toolkit, pass
|
||
--with-x-toolkit=no
|
||
to configure. Otherwise, install the development libraries for the toolkit
|
||
that you want to use (e.g. Gtk+) and re-run configure.])
|
||
fi
|
||
fi
|
||
fi
|
||
|
||
X_TOOLKIT_TYPE=$USE_X_TOOLKIT
|
||
|
||
LIBXTR6=
|
||
LIBXMU=
|
||
if test "${USE_X_TOOLKIT}" != "none"; then
|
||
AC_MSG_CHECKING([X11 toolkit version])
|
||
AC_CACHE_VAL([emacs_cv_x11_toolkit_version_6],
|
||
[AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <X11/Intrinsic.h>]],
|
||
[[#if XtSpecificationRelease < 6
|
||
fail;
|
||
#endif
|
||
]])], [emacs_cv_x11_toolkit_version_6=yes],
|
||
[emacs_cv_x11_toolkit_version_6=no])])
|
||
HAVE_X11XTR6=$emacs_cv_x11_toolkit_version_6
|
||
if test $emacs_cv_x11_toolkit_version_6 = yes; then
|
||
AC_MSG_RESULT([6 or newer])
|
||
AC_DEFINE([HAVE_X11XTR6], [1],
|
||
[Define to 1 if you have the X11R6 or newer version of Xt.])
|
||
LIBXTR6="-lSM -lICE"
|
||
case "$opsys" in
|
||
## Use libw.a along with X11R6 Xt.
|
||
unixware) LIBXTR6="$LIBXTR6 -lw" ;;
|
||
esac
|
||
else
|
||
AC_MSG_RESULT([before 6])
|
||
fi
|
||
|
||
dnl If using toolkit, check whether libXmu.a exists.
|
||
dnl tranle@intellicorp.com says libXmu.a can need XtMalloc in libXt.a to link.
|
||
OLDLIBS="$LIBS"
|
||
if test x$HAVE_X11XTR6 = xyes; then
|
||
OTHERLIBS='-lXt -lSM -lICE'
|
||
else
|
||
OTHERLIBS='-lXt'
|
||
fi
|
||
AC_SEARCH_LIBS([XmuConvertStandardSelection], [Xmu], [], [], [$OTHERLIBS])
|
||
if test "X$LIBS" != "X$OLDLIBS"; then
|
||
LIBXMU=$ac_cv_search_XmuConvertStandardSelection
|
||
fi
|
||
LIBS=$OLDLIBS
|
||
dnl ac_cv_search_XmuConvertStandardSelection is also referenced below.
|
||
fi
|
||
AC_SUBST([LIBXTR6])
|
||
AC_SUBST([LIBXMU])
|
||
|
||
LIBXP=
|
||
if test "${USE_X_TOOLKIT}" = "MOTIF"; then
|
||
# OpenMotif may be installed in such a way on some GNU/Linux systems.
|
||
if test -d /usr/include/openmotif; then
|
||
CPPFLAGS="-I/usr/include/openmotif $CPPFLAGS"
|
||
emacs_cv_openmotif=yes
|
||
case "$canonical" in
|
||
x86_64-*-linux-gnu* | powerpc64-*-linux-gnu* | sparc64-*-linux-gnu*)
|
||
test -d /usr/lib64/openmotif && LDFLAGS="-L/usr/lib64/openmotif $LDFLAGS"
|
||
;;
|
||
*)
|
||
test -d /usr/lib/openmotif && LDFLAGS="-L/usr/lib/openmotif $LDFLAGS"
|
||
esac
|
||
else
|
||
emacs_cv_openmotif=no
|
||
fi
|
||
AC_CACHE_CHECK([for (Open)Motif version 2.1], [emacs_cv_motif_version_2_1],
|
||
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <Xm/Xm.h>]],
|
||
[[#if XmVERSION > 2 || (XmVERSION == 2 && XmREVISION >= 1)
|
||
int x = 5;
|
||
#else
|
||
Motif version prior to 2.1.
|
||
#endif]])],
|
||
[emacs_cv_motif_version_2_1=yes],
|
||
[emacs_cv_motif_version_2_1=no])])
|
||
if test $emacs_cv_motif_version_2_1 = yes; then
|
||
AC_CHECK_LIB([Xp], [XpCreateContext], [LIBXP=-lXp])
|
||
if test x$emacs_cv_openmotif = xyes; then
|
||
REAL_CPPFLAGS="-I/usr/include/openmotif $REAL_CPPFLAGS"
|
||
fi
|
||
else
|
||
# We put this in CFLAGS temporarily to precede other -I options
|
||
# that might be in CFLAGS temporarily.
|
||
# We put this in CPPFLAGS where it precedes the other -I options.
|
||
OLD_CPPFLAGS=$CPPFLAGS
|
||
OLD_CFLAGS=$CFLAGS
|
||
CPPFLAGS="-I/usr/X11R6/LessTif/Motif1.2/include $CPPFLAGS"
|
||
CFLAGS="-I/usr/X11R6/LessTif/Motif1.2/include $CFLAGS"
|
||
AC_CACHE_CHECK([for LessTif where some systems put it], [emacs_cv_lesstif],
|
||
[AC_COMPILE_IFELSE(
|
||
[AC_LANG_PROGRAM(
|
||
[[#include </usr/X11R6/LessTif/Motif1.2/include/Xm/Xm.h>
|
||
]],
|
||
[[int x = 5;]])],
|
||
[emacs_cv_lesstif=yes],
|
||
[emacs_cv_lesstif=no])])
|
||
if test $emacs_cv_lesstif = yes; then
|
||
# Make sure this -I option remains in CPPFLAGS after it is set
|
||
# back to REAL_CPPFLAGS.
|
||
# There is no need to change REAL_CFLAGS, because REAL_CFLAGS does not
|
||
# have those other -I options anyway. Ultimately, having this
|
||
# directory ultimately in CPPFLAGS will be enough.
|
||
REAL_CPPFLAGS="-I/usr/X11R6/LessTif/Motif1.2/include $REAL_CPPFLAGS"
|
||
LDFLAGS="-L/usr/X11R6/LessTif/Motif1.2/lib $LDFLAGS"
|
||
else
|
||
CFLAGS=$OLD_CFLAGS
|
||
CPPFLAGS=$OLD_CPPFLAGS
|
||
fi
|
||
fi
|
||
AC_CHECK_HEADER([Xm/BulletinB.h], [],
|
||
[AC_MSG_ERROR([Motif toolkit requested but requirements not found.])])
|
||
fi
|
||
|
||
dnl Use toolkit scroll bars if configured for GTK or X toolkit and either
|
||
dnl using Motif or Xaw3d is available, and unless
|
||
dnl --with-toolkit-scroll-bars=no was specified.
|
||
|
||
AH_TEMPLATE([USE_TOOLKIT_SCROLL_BARS],
|
||
[Define to 1 if we should use toolkit scroll bars.])dnl
|
||
USE_TOOLKIT_SCROLL_BARS=no
|
||
if test "${with_toolkit_scroll_bars}" != "no"; then
|
||
if test "${USE_X_TOOLKIT}" != "none"; then
|
||
if test "${USE_X_TOOLKIT}" = "MOTIF"; then
|
||
AC_DEFINE([USE_TOOLKIT_SCROLL_BARS])
|
||
HAVE_XAW3D=no
|
||
USE_TOOLKIT_SCROLL_BARS=yes
|
||
elif test "${HAVE_XAW3D}" = "yes" || test "${USE_X_TOOLKIT}" = "LUCID"; then
|
||
AC_DEFINE([USE_TOOLKIT_SCROLL_BARS])
|
||
USE_TOOLKIT_SCROLL_BARS=yes
|
||
fi
|
||
elif test "${HAVE_GTK}" = "yes"; then
|
||
AC_DEFINE([USE_TOOLKIT_SCROLL_BARS])
|
||
USE_TOOLKIT_SCROLL_BARS=yes
|
||
elif test "${HAVE_NS}" = "yes"; then
|
||
AC_DEFINE([USE_TOOLKIT_SCROLL_BARS])
|
||
USE_TOOLKIT_SCROLL_BARS=yes
|
||
elif test "${HAVE_W32}" = "yes"; then
|
||
AC_DEFINE([USE_TOOLKIT_SCROLL_BARS])
|
||
USE_TOOLKIT_SCROLL_BARS=yes
|
||
elif test "${HAVE_BE_APP}" = "yes"; then
|
||
AC_DEFINE([USE_TOOLKIT_SCROLL_BARS])
|
||
USE_TOOLKIT_SCROLL_BARS=yes
|
||
fi
|
||
elif test "${window_system}" != "x11" && test "${window_system}" != "none"; then
|
||
AC_MSG_ERROR([Non-toolkit scroll bars are not implemented for your system])
|
||
fi
|
||
|
||
dnl See if XIM is available.
|
||
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
||
#include <X11/Xlib.h>
|
||
#include <X11/Xresource.h>]],
|
||
[[XIMProc callback;]])],
|
||
[HAVE_XIM=yes
|
||
AC_DEFINE([HAVE_XIM], [1], [Define to 1 if XIM is available])],
|
||
[HAVE_XIM=no])
|
||
|
||
dnl Note this is non-standard. --with-xim does not control whether
|
||
dnl XIM support is compiled in, it only affects the runtime default of
|
||
dnl use_xim in xterm.c.
|
||
if test "${with_xim}" != "no"; then
|
||
AC_DEFINE([USE_XIM], [1],
|
||
[Define to 1 to default runtime use of XIM to on.])
|
||
fi
|
||
|
||
# Check for XRender
|
||
HAVE_XRENDER=no
|
||
if test "${HAVE_X11}" = "yes"; then
|
||
AC_COMPILE_IFELSE(
|
||
[AC_LANG_PROGRAM(
|
||
[[#include <X11/Intrinsic.h>
|
||
#include <X11/extensions/Xrender.h>
|
||
]],
|
||
[[return !XRenderQueryExtension;]])],
|
||
[AC_CHECK_LIB([Xrender], [XRenderQueryExtension], [HAVE_XRENDER=yes])])
|
||
if test $HAVE_XRENDER = yes; then
|
||
XRENDER_LIBS="-lXrender"
|
||
AC_SUBST([XRENDER_LIBS])
|
||
AC_DEFINE([HAVE_XRENDER], [1], [Define to 1 if XRender is available.])
|
||
fi
|
||
fi
|
||
|
||
HAVE_CAIRO=no
|
||
if test "${HAVE_X11}" = "yes"; then
|
||
if test "${with_cairo}" != "no"; then
|
||
CAIRO_REQUIRED=1.8.0
|
||
CAIRO_MODULE="cairo >= $CAIRO_REQUIRED"
|
||
EMACS_CHECK_MODULES([CAIRO], [$CAIRO_MODULE])
|
||
if test $HAVE_CAIRO = yes; then
|
||
AS_IF([test "x$with_cairo_xcb" = "xyes"], [
|
||
CAIRO_XCB_MODULE="cairo-xcb >= $CAIRO_REQUIRED"
|
||
EMACS_CHECK_MODULES([CAIRO_XCB], [$CAIRO_XCB_MODULE])
|
||
AS_IF([test "x$HAVE_CAIRO_XCB" = "xyes"], [
|
||
CAIRO_CFLAGS="$CAIRO_CFLAGS $CAIRO_XCB_CFLAGS"
|
||
CAIRO_LIBS="$CAIRO_LIBS $CAIRO_XCB_LIBS"
|
||
AC_DEFINE([USE_CAIRO_XCB], [1],
|
||
[Define to 1 if cairo XCB surfaces are available.])])])
|
||
AC_DEFINE([USE_CAIRO], [1], [Define to 1 if using cairo.])
|
||
CFLAGS="$CFLAGS $CAIRO_CFLAGS"
|
||
LIBS="$LIBS $CAIRO_LIBS"
|
||
AC_SUBST([CAIRO_CFLAGS])
|
||
AC_SUBST([CAIRO_LIBS])
|
||
else
|
||
AC_MSG_WARN([cairo requested but not found.])
|
||
fi
|
||
fi
|
||
fi
|
||
|
||
dnl Enable xwidgets if GTK3 and WebKitGTK+ are available.
|
||
dnl Enable xwidgets if macOS Cocoa and WebKit framework are available.
|
||
HAVE_XWIDGETS=no
|
||
XWIDGETS_OBJ=
|
||
if test "$with_xwidgets" != "no"; then
|
||
if test "$USE_GTK_TOOLKIT" = "GTK3" && test "$window_system" != "none"; then
|
||
WEBKIT_REQUIRED=2.12
|
||
WEBKIT_MODULES="webkit2gtk-4.1 >= $WEBKIT_REQUIRED"
|
||
EMACS_CHECK_MODULES([WEBKIT], [$WEBKIT_MODULES])
|
||
if test "$HAVE_WEBKIT" = "no"; then
|
||
WEBKIT_MODULES="webkit2gtk-4.0 >= $WEBKIT_REQUIRED"
|
||
EMACS_CHECK_MODULES([WEBKIT], [$WEBKIT_MODULES])
|
||
fi
|
||
HAVE_XWIDGETS=$HAVE_WEBKIT
|
||
XWIDGETS_OBJ="xwidget.o"
|
||
if test "$HAVE_X_WINDOWS" = "yes" && test "${with_cairo}" = "no"; then
|
||
CAIRO_XLIB_MODULES="cairo >= 1.8.0 cairo-xlib >= 1.8.0"
|
||
EMACS_CHECK_MODULES([CAIRO_XLIB], [$CAIRO_XLIB_MODULES])
|
||
if test $HAVE_CAIRO_XLIB = "yes"; then
|
||
CAIRO_CFLAGS="$CAIRO_XLIB_CFLAGS"
|
||
CAIRO_LIBS="$CAIRO_XLIB_LIBS"
|
||
AC_SUBST([CAIRO_CFLAGS])
|
||
AC_SUBST([CAIRO_LIBS])
|
||
else
|
||
AC_MSG_ERROR([xwidgets requested, but a suitable cairo installation wasn't found])
|
||
fi
|
||
fi
|
||
elif test "${NS_IMPL_COCOA}" = "yes"; then
|
||
dnl FIXME: Check framework WebKit2
|
||
dnl WEBKIT_REQUIRED=M.m.p
|
||
WEBKIT_LIBS="-Wl,-framework -Wl,WebKit"
|
||
WEBKIT_CFLAGS="-I/System/Library/Frameworks/WebKit.framework/Headers"
|
||
HAVE_WEBKIT="yes"
|
||
HAVE_XWIDGETS=$HAVE_WEBKIT
|
||
XWIDGETS_OBJ="xwidget.o"
|
||
NS_OBJC_OBJ="$NS_OBJC_OBJ nsxwidget.o"
|
||
dnl Update NS_OBJC_OBJ with added nsxwidget.o
|
||
AC_SUBST([NS_OBJC_OBJ])
|
||
else
|
||
AC_MSG_ERROR([xwidgets requested, it requires GTK3 as X window toolkit or macOS Cocoa as window system.])
|
||
fi
|
||
|
||
test $HAVE_XWIDGETS = yes ||
|
||
AC_MSG_ERROR([xwidgets requested but WebKitGTK+ or WebKit framework not found.])
|
||
|
||
AC_DEFINE([HAVE_XWIDGETS], [1], [Define to 1 if you have xwidgets support.])
|
||
fi
|
||
AC_SUBST([XWIDGETS_OBJ])
|
||
|
||
if test "$window_system" = "pgtk"; then
|
||
CAIRO_REQUIRED=1.12.0
|
||
CAIRO_MODULE="cairo >= $CAIRO_REQUIRED"
|
||
EMACS_CHECK_MODULES([CAIRO], [$CAIRO_MODULE])
|
||
if test $HAVE_CAIRO = yes; then
|
||
AC_DEFINE([USE_CAIRO], [1], [Define to 1 if using cairo.])
|
||
else
|
||
AC_MSG_ERROR([cairo required but not found.])
|
||
fi
|
||
|
||
CFLAGS="$CFLAGS $CAIRO_CFLAGS"
|
||
LIBS="$LIBS $CAIRO_LIBS"
|
||
AC_SUBST([CAIRO_CFLAGS])
|
||
AC_SUBST([CAIRO_LIBS])
|
||
fi
|
||
|
||
if test "${HAVE_BE_APP}" = "yes"; then
|
||
if test "${with_be_cairo}" != "no"; then
|
||
CAIRO_REQUIRED=1.8.0
|
||
CAIRO_MODULE="cairo >= $CAIRO_REQUIRED"
|
||
EMACS_CHECK_MODULES([CAIRO], [$CAIRO_MODULE])
|
||
if test $HAVE_CAIRO = yes; then
|
||
AC_DEFINE([USE_BE_CAIRO], [1], [Define to 1 if using cairo on Haiku.])
|
||
CFLAGS="$CFLAGS $CAIRO_CFLAGS"
|
||
LIBS="$LIBS $CAIRO_LIBS"
|
||
AC_SUBST([CAIRO_CFLAGS])
|
||
AC_SUBST([CAIRO_LIBS])
|
||
else
|
||
AC_MSG_WARN([cairo requested but not found.])
|
||
fi
|
||
fi
|
||
fi
|
||
|
||
### Start of font-backend (under any platform) section.
|
||
# (nothing here yet -- this is a placeholder)
|
||
### End of font-backend (under any platform) section.
|
||
|
||
### Start of font-backend (under X11) section.
|
||
if test "${HAVE_X11}" = "yes"; then
|
||
if test $HAVE_CAIRO = yes; then
|
||
dnl Strict linkers fail with
|
||
dnl ftfont.o: undefined reference to symbol 'FT_New_Face'
|
||
dnl if -lfreetype is not specified.
|
||
dnl The following is needed to set FREETYPE_LIBS.
|
||
EMACS_CHECK_MODULES([FREETYPE], [freetype2])
|
||
|
||
test "$HAVE_FREETYPE" = "no" && AC_MSG_ERROR([cairo requires libfreetype])
|
||
|
||
EMACS_CHECK_MODULES([FONTCONFIG], [fontconfig >= 2.2.0])
|
||
|
||
test "$HAVE_FONTCONFIG" = "no" &&
|
||
AC_MSG_ERROR([cairo requires libfontconfig])
|
||
dnl For the "Does Emacs use" message at the end.
|
||
HAVE_XFT=no
|
||
else
|
||
## Use -lXft if available, unless '--with-xft=no'.
|
||
HAVE_XFT=maybe
|
||
if test "x${with_x}" = "xno"; then
|
||
with_xft="no";
|
||
fi
|
||
|
||
if test "$with_xft" != no; then
|
||
EMACS_CHECK_MODULES([FONTCONFIG], [fontconfig >= 2.2.0])
|
||
with_xft=$HAVE_FONTCONFIG
|
||
fi
|
||
|
||
if test "x${with_xft}" != "xno"; then
|
||
|
||
EMACS_CHECK_MODULES([XFT], [xft >= 0.13.0], [], [HAVE_XFT=no])
|
||
## Because xterm.c uses XRenderQueryExtension when XFT is
|
||
## enabled, we also need to link to -lXrender.
|
||
if test "$HAVE_XFT" != no && test "$HAVE_XRENDER" != no; then
|
||
OLD_CPPFLAGS="$CPPFLAGS"
|
||
OLD_CFLAGS="$CFLAGS"
|
||
OLD_LIBS="$LIBS"
|
||
CPPFLAGS="$CPPFLAGS $XFT_CFLAGS"
|
||
CFLAGS="$CFLAGS $XFT_CFLAGS"
|
||
LIBS="$XFT_LIBS $LIBS"
|
||
AC_CHECK_HEADER([X11/Xft/Xft.h],
|
||
[AC_CHECK_LIB([Xft], [XftFontOpen], [HAVE_XFT=yes],
|
||
[], [$XFT_LIBS])],
|
||
[],
|
||
[[#include <X11/X.h>]])
|
||
|
||
if test "${HAVE_XFT}" = "yes"; then
|
||
AC_DEFINE([HAVE_XFT], [1], [Define to 1 if you have the Xft library.])
|
||
AC_SUBST([XFT_LIBS])
|
||
C_SWITCH_X_SITE="$C_SWITCH_X_SITE $XFT_CFLAGS"
|
||
fi # "${HAVE_XFT}" = "yes"
|
||
CPPFLAGS=$OLD_CPPFLAGS
|
||
CFLAGS=$OLD_CFLAGS
|
||
LIBS=$OLD_LIBS
|
||
else
|
||
# Make sure XFT is disabled if we found XFT but not XRender
|
||
HAVE_XFT=no
|
||
fi # "$HAVE_XFT" != no
|
||
fi # "x${with_xft}" != "xno"
|
||
|
||
if test "$HAVE_XFT" != "yes"; then
|
||
dnl For the "Does Emacs use" message at the end.
|
||
HAVE_XFT=no
|
||
HAVE_FREETYPE=no
|
||
else
|
||
dnl Strict linkers fail with
|
||
dnl ftfont.o: undefined reference to symbol 'FT_New_Face'
|
||
dnl if -lfreetype is not specified.
|
||
dnl The following is needed to set FREETYPE_LIBS.
|
||
EMACS_CHECK_MODULES([FREETYPE], [freetype2])
|
||
|
||
test "$HAVE_FREETYPE" = "no" &&
|
||
AC_MSG_ERROR([libxft requires libfreetype])
|
||
fi
|
||
fi # $HAVE_CAIRO != yes
|
||
|
||
HAVE_LIBOTF=no
|
||
if test "${HAVE_FREETYPE}" = "yes"; then
|
||
AC_DEFINE([HAVE_FREETYPE], [1],
|
||
[Define to 1 if using the freetype and fontconfig libraries.])
|
||
OLD_CFLAGS=$CFLAGS
|
||
OLD_LIBS=$LIBS
|
||
CFLAGS="$CFLAGS $FREETYPE_CFLAGS"
|
||
LIBS="$FREETYPE_LIBS $LIBS"
|
||
AC_CHECK_FUNCS([FT_Face_GetCharVariantIndex])
|
||
CFLAGS=$OLD_CFLAGS
|
||
LIBS=$OLD_LIBS
|
||
if test "${with_libotf}" != "no"; then
|
||
EMACS_CHECK_MODULES([LIBOTF], [libotf])
|
||
if test "$HAVE_LIBOTF" = "yes"; then
|
||
AC_DEFINE([HAVE_LIBOTF], [1], [Define to 1 if using libotf.])
|
||
AC_CHECK_LIB([otf], [OTF_get_variation_glyphs],
|
||
[HAVE_OTF_GET_VARIATION_GLYPHS=yes],
|
||
[HAVE_OTF_GET_VARIATION_GLYPHS=no])
|
||
if test "${HAVE_OTF_GET_VARIATION_GLYPHS}" = "yes"; then
|
||
AC_DEFINE([HAVE_OTF_GET_VARIATION_GLYPHS], [1],
|
||
[Define to 1 if libotf has OTF_get_variation_glyphs.])
|
||
fi
|
||
if $PKG_CONFIG --atleast-version=0.9.16 libotf; then :; else
|
||
AC_DEFINE([HAVE_OTF_KANNADA_BUG], [1],
|
||
[Define to 1 if libotf is affected by https://debbugs.gnu.org/28110.])
|
||
fi
|
||
fi
|
||
fi
|
||
dnl FIXME should there be an error if HAVE_FREETYPE != yes?
|
||
dnl Does the new font backend require it, or can it work without it?
|
||
fi
|
||
|
||
HAVE_M17N_FLT=no
|
||
if test "${HAVE_LIBOTF}" = yes; then
|
||
if test "${with_m17n_flt}" != "no"; then
|
||
EMACS_CHECK_MODULES([M17N_FLT], [m17n-flt])
|
||
if test "$HAVE_M17N_FLT" = "yes"; then
|
||
AC_DEFINE([HAVE_M17N_FLT], [1], [Define to 1 if using libm17n-flt.])
|
||
fi
|
||
fi
|
||
fi
|
||
else # "${HAVE_X11}" != "yes"
|
||
if test $window_system = pgtk; then
|
||
EMACS_CHECK_MODULES([FONTCONFIG], [fontconfig >= 2.2.0])
|
||
EMACS_CHECK_MODULES([FREETYPE], [freetype2])
|
||
if test "$HAVE_FONTCONFIG" != yes -o "$HAVE_FREETYPE" != yes; then
|
||
AC_MSG_ERROR([fontconfig and freetype is required.])
|
||
fi
|
||
HAVE_LIBOTF=no
|
||
AC_DEFINE([HAVE_FREETYPE], [1],
|
||
[Define to 1 if using the freetype and fontconfig libraries.])
|
||
if test "${with_libotf}" != "no"; then
|
||
EMACS_CHECK_MODULES([LIBOTF], [libotf])
|
||
if test "$HAVE_LIBOTF" = "yes"; then
|
||
AC_DEFINE([HAVE_LIBOTF], [1], [Define to 1 if using libotf.])
|
||
AC_CHECK_LIB([otf], [OTF_get_variation_glyphs],
|
||
[HAVE_OTF_GET_VARIATION_GLYPHS=yes],
|
||
[HAVE_OTF_GET_VARIATION_GLYPHS=no])
|
||
if test "${HAVE_OTF_GET_VARIATION_GLYPHS}" = "yes"; then
|
||
AC_DEFINE([HAVE_OTF_GET_VARIATION_GLYPHS], [1],
|
||
[Define to 1 if libotf has OTF_get_variation_glyphs.])
|
||
fi
|
||
fi
|
||
fi
|
||
else
|
||
HAVE_XFT=no
|
||
HAVE_FREETYPE=no
|
||
HAVE_LIBOTF=no
|
||
HAVE_M17N_FLT=no
|
||
fi
|
||
fi # "${HAVE_X11}" != "yes"
|
||
|
||
HAVE_HARFBUZZ=no
|
||
### On MS-Windows we use hb_font_get_nominal_glyph, which appeared
|
||
### in HarfBuzz version 1.2.3
|
||
if test "${HAVE_W32}" = "yes"; then
|
||
harfbuzz_required_ver=1.2.3
|
||
else
|
||
harfbuzz_required_ver=0.9.42
|
||
fi
|
||
if test "${HAVE_X11}" = "yes" && test "${HAVE_FREETYPE}" = "yes" \
|
||
|| test "$window_system" = "pgtk" \
|
||
|| test "${HAVE_W32}" = "yes" \
|
||
|| test "$REALLY_ANDROID" = "yes"; then
|
||
if test "${with_harfbuzz}" != "no"; then
|
||
EMACS_CHECK_MODULES([HARFBUZZ], [harfbuzz >= $harfbuzz_required_ver])
|
||
AS_IF([test "$HAVE_HARFBUZZ" = "yes"],[
|
||
AC_DEFINE([HAVE_HARFBUZZ], [1], [Define to 1 if using HarfBuzz.])
|
||
### mingw32 and Cygwin-w32 don't use -lharfbuzz, since they load
|
||
### the library dynamically.
|
||
AS_IF([test "${HAVE_W32}" = "yes"], [HARFBUZZ_LIBS=])
|
||
## Now check for `hb_font_set_var_named_instance'.
|
||
OLD_CFLAGS=$CFLAGS
|
||
CFLAGS="$HARFBUZZ_CFLAGS $CFLAGS"
|
||
EMACS_CHECK_LIB([harfbuzz], [hb_font_set_var_named_instance],
|
||
[AC_DEFINE([HAVE_HB_FONT_SET_VAR_NAMED_INSTANCE], [1],
|
||
[Define to 1 if `hb_font_set_var_named_instance' is present.])],
|
||
[], [$HARFBUZZ_LIBS], [#include <hb.h>])
|
||
CFLAGS=$OLD_CFLAGS])
|
||
fi
|
||
fi
|
||
|
||
### Start of font-backend (under Haiku) selectionn.
|
||
if test "${HAVE_BE_APP}" = "yes"; then
|
||
if test $HAVE_CAIRO = "yes"; then
|
||
EMACS_CHECK_MODULES([FREETYPE], [freetype2 >= 2.5.0])
|
||
test "$HAVE_FREETYPE" = "no" &&
|
||
AC_MSG_ERROR([cairo on Haiku requires libfreetype])
|
||
EMACS_CHECK_MODULES([FONTCONFIG], [fontconfig >= 2.2.0])
|
||
test "$HAVE_FONTCONFIG" = "no" &&
|
||
AC_MSG_ERROR([cairo on Haiku requires libfontconfig])
|
||
fi
|
||
|
||
HAVE_LIBOTF=no
|
||
|
||
if test "${HAVE_FREETYPE}" = "yes"; then
|
||
AC_DEFINE([HAVE_FREETYPE], [1],
|
||
[Define to 1 if using the freetype and fontconfig libraries.])
|
||
OLD_CFLAGS=$CFLAGS
|
||
OLD_LIBS=$LIBS
|
||
CFLAGS="$CFLAGS $FREETYPE_CFLAGS"
|
||
LIBS="$FREETYPE_LIBS $LIBS"
|
||
AC_CHECK_FUNCS([FT_Face_GetCharVariantIndex])
|
||
CFLAGS=$OLD_CFLAGS
|
||
LIBS=$OLD_LIBS
|
||
if test "${with_libotf}" != "no"; then
|
||
EMACS_CHECK_MODULES([LIBOTF], [libotf])
|
||
if test "$HAVE_LIBOTF" = "yes"; then
|
||
AC_DEFINE([HAVE_LIBOTF], [1], [Define to 1 if using libotf.])
|
||
AC_CHECK_LIB([otf], [OTF_get_variation_glyphs],
|
||
[HAVE_OTF_GET_VARIATION_GLYPHS=yes],
|
||
[HAVE_OTF_GET_VARIATION_GLYPHS=no])
|
||
if test "${HAVE_OTF_GET_VARIATION_GLYPHS}" = "yes"; then
|
||
AC_DEFINE([HAVE_OTF_GET_VARIATION_GLYPHS], [1],
|
||
[Define to 1 if libotf has OTF_get_variation_glyphs.])
|
||
fi
|
||
if $PKG_CONFIG --atleast-version=0.9.16 libotf; then :; else
|
||
AC_DEFINE([HAVE_OTF_KANNADA_BUG], [1],
|
||
[Define to 1 if libotf is affected by https://debbugs.gnu.org/28110.])
|
||
fi
|
||
fi
|
||
fi
|
||
dnl FIXME should there be an error if HAVE_FREETYPE != yes?
|
||
dnl Does the new font backend require it, or can it work without it?
|
||
fi
|
||
fi
|
||
|
||
if test "${HAVE_BE_APP}" = "yes" && test "${HAVE_FREETYPE}" = "yes"; then
|
||
if test "${with_harfbuzz}" != "no"; then
|
||
EMACS_CHECK_MODULES([HARFBUZZ], [harfbuzz >= $harfbuzz_required_ver])
|
||
if test "$HAVE_HARFBUZZ" = "yes"; then
|
||
AC_DEFINE([HAVE_HARFBUZZ], [1], [Define to 1 if using HarfBuzz.])
|
||
fi
|
||
fi
|
||
fi
|
||
|
||
### End of font-backend section.
|
||
|
||
AC_SUBST([FREETYPE_CFLAGS])
|
||
AC_SUBST([FREETYPE_LIBS])
|
||
AC_SUBST([FONTCONFIG_CFLAGS])
|
||
AC_SUBST([FONTCONFIG_LIBS])
|
||
AC_SUBST([HARFBUZZ_CFLAGS])
|
||
AC_SUBST([HARFBUZZ_LIBS])
|
||
AC_SUBST([LIBOTF_CFLAGS])
|
||
AC_SUBST([LIBOTF_LIBS])
|
||
AC_SUBST([M17N_FLT_CFLAGS])
|
||
AC_SUBST([M17N_FLT_LIBS])
|
||
|
||
XCB_LIBS=
|
||
if test "${HAVE_X11}" = "yes"; then
|
||
AC_CHECK_HEADER([X11/Xlib-xcb.h],
|
||
[AC_CHECK_LIB([xcb], [xcb_translate_coordinates], [HAVE_XCB=yes])])
|
||
if test "${HAVE_XCB}" = "yes"; then
|
||
AC_CHECK_LIB([X11-xcb], [XGetXCBConnection], [HAVE_X11_XCB=yes])
|
||
if test "${HAVE_X11_XCB}" = "yes"; then
|
||
AC_DEFINE([USE_XCB], [1],
|
||
[Define to 1 if you have the XCB library and X11-XCB library for mixed
|
||
X11/XCB programming.])
|
||
XCB_LIBS="-lX11-xcb -lxcb"
|
||
fi
|
||
fi
|
||
fi
|
||
AC_SUBST([XCB_LIBS])
|
||
|
||
### Use -lXpm if available, unless '--with-xpm=no'.
|
||
### mingw32 doesn't use -lXpm, since it loads the library dynamically.
|
||
### The Cygwin-w32 build uses <noX/xpm.h> instead of <X11/xpm.h>, so
|
||
### we need to set LDFLAGS accordingly.
|
||
HAVE_XPM=no
|
||
LIBXPM=
|
||
if test "${HAVE_W32}" = "yes" && test "${opsys}" = "cygwin"; then
|
||
if test "${with_xpm}" != "no"; then
|
||
SAVE_LDFLAGS="$LDFLAGS"
|
||
LDFLAGS="$LDFLAGS -L/usr/lib/noX"
|
||
AC_CHECK_HEADER([noX/xpm.h],
|
||
[AC_CHECK_LIB([Xpm], [XpmReadFileToImage], [HAVE_XPM=yes])])
|
||
if test "${HAVE_XPM}" = "yes"; then
|
||
AC_CACHE_CHECK([for XpmReturnAllocPixels preprocessor define],
|
||
[emacs_cv_cpp_xpm_return_alloc_pixels],
|
||
[AC_EGREP_CPP([no_return_alloc_pixels],
|
||
[#include "noX/xpm.h"
|
||
#ifndef XpmReturnAllocPixels
|
||
no_return_alloc_pixels
|
||
#endif
|
||
], [emacs_cv_cpp_xpm_return_alloc_pixels=no],
|
||
[emacs_cv_cpp_xpm_return_alloc_pixels=yes])])
|
||
|
||
if test "$emacs_cv_cpp_xpm_return_alloc_pixels" = "no"; then
|
||
HAVE_XPM=no
|
||
LDFLAGS="$SAVE_LDFLAGS"
|
||
fi
|
||
fi
|
||
fi
|
||
|
||
if test "${HAVE_XPM}" = "yes"; then
|
||
AC_DEFINE([HAVE_XPM], [1],
|
||
[Define to 1 if you have the Xpm library (-lXpm).])
|
||
LIBXPM=-lXpm
|
||
fi
|
||
fi
|
||
|
||
if test "${HAVE_X11}" = "yes"; then
|
||
dnl Avoid Xpm on AIX unless requested, as it crashes; see Bug#17598.
|
||
case $opsys,$with_xpm_set,$with_xpm in
|
||
aix4-2,set,yes) ;;
|
||
aix4-2,*) with_xpm=no;;
|
||
esac
|
||
|
||
if test "${with_xpm}" != "no"; then
|
||
AC_CHECK_HEADER([X11/xpm.h],
|
||
[AC_CHECK_LIB([Xpm], [XpmReadFileToPixmap],
|
||
[HAVE_XPM=yes], [], [-lX11])])
|
||
if test "${HAVE_XPM}" = "yes"; then
|
||
AC_CACHE_CHECK([for XpmReturnAllocPixels preprocessor define],
|
||
[emacs_cv_cpp_xpm_return_alloc_pixels],
|
||
[AC_EGREP_CPP([no_return_alloc_pixels],
|
||
[#include "X11/xpm.h"
|
||
#ifndef XpmReturnAllocPixels
|
||
no_return_alloc_pixels
|
||
#endif
|
||
], [emacs_cv_cpp_xpm_return_alloc_pixels=no],
|
||
[emacs_cv_cpp_xpm_return_alloc_pixels=yes])])
|
||
|
||
if test "$emacs_cv_cpp_xpm_return_alloc_pixels" = "no"; then
|
||
HAVE_XPM=no
|
||
fi
|
||
fi
|
||
fi
|
||
|
||
if test "${HAVE_XPM}" = "yes"; then
|
||
AC_DEFINE([HAVE_XPM], [1],
|
||
[Define to 1 if you have the Xpm library (-lXpm).])
|
||
LIBXPM=-lXpm
|
||
elif test "$opsys,$LUCID_LIBW" = aix4-2,-lXaw; then
|
||
dnl AIX -lXaw needs -lXpm linked too; see Bug#17598 Message#152.
|
||
LIBXPM=-lXpm
|
||
fi
|
||
fi
|
||
|
||
### FIXME: Perhaps regroup to minimize code duplication due to MinGW's
|
||
### slightly different requirements wrt image libraries (it doesn't
|
||
### use -lXpm because it loads the xpm shared library dynamically at
|
||
### run time).
|
||
if test "${opsys}" = "mingw32"; then
|
||
if test "${with_xpm}" != "no"; then
|
||
AC_CHECK_HEADER([X11/xpm.h], [HAVE_XPM=yes], [HAVE_XPM=no], [
|
||
#define FOR_MSW 1])
|
||
fi
|
||
|
||
if test "${HAVE_XPM}" = "yes"; then
|
||
AC_DEFINE([HAVE_XPM], [1],
|
||
[Define to 1 if you have the Xpm library (-lXpm).])
|
||
fi
|
||
fi
|
||
|
||
AC_SUBST([LIBXPM])
|
||
|
||
### Use -ljpeg if available, unless '--with-jpeg=no'.
|
||
HAVE_JPEG=no
|
||
LIBJPEG=
|
||
JPEG_CFLAGS=
|
||
if test "${HAVE_X11}" = "yes" || test "${HAVE_W32}" = "yes" \
|
||
|| test "${HAVE_NS}" = "yes" || test "${HAVE_BE_APP}" = "yes" \
|
||
|| test "$window_system" = "pgtk" \
|
||
|| test "${REALLY_ANDROID}" = "yes"; then
|
||
if test "${with_jpeg}" != "no"; then
|
||
if test "${REALLY_ANDROID}" = "yes"; then
|
||
# Look for libjpeg using the NDK.
|
||
ndk_SEARCH_MODULE([libjpeg], [JPEG], [HAVE_JPEG=yes])
|
||
|
||
if test "$HAVE_JPEG" = "yes"; then
|
||
LIBJPEG="$JPEG_LIBS"
|
||
|
||
AC_DEFINE([HAVE_JPEG], [1],
|
||
[Define to 1 if you have the jpeg library (typically -ljpeg).])
|
||
fi
|
||
else
|
||
AC_CACHE_CHECK([for jpeglib 6b or later],
|
||
[emacs_cv_jpeglib],
|
||
[OLD_LIBS=$LIBS
|
||
for emacs_cv_jpeglib in yes -ljpeg no; do
|
||
case $emacs_cv_jpeglib in
|
||
yes) ;;
|
||
no) break;;
|
||
*) LIBS="$LIBS $emacs_cv_jpeglib";;
|
||
esac
|
||
AC_LINK_IFELSE(
|
||
[AC_LANG_PROGRAM(
|
||
[[#undef HAVE_STDLIB_H /* Avoid config.h/jpeglib.h collision. */
|
||
#include <stdio.h> /* jpeglib.h needs FILE and size_t. */
|
||
#include <jpeglib.h>
|
||
#include <jerror.h>
|
||
char verify[JPEG_LIB_VERSION < 62 ? -1 : 1];
|
||
struct jpeg_decompress_struct cinfo;
|
||
]],
|
||
[[
|
||
jpeg_create_decompress (&cinfo);
|
||
WARNMS (&cinfo, JWRN_JPEG_EOF);
|
||
jpeg_destroy_decompress (&cinfo);
|
||
]])],
|
||
[emacs_link_ok=yes],
|
||
[emacs_link_ok=no])
|
||
LIBS=$OLD_LIBS
|
||
test $emacs_link_ok = yes && break
|
||
done])
|
||
if test "$emacs_cv_jpeglib" != no; then
|
||
HAVE_JPEG=yes
|
||
AC_DEFINE([HAVE_JPEG], [1],
|
||
[Define to 1 if you have the jpeg library (typically -ljpeg).])
|
||
### mingw32 doesn't use -ljpeg, since it loads the library
|
||
### dynamically when needed, and doesn't want a run-time
|
||
### dependency on the jpeglib DLL.
|
||
test "$emacs_cv_jpeglib" != yes && test "${opsys}" != "mingw32" \
|
||
&& LIBJPEG=$emacs_cv_jpeglib
|
||
fi
|
||
fi
|
||
fi
|
||
fi
|
||
AC_SUBST([LIBJPEG])
|
||
AC_SUBST([JPEG_CFLAGS])
|
||
|
||
HAVE_LCMS2=no
|
||
LCMS2_CFLAGS=
|
||
LCMS2_LIBS=
|
||
if test "${with_lcms2}" != "no"; then
|
||
EMACS_CHECK_MODULES([LCMS2], [lcms2])
|
||
fi
|
||
if test "${HAVE_LCMS2}" = "yes"; then
|
||
AC_DEFINE([HAVE_LCMS2], [1],
|
||
[Define to 1 if you have the lcms2 library (-llcms2).])
|
||
### mingw32 doesn't use -llcms2, since it loads the library dynamically.
|
||
if test "${opsys}" = "mingw32"; then
|
||
LCMS2_LIBS=
|
||
fi
|
||
fi
|
||
AC_SUBST([LCMS2_CFLAGS])
|
||
AC_SUBST([LCMS2_LIBS])
|
||
|
||
HAVE_ZLIB=no
|
||
LIBZ=
|
||
if test "${with_zlib}" != "no"; then
|
||
OLIBS=$LIBS
|
||
AC_SEARCH_LIBS([inflateEnd], [z], [HAVE_ZLIB=yes])
|
||
LIBS=$OLIBS
|
||
case $ac_cv_search_inflateEnd in
|
||
-*) LIBZ=$ac_cv_search_inflateEnd ;;
|
||
esac
|
||
fi
|
||
if test "${HAVE_ZLIB}" = "yes"; then
|
||
AC_DEFINE([HAVE_ZLIB], [1],
|
||
[Define to 1 if you have the zlib library (-lz).])
|
||
### mingw32 doesn't use -lz, since it loads the library dynamically.
|
||
if test "${opsys}" = "mingw32"; then
|
||
LIBZ=
|
||
fi
|
||
fi
|
||
AC_SUBST([LIBZ])
|
||
|
||
### Dynamic library support
|
||
case $opsys in
|
||
cygwin|mingw32) DYNAMIC_LIB_SUFFIX=".dll" ;;
|
||
darwin) DYNAMIC_LIB_SUFFIX=".dylib" ;;
|
||
*) DYNAMIC_LIB_SUFFIX=".so" ;;
|
||
esac
|
||
case "${opsys}" in
|
||
darwin) DYNAMIC_LIB_SECONDARY_SUFFIX='.so' ;;
|
||
*) DYNAMIC_LIB_SECONDARY_SUFFIX='' ;;
|
||
esac
|
||
AC_DEFINE_UNQUOTED(DYNAMIC_LIB_SUFFIX, "$DYNAMIC_LIB_SUFFIX",
|
||
[System extension for dynamic libraries])
|
||
AC_DEFINE_UNQUOTED(DYNAMIC_LIB_SECONDARY_SUFFIX, "$DYNAMIC_LIB_SECONDARY_SUFFIX",
|
||
[Alternative system extension for dynamic libraries.])
|
||
|
||
AC_SUBST(DYNAMIC_LIB_SUFFIX)
|
||
AC_SUBST(DYNAMIC_LIB_SECONDARY_SUFFIX)
|
||
|
||
### Dynamic modules support
|
||
LIBMODULES=
|
||
HAVE_MODULES=no
|
||
MODULES_OBJ=
|
||
MODULES_SUFFIX="${DYNAMIC_LIB_SUFFIX}"
|
||
MODULES_SECONDARY_SUFFIX="${DYNAMIC_LIB_SECONDARY_SUFFIX}"
|
||
|
||
# pgtkterm.c uses dlsym
|
||
if test $window_system = pgtk; then
|
||
case $opsys in
|
||
gnu|gnu-linux)
|
||
LIBMODULES="-ldl"
|
||
;;
|
||
esac
|
||
fi
|
||
|
||
AS_IF([test "x$with_modules" != "xno"],
|
||
[AS_CASE(["$opsys"],
|
||
[gnu|gnu-linux],
|
||
[LIBMODULES="-ldl"
|
||
HAVE_MODULES=yes],
|
||
[cygwin|mingw32|darwin],
|
||
[HAVE_MODULES=yes],
|
||
# BSD systems have dlopen in libc.
|
||
[AC_CHECK_FUNC([dlopen], [HAVE_MODULES=yes])])
|
||
|
||
AS_IF([test "x$HAVE_MODULES" = "xno"],
|
||
[AS_IF([test "$with_modules" = "ifavailable"],
|
||
[AC_MSG_WARN([Dynamic modules are not supported on your system])],
|
||
[AC_MSG_ERROR([Dynamic modules are not supported on your system])])],
|
||
[SAVE_LIBS=$LIBS
|
||
LIBS="$LIBS $LIBMODULES"
|
||
AC_CHECK_FUNCS([dladdr dlfunc])
|
||
LIBS=$SAVE_LIBS])])
|
||
|
||
AS_IF([test "x$HAVE_MODULES" = xyes],
|
||
[MODULES_OBJ="emacs-module.o"
|
||
NEED_DYNLIB=yes
|
||
AC_DEFINE([HAVE_MODULES], [1], [Define to 1 if dynamic modules are enabled])
|
||
AC_DEFINE_UNQUOTED([MODULES_SUFFIX], ["$MODULES_SUFFIX"],
|
||
[System extension for dynamic libraries])
|
||
AS_IF([test -n "$MODULES_SECONDARY_SUFFIX"],
|
||
[AC_DEFINE_UNQUOTED([MODULES_SECONDARY_SUFFIX],
|
||
["$MODULES_SECONDARY_SUFFIX"],
|
||
[Alternative system extension for dynamic libraries.])])])
|
||
|
||
AC_SUBST([MODULES_OBJ])
|
||
AC_SUBST([LIBMODULES])
|
||
AC_SUBST([HAVE_MODULES])
|
||
AC_SUBST([MODULES_SUFFIX])
|
||
AC_SUBST([MODULES_SECONDARY_SUFFIX])
|
||
|
||
ARCH_INDEPENDENT_CONFIG_FILES([src/emacs-module.h])
|
||
AC_SUBST_FILE([module_env_snippet_25])
|
||
AC_SUBST_FILE([module_env_snippet_26])
|
||
AC_SUBST_FILE([module_env_snippet_27])
|
||
AC_SUBST_FILE([module_env_snippet_28])
|
||
AC_SUBST_FILE([module_env_snippet_29])
|
||
AC_SUBST_FILE([module_env_snippet_30])
|
||
AC_SUBST_FILE([module_env_snippet_31])
|
||
module_env_snippet_25="$srcdir/src/module-env-25.h"
|
||
module_env_snippet_26="$srcdir/src/module-env-26.h"
|
||
module_env_snippet_27="$srcdir/src/module-env-27.h"
|
||
module_env_snippet_28="$srcdir/src/module-env-28.h"
|
||
module_env_snippet_29="$srcdir/src/module-env-29.h"
|
||
module_env_snippet_30="$srcdir/src/module-env-30.h"
|
||
module_env_snippet_31="$srcdir/src/module-env-31.h"
|
||
emacs_major_version=`AS_ECHO([$PACKAGE_VERSION]) | sed 's/[[.]].*//'`
|
||
AC_SUBST([emacs_major_version])
|
||
|
||
### Emacs Lisp native compiler support
|
||
|
||
AC_DEFUN([libgccjit_smoke_test], [
|
||
AC_LANG_SOURCE(
|
||
[[#include <libgccjit.h>
|
||
#include <stdlib.h>
|
||
#include <stdio.h>
|
||
int
|
||
main (int argc, char **argv)
|
||
{
|
||
gcc_jit_context *ctxt;
|
||
gcc_jit_result *result;
|
||
ctxt = gcc_jit_context_acquire ();
|
||
if (!ctxt)
|
||
exit (1);
|
||
gcc_jit_type *int_type =
|
||
gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
|
||
gcc_jit_function *func =
|
||
gcc_jit_context_new_function (ctxt, NULL,
|
||
GCC_JIT_FUNCTION_EXPORTED,
|
||
int_type, "foo", 0, NULL, 0);
|
||
gcc_jit_block *block = gcc_jit_function_new_block (func, "foo");
|
||
gcc_jit_block_end_with_return (
|
||
block,
|
||
NULL,
|
||
gcc_jit_context_new_rvalue_from_int (ctxt, int_type, 1));
|
||
result = gcc_jit_context_compile (ctxt);
|
||
if (!result)
|
||
exit (1);
|
||
typedef int (*fn_type) (void);
|
||
fn_type foo =
|
||
(fn_type)gcc_jit_result_get_code (result, "foo");
|
||
if (!foo)
|
||
exit (1);
|
||
if (foo () != 1)
|
||
exit (1);
|
||
gcc_jit_context_release (ctxt);
|
||
gcc_jit_result_release (result);
|
||
return 0;
|
||
}]])])
|
||
|
||
AC_DEFUN([libgccjit_not_found_err], [
|
||
AC_MSG_ERROR([ELisp native compiler was requested, but libgccjit was not found.
|
||
Please try installing libgccjit or a similar package.
|
||
If you are sure you want Emacs be compiled without ELisp native compiler,
|
||
pass the --without-native-compilation option to configure.])])
|
||
|
||
AC_DEFUN([libgccjit_dev_not_found_err], [
|
||
AC_MSG_ERROR([ELisp native compiler was requested, but libgccjit header files were
|
||
not found.
|
||
Please try installing libgccjit-dev or a similar package.
|
||
If you are sure you want Emacs be compiled without ELisp native compiler,
|
||
pass the --without-native-compilation option to configure.])])
|
||
|
||
AC_DEFUN([libgccjit_broken_err], [
|
||
AC_MSG_ERROR([The installed libgccjit failed to compile and run a test program using
|
||
the libgccjit library; see config.log for the details of the failure.
|
||
The test program can be found here:
|
||
<https://gcc.gnu.org/onlinedocs/jit/intro/tutorial01.html>.
|
||
You can try compiling it yourself to investigate the issues.
|
||
Please report the issue to your distribution if libgccjit was installed
|
||
through that.
|
||
You can find the instructions on how to compile and install libgccjit from
|
||
source on this site:
|
||
<https://gcc.gnu.org/wiki/JIT>.])])
|
||
|
||
HAVE_NATIVE_COMP=no
|
||
LIBGCCJIT_LIBS=
|
||
LIBGCCJIT_CFLAGS=
|
||
if test "$canonical" = i686-pc-cygwin; then
|
||
if test "${with_cygwin32_native_compilation}" = yes; then
|
||
with_native_compilation=yes
|
||
elif test "${with_native_compilation}" != no; then
|
||
AC_MSG_ERROR([Native compilation is not supported on 32-bit Cygwin.
|
||
If you really want to try it anyway, use the configure option
|
||
'--with-cygwin32-native-compilation'.])
|
||
fi
|
||
fi
|
||
|
||
AC_DEFUN([libgccjit_not_found], [
|
||
AC_MSG_WARN([Elisp native compiler can't be enabled as libgccjit was not
|
||
found.
|
||
Please try installing libgccjit or a similar package if you want to have it
|
||
enabled.])
|
||
|
||
with_native_compilation=no
|
||
])
|
||
|
||
AC_DEFUN([libgccjit_dev_not_found], [
|
||
AC_MSG_WARN([Elisp native compiler can't be enabled as libgccjit header files
|
||
were not found.
|
||
Please try installing libgccjit-dev or a similar package if you want to have it
|
||
enabled.])
|
||
|
||
with_native_compilation=no
|
||
])
|
||
|
||
AC_DEFUN([libgccjit_broken], [
|
||
AC_MSG_WARN([Elisp native compiler can't be enabled as the installed libgccjit
|
||
failed to compile and run a test program using the libgccjit library; see
|
||
config.log for the details of the failure.
|
||
The test program can be found here:
|
||
<https://gcc.gnu.org/onlinedocs/jit/intro/tutorial01.html>.
|
||
You can try compiling it yourself to investigate the issues.
|
||
Please report the issue to your distribution if libgccjit was installed
|
||
through that.
|
||
You can find the instructions on how to compile and install libgccjit from
|
||
source on this site:
|
||
<https://gcc.gnu.org/wiki/JIT>.])
|
||
|
||
with_native_compilation=no])
|
||
|
||
if test "$with_features" = "no" \
|
||
&& test "${with_native_compilation}" = "default"; then
|
||
with_native_compilation=no
|
||
fi
|
||
|
||
if test "${with_native_compilation}" = "default"; then
|
||
# Check if libgccjit is available.
|
||
AC_CHECK_LIB([gccjit], [gcc_jit_context_acquire],
|
||
[], [libgccjit_not_found])
|
||
AC_CHECK_HEADERS([libgccjit.h], [], [libgccjit_dev_not_found])
|
||
if test "${with_native_compilation}" != "no"; then
|
||
# Check if libgccjit really works.
|
||
AC_RUN_IFELSE([libgccjit_smoke_test], [], [libgccjit_broken])
|
||
fi
|
||
if test "$with_unexec" = yes; then
|
||
with_native_compilation=no
|
||
fi
|
||
fi
|
||
|
||
if test "${with_native_compilation}" != "no"; then
|
||
if test "$with_unexec" = yes; then
|
||
AC_MSG_ERROR(['--with-native-compilation' is not compatible with unexec])
|
||
fi
|
||
if test "${HAVE_ZLIB}" = no; then
|
||
AC_MSG_ERROR(['--with-native-compilation' requires zlib])
|
||
fi
|
||
|
||
SAVE_CFLAGS=$CFLAGS
|
||
SAVE_LIBS=$LIBS
|
||
|
||
if test "${opsys}" = "darwin"; then
|
||
# Ensure libgccjit installed by Homebrew or macports can be found.
|
||
if test -n "$BREW"; then
|
||
if test -n "`$BREW --prefix --installed libgccjit 2>/dev/null`"; then
|
||
MAC_CFLAGS="-I$(dirname $($BREW ls -v libgccjit | \
|
||
grep libgccjit.h))"
|
||
MAC_LIBS="-L$(dirname $($BREW ls -v libgccjit \
|
||
| grep -m1 -E 'libgccjit\.(so|dylib)$'))"
|
||
fi
|
||
fi
|
||
|
||
if test -n "$HAVE_MACPORTS"; then
|
||
# Determine which gcc version has been installed (gcc11, for
|
||
# instance). Use the latest version, if more than one is
|
||
# available. (We filter out the gcc4 packages, because they
|
||
# don't support jit, and they have names like "gcc49" that
|
||
# sort later than "gcc11".)
|
||
PORT_PACKAGE=`port installed active | grep '^ *gcc@<:@0-9@:>@* ' | \
|
||
awk '{ print $1; }' | grep -v 'gcc4@<:@0-9@:>@' | \
|
||
sort -V | tail -n 1`
|
||
if test -n "$PORT_PACKAGE"; then
|
||
emacs_val=`port contents $PORT_PACKAGE | grep libgccjit.h`
|
||
emacs_val=`dirname $emacs_val`
|
||
MAC_CFLAGS="-I$emacs_val"
|
||
emacs_val=`port contents $PORT_PACKAGE | grep libgccjit.dylib`
|
||
emacs_val=`dirname $emacs_val`
|
||
MAC_LIBS="-L$emacs_val"
|
||
fi
|
||
fi
|
||
|
||
if test -n "$MAC_CFLAGS" && test -n "$MAC_LIBS"; then
|
||
CFLAGS="$CFLAGS ${MAC_CFLAGS}"
|
||
LIBS="$LIBS ${MAC_LIBS}"
|
||
fi
|
||
fi
|
||
|
||
# In the default case we already checked
|
||
if test "${with_native_compilation}" != "default"; then
|
||
# Check if libgccjit is available.
|
||
AC_CHECK_LIB([gccjit], [gcc_jit_context_acquire],
|
||
[], [libgccjit_not_found_err])
|
||
AC_CHECK_HEADERS([libgccjit.h], [], [libgccjit_dev_not_found_err])
|
||
# Check if libgccjit really works.
|
||
AC_RUN_IFELSE([libgccjit_smoke_test], [], [libgccjit_broken_err])
|
||
fi
|
||
HAVE_NATIVE_COMP=yes
|
||
case "${opsys}" in
|
||
# mingw32 loads the library dynamically.
|
||
mingw32) ;;
|
||
# Neither NetBSD, OpenBSD nor Haiku have libdl, with all dynamic
|
||
# linker functions placed within libc.
|
||
netbsd|openbsd|haiku)
|
||
LIBGCCJIT_LIBS="-lgccjit" ;;
|
||
darwin)
|
||
LIBGCCJIT_CFLAGS="${MAC_CFLAGS}"
|
||
LIBGCCJIT_LIBS="${MAC_LIBS} -lgccjit -ldl";;
|
||
*)
|
||
LIBGCCJIT_LIBS="-lgccjit -ldl" ;;
|
||
esac
|
||
NEED_DYNLIB=yes
|
||
AC_DEFINE([HAVE_NATIVE_COMP], [1],
|
||
[Define to 1 if native compiler is available.])
|
||
|
||
CFLAGS=$SAVE_CFLAGS
|
||
LIBS=$SAVE_LIBS
|
||
fi
|
||
AC_DEFINE_UNQUOTED([NATIVE_ELISP_SUFFIX], [".eln"],
|
||
[System extension for native compiled elisp])
|
||
AC_SUBST([HAVE_NATIVE_COMP])
|
||
AC_SUBST([LIBGCCJIT_CFLAGS])
|
||
AC_SUBST([LIBGCCJIT_LIBS])
|
||
|
||
DYNLIB_OBJ=
|
||
if test "${NEED_DYNLIB}" = yes; then
|
||
DYNLIB_OBJ="dynlib.o"
|
||
fi
|
||
AC_SUBST([DYNLIB_OBJ])
|
||
|
||
### Use -lpng if available, unless '--with-png=no'.
|
||
HAVE_PNG=no
|
||
LIBPNG=
|
||
PNG_CFLAGS=
|
||
if test "${with_png}" != no; then
|
||
# mingw32 loads the library dynamically.
|
||
if test "$opsys" = mingw32; then
|
||
AC_CHECK_HEADER([png.h], [HAVE_PNG=yes])
|
||
elif test "${HAVE_X11}" = "yes" || test "${HAVE_W32}" = "yes" \
|
||
|| test "${HAVE_NS}" = "yes" || test "${HAVE_BE_APP}" = "yes" \
|
||
|| test "$window_system" = "pgtk" \
|
||
|| test "${REALLY_ANDROID}" = "yes"; then
|
||
EMACS_CHECK_MODULES([PNG], [libpng >= 1.0.0])
|
||
if test $HAVE_PNG = yes; then
|
||
LIBPNG=$PNG_LIBS
|
||
else
|
||
# Test old way in case pkg-config doesn't have it (older machines).
|
||
AC_MSG_CHECKING([for libpng not configured by pkg-config])
|
||
|
||
png_cflags=`(libpng-config --cflags) 2>&AS_MESSAGE_LOG_FD` &&
|
||
png_ldflags=`(libpng-config --ldflags) 2>&AS_MESSAGE_LOG_FD` || {
|
||
# libpng-config does not work; configure by hand.
|
||
# Debian unstable as of July 2003 has multiple libpngs, and puts png.h
|
||
# in /usr/include/libpng.
|
||
if test -r /usr/include/libpng/png.h &&
|
||
test ! -r /usr/include/png.h; then
|
||
png_cflags=-I/usr/include/libpng
|
||
else
|
||
png_cflags=
|
||
fi
|
||
png_ldflags='-lpng'
|
||
}
|
||
SAVE_CFLAGS=$CFLAGS
|
||
SAVE_LIBS=$LIBS
|
||
CFLAGS="$CFLAGS $png_cflags"
|
||
LIBS="$png_ldflags -lz -lm $LIBS"
|
||
AC_LINK_IFELSE(
|
||
[AC_LANG_PROGRAM([[#include <png.h>]],
|
||
[[return !png_get_channels (0, 0);]])],
|
||
[HAVE_PNG=yes
|
||
PNG_CFLAGS=`AS_ECHO(["$png_cflags"]) | sed -e "$edit_cflags"`
|
||
LIBPNG=$png_ldflags])
|
||
CFLAGS=$SAVE_CFLAGS
|
||
LIBS=$SAVE_LIBS
|
||
AC_MSG_RESULT([$HAVE_PNG])
|
||
fi
|
||
|
||
# $LIBPNG requires explicit -lz in some cases.
|
||
# We don't know what those cases are, exactly, so play it safe and
|
||
# append -lz to any nonempty $LIBPNG, unless we're already using LIBZ.
|
||
case " $LIBPNG ",$LIBZ in
|
||
*' -lz '*, | *' ',?*) ;;
|
||
*) LIBPNG="$LIBPNG -lz" ;;
|
||
esac
|
||
fi
|
||
fi
|
||
if test $HAVE_PNG = yes; then
|
||
AC_DEFINE([HAVE_PNG], [1], [Define to 1 if you have the png library.])
|
||
|
||
SAVE_CFLAGS=$CFLAGS
|
||
CFLAGS="$CFLAGS $PNG_CFLAGS"
|
||
AC_CHECK_DECL([png_longjmp],
|
||
[],
|
||
[AC_DEFINE([PNG_DEPSTRUCT], [],
|
||
[Define to empty to suppress deprecation warnings when building
|
||
with --enable-gcc-warnings and with libpng versions before 1.5,
|
||
which lack png_longjmp.])],
|
||
[[#include <png.h>
|
||
]])
|
||
CFLAGS=$SAVE_CFLAGS
|
||
fi
|
||
AC_SUBST([LIBPNG])
|
||
AC_SUBST([PNG_CFLAGS])
|
||
|
||
### Use -ltiff if available, unless '--with-tiff=no'.
|
||
### mingw32 doesn't use -ltiff, since it loads the library dynamically.
|
||
HAVE_TIFF=no
|
||
LIBTIFF=
|
||
TIFF_CFLAGS=
|
||
if test "${opsys}" = "mingw32"; then
|
||
if test "${with_tiff}" != "no"; then
|
||
AC_CHECK_HEADER([tiffio.h], [HAVE_TIFF=yes], [HAVE_TIFF=no])
|
||
fi
|
||
if test "${HAVE_TIFF}" = "yes"; then
|
||
AC_DEFINE([HAVE_TIFF], [1],
|
||
[Define to 1 if you have the tiff library (-ltiff).])
|
||
fi
|
||
elif test "${HAVE_X11}" = "yes" || test "${HAVE_W32}" = "yes" \
|
||
|| test "${HAVE_NS}" = "yes" || test "${HAVE_BE_APP}" = "yes" \
|
||
|| test "$window_system" = "pgtk" \
|
||
|| test "${REALLY_ANDROID}" = "yes"; then
|
||
if test "${with_tiff}" != "no"; then
|
||
if test "${REALLY_ANDROID}" != "yes"; then
|
||
AC_CHECK_HEADER([tiffio.h],
|
||
[tifflibs="-lz -lm"
|
||
# At least one tiff package requires the jpeg library.
|
||
if test "${HAVE_JPEG}" = yes; then tifflibs="-ljpeg $tifflibs"; fi
|
||
AC_CHECK_LIB([tiff], [TIFFGetVersion], [HAVE_TIFF=yes], [],
|
||
[$tifflibs])])
|
||
else
|
||
ndk_SEARCH_MODULE([libtiff], [TIFF], [HAVE_TIFF=yes])
|
||
|
||
if test "$HAVE_TIFF" = "yes"; then
|
||
LIBTIFF="$TIFF_LIBS"
|
||
fi
|
||
fi
|
||
fi
|
||
|
||
if test "${HAVE_TIFF}" = "yes"; then
|
||
AC_DEFINE([HAVE_TIFF], [1],
|
||
[Define to 1 if you have the tiff library (-ltiff).])
|
||
|
||
if test "$REALLY_ANDROID" != "yes"; then
|
||
dnl FIXME -lz -lm, as per libpng?
|
||
LIBTIFF=-ltiff
|
||
fi
|
||
fi
|
||
fi
|
||
AC_SUBST([LIBTIFF])
|
||
AC_SUBST([TIFF_CFLAGS])
|
||
|
||
### Use -lgif or -lungif if available, unless '--with-gif=no'.
|
||
### mingw32 doesn't use -lgif/-lungif, since it loads the library dynamically.
|
||
HAVE_GIF=no
|
||
GIF_CFLAGS=
|
||
LIBGIF=
|
||
if test "${opsys}" = "mingw32"; then
|
||
if test "${with_gif}" != "no"; then
|
||
AC_CHECK_HEADER([gif_lib.h], [HAVE_GIF=yes], [HAVE_GIF=no])
|
||
fi
|
||
if test "${HAVE_GIF}" = "yes"; then
|
||
AC_DEFINE([HAVE_GIF], [1],
|
||
[Define to 1 if you have a gif (or ungif) library.])
|
||
fi
|
||
elif test "${HAVE_X11}" = "yes" && test "${with_gif}" != "no" \
|
||
|| test "${HAVE_W32}" = "yes" || test "${HAVE_NS}" = "yes" \
|
||
|| test "${HAVE_BE_APP}" = "yes" || test "$window_system" = "pgtk" \
|
||
|| test "${REALLY_ANDROID}" = "yes" \
|
||
&& test "${with_gif}" != "no"; then
|
||
AC_CHECK_HEADER([gif_lib.h],
|
||
# EGifPutExtensionLast only exists from version libungif-4.1.0b1.
|
||
# Earlier versions can crash Emacs, but version 5.0 removes EGifPutExtensionLast.
|
||
[AC_CHECK_LIB([gif], [GifMakeMapObject], [HAVE_GIF=yes],
|
||
[AC_CHECK_LIB([gif], [EGifPutExtensionLast],
|
||
[HAVE_GIF=yes],
|
||
[HAVE_GIF=maybe])])])
|
||
|
||
if test "$HAVE_GIF" = yes; then
|
||
LIBGIF=-lgif
|
||
elif test "$HAVE_GIF" = maybe; then
|
||
# If gif_lib.h but no libgif, try libungif.
|
||
AC_CHECK_LIB([ungif], [EGifPutExtensionLast],
|
||
[HAVE_GIF=yes],
|
||
[HAVE_GIF=no])
|
||
test "$HAVE_GIF" = yes && LIBGIF=-lungif
|
||
fi
|
||
|
||
# Finally, try ndk-build on Android.
|
||
if test "$REALLY_ANDROID" = "yes"; then
|
||
ndk_SEARCH_MODULE([libgif], [GIF], [HAVE_GIF=yes],
|
||
[HAVE_GIF=no])
|
||
test "$HAVE_GIF" = yes && LIBGIF="$GIF_LIBS"
|
||
fi
|
||
|
||
if test "${HAVE_GIF}" = "yes"; then
|
||
AC_DEFINE([HAVE_GIF], [1],
|
||
[Define to 1 if you have a gif (or ungif) library.])
|
||
fi
|
||
fi
|
||
AC_SUBST([LIBGIF])
|
||
AC_SUBST([GIF_CFLAGS])
|
||
|
||
dnl Check for required libraries.
|
||
MISSING=
|
||
WITH_IFAVAILABLE=
|
||
if test "${HAVE_X11}" = "yes"; then
|
||
case $with_xpm,$HAVE_XPM in
|
||
no,* | ifavailable,* | *,yes) ;;
|
||
*) MISSING="libXpm"
|
||
WITH_IFAVAILABLE="--with-xpm=ifavailable";;
|
||
esac
|
||
case $with_jpeg,$HAVE_JPEG in
|
||
no,* | ifavailable,* | *,yes) ;;
|
||
*) MISSING="$MISSING libjpeg"
|
||
WITH_IFAVAILABLE="$WITH_IFAVAILABLE --with-jpeg=ifavailable";;
|
||
esac
|
||
case $with_png,$HAVE_PNG in
|
||
no,* | ifavailable,* | *,yes) ;;
|
||
*) MISSING="$MISSING libpng"
|
||
WITH_IFAVAILABLE="$WITH_IFAVAILABLE --with-png=ifavailable";;
|
||
esac
|
||
case $with_gif,$HAVE_GIF in
|
||
no,* | ifavailable,* | *,yes) ;;
|
||
*) MISSING="$MISSING libgif/libungif"
|
||
WITH_IFAVAILABLE="$WITH_IFAVAILABLE --with-gif=ifavailable";;
|
||
esac
|
||
case $with_tiff,$HAVE_TIFF in
|
||
no,* | ifavailable,* | *,yes) ;;
|
||
*) MISSING="$MISSING libtiff"
|
||
WITH_IFAVAILABLE="$WITH_IFAVAILABLE --with-tiff=ifavailable";;
|
||
esac
|
||
fi
|
||
case $with_gnutls,$HAVE_GNUTLS in
|
||
no,* | ifavailable,* | *,yes) ;;
|
||
*) MISSING="$MISSING gnutls"
|
||
WITH_IFAVAILABLE="$WITH_IFAVAILABLE --with-gnutls=ifavailable";;
|
||
esac
|
||
case $with_tree_sitter,$HAVE_TREE_SITTER in
|
||
no,* | ifavailable,* | *,yes) ;;
|
||
*) MISSING="$MISSING tree-sitter"
|
||
WITH_IFAVAILABLE="$WITH_IFAVAILABLE --with-tree-sitter=ifavailable";;
|
||
esac
|
||
|
||
if test "X${MISSING}" != X; then
|
||
# If we have a missing library, and we don't have pkg-config installed,
|
||
# the missing pkg-config may be the reason. Give the user a hint.
|
||
if test "X${PKG_CONFIG}" = X; then
|
||
AC_MSG_WARN([Unable to locate a usable pkg-config])
|
||
fi
|
||
AC_MSG_ERROR([The following required libraries were not found:
|
||
$MISSING
|
||
Maybe some development libraries/packages are missing?
|
||
To build anyway, give:
|
||
$WITH_IFAVAILABLE
|
||
as options to configure.])
|
||
fi
|
||
|
||
### Use -lgpm if available, unless '--with-gpm=no'.
|
||
HAVE_GPM=no
|
||
LIBGPM=
|
||
if test "${with_gpm}" != "no"; then
|
||
AC_CHECK_HEADER([gpm.h],
|
||
[AC_CHECK_LIB([gpm], [Gpm_Open], [HAVE_GPM=yes])])
|
||
|
||
if test "${HAVE_GPM}" = "yes"; then
|
||
AC_DEFINE([HAVE_GPM], [1],
|
||
[Define to 1 if you have the gpm library (-lgpm).])
|
||
LIBGPM=-lgpm
|
||
fi
|
||
fi
|
||
AC_SUBST([LIBGPM])
|
||
|
||
dnl Check for malloc/malloc.h on darwin
|
||
AC_CHECK_HEADERS_ONCE([malloc/malloc.h])
|
||
|
||
GNUSTEP_CFLAGS=
|
||
### Use NeXTstep API to implement GUI.
|
||
if test "${HAVE_NS}" = "yes"; then
|
||
AC_DEFINE([HAVE_NS], [1],
|
||
[Define to 1 if you are using the NeXTstep API,
|
||
either GNUstep or Cocoa on macOS.])
|
||
if test "${NS_IMPL_COCOA}" = "yes"; then
|
||
AC_DEFINE([NS_IMPL_COCOA], [1],
|
||
[Define to 1 if you are using NS windowing under macOS.])
|
||
fi
|
||
if test "${NS_IMPL_GNUSTEP}" = "yes"; then
|
||
AC_DEFINE([NS_IMPL_GNUSTEP], [1],
|
||
[Define to 1 if you are using NS windowing under GNUstep.])
|
||
if test $NS_GNUSTEP_CONFIG != yes; then
|
||
# See also .m.o rule in src/Makefile.in. */
|
||
# FIXME: are all these flags really needed? Document here why. */
|
||
GNUSTEP_CFLAGS="-D_REENTRANT -fPIC -fno-strict-aliasing -I${GNUSTEP_SYSTEM_HEADERS} ${GNUSTEP_LOCAL_HEADERS}"
|
||
## Extra CFLAGS applied to src/*.m files.
|
||
GNU_OBJC_CFLAGS="$GNU_OBJC_CFLAGS -fgnu-runtime -Wno-import -fconstant-string-class=NSConstantString -DGNUSTEP_BASE_LIBRARY=1 -DGNU_GUI_LIBRARY=1 -DGNU_RUNTIME=1 -DGSWARN -DGSDIAGNOSE"
|
||
fi
|
||
fi
|
||
OTHER_FILES=ns-app
|
||
fi
|
||
|
||
### Use session management (-lSM -lICE) if available
|
||
HAVE_X_SM=no
|
||
LIBXSM=
|
||
if test "${HAVE_X11}" = "yes"; then
|
||
AC_CHECK_HEADER([X11/SM/SMlib.h],
|
||
[AC_CHECK_LIB([SM], [SmcOpenConnection], [HAVE_X_SM=yes], [], [-lICE])])
|
||
|
||
if test "${HAVE_X_SM}" = "yes"; then
|
||
AC_DEFINE([HAVE_X_SM], [1],
|
||
[Define to 1 if you have the SM library (-lSM).])
|
||
LIBXSM="-lSM -lICE"
|
||
fi
|
||
fi
|
||
AC_SUBST([LIBXSM])
|
||
|
||
### Use XRandr (-lXrandr) if available
|
||
HAVE_XRANDR=no
|
||
if test "${HAVE_X11}" = "yes"; then
|
||
XRANDR_REQUIRED=1.2.2
|
||
XRANDR_MODULES="xrandr >= $XRANDR_REQUIRED"
|
||
EMACS_CHECK_MODULES([XRANDR], [$XRANDR_MODULES])
|
||
if test $HAVE_XRANDR = no; then
|
||
# Test old way in case pkg-config doesn't have it (older machines).
|
||
# Include Xrender.h by hand to work around bug in older Xrandr.h
|
||
# (e.g. RHEL5) and silence (harmless) configure warning (bug#18465).
|
||
AC_CHECK_HEADER([X11/extensions/Xrandr.h],
|
||
[AC_CHECK_LIB([Xrandr], [XRRGetScreenResources], [HAVE_XRANDR=yes])],
|
||
[], [AC_INCLUDES_DEFAULT
|
||
#include <X11/extensions/Xrender.h>])
|
||
if test $HAVE_XRANDR = yes; then
|
||
XRANDR_LIBS=-lXrandr
|
||
fi
|
||
fi
|
||
if test $HAVE_XRANDR = yes; then
|
||
AC_DEFINE([HAVE_XRANDR], [1],
|
||
[Define to 1 if you have the XRandr extension.])
|
||
fi
|
||
fi
|
||
AC_SUBST([XRANDR_CFLAGS])
|
||
AC_SUBST([XRANDR_LIBS])
|
||
|
||
### Use Xinerama (-lXinerama) if available
|
||
HAVE_XINERAMA=no
|
||
if test "${HAVE_X11}" = "yes"; then
|
||
XINERAMA_REQUIRED=1.0.2
|
||
XINERAMA_MODULES="xinerama >= $XINERAMA_REQUIRED"
|
||
EMACS_CHECK_MODULES([XINERAMA], [$XINERAMA_MODULES])
|
||
if test $HAVE_XINERAMA = no; then
|
||
# Test old way in case pkg-config doesn't have it (older machines).
|
||
AC_CHECK_HEADER([X11/extensions/Xinerama.h],
|
||
[AC_CHECK_LIB([Xinerama], [XineramaQueryExtension],
|
||
[HAVE_XINERAMA=yes])])
|
||
if test $HAVE_XINERAMA = yes; then
|
||
XINERAMA_LIBS=-lXinerama
|
||
fi
|
||
fi
|
||
if test $HAVE_XINERAMA = yes; then
|
||
AC_DEFINE([HAVE_XINERAMA], [1],
|
||
[Define to 1 if you have the Xinerama extension.])
|
||
fi
|
||
fi
|
||
AC_SUBST([XINERAMA_CFLAGS])
|
||
AC_SUBST([XINERAMA_LIBS])
|
||
|
||
### Use Xfixes (-lXfixes) if available
|
||
HAVE_XFIXES=no
|
||
if test "${HAVE_X11}" = "yes"; then
|
||
XFIXES_REQUIRED=1.0.0
|
||
XFIXES_MODULES="xfixes >= $XFIXES_REQUIRED"
|
||
EMACS_CHECK_MODULES([XFIXES], [$XFIXES_MODULES])
|
||
if test $HAVE_XFIXES = no; then
|
||
# Test old way in case pkg-config doesn't have it (older machines).
|
||
AC_CHECK_HEADER([X11/extensions/Xfixes.h],
|
||
[AC_CHECK_LIB([Xfixes], [XFixesHideCursor], [HAVE_XFIXES=yes])])
|
||
if test $HAVE_XFIXES = yes; then
|
||
XFIXES_LIBS=-lXfixes
|
||
fi
|
||
fi
|
||
if test $HAVE_XFIXES = yes; then
|
||
AC_DEFINE([HAVE_XFIXES], [1],
|
||
[Define to 1 if you have the Xfixes extension.])
|
||
fi
|
||
fi
|
||
AC_SUBST([XFIXES_CFLAGS])
|
||
AC_SUBST([XFIXES_LIBS])
|
||
|
||
## Use XInput 2.0 if available
|
||
HAVE_XINPUT2=no
|
||
if test "${HAVE_X11}" = "yes" && test "${with_xinput2}" != "no"; then
|
||
EMACS_CHECK_MODULES([XINPUT], [xi])
|
||
if test $HAVE_XINPUT = yes; then
|
||
# Now check for XInput2.h
|
||
AC_CHECK_HEADER([X11/extensions/XInput2.h],
|
||
[AC_CHECK_LIB([Xi], [XIGrabButton], [HAVE_XINPUT2=yes])])
|
||
fi
|
||
if test $HAVE_XINPUT2 = yes; then
|
||
AC_DEFINE([HAVE_XINPUT2], [1],
|
||
[Define to 1 if the X Input Extension version 2.0 or later is present.])
|
||
if test "$USE_GTK_TOOLKIT" = "GTK2"; then
|
||
AC_MSG_WARN([You are building Emacs with GTK+ 2 and the X Input Extension version 2.
|
||
This might lead to problems if your version of GTK+ is not built with support for XInput 2.])
|
||
fi
|
||
|
||
# Now check for some members (which used in conjunction with
|
||
# protocol definitions) can be used to determine the version of
|
||
# XInput supported.
|
||
AC_CHECK_MEMBERS([XIScrollClassInfo.type, XITouchClassInfo.type,
|
||
XIBarrierReleasePointerInfo.deviceid, XIGestureClassInfo.type],
|
||
[], [], [#include <X11/extensions/XInput2.h>])
|
||
fi
|
||
fi
|
||
AC_SUBST([XINPUT_CFLAGS])
|
||
AC_SUBST([XINPUT_LIBS])
|
||
|
||
XSYNC_LIBS=
|
||
XSYNC_CFLAGS=
|
||
HAVE_XSYNC=no
|
||
if test "${HAVE_X11}" = "yes"; then
|
||
AC_CHECK_HEADER([X11/extensions/sync.h],
|
||
[AC_CHECK_LIB([Xext], [XSyncQueryExtension], [HAVE_XSYNC=yes])],
|
||
[], [#include <X11/Xlib.h>])
|
||
|
||
if test "${HAVE_XSYNC}" = "yes"; then
|
||
AC_DEFINE([HAVE_XSYNC], [1],
|
||
[Define to 1 if the X Synchronization Extension is available.])
|
||
XSYNC_LIBS="-lXext"
|
||
OLDLIBS="$LIBS"
|
||
LIBS="-lXext $LIBS" # Set this temporarily for AC_CHECK_FUNC
|
||
AC_CHECK_FUNCS([XSyncTriggerFence]) # Check for version 3.1
|
||
LIBS="$OLDLIBS"
|
||
fi
|
||
fi
|
||
AC_SUBST([XSYNC_LIBS])
|
||
AC_SUBST([XSYNC_CFLAGS])
|
||
|
||
### Use Xdbe (-lXdbe) if available
|
||
HAVE_XDBE=no
|
||
if test "${HAVE_X11}" = "yes"; then
|
||
if test "${with_xdbe}" != "no"; then
|
||
AC_CHECK_HEADER([X11/extensions/Xdbe.h],
|
||
[AC_CHECK_LIB([Xext], [XdbeAllocateBackBufferName], [HAVE_XDBE=yes])],
|
||
[],
|
||
[#include <X11/Xlib.h>
|
||
])
|
||
fi
|
||
if test $HAVE_XDBE = yes; then
|
||
XDBE_LIBS=-lXext
|
||
fi
|
||
if test $HAVE_XDBE = yes; then
|
||
AC_DEFINE([HAVE_XDBE], [1], [Define to 1 if you have the Xdbe extension.])
|
||
fi
|
||
fi
|
||
AC_SUBST([XDBE_CFLAGS])
|
||
AC_SUBST([XDBE_LIBS])
|
||
|
||
### Use the Nonrectangular Window Shape extension if available.
|
||
HAVE_XSHAPE=no
|
||
HAVE_XCB_SHAPE=no
|
||
if test "${HAVE_X11}" = "yes"; then
|
||
AC_CHECK_HEADER([X11/extensions/shape.h],
|
||
[AC_CHECK_LIB([Xext], [XShapeQueryVersion], [HAVE_XSHAPE=yes])],
|
||
[],
|
||
[#include <X11/extensions/shape.h>
|
||
])
|
||
if test $HAVE_XSHAPE = yes; then
|
||
XSHAPE_LIBS=-lXext
|
||
AC_CHECK_HEADER([xcb/shape.h],
|
||
[AC_CHECK_LIB([xcb-shape], [xcb_shape_combine], [HAVE_XCB_SHAPE=yes])],
|
||
[],
|
||
[#include <xcb/shape.h>])
|
||
|
||
if test $HAVE_XCB_SHAPE = yes && test "$XCB_LIBS" != ""; then
|
||
XSHAPE_LIBS="$XSHAPE_LIBS -lxcb-shape"
|
||
AC_DEFINE([HAVE_XCB_SHAPE], [1],
|
||
[Define to 1 if XCB supports the
|
||
Nonrectangular Window Shape extension.])
|
||
fi
|
||
fi
|
||
if test $HAVE_XSHAPE = yes; then
|
||
AC_DEFINE([HAVE_XSHAPE], [1],
|
||
[Define to 1 if you have the Nonrectangular Window Shape extension.])
|
||
fi
|
||
fi
|
||
AC_SUBST([XSHAPE_CFLAGS])
|
||
AC_SUBST([XSHAPE_LIBS])
|
||
|
||
### Use Xcomposite (-lXcomposite) if available
|
||
HAVE_XCOMPOSITE=no
|
||
if test "${HAVE_X11}" = "yes"; then
|
||
AC_CHECK_HEADER([X11/extensions/Xcomposite.h],
|
||
[AC_CHECK_LIB([Xcomposite], [XCompositeRedirectWindow],
|
||
[HAVE_XCOMPOSITE=yes])],
|
||
[],
|
||
[#include <X11/extensions/Xcomposite.h>
|
||
])
|
||
if test $HAVE_XCOMPOSITE = yes; then
|
||
XCOMPOSITE_LIBS=-lXcomposite
|
||
fi
|
||
if test $HAVE_XCOMPOSITE = yes; then
|
||
AC_DEFINE([HAVE_XCOMPOSITE], [1],
|
||
[Define to 1 if you have the XCOMPOSITE extension.])
|
||
fi
|
||
fi
|
||
AC_SUBST([XCOMPOSITE_CFLAGS])
|
||
AC_SUBST([XCOMPOSITE_LIBS])
|
||
|
||
### Use libxml (-lxml2) if available
|
||
### mingw32 doesn't use -lxml2, since it loads the library dynamically.
|
||
HAVE_LIBXML2=no
|
||
if test "${with_xml2}" != "no"; then
|
||
### I'm not sure what the version number should be, so I just guessed.
|
||
EMACS_CHECK_MODULES([LIBXML2], [libxml-2.0 > 2.6.17])
|
||
# Built-in libxml2 on OS X 10.8 lacks libxml-2.0.pc.
|
||
if test "${HAVE_LIBXML2}" != "yes" && test "$opsys" = "darwin"; then
|
||
SAVE_CPPFLAGS="$CPPFLAGS"
|
||
if test -z "$xcsdkdir" -a -n "$XCRUN" -a ! -d /usr/include; then
|
||
dnl /usr/include is not found. Try Xcode SDK dir if it is sane.
|
||
xcsdkdir=`$XCRUN --show-sdk-path 2>/dev/null`
|
||
case $xcsdkdir in
|
||
*[[\\\"\#\$\&\'\`$am_lf\ \ ]]*)
|
||
xcsdkdir="" ;;
|
||
esac
|
||
fi
|
||
CPPFLAGS="$CPPFLAGS -isystem${xcsdkdir}/usr/include/libxml2"
|
||
AC_CHECK_HEADER([libxml/HTMLparser.h],
|
||
[AC_CHECK_DECL([HTML_PARSE_RECOVER], [HAVE_LIBXML2=yes], [],
|
||
[#include <libxml/HTMLparser.h>])])
|
||
CPPFLAGS="$SAVE_CPPFLAGS"
|
||
if test "${HAVE_LIBXML2}" = "yes"; then
|
||
LIBXML2_CFLAGS="-isystem${xcsdkdir}/usr/include/libxml2"
|
||
LIBXML2_LIBS="-lxml2"
|
||
fi
|
||
fi
|
||
if test "${HAVE_LIBXML2}" = "yes"; then
|
||
if test "${opsys}" != "mingw32"; then
|
||
SAVE_CFLAGS=$CFLAGS
|
||
CFLAGS="$CFLAGS $LIBXML2_CFLAGS"
|
||
EMACS_CHECK_LIB([xml2], [htmlReadMemory],
|
||
[HAVE_LIBXML2=yes],
|
||
[HAVE_LIBXML2=no],
|
||
[$LIBXML2_LIBS], [#include <libxml/HTMLparser.h>])
|
||
CFLAGS="$SAVE_CFLAGS"
|
||
else
|
||
LIBXML2_LIBS=""
|
||
fi
|
||
if test "${HAVE_LIBXML2}" = "yes"; then
|
||
AC_DEFINE([HAVE_LIBXML2], [1],
|
||
[Define to 1 if you have the libxml library (-lxml2).])
|
||
else
|
||
LIBXML2_LIBS=""
|
||
LIBXML2_CFLAGS=""
|
||
fi
|
||
fi
|
||
fi
|
||
AC_SUBST([LIBXML2_LIBS])
|
||
AC_SUBST([LIBXML2_CFLAGS])
|
||
|
||
BLESSMAIL_TARGET=
|
||
LIBS_MAIL=
|
||
if test ! "$with_mailutils"; then
|
||
# Check for mail-locking functions in a "mail" library. Probably this should
|
||
# have the same check as for liblockfile below.
|
||
AC_CHECK_LIB([mail], [maillock], [have_mail=yes], [have_mail=no])
|
||
if test $have_mail = yes; then
|
||
LIBS_MAIL=-lmail
|
||
AC_DEFINE([HAVE_LIBMAIL], [1],
|
||
[Define to 1 if you have the 'mail' library (-lmail).])
|
||
|
||
OLD_LIBS=$LIBS
|
||
LIBS="$LIBS_MAIL $LIBS"
|
||
AC_CHECK_FUNCS([touchlock])
|
||
LIBS=$OLD_LIBS
|
||
fi
|
||
dnl Debian, at least:
|
||
AC_CHECK_LIB([lockfile], [maillock], [have_lockfile=yes], [have_lockfile=no])
|
||
if test $have_lockfile = yes; then
|
||
LIBS_MAIL=-llockfile
|
||
AC_DEFINE([HAVE_LIBLOCKFILE], [1],
|
||
[Define to 1 if you have the 'lockfile' library (-llockfile).])
|
||
else
|
||
# If we have the shared liblockfile, assume we must use it for mail
|
||
# locking (e.g. Debian). If we couldn't link against liblockfile
|
||
# (no liblockfile.a installed), ensure that we don't need to.
|
||
dnl This works for files generally, not just executables.
|
||
dnl Should we look elsewhere for it? Maybe examine /etc/ld.so.conf?
|
||
AC_CHECK_PROG([liblockfile], [liblockfile.so], [yes], [no],
|
||
[/usr/lib:/lib:/usr/local/lib:$LD_LIBRARY_PATH])
|
||
if test "$ac_cv_prog_liblockfile" = yes; then
|
||
AC_MSG_ERROR([Shared liblockfile found but can't link against it.
|
||
This probably means that movemail could lose mail.
|
||
There may be a 'development' package to install containing liblockfile.])
|
||
fi
|
||
fi
|
||
AC_CHECK_HEADERS([maillock.h])
|
||
|
||
## Define MAIL_USE_FLOCK (or LOCKF) if the mailer uses flock (or lockf) to
|
||
## interlock access to the mail spool. The alternative is a lock file named
|
||
## /usr/spool/mail/$USER.lock.
|
||
mail_lock=no
|
||
case $opsys in
|
||
aix4-2) mail_lock="lockf" ;;
|
||
|
||
gnu|freebsd|dragonfly|netbsd|openbsd|darwin) mail_lock="flock" ;;
|
||
|
||
## On GNU/Linux systems, both methods are used by various mail programs.
|
||
## I assume most people are using newer mailers that have heard of flock.
|
||
## Change this if you need to.
|
||
## Debian contains a patch which says: "On Debian/GNU/Linux systems,
|
||
## configure gets the right answers, and that means *NOT* using flock.
|
||
## Using flock is guaranteed to be the wrong thing. See Debian Policy
|
||
## for details." and then uses '#ifdef DEBIAN'. Unfortunately the
|
||
## Debian maintainer hasn't provided a clean fix for Emacs.
|
||
## movemail.c will use 'maillock' when MAILDIR, HAVE_LIBMAIL and
|
||
## HAVE_MAILLOCK_H are defined, so the following appears to be the
|
||
## correct logic. -- fx
|
||
## We must check for HAVE_LIBLOCKFILE too, as movemail does.
|
||
## liblockfile is a Free Software replacement for libmail, used on
|
||
## Debian systems and elsewhere. -rfr.
|
||
gnu-*)
|
||
mail_lock="flock"
|
||
if test $have_mail = yes || test $have_lockfile = yes; then
|
||
test $ac_cv_header_maillock_h = yes && mail_lock=no
|
||
fi ;;
|
||
|
||
mingw32)
|
||
mail_lock="none-needed" ;;
|
||
esac
|
||
|
||
case $mail_lock in
|
||
flock) AC_DEFINE([MAIL_USE_FLOCK], [1],
|
||
[Define if the mailer uses flock to interlock the mail spool.]);;
|
||
|
||
lockf) AC_DEFINE([MAIL_USE_LOCKF], [1],
|
||
[Define if the mailer uses lockf to interlock the mail spool.]);;
|
||
|
||
none-needed) ;;
|
||
|
||
*) BLESSMAIL_TARGET="need-blessmail" ;;
|
||
esac
|
||
fi
|
||
AC_SUBST([BLESSMAIL_TARGET])
|
||
AC_SUBST([LIBS_MAIL])
|
||
|
||
HAVE_SECCOMP=no
|
||
AC_CHECK_HEADERS(
|
||
[linux/seccomp.h linux/filter.h],
|
||
[AC_CHECK_DECLS(
|
||
[SECCOMP_SET_MODE_FILTER, SECCOMP_FILTER_FLAG_TSYNC],
|
||
[HAVE_SECCOMP=yes], [],
|
||
[[
|
||
#include <linux/seccomp.h>
|
||
]])])
|
||
AC_SUBST([HAVE_SECCOMP])
|
||
|
||
EMACS_CHECK_MODULES([LIBSECCOMP], [libseccomp >= 2.5.2])
|
||
AC_SUBST([HAVE_LIBSECCOMP])
|
||
AC_SUBST([LIBSECCOMP_LIBS])
|
||
AC_SUBST([LIBSECCOMP_CFLAGS])
|
||
|
||
AC_CHECK_SIZEOF([long])
|
||
SIZEOF_LONG="$ac_cv_sizeof_long"
|
||
AC_SUBST([SIZEOF_LONG])
|
||
|
||
OLD_LIBS=$LIBS
|
||
LIBS="$LIB_PTHREAD $LIB_MATH $LIBS"
|
||
AC_CHECK_FUNCS([accept4 fchdir gethostname \
|
||
getrusage get_current_dir_name \
|
||
lrand48 random rint tcdrain trunc \
|
||
select getpagesize newlocale \
|
||
getrlimit setrlimit shutdown \
|
||
pthread_sigmask strsignal setitimer \
|
||
sendto recvfrom getsockname getifaddrs freeifaddrs \
|
||
gai_strerror sync \
|
||
endpwent getgrent endgrent \
|
||
cfmakeraw cfsetspeed __executable_start log2 pthread_setname_np \
|
||
pthread_set_name_np])
|
||
|
||
# getpwent is not present in older versions of Android. (bug#65319)
|
||
gl_CHECK_FUNCS_ANDROID([getpwent], [[#include <pwd.h>]])
|
||
|
||
# renameat2 is not present in older versions of Android.
|
||
gl_CHECK_FUNCS_ANDROID([renameat2], [[#include <stdio.h>]])
|
||
|
||
if test "$ac_cv_func_cfmakeraw" != "yes"; then
|
||
# On some systems (Android), cfmakeraw is inline, so AC_CHECK_FUNCS
|
||
# cannot find it. Check if some code including termios.h and using
|
||
# cfmakeraw builds.
|
||
AC_CACHE_CHECK([whether cfmakeraw is inline],
|
||
[emacs_cv_func_cfmakeraw_inline],
|
||
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
|
||
[[#include <termios.h>]],
|
||
[[&cfmakeraw;]])],
|
||
[emacs_cv_func_cfmakeraw_inline=yes],
|
||
[emacs_cv_func_cfmakeraw_inline=no])])
|
||
|
||
if test "$emacs_cv_func_cfmakeraw_inline" = "yes"; then
|
||
# Define HAVE_CFMAKERAW again.
|
||
AC_DEFINE([HAVE_CFMAKERAW], [1])
|
||
fi
|
||
fi
|
||
|
||
if test "$ac_cv_func_cfsetspeed" != "yes"; then
|
||
AC_CACHE_CHECK([whether cfsetspeed is inline],
|
||
[emacs_cv_func_cfsetspeed_inline],
|
||
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
|
||
[[#include <termios.h>]],
|
||
[[&cfsetspeed;]])],
|
||
[emacs_cv_func_cfsetspeed_inline=yes],
|
||
[emacs_cv_func_cfsetspeed_inline=no])])
|
||
|
||
if test "$emacs_cv_func_cfsetspeed_inline" = "yes"; then
|
||
# Define HAVE_CFSETSPEED again.
|
||
AC_DEFINE([HAVE_CFSETSPEED], [1])
|
||
fi
|
||
fi
|
||
|
||
LIBS=$OLD_LIBS
|
||
|
||
if test "$ac_cv_func_pthread_setname_np" = "yes"; then
|
||
AC_CACHE_CHECK(
|
||
[whether pthread_setname_np takes a single argument],
|
||
[emacs_cv_pthread_setname_np_1arg],
|
||
[AC_COMPILE_IFELSE(
|
||
[AC_LANG_PROGRAM(
|
||
[[#include <pthread.h>]],
|
||
[[pthread_setname_np ("a");]])],
|
||
[emacs_cv_pthread_setname_np_1arg=yes],
|
||
[emacs_cv_pthread_setname_np_1arg=no])])
|
||
if test "$emacs_cv_pthread_setname_np_1arg" = "yes"; then
|
||
AC_DEFINE(
|
||
[HAVE_PTHREAD_SETNAME_NP_1ARG], [1],
|
||
[Define to 1 if pthread_setname_np takes a single argument.])
|
||
else
|
||
AC_CACHE_CHECK(
|
||
[whether pthread_setname_np takes three arguments],
|
||
[emacs_cv_pthread_setname_np_3arg],
|
||
[AC_COMPILE_IFELSE(
|
||
[AC_LANG_PROGRAM(
|
||
[[#include <pthread.h>]],
|
||
[[pthread_setname_np (0, "%s", "a");]])],
|
||
[emacs_cv_pthread_setname_np_3arg=yes],
|
||
[emacs_cv_pthread_setname_np_3arg=no])])
|
||
if test "$emacs_cv_pthread_setname_np_3arg" = "yes"; then
|
||
AC_DEFINE(
|
||
[HAVE_PTHREAD_SETNAME_NP_3ARG], [1],
|
||
[Define to 1 if pthread_setname_np takes three arguments.])
|
||
fi
|
||
fi
|
||
fi
|
||
|
||
dnl No need to check for posix_memalign if aligned_alloc works.
|
||
AC_CHECK_FUNCS([aligned_alloc posix_memalign], [break])
|
||
AC_CHECK_DECLS([aligned_alloc], [], [], [[#include <stdlib.h>]])
|
||
|
||
case $with_unexec,$canonical in
|
||
yes,alpha*)
|
||
AC_CHECK_DECL([__ELF__], [],
|
||
[AC_MSG_ERROR([Non-ELF systems are not supported on this platform.])]);;
|
||
esac
|
||
|
||
if test "$with_unexec" = yes && test "$opsys" = "haiku"; then
|
||
dnl A serious attempt was actually made to port unexec to Haiku.
|
||
dnl Something in libstdc++ seems to prevent it from working.
|
||
AC_MSG_ERROR([Haiku is not supported by the legacy unexec dumper.
|
||
Please use the portable dumper instead.])
|
||
fi
|
||
|
||
# Dump loading. Android lacks posix_madvise.
|
||
AC_CHECK_FUNCS([posix_madvise madvise])
|
||
|
||
dnl Cannot use AC_CHECK_FUNCS
|
||
AC_CACHE_CHECK([for __builtin_frame_address],
|
||
[emacs_cv_func___builtin_frame_address],
|
||
[AC_LINK_IFELSE([AC_LANG_PROGRAM([], [__builtin_frame_address (0);])],
|
||
[emacs_cv_func___builtin_frame_address=yes],
|
||
[emacs_cv_func___builtin_frame_address=no])])
|
||
if test $emacs_cv_func___builtin_frame_address = yes; then
|
||
AC_DEFINE([HAVE___BUILTIN_FRAME_ADDRESS], [1],
|
||
[Define to 1 if you have the '__builtin_frame_address' function.])
|
||
fi
|
||
AC_CACHE_CHECK([for __builtin_unwind_init],
|
||
[emacs_cv_func___builtin_unwind_init],
|
||
[AC_LINK_IFELSE([AC_LANG_PROGRAM([], [__builtin_unwind_init ();])],
|
||
[emacs_cv_func___builtin_unwind_init=yes],
|
||
[emacs_cv_func___builtin_unwind_init=no])])
|
||
if test $emacs_cv_func___builtin_unwind_init = yes; then
|
||
AC_DEFINE([HAVE___BUILTIN_UNWIND_INIT], [1],
|
||
[Define to 1 if you have the '__builtin_unwind_init' function.])
|
||
fi
|
||
|
||
AC_CHECK_HEADERS_ONCE([sys/un.h])
|
||
|
||
AC_FUNC_FSEEKO
|
||
|
||
# UNIX98 PTYs.
|
||
AC_CHECK_FUNCS([grantpt])
|
||
|
||
# PTY-related GNU extensions.
|
||
AC_CHECK_FUNCS([getpt posix_openpt])
|
||
|
||
dnl Run a test program that contains a call to tputs, a call that is
|
||
dnl never executed. This tests whether a pre-'main' dynamic linker
|
||
dnl works with the library. It's too much trouble to actually call
|
||
dnl tputs in the test program, due to portability hassles. When
|
||
dnl cross-compiling, assume the test program will run if it links.
|
||
AC_DEFUN([tputs_link_source], [
|
||
AC_LANG_SOURCE(
|
||
[[extern void tputs (const char *, int, int (*)(int));
|
||
int main (int argc, char **argv)
|
||
{
|
||
if (argc == 10000)
|
||
tputs (argv[0], 0, 0);
|
||
return 0;
|
||
}]])
|
||
])
|
||
# Check this now, so that we will NOT find the above functions in ncurses.
|
||
# That is because we have not set up to link ncurses in lib-src.
|
||
# It's better to believe a function is not available
|
||
# than to expect to find it in ncurses.
|
||
# Also we need tputs and friends to be able to build at all.
|
||
AC_CACHE_CHECK([for library containing tputs], [emacs_cv_tputs_lib],
|
||
[if test "${opsys}" = "mingw32" || test x"$REALLY_ANDROID" = "xyes"; then
|
||
emacs_cv_tputs_lib='none required'
|
||
else
|
||
# curses precedes termcap because of AIX (Bug#9736#35) and OpenIndiana.
|
||
tputs_libraries='tinfo ncurses terminfo curses termcap tinfow ncursesw'
|
||
for tputs_library in '' $tputs_libraries; do
|
||
OLIBS=$LIBS
|
||
if test -z "$tputs_library"; then
|
||
emacs_cv_tputs_lib='none required'
|
||
else
|
||
emacs_cv_tputs_lib=-l$tputs_library
|
||
LIBS="$emacs_cv_tputs_lib $LIBS"
|
||
fi
|
||
AC_RUN_IFELSE([tputs_link_source], [], [emacs_cv_tputs_lib=no],
|
||
[AC_LINK_IFELSE([tputs_link_source], [], [emacs_cv_tputs_lib=no])])
|
||
LIBS=$OLIBS
|
||
if test "X$emacs_cv_tputs_lib" != Xno; then
|
||
break
|
||
fi
|
||
done
|
||
fi])
|
||
AS_CASE(["$emacs_cv_tputs_lib"],
|
||
[no], [AC_MSG_ERROR([The required function 'tputs' was not found in any library.
|
||
The following libraries were tried (in order):
|
||
libtinfo, libncurses, libterminfo, libcurses, libtermcap
|
||
Please try installing whichever of these libraries is most appropriate
|
||
for your system, together with its header files.
|
||
For example, a libncurses-dev(el) or similar package.])],
|
||
[-l*], [LIBS_TERMCAP=$emacs_cv_tputs_lib],
|
||
[*], [LIBS_TERMCAP=])
|
||
|
||
## Use termcap instead of terminfo?
|
||
## Only true for: freebsd < 40000, ms-w32, msdos, netbsd < 599002500.
|
||
TERMINFO=yes
|
||
## FIXME? In the cases below where we unconditionally set
|
||
## LIBS_TERMCAP="-lncurses", this overrides LIBS_TERMCAP = -ltinfo,
|
||
## if that was found above to have tputs.
|
||
## Should we use the gnu* logic everywhere?
|
||
case "$opsys$REALLY_ANDROID" in
|
||
## darwin: Prevents crashes when running Emacs in Terminal.app under 10.2.
|
||
## The ncurses library has been moved out of the System framework in
|
||
## Mac OS X 10.2. So if configure detects it, set the command-line
|
||
## option to use it.
|
||
darwin) LIBS_TERMCAP="-lncurses" ;;
|
||
|
||
gnu*) test -z "$LIBS_TERMCAP" && LIBS_TERMCAP="-lncurses" ;;
|
||
|
||
freebsd)
|
||
AC_MSG_CHECKING([whether FreeBSD is new enough to use terminfo])
|
||
AC_CACHE_VAL([emacs_cv_freebsd_terminfo],
|
||
[AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <osreldate.h>]],
|
||
[[#if __FreeBSD_version < 400000
|
||
fail;
|
||
#endif
|
||
]])], [emacs_cv_freebsd_terminfo=yes],
|
||
[emacs_cv_freebsd_terminfo=no])])
|
||
|
||
AC_MSG_RESULT([$emacs_cv_freebsd_terminfo])
|
||
|
||
if test $emacs_cv_freebsd_terminfo = yes; then
|
||
LIBS_TERMCAP="-lncurses"
|
||
else
|
||
TERMINFO=no
|
||
LIBS_TERMCAP="-ltermcap"
|
||
fi
|
||
;;
|
||
|
||
# The case condition is a concatenation of both $opsys and
|
||
# $REALLY_ANDROID. Only disable termcap if building a GUI program.
|
||
# (bug#65340)
|
||
mingw32 | androidyes)
|
||
TERMINFO=no
|
||
LIBS_TERMCAP=
|
||
;;
|
||
|
||
netbsd)
|
||
# NetBSD versions prior to 6.0 lack native terminfo, but have a
|
||
# tputs() built on top of termcap in these libraries. Use native
|
||
# termcap instead in this case. NetBSD >= 6.0 has native terminfo
|
||
# implementation in -lterminfo.
|
||
if test "x$LIBS_TERMCAP" = "x-ltermcap" -o "x$LIBS_TERMCAP" = "x-lcurses"; then
|
||
TERMINFO=no
|
||
LIBS_TERMCAP="-ltermcap"
|
||
fi
|
||
;;
|
||
|
||
openbsd | dragonfly) LIBS_TERMCAP="-lncurses" ;;
|
||
|
||
## hpux: Make sure we get select from libc rather than from libcurses
|
||
## because libcurses on HPUX 10.10 has a broken version of select.
|
||
## We used to use -lc -lcurses, but this may be cleaner.
|
||
## FIXME? But TERMINFO = yes on hpux (it used to be explicitly
|
||
# set that way, now it uses the default). Isn't this a contradiction?
|
||
hpux*) LIBS_TERMCAP="-ltermcap" ;;
|
||
|
||
esac
|
||
|
||
TERMCAP_OBJ=tparam.o
|
||
if test $TERMINFO = yes; then
|
||
AC_DEFINE([TERMINFO], [1],
|
||
[Define to 1 if you use terminfo instead of termcap.])
|
||
TERMCAP_OBJ=terminfo.o
|
||
AC_CACHE_CHECK([whether $LIBS_TERMCAP library defines BC],
|
||
[emacs_cv_terminfo_defines_BC],
|
||
[OLD_LIBS=$LIBS
|
||
LIBS="$LIBS $LIBS_TERMCAP"
|
||
AC_LINK_IFELSE([AC_LANG_PROGRAM([[extern char *BC;]], [[return !*BC;]])],
|
||
[emacs_cv_terminfo_defines_BC=yes],
|
||
[emacs_cv_terminfo_defines_BC=no])
|
||
LIBS=$OLD_LIBS])
|
||
if test "$emacs_cv_terminfo_defines_BC" = yes; then
|
||
AC_DEFINE([TERMINFO_DEFINES_BC], [1], [Define to 1 if the
|
||
terminfo library defines the variables BC, PC, and UP.])
|
||
fi
|
||
fi
|
||
if test "X$LIBS_TERMCAP" = "X-lncurses"; then
|
||
AC_DEFINE([USE_NCURSES], [1], [Define to 1 if you use ncurses.])
|
||
fi
|
||
AC_SUBST([LIBS_TERMCAP])
|
||
AC_SUBST([TERMCAP_OBJ])
|
||
|
||
# GNU/Linux-specific timer functions.
|
||
AC_CACHE_CHECK([for timerfd interface], [emacs_cv_have_timerfd],
|
||
[AC_COMPILE_IFELSE(
|
||
[AC_LANG_PROGRAM([[#include <sys/timerfd.h>
|
||
]],
|
||
[[timerfd_create (CLOCK_REALTIME,
|
||
TFD_CLOEXEC | TFD_NONBLOCK);
|
||
timerfd_settime (0, TFD_TIMER_ABSTIME, 0, 0);]])],
|
||
[emacs_cv_have_timerfd=yes],
|
||
[emacs_cv_have_timerfd=no])])
|
||
if test "$emacs_cv_have_timerfd" = yes; then
|
||
AC_DEFINE([HAVE_TIMERFD], [1],
|
||
[Define to 1 if timerfd functions are supported as in GNU/Linux.])
|
||
fi
|
||
|
||
# Alternate stack for signal handlers.
|
||
AC_CACHE_CHECK([whether signals can be handled on alternate stack],
|
||
[emacs_cv_alternate_stack],
|
||
[AC_COMPILE_IFELSE(
|
||
[AC_LANG_PROGRAM([[#include <signal.h>
|
||
#include <stdlib.h>
|
||
]],
|
||
[[stack_t ss;
|
||
struct sigaction sa;
|
||
ss.ss_sp = malloc (SIGSTKSZ);
|
||
ss.ss_size = SIGSTKSZ;
|
||
sa.sa_flags = SA_SIGINFO | SA_ONSTACK;
|
||
sigaltstack (&ss, 0);
|
||
sigaction (SIGSEGV, &sa, 0);]])],
|
||
[emacs_cv_alternate_stack=yes],
|
||
[emacs_cv_alternate_stack=no])])
|
||
|
||
# Do we need the Hesiod library to provide the support routines?
|
||
dnl FIXME? Should we be skipping this on Darwin too?
|
||
LIBHESIOD=
|
||
LIBRESOLV=
|
||
if test "$with_hesiod" != no ; then
|
||
# Don't set $LIBS here -- see comments above. FIXME which comments?
|
||
resolv=no
|
||
AC_CHECK_FUNC([res_send], [], [AC_CHECK_FUNC([__res_send], [],
|
||
[AC_CHECK_LIB([resolv], [res_send], [resolv=yes],
|
||
[AC_CHECK_LIB([resolv], [__res_send], [resolv=yes])])])])
|
||
if test "$resolv" = yes ; then
|
||
RESOLVLIB=-lresolv
|
||
else
|
||
RESOLVLIB=
|
||
fi
|
||
hesiod=no
|
||
AC_CHECK_FUNC([hes_getmailhost], [],
|
||
[AC_CHECK_LIB([hesiod], [hes_getmailhost],
|
||
[hesiod=yes], [:], [$RESOLVLIB])])
|
||
|
||
if test x"$hesiod" = xyes; then
|
||
LIBHESIOD=-lhesiod
|
||
LIBRESOLV=$RESOLVLIB
|
||
fi
|
||
fi
|
||
AC_SUBST([LIBHESIOD])
|
||
AC_SUBST([LIBRESOLV])
|
||
|
||
# These tell us which Kerberos-related libraries to use.
|
||
COM_ERRLIB=
|
||
CRYPTOLIB=
|
||
KRB5LIB=
|
||
DESLIB=
|
||
KRB4LIB=
|
||
|
||
if test "${with_kerberos}" != no; then
|
||
OLD_LIBS=$LIBS
|
||
AC_CHECK_LIB([com_err], [com_err], [have_com_err=yes], [have_com_err=no])
|
||
if test $have_com_err = yes; then
|
||
COM_ERRLIB=-lcom_err
|
||
LIBS="$COM_ERRLIB $LIBS"
|
||
fi
|
||
AC_CHECK_LIB([crypto], [mit_des_cbc_encrypt],
|
||
[have_crypto=yes],
|
||
[have_crypto=no])
|
||
if test $have_crypto = yes; then
|
||
CRYPTOLIB=-lcrypto
|
||
LIBS="$CRYPTOLIB $LIBS"
|
||
fi
|
||
AC_CHECK_LIB([k5crypto], [mit_des_cbc_encrypt],
|
||
[have_k5crypto=yes],
|
||
[have_k5crypto=no])
|
||
if test $have_k5crypto = yes; then
|
||
CRYPTOLIB=-lk5crypto
|
||
LIBS="$CRYPTOLIB $LIBS"
|
||
fi
|
||
AC_CHECK_LIB([krb5], [krb5_init_context], [have_krb5=yes], [have_krb5=no])
|
||
if test $have_krb5=yes; then
|
||
KRB5LIB=-lkrb5
|
||
LIBS="$KRB5LIB $LIBS"
|
||
fi
|
||
dnl FIXME Simplify. Does not match 22 logic, thanks to default_off?
|
||
if test "${with_kerberos5}" = no; then
|
||
AC_CHECK_LIB([des425], [des_cbc_encrypt],
|
||
[have_des425=yes],
|
||
[have_des425=no])
|
||
if test $have_des425 = yes; then
|
||
DESLIB=-ldes425
|
||
LIBS="$DESLIB $LIBS"
|
||
else
|
||
AC_CHECK_LIB([des], [des_cbc_encrypt], [have_des=yes], [have_des=no])
|
||
if test $have_des = yes; then
|
||
DESLIB=-ldes
|
||
LIBS="$DESLIB $LIBS"
|
||
fi
|
||
fi
|
||
AC_CHECK_LIB([krb4], [krb_get_cred], [have_krb4=yes], [have_krb4=no])
|
||
if test $have_krb4 = yes; then
|
||
KRB4LIB=-lkrb4
|
||
LIBS="$KRB4LIB $LIBS"
|
||
else
|
||
AC_CHECK_LIB([krb], [krb_get_cred], [have_krb=yes], [have_krb=no])
|
||
if test $have_krb = yes; then
|
||
KRB4LIB=-lkrb
|
||
LIBS="$KRB4LIB $LIBS"
|
||
fi
|
||
fi
|
||
fi
|
||
|
||
if test "${with_kerberos5}" != no; then
|
||
AC_CHECK_HEADERS([krb5.h],
|
||
[AC_CHECK_MEMBERS([krb5_error.text, krb5_error.e_text], [], [],
|
||
[#include <krb5.h>])])
|
||
else
|
||
AC_CHECK_HEADERS([krb.h], [],
|
||
[AC_CHECK_HEADERS([kerberosIV/krb.h], [],
|
||
[AC_CHECK_HEADERS([kerberos/krb.h])])])
|
||
fi
|
||
AC_CHECK_HEADERS([com_err.h])
|
||
LIBS=$OLD_LIBS
|
||
fi
|
||
|
||
AC_SUBST([COM_ERRLIB])
|
||
AC_SUBST([CRYPTOLIB])
|
||
AC_SUBST([KRB5LIB])
|
||
AC_SUBST([DESLIB])
|
||
AC_SUBST([KRB4LIB])
|
||
|
||
AC_CHECK_HEADERS([valgrind/valgrind.h])
|
||
|
||
AC_CHECK_MEMBERS([struct unipair.unicode], [], [], [[#include <linux/kd.h>]])
|
||
|
||
AC_CHECK_FUNCS_ONCE([__lsan_ignore_object])
|
||
|
||
AC_FUNC_FORK
|
||
|
||
dnl AC_CHECK_FUNCS_ONCE wouldn’t be right for snprintf, which needs
|
||
dnl the current CFLAGS etc.
|
||
AC_CHECK_FUNCS([snprintf open_memstream])
|
||
|
||
dnl posix_spawn. The chdir and setsid functionality is relatively
|
||
dnl recent, so we check for it specifically.
|
||
AC_CHECK_HEADERS([spawn.h])
|
||
AC_SUBST([HAVE_SPAWN_H])
|
||
AC_CHECK_FUNCS([posix_spawn \
|
||
posix_spawn_file_actions_addchdir \
|
||
posix_spawn_file_actions_addchdir_np \
|
||
posix_spawnattr_setflags])
|
||
AC_SUBST([HAVE_POSIX_SPAWN])
|
||
AC_SUBST([HAVE_POSIX_SPAWN_FILE_ACTIONS_ADDCHDIR])
|
||
AC_SUBST([HAVE_POSIX_SPAWN_FILE_ACTIONS_ADDCHDIR_NP])
|
||
AC_SUBST([HAVE_POSIX_SPAWNATTR_SETFLAGS])
|
||
AC_CHECK_DECLS([POSIX_SPAWN_SETSID], [], [], [[
|
||
#include <spawn.h>
|
||
]])
|
||
AC_SUBST([HAVE_DECL_POSIX_SPAWN_SETSID])
|
||
|
||
dnl Check for glib. This differs from other library checks in that
|
||
dnl Emacs need not link to glib unless some other library is already
|
||
dnl linking to glib. Although glib provides no facilities that Emacs
|
||
dnl needs for its own purposes, when glib is present Emacs needs to
|
||
dnl use primitives like g_main_context_query to avoid clashing with
|
||
dnl glib at a low level.
|
||
dnl
|
||
dnl Check this late, since it depends on $GTK_CFLAGS etc.
|
||
XGSELOBJ=
|
||
AC_CACHE_CHECK([whether GLib is linked in], [emacs_cv_links_glib],
|
||
[OLDCFLAGS="$CFLAGS"
|
||
OLDLIBS="$LIBS"
|
||
CFLAGS="$CFLAGS $GTK_CFLAGS $RSVG_CFLAGS $DBUS_CFLAGS $SETTINGS_CFLAGS"
|
||
LIBS="$LIBS $GTK_LIBS $RSVG_LIBS $DBUS_LIBS $SETTINGS_LIBS"
|
||
CFLAGS="$CFLAGS $NOTIFY_CFLAGS $CAIRO_CFLAGS"
|
||
LIBS="$LIBS $NOTIFY_LIBS $CAIRO_LIBS"
|
||
AC_LINK_IFELSE([AC_LANG_PROGRAM(
|
||
[[#include <glib.h>
|
||
]],
|
||
[[g_print ("Hello world");]])],
|
||
[emacs_cv_links_glib=yes],
|
||
[emacs_cv_links_glib=no])
|
||
CFLAGS="$OLDCFLAGS"
|
||
LIBS="$OLDLIBS"])
|
||
if test "${emacs_cv_links_glib}" = "yes"; then
|
||
AC_DEFINE([HAVE_GLIB], [1], [Define to 1 if GLib is linked in.])
|
||
if test "$HAVE_NS" = no ; then
|
||
XGSELOBJ=xgselect.o
|
||
fi
|
||
fi
|
||
AC_SUBST([XGSELOBJ])
|
||
|
||
AC_DEFUN([EMACS_PAPER_WIDTH],
|
||
[AC_REQUIRE([AM_LANGINFO_CODESET])
|
||
AS_IF([test "$am_cv_langinfo_codeset" = yes],
|
||
[AC_CACHE_CHECK([for nl_langinfo and _NL_PAPER_WIDTH],
|
||
[emacs_cv_langinfo__nl_paper_width],
|
||
[AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <langinfo.h>]],
|
||
[[char *cs = nl_langinfo (_NL_PAPER_WIDTH);]])],
|
||
[emacs_cv_langinfo__nl_paper_width=yes],
|
||
[emacs_cv_langinfo__nl_paper_width=no])
|
||
])
|
||
AS_IF([test "$emacs_cv_langinfo__nl_paper_width" = yes],
|
||
[AC_DEFINE([HAVE_LANGINFO__NL_PAPER_WIDTH], [1],
|
||
[Define if you have <langinfo.h>
|
||
and nl_langinfo (_NL_PAPER_WIDTH).])])])])
|
||
EMACS_PAPER_WIDTH
|
||
|
||
AC_TYPE_MBSTATE_T
|
||
|
||
dnl Fixme: AC_SYS_POSIX_TERMIOS should probably be used, but it's not clear
|
||
dnl how the tty code is related to POSIX and/or other versions of termios.
|
||
dnl The following looks like a useful start.
|
||
dnl
|
||
dnl AC_SYS_POSIX_TERMIOS
|
||
dnl if test $ac_cv_sys_posix_termios = yes; then
|
||
dnl AC_DEFINE([HAVE_TERMIOS], [1],
|
||
dnl [Define to 1 if you have POSIX-style
|
||
dnl functions and macros for terminal control.])
|
||
dnl AC_DEFINE([HAVE_TCATTR], [1],
|
||
dnl [Define to 1 if you have tcgetattr and tcsetattr.])
|
||
dnl fi
|
||
|
||
dnl Turned on June 1996 supposing nobody will mind it.
|
||
dnl MinGW emulates passwd database, so this feature doesn't make sense there.
|
||
if test "${opsys}" != "mingw32"; then
|
||
AC_DEFINE([AMPERSAND_FULL_NAME], [1], [Define to use the convention that &
|
||
in the full name stands for the login id.])
|
||
fi
|
||
|
||
dnl Everybody supports this, except MS.
|
||
dnl Seems like the kind of thing we should be testing for, though.
|
||
## Note: PTYs are broken on darwin <6. Use at your own risk.
|
||
if test "${opsys}" != "mingw32"; then
|
||
AC_DEFINE([HAVE_PTYS], [1], [Define if the system supports pty devices.])
|
||
fi
|
||
|
||
dnl Everybody supports this, except MS-DOS.
|
||
dnl Seems like the kind of thing we should be testing for, though.
|
||
AC_DEFINE([HAVE_SOCKETS], [1], [Define if the system supports
|
||
4.2-compatible sockets.])
|
||
|
||
AH_TEMPLATE([INTERNAL_TERMINAL],
|
||
[This is substituted when $TERM is "internal".])
|
||
|
||
AH_TEMPLATE([NULL_DEVICE], [Name of the file to open to get
|
||
a null file, or a data sink.])
|
||
if test "${opsys}" = "mingw32"; then
|
||
AC_DEFINE([NULL_DEVICE], ["NUL:"])
|
||
else
|
||
AC_DEFINE([NULL_DEVICE], ["/dev/null"])
|
||
fi
|
||
|
||
if test "${opsys}" = "mingw32"; then
|
||
SEPCHAR=';'
|
||
else
|
||
SEPCHAR=':'
|
||
fi
|
||
AC_DEFINE_UNQUOTED([SEPCHAR], ['$SEPCHAR'],
|
||
[Character that separates PATH elements.])
|
||
dnl This is for MinGW, and is used in test/Makefile.in.
|
||
dnl The MSYS Bash has heuristics for replacing ':' with ';' when it
|
||
dnl decides that a command-line argument to be passed to a MinGW program
|
||
dnl is a PATH-style list of directories. But that heuristics plays it
|
||
dnl safe, and only does the replacement when it is _absolutely_ sure it
|
||
dnl sees a colon-separated list of file names; e.g. ":." is left alone,
|
||
dnl which breaks in-tree builds. So we do this manually instead.
|
||
dnl Note that we cannot rely on PATH_SEPARATOR, as that one will always
|
||
dnl be computed as ':' in MSYS Bash.
|
||
AC_SUBST([SEPCHAR])
|
||
|
||
dnl Everybody supports this, except MS-DOS.
|
||
AC_DEFINE([subprocesses], [1], [Define to enable asynchronous subprocesses.])
|
||
|
||
AC_DEFINE([DIRECTORY_SEP], ['/'],
|
||
[Character that separates directories in a file name.])
|
||
|
||
if test "${opsys}" = "mingw32"; then
|
||
AC_DEFINE([IS_DEVICE_SEP(_c_)], [((_c_) == ':')],
|
||
[Returns true if character is a device separator.])
|
||
|
||
AC_DEFINE([IS_DIRECTORY_SEP(_c_)], [((_c_) == '/' || (_c_) == '\\')],
|
||
[Returns true if character is a directory separator.])
|
||
|
||
AC_DEFINE([IS_ANY_SEP(_c_)],
|
||
[(IS_DIRECTORY_SEP (_c_) || IS_DEVICE_SEP (_c_))],
|
||
[Returns true if character is any form of separator.])
|
||
else
|
||
AC_DEFINE([IS_DEVICE_SEP(_c_)], 0,
|
||
[Returns true if character is a device separator.])
|
||
|
||
AC_DEFINE([IS_DIRECTORY_SEP(_c_)], [((_c_) == DIRECTORY_SEP)],
|
||
[Returns true if character is a directory separator.])
|
||
|
||
AC_DEFINE([IS_ANY_SEP(_c_)], [(IS_DIRECTORY_SEP (_c_))],
|
||
[Returns true if character is any form of separator.])
|
||
fi
|
||
|
||
if test "$USE_X_TOOLKIT" != "none"; then
|
||
have_editres=yes
|
||
case $opsys in
|
||
hpux*)
|
||
dnl Assar Westerlund <assar@sics.se> says this is necessary
|
||
dnl for HP-UX 10.20, and that it works for HP-UX 0 as well.
|
||
have_editres=no
|
||
;;
|
||
esac
|
||
if test "$have_editres" != no && test ! -z "$LIBXMU"; then
|
||
OLDLIBS="$LIBS"
|
||
dnl See libXmu.a check above.
|
||
if test x$HAVE_X11XTR6 = xyes; then
|
||
LIBS="-lXt -lSM -lICE $LIBXMU"
|
||
else
|
||
OTHERLIBS="-lXt -$LIBXMU"
|
||
fi
|
||
AC_LINK_IFELSE([AC_LANG_PROGRAM(
|
||
[[#include <X11/Intrinsic.h>
|
||
#include <X11/Xmu/Editres.h>]],
|
||
[[_XEditResCheckMessages (0, 0, 0, 0);]])],
|
||
[AC_DEFINE([X_TOOLKIT_EDITRES], [1],
|
||
[Define to 1 if we should use XEditRes.])])
|
||
LIBS=$OLDLIBS
|
||
fi
|
||
fi
|
||
|
||
case $opsys in
|
||
solaris | unixware )
|
||
dnl Some SVr4s don't define NSIG in sys/signal.h for ANSI environments;
|
||
dnl instead, there's a system variable _sys_nsig. Unfortunately, we
|
||
dnl need the constant to dimension an array. So wire in the appropriate
|
||
dnl value here.
|
||
AC_DEFINE([NSIG_MINIMUM], [32], [Minimum value of NSIG.])
|
||
;;
|
||
esac
|
||
|
||
emacs_broken_SIGIO=no
|
||
|
||
case $opsys in
|
||
dnl SIGIO exists, but the feature doesn't work in the way Emacs needs.
|
||
hpux* | nacl | solaris | unixware )
|
||
emacs_broken_SIGIO=yes
|
||
;;
|
||
|
||
aix4-2)
|
||
dnl On AIX Emacs uses the gmalloc.c malloc implementation. But given
|
||
dnl the way this system works, libc functions that return malloced
|
||
dnl memory use the libc malloc implementation. Calling xfree or
|
||
dnl xrealloc on the results of such functions results in a crash.
|
||
dnl
|
||
dnl One solution for this could be to define SYSTEM_MALLOC in configure,
|
||
dnl but that does not currently work on this system.
|
||
dnl
|
||
dnl It is possible to completely override the malloc implementation on
|
||
dnl AIX, but that involves putting the malloc functions in a shared
|
||
dnl library and setting the MALLOCTYPE environment variable to point to
|
||
dnl that shared library.
|
||
dnl
|
||
dnl Emacs currently calls xrealloc on the results of get_current_dir name,
|
||
dnl to avoid a crash just use the Emacs implementation for that function.
|
||
dnl
|
||
dnl FIXME We could change the AC_CHECK_FUNCS call near the start
|
||
dnl of this file, so that we do not check for get_current_dir_name
|
||
dnl on AIX. But that might be fragile if something else ends
|
||
dnl up testing for get_current_dir_name as a dependency.
|
||
AC_DEFINE([BROKEN_GET_CURRENT_DIR_NAME], [1], [Define if
|
||
get_current_dir_name should not be used.])
|
||
;;
|
||
|
||
freebsd)
|
||
dnl Circumvent a bug in FreeBSD. In the following sequence of
|
||
dnl writes/reads on a PTY, read(2) returns bogus data:
|
||
dnl
|
||
dnl write(2) 1022 bytes
|
||
dnl write(2) 954 bytes, get EAGAIN
|
||
dnl read(2) 1024 bytes in process_read_output
|
||
dnl read(2) 11 bytes in process_read_output
|
||
dnl
|
||
dnl That is, read(2) returns more bytes than have ever been written
|
||
dnl successfully. The 1033 bytes read are the 1022 bytes written
|
||
dnl successfully after processing (for example with CRs added if the
|
||
dnl terminal is set up that way which it is here). The same bytes will
|
||
dnl be seen again in a later read(2), without the CRs.
|
||
AC_DEFINE([BROKEN_PTY_READ_AFTER_EAGAIN], [1], [Define on FreeBSD to
|
||
work around an issue when reading from a PTY.])
|
||
;;
|
||
esac
|
||
|
||
case $opsys in
|
||
gnu-* | android | solaris | cygwin )
|
||
dnl FIXME Can't we test if this exists (eg /proc/$$)?
|
||
AC_DEFINE([HAVE_PROCFS], [1], [Define if you have the /proc filesystem.])
|
||
;;
|
||
esac
|
||
|
||
case $opsys in
|
||
darwin | dragonfly | freebsd | netbsd | openbsd )
|
||
AC_DEFINE([DONT_REOPEN_PTY], [1], [Define if process.c does not need to
|
||
close a pty to make it a controlling terminal (it is already a
|
||
controlling terminal of the subprocess, because we did ioctl TIOCSCTTY).])
|
||
;;
|
||
esac
|
||
|
||
dnl FIXME Surely we can test for this rather than hard-code it.
|
||
case $opsys in
|
||
netbsd | openbsd) sound_device="/dev/audio" ;;
|
||
*) sound_device="/dev/dsp" ;;
|
||
esac
|
||
|
||
dnl Used in sound.c
|
||
AC_DEFINE_UNQUOTED([DEFAULT_SOUND_DEVICE], ["$sound_device"],
|
||
[Name of the default sound device.])
|
||
|
||
|
||
dnl Emacs can read input using SIGIO and buffering characters itself,
|
||
dnl or using CBREAK mode and making C-g cause SIGINT.
|
||
dnl The choice is controlled by the variable interrupt_input.
|
||
dnl
|
||
dnl Define INTERRUPT_INPUT to make interrupt_input = 1 the default (use SIGIO)
|
||
dnl
|
||
dnl Emacs uses the presence of the USABLE_SIGIO macro
|
||
dnl to indicate whether or not signal-driven I/O is possible. It uses
|
||
dnl INTERRUPT_INPUT to decide whether to use it by default.
|
||
dnl
|
||
dnl SIGIO can be used only on systems that implement it (4.2 and 4.3).
|
||
dnl CBREAK mode has two disadvantages
|
||
dnl 1) At least in 4.2, it is impossible to handle the Meta key properly.
|
||
dnl I hear that in system V this problem does not exist.
|
||
dnl 2) Control-G causes output to be discarded.
|
||
dnl I do not know whether this can be fixed in system V.
|
||
dnl
|
||
dnl Another method of doing input is planned but not implemented.
|
||
dnl It would have Emacs fork off a separate process
|
||
dnl to read the input and send it to the true Emacs process
|
||
dnl through a pipe.
|
||
case $opsys in
|
||
darwin | gnu-linux | gnu-kfreebsd)
|
||
AC_DEFINE([INTERRUPT_INPUT], [1], [Define to read input using SIGIO.])
|
||
;;
|
||
esac
|
||
|
||
|
||
dnl If the system's imake configuration file defines 'NeedWidePrototypes'
|
||
dnl as 'NO', we must define NARROWPROTO manually. Such a define is
|
||
dnl generated in the Makefile generated by 'xmkmf'. If we don't define
|
||
dnl NARROWPROTO, we will see the wrong function prototypes for X functions
|
||
dnl taking float or double parameters.
|
||
case $opsys in
|
||
cygwin|gnu|gnu-linux|gnu-kfreebsd|freebsd|netbsd|openbsd)
|
||
AC_DEFINE([NARROWPROTO], [1], [Define if system's imake configuration
|
||
file defines 'NeedWidePrototypes' as 'NO'.])
|
||
;;
|
||
esac
|
||
|
||
|
||
dnl Used in process.c, this must be a loop, even if it only runs once.
|
||
AH_TEMPLATE([PTY_ITERATION], [How to iterate over PTYs.])
|
||
dnl Only used if !PTY_ITERATION. Iterate from FIRST_PTY_LETTER to z,
|
||
dnl trying suffixes 0-16.
|
||
AH_TEMPLATE([FIRST_PTY_LETTER], [Letter to use in finding device name of
|
||
first PTY, if PTYs are supported.])
|
||
AH_TEMPLATE([PTY_OPEN], [How to open a PTY, if non-standard.])
|
||
AH_TEMPLATE([PTY_NAME_SPRINTF], [How to get the device name of the control
|
||
end of a PTY, if non-standard.])
|
||
AH_TEMPLATE([PTY_TTY_NAME_SPRINTF], [How to get device name of the tty
|
||
end of a PTY, if non-standard.])
|
||
|
||
case $opsys in
|
||
aix4-2 )
|
||
AC_DEFINE([PTY_ITERATION], [int c; for (c = 0; !c ; c++)])
|
||
dnl You allocate a pty by opening /dev/ptc to get the master side.
|
||
dnl To get the name of the slave side, you just ttyname() the master side.
|
||
AC_DEFINE([PTY_NAME_SPRINTF], [strcpy (pty_name, "/dev/ptc");])
|
||
AC_DEFINE([PTY_TTY_NAME_SPRINTF], [strcpy (pty_name, ttyname (fd));])
|
||
;;
|
||
|
||
cygwin )
|
||
AC_DEFINE([PTY_ITERATION], [int i; for (i = 0; i < 1; i++)])
|
||
dnl multi-line AC_DEFINEs are hard. :(
|
||
AC_DEFINE([PTY_OPEN],
|
||
[ do { int dummy; sigset_t blocked, procmask; sigemptyset (&blocked); sigaddset (&blocked, SIGCHLD); pthread_sigmask (SIG_BLOCK, &blocked, &procmask); if (-1 == openpty (&fd, &dummy, pty_name, 0, 0)) fd = -1; pthread_sigmask (SIG_SETMASK, &procmask, 0); if (fd >= 0) emacs_close (dummy); } while (false)])
|
||
AC_DEFINE([PTY_NAME_SPRINTF], [])
|
||
AC_DEFINE([PTY_TTY_NAME_SPRINTF], [])
|
||
;;
|
||
|
||
gnu | qnxnto )
|
||
AC_DEFINE([FIRST_PTY_LETTER], ['p'])
|
||
;;
|
||
|
||
android )
|
||
AC_DEFINE([PTY_ITERATION], [int i; for (i = 0; i < 1; ++i)])
|
||
dnl grantpt may be defined in libc but not declared. The same
|
||
dnl goes for posix_openpt. When that is the case, it means that
|
||
dnl grantpt or posix_openpt cannot actually be used.
|
||
AC_CHECK_DECLS([grantpt, posix_openpt])
|
||
AS_IF([test "x$ac_cv_have_decl_grantpt" = xyes],
|
||
[AC_DEFINE([PTY_TTY_NAME_SPRINTF],
|
||
[{ char *ptyname = 0; sigset_t blocked; sigemptyset (&blocked); sigaddset (&blocked, SIGCHLD); pthread_sigmask (SIG_BLOCK, &blocked, 0); if (grantpt (fd) != -1 && unlockpt (fd) != -1) ptyname = ptsname(fd); pthread_sigmask (SIG_UNBLOCK, &blocked, 0); if (!ptyname) { emacs_close (fd); return -1; } snprintf (pty_name, PTY_NAME_SIZE, "%s", ptyname); }])],
|
||
[AC_DEFINE([PTY_TTY_NAME_SPRINTF],
|
||
[{ char *ptyname = 0; sigset_t blocked; sigemptyset (&blocked); sigaddset (&blocked, SIGCHLD); pthread_sigmask (SIG_BLOCK, &blocked, 0); if (unlockpt (fd) != -1) ptyname = ptsname(fd); pthread_sigmask (SIG_UNBLOCK, &blocked, 0); if (!ptyname) { emacs_close (fd); return -1; } snprintf (pty_name, PTY_NAME_SIZE, "%s", ptyname); }])])
|
||
AS_IF([test "x$ac_cv_have_decl_posix_openpt" = xyes],
|
||
[AC_DEFINE([PTY_OPEN],
|
||
[do { fd = posix_openpt (O_RDWR | O_CLOEXEC | O_NOCTTY); if (fd < 0 && errno == EINVAL) fd = posix_openpt (O_RDWR | O_NOCTTY); } while (false)])
|
||
AC_DEFINE([PTY_NAME_SPRINTF], [])],
|
||
[AC_DEFINE([PTY_NAME_SPRINTF], [])
|
||
AC_DEFINE([PTY_OPEN], [fd = getpt ()])])
|
||
;;
|
||
|
||
gnu-linux | gnu-kfreebsd | dragonfly | freebsd | openbsd | netbsd | darwin | nacl )
|
||
dnl if HAVE_GRANTPT
|
||
if test "x$ac_cv_func_grantpt" = xyes; then
|
||
AC_DEFINE([UNIX98_PTYS], [1], [Define if the system has Unix98 PTYs.])
|
||
AC_DEFINE([PTY_ITERATION], [int i; for (i = 0; i < 1; i++)])
|
||
dnl Note that grantpt and unlockpt may fork. We must block SIGCHLD
|
||
dnl to prevent sigchld_handler from intercepting the child's death.
|
||
AC_DEFINE([PTY_TTY_NAME_SPRINTF],
|
||
[{ char *ptyname = 0; sigset_t blocked; sigemptyset (&blocked); sigaddset (&blocked, SIGCHLD); pthread_sigmask (SIG_BLOCK, &blocked, 0); if (grantpt (fd) != -1 && unlockpt (fd) != -1) ptyname = ptsname(fd); pthread_sigmask (SIG_UNBLOCK, &blocked, 0); if (!ptyname) { emacs_close (fd); return -1; } snprintf (pty_name, PTY_NAME_SIZE, "%s", ptyname); }])
|
||
dnl if HAVE_POSIX_OPENPT
|
||
if test "x$ac_cv_func_posix_openpt" = xyes; then
|
||
AC_DEFINE([PTY_OPEN],
|
||
[do { fd = posix_openpt (O_RDWR | O_CLOEXEC | O_NOCTTY); if (fd < 0 && errno == EINVAL) fd = posix_openpt (O_RDWR | O_NOCTTY); } while (false)])
|
||
AC_DEFINE([PTY_NAME_SPRINTF], [])
|
||
dnl if HAVE_GETPT
|
||
elif test "x$ac_cv_func_getpt" = xyes; then
|
||
AC_DEFINE([PTY_OPEN], [fd = getpt ()])
|
||
AC_DEFINE([PTY_NAME_SPRINTF], [])
|
||
else
|
||
AC_DEFINE([PTY_NAME_SPRINTF], [strcpy (pty_name, "/dev/ptmx");])
|
||
fi
|
||
else
|
||
AC_DEFINE([FIRST_PTY_LETTER], ['p'])
|
||
fi
|
||
;;
|
||
|
||
hpux*)
|
||
AC_DEFINE([FIRST_PTY_LETTER], ['p'])
|
||
AC_DEFINE([PTY_NAME_SPRINTF],
|
||
[sprintf (pty_name, "/dev/ptym/pty%c%x", c, i);])
|
||
AC_DEFINE([PTY_TTY_NAME_SPRINTF],
|
||
[sprintf (pty_name, "/dev/pty/tty%c%x", c, i);])
|
||
;;
|
||
|
||
solaris )
|
||
dnl On SysVr4, grantpt(3) forks a subprocess, so do not use
|
||
dnl O_CLOEXEC when opening the pty, and keep the SIGCHLD handler
|
||
dnl from intercepting that death. If any child but grantpt's should die
|
||
dnl within, it should be caught after sigrelse(2).
|
||
AC_DEFINE([PTY_OPEN], [fd = open (pty_name, O_RDWR | O_NONBLOCK)])
|
||
AC_DEFINE([PTY_TTY_NAME_SPRINTF],
|
||
[{ char *ptsname (int), *ptyname; int grantpt_result; sigset_t blocked; sigemptyset (&blocked); sigaddset (&blocked, SIGCHLD); pthread_sigmask (SIG_BLOCK, &blocked, 0); grantpt_result = grantpt (fd); pthread_sigmask (SIG_UNBLOCK, &blocked, 0); if (grantpt_result == -1 || unlockpt (fd) == -1 || !(ptyname = ptsname (fd))) { emacs_close (fd); return -1; } snprintf (pty_name, PTY_NAME_SIZE, "%s", ptyname); }])
|
||
;;
|
||
|
||
unixware )
|
||
dnl Comments are as per solaris.
|
||
AC_DEFINE([PTY_OPEN], [fd = open (pty_name, O_RDWR | O_NONBLOCK)])
|
||
AC_DEFINE([PTY_TTY_NAME_SPRINTF],
|
||
[{ char *ptsname (int), *ptyname; int grantpt_result; sigset_t blocked; sigemptyset (&blocked); sigaddset (&blocked, SIGCHLD); pthread_sigmask (SIG_BLOCK, &blocked, 0); grantpt_result = grantpt (fd); pthread_sigmask (SIG_UNBLOCK, &blocked, 0); if (grantpt_result == -1) fatal("could not grant slave pty"); if (unlockpt(fd) == -1) fatal("could not unlock slave pty"); if (!(ptyname = ptsname(fd))) fatal ("could not enable slave pty"); snprintf (pty_name, PTY_NAME_SIZE, "%s", ptyname); }])
|
||
;;
|
||
|
||
haiku*)
|
||
AC_DEFINE([FIRST_PTY_LETTER], ['s'])
|
||
AC_DEFINE([PTY_NAME_SPRINTF], [])
|
||
dnl on Haiku pty names aren't distinctive, thus the use of posix_openpt
|
||
AC_DEFINE([PTY_OPEN], [fd = posix_openpt (O_RDWR | O_NONBLOCK)])
|
||
AC_DEFINE([PTY_TTY_NAME_SPRINTF],
|
||
[{ char *ptyname; int grantpt_result; sigset_t blocked; sigemptyset (&blocked); sigaddset (&blocked, SIGCHLD); pthread_sigmask (SIG_BLOCK, &blocked, 0); grantpt_result = grantpt (fd); pthread_sigmask (SIG_UNBLOCK, &blocked, 0); if (grantpt_result == -1) fatal("could not grant slave pty"); if (unlockpt(fd) == -1) fatal("could not unlock slave pty"); if (!(ptyname = ptsname(fd))) fatal ("could not enable slave pty"); snprintf (pty_name, PTY_NAME_SIZE, "%s", ptyname); }])
|
||
;;
|
||
esac
|
||
|
||
|
||
case $opsys in
|
||
solaris | unixware )
|
||
dnl This change means that we don't loop through allocate_pty too
|
||
dnl many times in the (rare) event of a failure.
|
||
AC_DEFINE([FIRST_PTY_LETTER], ['z'])
|
||
AC_DEFINE([PTY_NAME_SPRINTF], [strcpy (pty_name, "/dev/ptmx");])
|
||
dnl Push various streams modules onto a PTY channel. Used in process.c.
|
||
AC_DEFINE([SETUP_SLAVE_PTY],
|
||
[if (ioctl (std_in, I_PUSH, "ptem") == -1) fatal ("ioctl I_PUSH ptem"); if (ioctl (std_in, I_PUSH, "ldterm") == -1) fatal ("ioctl I_PUSH ldterm"); if (ioctl (std_in, I_PUSH, "ttcompat") == -1) fatal ("ioctl I_PUSH ttcompat");], [How to set up a slave PTY, if needed.])
|
||
;;
|
||
esac
|
||
|
||
|
||
AH_TEMPLATE([SIGNALS_VIA_CHARACTERS], [Make process_send_signal work by
|
||
"typing" a signal character on the pty.])
|
||
|
||
case $opsys in
|
||
dnl Perry Smith <pedz@ddivt1.austin.ibm.com> says this is correct for AIX.
|
||
aix4-2 | cygwin | gnu | dragonfly | freebsd | netbsd | openbsd | darwin )
|
||
AC_DEFINE([SIGNALS_VIA_CHARACTERS], [1])
|
||
;;
|
||
|
||
dnl 21 Jun 06: Eric Hanchrow <offby1@blarg.net> says this works.
|
||
dnl FIXME Does gnu-kfreebsd have linux/version.h? It seems unlikely...
|
||
gnu-linux | gnu-kfreebsd )
|
||
|
||
AC_CACHE_CHECK([for signals via characters], [emacs_cv_signals_via_chars],
|
||
[AC_PREPROC_IFELSE([AC_LANG_PROGRAM([[
|
||
#include <linux/version.h>
|
||
#if LINUX_VERSION_CODE < 0x20400
|
||
# error "Linux version too old"
|
||
#endif
|
||
]], [[]])],
|
||
[emacs_cv_signals_via_chars=yes],
|
||
[emacs_cv_signals_via_chars=no])])
|
||
|
||
test "$emacs_cv_signals_via_chars" = yes &&
|
||
AC_DEFINE([SIGNALS_VIA_CHARACTERS], [1])
|
||
;;
|
||
esac
|
||
|
||
|
||
AH_TEMPLATE([TAB3], [Undocumented.])
|
||
|
||
case $opsys in
|
||
darwin) AC_DEFINE([TAB3], [OXTABS]) ;;
|
||
|
||
gnu | dragonfly | freebsd | netbsd | openbsd )
|
||
AC_DEFINE([TABDLY], [OXTABS], [Undocumented.])
|
||
AC_DEFINE([TAB3], [OXTABS])
|
||
;;
|
||
|
||
gnu-linux | gnu-kfreebsd )
|
||
AC_PREPROC_IFELSE(
|
||
[AC_LANG_PROGRAM(
|
||
[[
|
||
#ifndef __ia64__
|
||
# error "not ia64"
|
||
#endif
|
||
]], [[]])],
|
||
[AC_DEFINE([GC_MARK_SECONDARY_STACK()],
|
||
[do { extern void *__libc_ia64_register_backing_store_base; __builtin_ia64_flushrs (); mark_memory (__libc_ia64_register_backing_store_base, __builtin_ia64_bsp ());} while (false)],
|
||
[Mark a secondary stack, like the register stack on the ia64.])], [])
|
||
;;
|
||
|
||
hpux*)
|
||
AC_DEFINE([RUN_TIME_REMAP], [1], [Define if emacs.c needs to call
|
||
run_time_remap; for HPUX.])
|
||
;;
|
||
esac
|
||
|
||
|
||
dnl This won't be used automatically yet. We also need to know, at least,
|
||
dnl that the stack is continuous.
|
||
AH_TEMPLATE([GC_SETJMP_WORKS], [Define if setjmp is known to save all
|
||
registers relevant for conservative garbage collection in the jmp_buf.])
|
||
|
||
|
||
case $opsys in
|
||
dnl Not all the architectures are tested, but there are Debian packages
|
||
dnl for SCM and/or Guile on them, so the technique must work. See also
|
||
dnl comments in alloc.c concerning setjmp and gcc.
|
||
dnl Fixme: it's probably safe to just use the GCC conditional below.
|
||
gnu-linux | gnu-kfreebsd )
|
||
AC_PREPROC_IFELSE([AC_LANG_PROGRAM([[
|
||
#if defined __i386__ || defined __sparc__ || defined __mc68000__ \
|
||
|| defined __alpha__ || defined __mips__ || defined __s390__ \
|
||
|| defined __arm__ || defined __powerpc__ || defined __amd64__ \
|
||
|| defined __x86_64__ \
|
||
|| defined __ia64__ || defined __sh__
|
||
/* ok */
|
||
#else
|
||
# error "setjmp not known to work on this arch"
|
||
#endif
|
||
]], [[]])], [AC_DEFINE([GC_SETJMP_WORKS], [1])])
|
||
;;
|
||
esac
|
||
|
||
|
||
if test x$GCC = xyes; then
|
||
dnl GC_SETJMP_WORKS is nearly always appropriate for GCC.
|
||
AC_DEFINE([GC_SETJMP_WORKS], [1])
|
||
else
|
||
case $opsys in
|
||
aix* | dragonfly | freebsd | netbsd | openbsd | solaris )
|
||
AC_DEFINE([GC_SETJMP_WORKS], [1])
|
||
;;
|
||
esac
|
||
fi dnl GCC?
|
||
|
||
dnl In a weird quirk, MS runtime uses _setjmp and longjmp.
|
||
AC_CACHE_CHECK([for _setjmp], [emacs_cv_func__setjmp],
|
||
[AC_LINK_IFELSE(
|
||
[AC_LANG_PROGRAM(
|
||
[[#include <setjmp.h>
|
||
#ifdef __MINGW32__
|
||
# define _longjmp longjmp
|
||
#endif
|
||
]],
|
||
[[jmp_buf j;
|
||
if (! _setjmp (j))
|
||
_longjmp (j, 1);]])],
|
||
[emacs_cv_func__setjmp=yes],
|
||
[emacs_cv_func__setjmp=no])])
|
||
if test $emacs_cv_func__setjmp = yes; then
|
||
AC_DEFINE([HAVE__SETJMP], [1], [Define to 1 if _setjmp and _longjmp work.])
|
||
fi
|
||
|
||
# We need to preserve signal mask to handle C stack overflows.
|
||
AC_CACHE_CHECK([for sigsetjmp], [emacs_cv_func_sigsetjmp],
|
||
[AC_LINK_IFELSE(
|
||
[AC_LANG_PROGRAM(
|
||
[[#include <setjmp.h>
|
||
]],
|
||
[[sigjmp_buf j;
|
||
if (! sigsetjmp (j, 1))
|
||
siglongjmp (j, 1);]])],
|
||
[emacs_cv_func_sigsetjmp=yes],
|
||
[emacs_cv_func_sigsetjmp=no])])
|
||
if test $emacs_cv_func_sigsetjmp = yes; then
|
||
AC_DEFINE([HAVE_SIGSETJMP], [1],
|
||
[Define to 1 if sigsetjmp and siglongjmp work.])
|
||
fi
|
||
|
||
case $emacs_cv_func_sigsetjmp,$emacs_cv_alternate_stack,$opsys in
|
||
yes,yes,* | *,*,mingw32)
|
||
AC_DEFINE([HAVE_STACK_OVERFLOW_HANDLING], [1],
|
||
[Define to 1 if C stack overflow can be handled in some cases.]);;
|
||
esac
|
||
|
||
case $opsys in
|
||
solaris | unixware )
|
||
dnl TIOCGPGRP is broken in SysVr4, so we can't send signals to PTY
|
||
dnl subprocesses the usual way. But TIOCSIGNAL does work for PTYs,
|
||
dnl and this is all we need.
|
||
AC_DEFINE([TIOCSIGSEND], [TIOCSIGNAL], [Some platforms redefine this.])
|
||
;;
|
||
esac
|
||
|
||
|
||
case $opsys in
|
||
hpux* | solaris )
|
||
dnl Used in xfaces.c.
|
||
AC_DEFINE([XOS_NEEDS_TIME_H], [1], [Compensate for a bug in Xos.h on
|
||
some systems, where it requires time.h.])
|
||
;;
|
||
esac
|
||
|
||
|
||
dnl Define symbols to identify the version of Unix this is.
|
||
dnl Define all the symbols that apply correctly.
|
||
AH_TEMPLATE([DOS_NT], [Define if the system is MS DOS or MS Windows.])
|
||
AH_TEMPLATE([MSDOS], [Define if the system is MS DOS.])
|
||
AH_TEMPLATE([USG], [Define if the system is compatible with System III.])
|
||
AH_TEMPLATE([USG5_4],
|
||
[Define if the system is compatible with System V Release 4.])
|
||
|
||
case $opsys in
|
||
aix4-2)
|
||
AC_DEFINE([USG], [])
|
||
dnl This symbol should be defined on AIX Version 3 ???????
|
||
AC_PREPROC_IFELSE([AC_LANG_PROGRAM([[
|
||
#ifndef _AIX
|
||
# error "_AIX not defined"
|
||
#endif
|
||
]], [[]])], [], [AC_DEFINE([_AIX], [], [Define if the system is AIX.])])
|
||
;;
|
||
|
||
cygwin)
|
||
AC_DEFINE([CYGWIN], [1], [Define if the system is Cygwin.])
|
||
;;
|
||
|
||
darwin)
|
||
dnl Not __APPLE__, as this may not be defined on non-macOS Darwin.
|
||
dnl Not DARWIN, because Panther and lower CoreFoundation.h use DARWIN to
|
||
dnl distinguish macOS from pure Darwin.
|
||
AC_DEFINE([DARWIN_OS], [], [Define if the system is Darwin.])
|
||
;;
|
||
|
||
gnu-linux | gnu-kfreebsd )
|
||
AC_DEFINE([USG], [])
|
||
AC_DEFINE([GNU_LINUX], [],
|
||
[Define if this system is compatible with GNU/Linux.])
|
||
;;
|
||
|
||
hpux*)
|
||
AC_DEFINE([USG], [])
|
||
AC_DEFINE([HPUX], [], [Define if the system is HPUX.])
|
||
;;
|
||
|
||
mingw32)
|
||
AC_DEFINE([DOS_NT], [])
|
||
AC_DEFINE([WINDOWSNT], [1], [Define if compiling for native MS Windows.])
|
||
if test "x$ac_enable_checking" != "x" ; then
|
||
AC_DEFINE([EMACSDEBUG], [1],
|
||
[Define to 1 to enable w32 debug facilities.])
|
||
fi
|
||
;;
|
||
|
||
solaris)
|
||
AC_DEFINE([USG], [])
|
||
AC_DEFINE([USG5_4], [])
|
||
AC_DEFINE([SOLARIS2], [], [Define if the system is Solaris.])
|
||
;;
|
||
|
||
unixware)
|
||
AC_DEFINE([USG], [])
|
||
AC_DEFINE([USG5_4], [])
|
||
;;
|
||
|
||
haiku)
|
||
AC_DEFINE([HAIKU], [], [Define if the system is Haiku.])
|
||
;;
|
||
esac
|
||
|
||
AC_SYS_POSIX_TERMIOS
|
||
if test $ac_cv_sys_posix_termios = yes; then
|
||
AC_CHECK_SIZEOF([speed_t], [], [#include <termios.h>])
|
||
dnl on Haiku, and possibly other platforms, speed_t is defined to
|
||
dnl unsigned char, even when speeds greater than 200 baud are
|
||
dnl defined.
|
||
|
||
if test ${ac_cv_sizeof_speed_t} -lt 2; then
|
||
AC_DEFINE([HAVE_TINY_SPEED_T], [1],
|
||
[Define to 1 if speed_t has some sort of nonsensically tiny size.])
|
||
fi
|
||
fi
|
||
|
||
AC_CACHE_CHECK([for usable FIONREAD], [emacs_cv_usable_FIONREAD],
|
||
[case $opsys in
|
||
aix4-2 | nacl)
|
||
dnl BUILD 9008 - FIONREAD problem still exists in X-Windows.
|
||
emacs_cv_usable_FIONREAD=no
|
||
;;
|
||
|
||
mingw32)
|
||
emacs_cv_usable_FIONREAD=yes
|
||
;;
|
||
|
||
*)
|
||
AC_COMPILE_IFELSE(
|
||
[AC_LANG_PROGRAM([[#include <sys/types.h>
|
||
#include <sys/ioctl.h>
|
||
#ifdef USG5_4
|
||
# include <sys/filio.h>
|
||
#endif
|
||
]],
|
||
[[int foo = ioctl (0, FIONREAD, &foo);]])],
|
||
[emacs_cv_usable_FIONREAD=yes],
|
||
[emacs_cv_usable_FIONREAD=no])
|
||
;;
|
||
esac])
|
||
if test $emacs_cv_usable_FIONREAD = yes; then
|
||
AC_DEFINE([USABLE_FIONREAD], [1], [Define to 1 if FIONREAD is usable.])
|
||
|
||
if test $emacs_broken_SIGIO = no; then
|
||
AC_CACHE_CHECK([for usable SIGIO], [emacs_cv_usable_SIGIO],
|
||
[AC_COMPILE_IFELSE(
|
||
[AC_LANG_PROGRAM([[#include <fcntl.h>
|
||
#include <signal.h>
|
||
]],
|
||
[[int foo = SIGIO | F_SETFL | FASYNC;]])],
|
||
[emacs_cv_usable_SIGIO=yes],
|
||
[emacs_cv_usable_SIGIO=no])],
|
||
[emacs_cv_usable_SIGIO=yes],
|
||
[emacs_cv_usable_SIGIO=no])
|
||
if test $emacs_cv_usable_SIGIO = yes; then
|
||
AC_DEFINE([USABLE_SIGIO], [1], [Define to 1 if SIGIO is usable.])
|
||
fi
|
||
fi
|
||
|
||
if test $emacs_broken_SIGIO = no && test $emacs_cv_usable_SIGIO = no; then
|
||
AC_CACHE_CHECK([for usable SIGPOLL], [emacs_cv_usable_SIGPOLL],
|
||
[AC_COMPILE_IFELSE(
|
||
[AC_LANG_PROGRAM([[#include <fcntl.h>
|
||
#include <signal.h>
|
||
]],
|
||
[[int foo = SIGPOLL | F_SETFL;]])],
|
||
[emacs_cv_usable_SIGPOLL=yes],
|
||
[emacs_cv_usable_SIGPOLL=no])],
|
||
[emacs_cv_usable_SIGPOLL=yes],
|
||
[emacs_cv_usable_SIGPOLL=no])
|
||
if test $emacs_cv_usable_SIGPOLL = yes; then
|
||
AC_DEFINE([USABLE_SIGPOLL], [1], [Define to 1 if SIGPOLL is usable but SIGIO is not.])
|
||
fi
|
||
fi
|
||
fi
|
||
|
||
case $opsys in
|
||
hpux11)
|
||
dnl It works to open the pty's tty in the parent (Emacs), then
|
||
dnl close and reopen it in the child.
|
||
AC_DEFINE([USG_SUBTTY_WORKS], [1], [Define for USG systems where it
|
||
works to open a pty's tty in the parent process, then close and
|
||
reopen it in the child.])
|
||
;;
|
||
|
||
solaris)
|
||
AC_DEFINE([_STRUCTURED_PROC], [1], [Needed for system_process_attributes
|
||
on Solaris.])
|
||
;;
|
||
esac
|
||
|
||
# Set up the CFLAGS for real compilation, so we can substitute it.
|
||
CFLAGS="$REAL_CFLAGS"
|
||
CPPFLAGS="$REAL_CPPFLAGS"
|
||
LIBS="$REAL_LIBS"
|
||
|
||
## Hack to detect a buggy GCC version.
|
||
if test "$GCC" = yes && \
|
||
$CC --version 2> /dev/null | grep 'gcc.* 4.5.0' >/dev/null; then
|
||
case $CFLAGS in
|
||
*-fno-optimize-sibling-calls*) ;;
|
||
*-O@<:@23@:>@*)
|
||
AC_MSG_ERROR([GCC 4.5.0 has problems compiling Emacs; see etc/PROBLEMS.]);;
|
||
esac
|
||
fi
|
||
|
||
version=$PACKAGE_VERSION
|
||
|
||
copyright="Copyright (C) 2024 Free Software Foundation, Inc."
|
||
AC_DEFINE_UNQUOTED([COPYRIGHT], ["$copyright"],
|
||
[Short copyright string for this version of Emacs.])
|
||
AC_SUBST([copyright])
|
||
|
||
### Specify what sort of things we'll be editing into Makefile and config.h.
|
||
### Use configuration here uncanonicalized to avoid exceeding size limits.
|
||
AC_SUBST([version])
|
||
AC_SUBST([configuration])
|
||
## Unused?
|
||
AC_SUBST([canonical])
|
||
AC_SUBST([srcdir])
|
||
AC_SUBST([prefix])
|
||
AC_SUBST([exec_prefix])
|
||
AC_SUBST([bindir])
|
||
AC_SUBST([datadir])
|
||
AC_SUBST([gsettingsschemadir])
|
||
AC_SUBST([sharedstatedir])
|
||
AC_SUBST([libexecdir])
|
||
AC_SUBST([mandir])
|
||
AC_SUBST([infodir])
|
||
AC_SUBST([lispdirrel])
|
||
AC_SUBST([lispdir])
|
||
AC_SUBST([standardlisppath])
|
||
AC_SUBST([locallisppath])
|
||
AC_SUBST([lisppath])
|
||
AC_SUBST([x_default_search_path])
|
||
AC_SUBST([etcdir])
|
||
AC_SUBST([archlibdir])
|
||
AC_SUBST([etcdocdir])
|
||
AC_SUBST([bitmapdir])
|
||
AC_SUBST([gamedir])
|
||
AC_SUBST([gameuser])
|
||
AC_SUBST([gamegroup])
|
||
## FIXME? Nothing uses @LD_SWITCH_X_SITE@.
|
||
## src/Makefile.in did add LD_SWITCH_X_SITE (as a cpp define) to the
|
||
## end of LIBX_BASE, but nothing ever set it.
|
||
AC_SUBST([LD_SWITCH_X_SITE])
|
||
AC_SUBST([C_SWITCH_X_SITE])
|
||
AC_SUBST([GNUSTEP_CFLAGS])
|
||
AC_SUBST([CFLAGS])
|
||
## Used in lwlib/Makefile.in.
|
||
AC_SUBST([X_TOOLKIT_TYPE])
|
||
AC_SUBST([ns_appdir])
|
||
AC_SUBST([ns_appbindir])
|
||
AC_SUBST([ns_applibexecdir])
|
||
AC_SUBST([ns_applibdir])
|
||
AC_SUBST([ns_appresdir])
|
||
AC_SUBST([ns_appsrc])
|
||
AC_SUBST([GNU_OBJC_CFLAGS])
|
||
AC_SUBST([OTHER_FILES])
|
||
|
||
if test -n "${term_header}"; then
|
||
AC_DEFINE_UNQUOTED([TERM_HEADER], ["${term_header}"],
|
||
[Define to the header for the built-in window system.])
|
||
fi
|
||
|
||
AC_DEFINE_UNQUOTED([EMACS_CONFIGURATION], ["${canonical}"],
|
||
[Define to the canonical Emacs configuration name.])
|
||
AC_DEFINE_UNQUOTED([EMACS_CONFIG_OPTIONS], "${emacs_config_options}",
|
||
[Define to the options passed to configure.])
|
||
|
||
XMENU_OBJ=
|
||
XOBJ=
|
||
FONT_OBJ=
|
||
if test "${HAVE_X_WINDOWS}" = "yes" ; then
|
||
AC_DEFINE([HAVE_X_WINDOWS], [1],
|
||
[Define to 1 if you want to use the X window system.])
|
||
XMENU_OBJ=xmenu.o
|
||
XOBJ="xterm.o xfns.o xselect.o xrdb.o xsmfns.o xsettings.o"
|
||
FONT_OBJ=xfont.o
|
||
if test "$HAVE_CAIRO" = "yes"; then
|
||
FONT_OBJ="$FONT_OBJ ftfont.o ftcrfont.o"
|
||
elif test "$HAVE_XFT" = "yes"; then
|
||
FONT_OBJ="$FONT_OBJ ftfont.o xftfont.o"
|
||
elif test "$HAVE_FREETYPE" = "yes"; then
|
||
FONT_OBJ="$FONT_OBJ ftfont.o"
|
||
fi
|
||
fi
|
||
|
||
if test "${window_system}" = "pgtk"; then
|
||
FONT_OBJ="ftfont.o ftcrfont.o"
|
||
fi
|
||
|
||
if test "${HAVE_BE_APP}" = "yes" ; then
|
||
if test "${HAVE_CAIRO}" = "yes"; then
|
||
FONT_OBJ="$FONT_OBJ ftfont.o ftcrfont.o"
|
||
fi
|
||
fi
|
||
|
||
if test "${HAVE_HARFBUZZ}" = "yes" ; then
|
||
FONT_OBJ="$FONT_OBJ hbfont.o"
|
||
fi
|
||
AC_SUBST([FONT_OBJ])
|
||
AC_SUBST([XMENU_OBJ])
|
||
AC_SUBST([XOBJ])
|
||
AC_SUBST([FONT_OBJ])
|
||
|
||
WIDGET_OBJ=
|
||
MOTIF_LIBW=
|
||
if test "${USE_X_TOOLKIT}" != "none" ; then
|
||
WIDGET_OBJ=widget.o
|
||
AC_DEFINE([USE_X_TOOLKIT], [1], [Define to 1 if using an X toolkit.])
|
||
if test "${USE_X_TOOLKIT}" = "LUCID"; then
|
||
AC_DEFINE([USE_LUCID], [1], [Define to 1 if using the Lucid X toolkit.])
|
||
elif test "${USE_X_TOOLKIT}" = "MOTIF"; then
|
||
AC_DEFINE([USE_MOTIF], [1], [Define to 1 if using the Motif X toolkit.])
|
||
MOTIF_LIBW=-lXm
|
||
case "$opsys" in
|
||
gnu-linux)
|
||
## Paul Abrahams <abrahams at equinox.shaysnet.com> says this is needed.
|
||
MOTIF_LIBW="$MOTIF_LIBW -lXpm"
|
||
;;
|
||
|
||
unixware)
|
||
## Richard Anthony Ryan <ryanr at ellingtn.ftc.nrcs.usda.gov>
|
||
## says -lXimp is needed in UNIX_SV ... 4.2 1.1.2.
|
||
MOTIF_LIBW="MOTIF_LIBW -lXimp"
|
||
;;
|
||
|
||
aix4-2)
|
||
## olson@mcs.anl.gov says -li18n is needed by -lXm.
|
||
MOTIF_LIBW="$MOTIF_LIBW -li18n"
|
||
;;
|
||
esac
|
||
MOTIF_LIBW="$MOTIF_LIBW $LIBXP"
|
||
fi
|
||
fi
|
||
AC_SUBST([WIDGET_OBJ])
|
||
|
||
TOOLKIT_LIBW=
|
||
case "$USE_X_TOOLKIT" in
|
||
MOTIF) TOOLKIT_LIBW="$MOTIF_LIBW" ;;
|
||
LUCID) TOOLKIT_LIBW="$LUCID_LIBW" ;;
|
||
none) test "x$HAVE_GTK" = "xyes" && TOOLKIT_LIBW="$GTK_LIBS" ;;
|
||
esac
|
||
if test "$HAVE_XWIDGETS" = "yes"; then
|
||
TOOLKIT_LIBW="$TOOLKIT_LIBW -lXcomposite"
|
||
fi
|
||
AC_SUBST([TOOLKIT_LIBW])
|
||
|
||
if test "${opsys}" != "mingw32"; then
|
||
if test "$USE_X_TOOLKIT" = "none"; then
|
||
LIBXT_OTHER="\$(LIBXSM)"
|
||
else
|
||
LIBXT_OTHER="\$(LIBXMU) -lXt \$(LIBXTR6) -lXext"
|
||
fi
|
||
fi
|
||
AC_SUBST([LIBXT_OTHER])
|
||
|
||
if test "${HAVE_X11}" = "yes" ; then
|
||
AC_DEFINE([HAVE_X11], [1],
|
||
[Define to 1 if you want to use version 11 of X windows.])
|
||
LIBX_OTHER="\$(LIBXT) \$(LIBX_EXTRA)"
|
||
else
|
||
LIBX_OTHER=
|
||
fi
|
||
AC_SUBST([LIBX_OTHER])
|
||
|
||
HAVE_OLDXMENU=no
|
||
if test "$HAVE_GTK" = yes || test "$HAVE_X11" != yes; then
|
||
LIBXMENU=
|
||
elif test "$USE_X_TOOLKIT" = none; then
|
||
HAVE_OLDXMENU=yes
|
||
LIBXMENU='$(oldXMenudir)/libXMenu11.a'
|
||
AUTODEPEND_PARENTS="$AUTODEPEND_PARENTS oldXMenu"
|
||
else
|
||
LIBXMENU='$(lwlibdir)/liblw.a'
|
||
AUTODEPEND_PARENTS="$AUTODEPEND_PARENTS lwlib"
|
||
fi
|
||
AC_SUBST([LIBXMENU])
|
||
|
||
AC_CACHE_CHECK([for struct alignment],
|
||
[emacs_cv_struct_alignment],
|
||
[AC_COMPILE_IFELSE(
|
||
[AC_LANG_PROGRAM([[#include <stddef.h>
|
||
struct s { char c; } __attribute__ ((aligned (8)));
|
||
struct t { char c; struct s s; };
|
||
char verify[offsetof (struct t, s) == 8 ? 1 : -1];
|
||
]])],
|
||
[emacs_cv_struct_alignment=yes],
|
||
[emacs_cv_struct_alignment=no])])
|
||
if test "$emacs_cv_struct_alignment" = yes; then
|
||
AC_DEFINE([HAVE_STRUCT_ATTRIBUTE_ALIGNED], [1],
|
||
[Define to 1 if 'struct __attribute__ ((aligned (N)))' aligns the
|
||
structure to an N-byte boundary.])
|
||
fi
|
||
|
||
AC_C_RESTRICT
|
||
AC_C_TYPEOF
|
||
|
||
AC_CACHE_CHECK([for statement expressions],
|
||
[emacs_cv_statement_expressions],
|
||
[AC_COMPILE_IFELSE(
|
||
[AC_LANG_PROGRAM([], [[return ({ int x = 5; x-x; });]])],
|
||
[emacs_cv_statement_expressions=yes],
|
||
[emacs_cv_statement_expressions=no])])
|
||
if test "$emacs_cv_statement_expressions" = yes; then
|
||
AC_DEFINE([HAVE_STATEMENT_EXPRESSIONS], [1],
|
||
[Define to 1 if statement expressions work.])
|
||
fi
|
||
|
||
if test "${GNU_MALLOC}" = "yes" ; then
|
||
AC_DEFINE([GNU_MALLOC], [1],
|
||
[Define to 1 if you want to use the GNU memory allocator.])
|
||
fi
|
||
|
||
RALLOC_OBJ=
|
||
if test "${REL_ALLOC}" = "yes" ; then
|
||
AC_DEFINE([REL_ALLOC], [1],
|
||
[Define REL_ALLOC if you want to use the relocating allocator for
|
||
buffer space.])
|
||
|
||
test "$system_malloc" != "yes" && RALLOC_OBJ=ralloc.o
|
||
fi
|
||
AC_SUBST([RALLOC_OBJ])
|
||
|
||
if test "$opsys" = "cygwin"; then
|
||
CYGWIN_OBJ="cygw32.o"
|
||
## Cygwin differs because of its unexec().
|
||
PRE_ALLOC_OBJ=
|
||
POST_ALLOC_OBJ=lastfile.o
|
||
elif test "$opsys" = "mingw32"; then
|
||
CYGWIN_OBJ=
|
||
PRE_ALLOC_OBJ=
|
||
POST_ALLOC_OBJ=lastfile.o
|
||
else
|
||
CYGWIN_OBJ=
|
||
PRE_ALLOC_OBJ=lastfile.o
|
||
POST_ALLOC_OBJ=
|
||
fi
|
||
AC_SUBST([CYGWIN_OBJ])
|
||
AC_SUBST([PRE_ALLOC_OBJ])
|
||
AC_SUBST([POST_ALLOC_OBJ])
|
||
|
||
dnl Call this 'FORTIFY_SOUR' so that it sorts before the 'FORTIFY_SOURCE'
|
||
dnl verbatim defined above. The tricky name is apropos, as this hack
|
||
dnl makes Fortify go sour!
|
||
AH_VERBATIM([FORTIFY_SOUR],
|
||
[/* Without the following workaround, Emacs runs slowly on OS X 10.8.
|
||
The workaround disables some useful run-time checking, so it
|
||
should be conditional to the platforms with the performance bug.
|
||
Perhaps Apple will fix this some day; also see m4/extern-inline.m4. */
|
||
#if defined __APPLE__ && defined __GNUC__
|
||
# ifndef _DONT_USE_CTYPE_INLINE_
|
||
# define _DONT_USE_CTYPE_INLINE_
|
||
# endif
|
||
# ifndef _FORTIFY_SOURCE
|
||
# define _FORTIFY_SOURCE 0
|
||
# endif
|
||
#endif
|
||
])
|
||
|
||
# If user asks to omit features, disable optional features that gnulib
|
||
# might otherwise enable.
|
||
if test "$with_features" = no && test "$enable_acl" != yes; then
|
||
enable_acl=no
|
||
fi
|
||
|
||
# Configure gnulib. Although this does not affect CFLAGS or LIBS permanently.
|
||
# it temporarily reverts them to their pre-pkg-config values,
|
||
# because gnulib needs to work with both src (which uses the
|
||
# pkg-config stuff) and lib-src (which does not). For example, gnulib
|
||
# may need to determine whether CLOCK_TIME_LIB should contain -lrt,
|
||
# and it therefore needs to run in an environment where LIBS does not
|
||
# already contain -lrt merely because 'pkg-config --libs' printed '-lrt'
|
||
# for some package unrelated to lib-src.
|
||
SAVE_CFLAGS=$CFLAGS
|
||
SAVE_LIBS=$LIBS
|
||
CFLAGS=$pre_PKG_CONFIG_CFLAGS
|
||
LIBS="$LIB_PTHREAD $pre_PKG_CONFIG_LIBS"
|
||
gl_ASSERT_NO_GNULIB_POSIXCHECK
|
||
gl_ASSERT_NO_GNULIB_TESTS
|
||
gl_EEMALLOC
|
||
gl_INIT
|
||
CFLAGS=$SAVE_CFLAGS
|
||
LIBS=$SAVE_LIBS
|
||
|
||
# Set up libgmp on Android. Make sure to override what gnulib has
|
||
# found.
|
||
LIBGMP_CFLAGS=
|
||
if test "$REALLY_ANDROID" = "yes" && test "$with_libgmp" != "no"; then
|
||
HAVE_LIBGMP=no
|
||
ndk_SEARCH_MODULE([libgmp], [LIBGMP], [HAVE_LIBGMP=yes])
|
||
|
||
if test "$HAVE_LIBGMP" = "yes"; then
|
||
SAVE_CFLAGS="$CFLAGS"
|
||
CFLAGS="$CFLAGS $LIBGMP_CFLAGS"
|
||
unset ac_cv_header_gmp_h
|
||
unset ac_cv_header_gmp_gmp_h
|
||
AC_CHECK_HEADERS([gmp.h gmp/gmp.h], [break])
|
||
CFLAGS="$SAVE_CFLAGS"
|
||
GL_GENERATE_GMP_H=
|
||
GL_GENERATE_GMP_H_CONDITION=
|
||
GL_GENERATE_GMP_GMP_H=
|
||
GL_GENERATE_GMP_GMP_H_CONDITION=
|
||
GL_GENERATE_MINI_GMP_H=
|
||
GL_GENERATE_MINI_GMP_H_CONDITION=
|
||
|
||
if test "$ac_cv_header_gmp_h" != "no" \
|
||
|| test "$ac_cv_header_gmp_gmp_h" != "no"; then
|
||
HAVE_LIBGMP=yes
|
||
GL_GENERATE_GMP_H=false
|
||
LIBGMP="$LIBGMP_LIBS"
|
||
GMP_H=
|
||
fi
|
||
fi
|
||
fi
|
||
AC_SUBST([LIBGMP_CFLAGS])
|
||
|
||
# timer_getoverrun needs the same library as timer_settime
|
||
OLD_LIBS=$LIBS
|
||
LIBS="$LIB_TIMER_TIME $LIBS"
|
||
AC_CHECK_FUNCS([timer_getoverrun])
|
||
LIBS=$OLD_LIBS
|
||
|
||
if test "${opsys}" = "mingw32"; then
|
||
CPPFLAGS="$CPPFLAGS -DUSE_CRT_DLL=1 -I \${abs_top_srcdir}/nt/inc"
|
||
# Remove unneeded switches from the value of CC that goes to Makefiles
|
||
CC=`AS_ECHO(["$CC"]) | sed -e "s,$GCC_TEST_OPTIONS,,"`
|
||
fi
|
||
|
||
case "$opsys" in
|
||
aix4-2) LD_SWITCH_SYSTEM_TEMACS="-Wl,-bnodelcsect" ;;
|
||
|
||
cygwin) LD_SWITCH_SYSTEM_TEMACS="-Wl,-stack,0x00800000" ;;
|
||
|
||
darwin)
|
||
if test "$HAVE_NS" = "yes"; then
|
||
libs_nsgui="-framework AppKit"
|
||
if test "$NS_IMPL_COCOA" = "yes"; then
|
||
libs_nsgui="$libs_nsgui -framework IOKit -framework Carbon \
|
||
-framework IOSurface -framework QuartzCore"
|
||
if test "$emacs_cv_macosx_12_0" = "yes"; then
|
||
libs_nsgui="$libs_nsgui -framework UniformTypeIdentifiers"
|
||
fi
|
||
fi
|
||
else
|
||
libs_nsgui=
|
||
fi
|
||
LD_SWITCH_SYSTEM_TEMACS=$libs_nsgui
|
||
## The -headerpad option tells ld (see man page) to leave room at the
|
||
## end of the header for adding load commands. Needed for dumping.
|
||
## 0x1000 is enough for roughly 52 load commands on the x86_64
|
||
## architecture (where they are 78 bytes each). The actual number of
|
||
## load commands added is not consistent but normally ranges from
|
||
## about 14 to about 34. Setting it high gets us plenty of slop and
|
||
## only costs about 1.5K of wasted binary space.
|
||
headerpad_extra=1000
|
||
if test "$with_unexec" = yes; then
|
||
LD_SWITCH_SYSTEM_TEMACS="-fno-pie $LD_SWITCH_SYSTEM_TEMACS -Xlinker -headerpad -Xlinker $headerpad_extra"
|
||
fi
|
||
|
||
## This is here because src/Makefile.in did some extra fiddling around
|
||
## with LD_SWITCH_SYSTEM. It seems cleaner to put this in
|
||
## LD_SWITCH_SYSTEM_TEMACS instead,
|
||
test "x$LD_SWITCH_SYSTEM" = "x" && test "x$GCC" != "xyes" && \
|
||
LD_SWITCH_SYSTEM_TEMACS="-X $LD_SWITCH_SYSTEM_TEMACS"
|
||
;;
|
||
|
||
## LD_SWITCH_X_SITE_RPATH is a -rpath option saying where to
|
||
## find X at run-time.
|
||
## When handled by cpp, this was in LD_SWITCH_SYSTEM. However, at the
|
||
## point where configure sourced the s/*.h file, LD_SWITCH_X_SITE_RPATH
|
||
## had not yet been defined and was expanded to null. Hence LD_SWITCH_SYSTEM
|
||
## had different values in configure (in ac_link) and src/Makefile.in.
|
||
## It seems clearer therefore to put this piece in LD_SWITCH_SYSTEM_TEMACS.
|
||
gnu*) LD_SWITCH_SYSTEM_TEMACS="\$(LD_SWITCH_X_SITE_RPATH)" ;;
|
||
|
||
mingw32)
|
||
## Is it any better under MinGW64 to relocate emacs into higher addresses?
|
||
## If the values of -image-base are modified, the corresponding
|
||
## values of DEFAULT_IMAGE_BASE in w32fns.c should be kept in sync.
|
||
case "$canonical" in
|
||
x86_64-*-*) LD_SWITCH_SYSTEM_TEMACS="-Wl,-stack,0x00800000 -Wl,-heap,0x00100000 -Wl,-image-base,0x400000000 -Wl,-entry,__start -Wl,-Map,./temacs.map" ;;
|
||
*) LD_SWITCH_SYSTEM_TEMACS="-Wl,-stack,0x00800000 -Wl,-heap,0x00100000 -Wl,-image-base,0x01000000 -Wl,-entry,__start -Wl,-Map,./temacs.map" ;;
|
||
esac
|
||
## If they want unexec, disable Windows ASLR for the Emacs binary
|
||
if test "$with_dumping" = "unexec"; then
|
||
case "$canonical" in
|
||
x86_64-*-*) LD_SWITCH_SYSTEM_TEMACS="$LD_SWITCH_SYSTEM_TEMACS -Wl,-disable-dynamicbase -Wl,-disable-high-entropy-va -Wl,-default-image-base-low" ;;
|
||
*) LD_SWITCH_SYSTEM_TEMACS="$LD_SWITCH_SYSTEM_TEMACS -Wl,-disable-dynamicbase" ;;
|
||
esac
|
||
fi
|
||
;;
|
||
|
||
*) LD_SWITCH_SYSTEM_TEMACS= ;;
|
||
esac
|
||
|
||
# -no-pie or -nopie fixes a temacs segfault on Gentoo, OpenBSD,
|
||
# Ubuntu, and other systems with "hardened" GCC configurations for
|
||
# some reason (Bug#18784). We don't know why this works, but not
|
||
# segfaulting is better than segfaulting. Use ac_c_werror_flag=yes
|
||
# when trying the option, otherwise clang keeps warning that it does
|
||
# not understand it, and pre-4.6 GCC has a similar problem
|
||
# (Bug#20338). Prefer -no-pie to -nopie, as -no-pie is the
|
||
# spelling used by GCC 6.1.0 and later (Bug#24682).
|
||
AC_CACHE_CHECK(
|
||
[for $CC option to disable position independent executables],
|
||
[emacs_cv_prog_cc_no_pie],
|
||
[if test $with_unexec = no; then
|
||
emacs_cv_prog_cc_no_pie='not needed'
|
||
else
|
||
emacs_save_c_werror_flag=$ac_c_werror_flag
|
||
emacs_save_LDFLAGS=$LDFLAGS
|
||
ac_c_werror_flag=yes
|
||
for emacs_cv_prog_cc_no_pie in -no-pie -nopie no; do
|
||
test $emacs_cv_prog_cc_no_pie = no && break
|
||
LDFLAGS="$emacs_save_LDFLAGS $emacs_cv_prog_cc_no_pie"
|
||
AC_LINK_IFELSE([AC_LANG_PROGRAM([], [])], [break])
|
||
done
|
||
ac_c_werror_flag=$emacs_save_c_werror_flag
|
||
LDFLAGS=$emacs_save_LDFLAGS
|
||
fi])
|
||
case $emacs_cv_prog_cc_no_pie in
|
||
-*)
|
||
LD_SWITCH_SYSTEM_TEMACS="$LD_SWITCH_SYSTEM_TEMACS $emacs_cv_prog_cc_no_pie"
|
||
;;
|
||
esac
|
||
|
||
if test x$ac_enable_profiling != x ; then
|
||
case $opsys in
|
||
*freebsd | gnu-linux) ;;
|
||
*) LD_SWITCH_SYSTEM_TEMACS="$LD_SWITCH_SYSTEM_TEMACS -pg" ;;
|
||
esac
|
||
fi
|
||
|
||
LD_SWITCH_SYSTEM_TEMACS="$LDFLAGS_NOCOMBRELOC $LD_SWITCH_SYSTEM_TEMACS"
|
||
|
||
AC_SUBST([LD_SWITCH_SYSTEM_TEMACS])
|
||
|
||
## Common for all window systems
|
||
if test "$window_system" != "none"; then
|
||
AC_DEFINE([HAVE_WINDOW_SYSTEM], [1], [Define if you have a window system.])
|
||
AC_DEFINE([POLL_FOR_INPUT], [1],
|
||
[Define if you poll periodically to detect C-g.])
|
||
WINDOW_SYSTEM_OBJ="fontset.o fringe.o image.o"
|
||
|
||
if test "$window_system" = "x11" || test "$REALLY_ANDROID" = "yes"; then
|
||
AC_DEFINE([HAVE_TEXT_CONVERSION], [1],
|
||
[Define if the window system has text conversion support.])
|
||
WINDOW_SYSTEM_OBJ="$WINDOW_SYSTEM_OBJ textconv.o"
|
||
fi
|
||
fi
|
||
|
||
AC_SUBST([WINDOW_SYSTEM_OBJ])
|
||
|
||
# Some systems have MB_CUR_MAX defined to a call to
|
||
# __ctype_get_mb_cur_max, but do not have __ctype_get_mb_cur_max in
|
||
# libc. Check for that situation and define MB_CUR_MAX to something
|
||
# sane.
|
||
|
||
AC_CHECK_FUNC([__ctype_get_mb_cur_max])
|
||
|
||
AC_CACHE_CHECK([whether MB_CUR_MAX is defined to function that won't link],
|
||
[emacs_cv_broken_mb_cur_max],
|
||
[AC_EGREP_CPP(__ctype_get_mb_cur_max, [
|
||
#include <stdlib.h>
|
||
#ifndef MB_CUR_MAX
|
||
#define MB_CUR_MAX -1
|
||
#endif
|
||
static int foo = MB_CUR_MAX;
|
||
], [AS_IF([test "$ac_cv_func___ctype_get_mb_cur_max" = "yes"],
|
||
[emacs_cv_broken_mb_cur_max=no],
|
||
[emacs_cv_broken_mb_cur_max=yes])],
|
||
[emacs_cv_broken_mb_cur_max=no])])
|
||
|
||
AS_IF([test "$emacs_cv_broken_mb_cur_max" = "yes"],
|
||
# Define this to 4, which is right for Android.
|
||
[AS_CASE([$opsys], [android],
|
||
[AC_DEFINE([REPLACEMENT_MB_CUR_MAX], [4],
|
||
[Define to MB_CUR_MAX if stdlib.h is broken.])],
|
||
[AC_MSG_ERROR([MB_CUR_MAX does not work on your system.
|
||
Please modify configure.ac to set an appropriate value, then
|
||
send your change to bug-gnu-emacs@gnu.org])])])
|
||
|
||
AH_TOP([/* GNU Emacs site configuration template file.
|
||
|
||
Copyright (C) 1988, 1993-1994, 1999-2002, 2004-2021
|
||
Free Software Foundation, Inc.
|
||
|
||
This file is part of GNU Emacs.
|
||
|
||
GNU Emacs 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.
|
||
|
||
GNU Emacs 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 GNU Emacs. If not, see <https://www.gnu.org/licenses/>. */
|
||
|
||
|
||
/* No code in Emacs #includes config.h twice, but some bits of code
|
||
intended to work with other packages as well (like gmalloc.c)
|
||
think they can include it as many times as they like. */
|
||
#ifndef EMACS_CONFIG_H
|
||
#define EMACS_CONFIG_H
|
||
])dnl
|
||
|
||
AH_BOTTOM([#include <conf_post.h>
|
||
|
||
#endif /* EMACS_CONFIG_H */
|
||
|
||
/*
|
||
Local Variables:
|
||
mode: c
|
||
End:
|
||
*/
|
||
])dnl
|
||
|
||
#### Report on what we decided to do.
|
||
#### Report GTK as a toolkit, even if it doesn't use Xt.
|
||
#### It makes printing result more understandable as using GTK sets
|
||
#### toolkit_scroll_bars to yes by default.
|
||
if test "${HAVE_GTK}" = "yes"; then
|
||
USE_X_TOOLKIT="$USE_GTK_TOOLKIT"
|
||
fi
|
||
|
||
if test $USE_ACL -ne 0; then
|
||
ACL_SUMMARY="yes"
|
||
test "$LIB_ACL" && ACL_SUMMARY="$ACL_SUMMARY $LIB_ACL"
|
||
test "$LIB_XATTR" && ACL_SUMMARY="$ACL_SUMMARY $LIB_XATTR"
|
||
else
|
||
ACL_SUMMARY=no
|
||
fi
|
||
|
||
if test -z "$GMP_H"; then
|
||
HAVE_GMP=yes
|
||
else
|
||
HAVE_GMP=no
|
||
fi
|
||
|
||
emacs_standard_dirs='Standard dirs'
|
||
AS_ECHO(["
|
||
Configured for '${canonical}'.
|
||
|
||
Where should the build process find the source code? ${srcdir}
|
||
What compiler should emacs be built with? ${CC} ${CFLAGS}
|
||
Should Emacs use the GNU version of malloc? ${GNU_MALLOC}${GNU_MALLOC_reason}
|
||
Should Emacs use a relocating allocator for buffers? ${REL_ALLOC}
|
||
Should Emacs use mmap(2) for buffer allocation? $use_mmap_for_buffers
|
||
What window system should Emacs use? ${window_system}
|
||
What toolkit should Emacs use? ${USE_X_TOOLKIT}
|
||
Where do we find X Windows header files? ${x_includes:-$emacs_standard_dirs}
|
||
Where do we find X Windows libraries? ${x_libraries:-$emacs_standard_dirs}"])
|
||
|
||
#### Please respect alphabetical ordering when making additions.
|
||
optsep=
|
||
emacs_config_features=
|
||
for opt in ACL BE_APP CAIRO DBUS FREETYPE GCONF GIF GLIB GMP GNUTLS GPM GSETTINGS \
|
||
HARFBUZZ IMAGEMAGICK JPEG LCMS2 LIBOTF LIBSELINUX LIBSYSTEMD LIBXML2 \
|
||
M17N_FLT MODULES NATIVE_COMP NOTIFY NS OLDXMENU PDUMPER PGTK PNG RSVG SECCOMP \
|
||
SOUND SQLITE3 THREADS TIFF TOOLKIT_SCROLL_BARS TREE_SITTER \
|
||
UNEXEC WEBP X11 XAW3D XDBE XFT XIM XINPUT2 XPM XWIDGETS X_TOOLKIT \
|
||
ZLIB; do
|
||
|
||
case $opt in
|
||
PDUMPER) val=${with_pdumper} ;;
|
||
UNEXEC) val=${with_unexec} ;;
|
||
GLIB) val=${emacs_cv_links_glib} ;;
|
||
NOTIFY|ACL) eval val=\${${opt}_SUMMARY} ;;
|
||
TOOLKIT_SCROLL_BARS|X_TOOLKIT) eval val=\${USE_$opt} ;;
|
||
THREADS) val=${threads_enabled} ;;
|
||
*) eval val=\${HAVE_$opt} ;;
|
||
esac
|
||
case x$val in
|
||
xno|xnone|x) continue ;;
|
||
esac
|
||
case $opt in
|
||
X_TOOLKIT)
|
||
case $val in
|
||
GTK*|LUCID|MOTIF) opt=$val ;;
|
||
*) continue ;;
|
||
esac
|
||
;;
|
||
NOTIFY)
|
||
case $val in
|
||
*lkqueue*) opt="$opt LIBKQUEUE" ;;
|
||
*kqueue*) opt="$opt KQUEUE" ;;
|
||
*inotify*) opt="$opt INOTIFY" ;;
|
||
*gfile*) opt="$opt GFILENOTIFY" ;;
|
||
*w32*) opt="$opt W32NOTIFY" ;;
|
||
esac
|
||
;;
|
||
esac
|
||
AS_VAR_APPEND([emacs_config_features], ["$optsep$opt"])
|
||
optsep=' '
|
||
done
|
||
AC_DEFINE_UNQUOTED([EMACS_CONFIG_FEATURES], ["${emacs_config_features}"],
|
||
[Summary of some of the main features enabled by configure.])
|
||
|
||
# This is just a printable representation of the shared user ID.
|
||
android_shared_user=
|
||
AS_IF([test -n "$with_shared_user_id"],[android_shared_user="($with_shared_user_id)"])
|
||
|
||
AS_ECHO([" Does Emacs use -lXaw3d? ${HAVE_XAW3D}
|
||
Is Emacs being built for Android? ${ANDROID} ${android_shared_user}
|
||
Does Emacs use the X Double Buffer Extension? ${HAVE_XDBE}
|
||
Does Emacs use -lXpm? ${HAVE_XPM}
|
||
Does Emacs use -ljpeg? ${HAVE_JPEG}
|
||
Does Emacs use -ltiff? ${HAVE_TIFF}
|
||
Does Emacs use a gif library? ${HAVE_GIF} $LIBGIF
|
||
Does Emacs use a png library? ${HAVE_PNG} $LIBPNG
|
||
Does Emacs use -lrsvg-2? ${HAVE_RSVG}
|
||
Does Emacs use -lwebp? ${HAVE_WEBP}
|
||
Does Emacs use -lsqlite3? ${HAVE_SQLITE3}
|
||
Does Emacs use cairo? ${HAVE_CAIRO}
|
||
Does Emacs use -llcms2? ${HAVE_LCMS2}
|
||
Does Emacs use imagemagick? ${HAVE_IMAGEMAGICK}
|
||
Does Emacs use native APIs for images? ${NATIVE_IMAGE_API}
|
||
Does Emacs support sound? ${HAVE_SOUND}
|
||
Does Emacs use -lgpm? ${HAVE_GPM}
|
||
Does Emacs use -ldbus? ${HAVE_DBUS}
|
||
Does Emacs use -lgconf? ${HAVE_GCONF}
|
||
Does Emacs use GSettings? ${HAVE_GSETTINGS}
|
||
Does Emacs use a file notification library? ${NOTIFY_SUMMARY}
|
||
Does Emacs use access control lists? ${ACL_SUMMARY}
|
||
Does Emacs use -lselinux? ${HAVE_LIBSELINUX}
|
||
Does Emacs use -lgnutls? ${HAVE_GNUTLS}
|
||
Does Emacs use -lxml2? ${HAVE_LIBXML2}
|
||
Does Emacs use -lfreetype? ${HAVE_FREETYPE}
|
||
Does Emacs use HarfBuzz? ${HAVE_HARFBUZZ}
|
||
Does Emacs use -lm17n-flt? ${HAVE_M17N_FLT}
|
||
Does Emacs use -lotf? ${HAVE_LIBOTF}
|
||
Does Emacs use -lxft? ${HAVE_XFT}
|
||
Does Emacs use -lsystemd? ${HAVE_LIBSYSTEMD}
|
||
Does Emacs use -ltree-sitter? ${HAVE_TREE_SITTER}
|
||
Does Emacs use the GMP library? ${HAVE_GMP}
|
||
Does Emacs directly use zlib? ${HAVE_ZLIB}
|
||
Does Emacs have dynamic modules support? ${HAVE_MODULES}
|
||
Does Emacs use toolkit scroll bars? ${USE_TOOLKIT_SCROLL_BARS}
|
||
Does Emacs support Xwidgets? ${HAVE_XWIDGETS}
|
||
Does Emacs have threading support in lisp? ${threads_enabled}
|
||
Does Emacs support the portable dumper? ${with_pdumper}
|
||
Does Emacs support legacy unexec dumping? ${with_unexec}
|
||
Which dumping strategy does Emacs use? ${with_dumping}
|
||
Does Emacs have native lisp compiler? ${HAVE_NATIVE_COMP}
|
||
Does Emacs use version 2 of the X Input Extension? ${HAVE_XINPUT2}
|
||
Does Emacs generate a smaller-size Japanese dictionary? ${with_small_ja_dic}
|
||
"])
|
||
|
||
if test -n "${EMACSDATA}"; then
|
||
AS_ECHO([" Environment variable EMACSDATA set to: $EMACSDATA"])
|
||
fi
|
||
if test -n "${EMACSDOC}"; then
|
||
AS_ECHO([" Environment variable EMACSDOC set to: $EMACSDOC"])
|
||
fi
|
||
|
||
echo
|
||
|
||
if test "$HAVE_NS" = "yes"; then
|
||
echo
|
||
AS_ECHO(["Run '${MAKE-make}' to build Emacs, then run 'src/emacs' to test it.
|
||
Run '${MAKE-make} install' in order to build an application bundle.
|
||
The application will go to nextstep/Emacs.app and can be run or moved
|
||
from there."])
|
||
if test "$EN_NS_SELF_CONTAINED" = "yes"; then
|
||
echo "The application will be fully self-contained."
|
||
else
|
||
AS_ECHO(["The lisp resources for the application will be installed under ${prefix}.
|
||
You may need to run \"${MAKE-make} install\" with sudo. The application will fail
|
||
to run if these resources are not installed."])
|
||
fi
|
||
echo
|
||
fi
|
||
|
||
case $opsys,$emacs_uname_r in
|
||
cygwin,1.5.*)
|
||
AC_MSG_WARN([[building Emacs on Cygwin 1.5 is not supported.]])
|
||
echo
|
||
;;
|
||
cygwin,3.0.[[0-7]]'('* | cygwin,3.1.[[0-2]]'('*)
|
||
AC_DEFINE([HAVE_CYGWIN_O_PATH_BUG], [1],
|
||
[Define to 1 if opening a FIFO, socket, or symlink with O_PATH is buggy.]);;
|
||
esac
|
||
|
||
# Remove any trailing slashes in these variables.
|
||
case $prefix in
|
||
*/) prefix=`AS_DIRNAME(["$prefix."])`;;
|
||
esac
|
||
case $exec_prefix in
|
||
*/) exec_prefix=`AS_DIRNAME(["$exec_prefix."])`;;
|
||
esac
|
||
|
||
if test "$HAVE_NS" = "yes"; then
|
||
if test "$NS_IMPL_GNUSTEP" = yes; then
|
||
AC_CONFIG_FILES([nextstep/GNUstep/Emacs.base/Resources/Info-gnustep.plist:nextstep/templates/Info-gnustep.plist.in \
|
||
nextstep/GNUstep/Emacs.base/Resources/Emacs.desktop:nextstep/templates/Emacs.desktop.in])
|
||
ns_check_file=Resources/Info-gnustep.plist
|
||
else
|
||
AC_CONFIG_FILES([nextstep/Cocoa/Emacs.base/Contents/Info.plist:nextstep/templates/Info.plist.in \
|
||
nextstep/Cocoa/Emacs.base/Contents/Resources/English.lproj/InfoPlist.strings:nextstep/templates/InfoPlist.strings.in])
|
||
ns_check_file=Contents/Info.plist
|
||
fi
|
||
AC_SUBST([ns_check_file])
|
||
fi
|
||
|
||
AC_CONFIG_FILES([Makefile lib/gnulib.mk])
|
||
|
||
dnl config.status treats $srcdir specially, so I think this is ok...
|
||
ARCH_INDEPENDENT_CONFIG_FILES([$srcdir/doc/man/emacs.1])
|
||
|
||
AC_CONFIG_FILES([lib/Makefile lib-src/Makefile oldXMenu/Makefile src/Makefile
|
||
lwlib/Makefile nextstep/Makefile nt/Makefile])
|
||
ARCH_INDEPENDENT_CONFIG_FILES([doc/emacs/Makefile doc/misc/Makefile
|
||
doc/lispintro/Makefile doc/lispref/Makefile
|
||
lisp/Makefile leim/Makefile])
|
||
|
||
SUBDIR_MAKEFILES="lib/Makefile lib-src/Makefile oldXMenu/Makefile src/Makefile lwlib/Makefile nextstep/Makefile nt/Makefile doc/emacs/Makefile doc/misc/Makefile doc/lispintro/Makefile doc/lispref/Makefile lisp/Makefile leim/Makefile"
|
||
|
||
dnl The test/ directory is missing if './make-dist --no-tests' was used.
|
||
opt_makefile=test/Makefile
|
||
if test -f "$srcdir/$opt_makefile.in"; then
|
||
SUBDIR_MAKEFILES="$SUBDIR_MAKEFILES $opt_makefile"
|
||
dnl Again, it's best not to use a variable. Though you can add
|
||
dnl ", [], [opt_makefile='$opt_makefile']" and it should work.
|
||
ARCH_INDEPENDENT_CONFIG_FILES([test/Makefile])
|
||
ARCH_INDEPENDENT_CONFIG_FILES([test/manual/noverlay/Makefile])
|
||
fi
|
||
opt_makefile=test/infra/Makefile
|
||
if test -f "$srcdir/$opt_makefile.in"; then
|
||
SUBDIR_MAKEFILES="$SUBDIR_MAKEFILES $opt_makefile"
|
||
dnl Again, it's best not to use a variable. Though you can add
|
||
dnl ", [], [opt_makefile='$opt_makefile']" and it should work.
|
||
ARCH_INDEPENDENT_CONFIG_FILES([test/infra/Makefile])
|
||
fi
|
||
|
||
if test "$ANDROID" = "yes"; then
|
||
SUBDIR_MAKEFILES="$SUBDIR_MAKEFILES java/Makefile cross/Makefile"
|
||
fi
|
||
|
||
dnl The admin/ directory used to be excluded from tarfiles.
|
||
if test -d $srcdir/admin; then
|
||
SUBDIR_MAKEFILES="$SUBDIR_MAKEFILES admin/charsets/Makefile admin/unidata/Makefile admin/grammars/Makefile"
|
||
ARCH_INDEPENDENT_CONFIG_FILES([admin/charsets/Makefile])
|
||
ARCH_INDEPENDENT_CONFIG_FILES([admin/unidata/Makefile])
|
||
ARCH_INDEPENDENT_CONFIG_FILES([admin/grammars/Makefile])
|
||
fi dnl -d admin
|
||
|
||
|
||
SUBDIR_MAKEFILES_IN=`echo " ${SUBDIR_MAKEFILES}" | sed -e 's| | $(srcdir)/|g' -e 's|Makefile|Makefile.in|g'`
|
||
|
||
AC_SUBST([SUBDIR_MAKEFILES_IN])
|
||
|
||
SMALL_JA_DIC=$with_small_ja_dic
|
||
AC_SUBST([SMALL_JA_DIC])
|
||
|
||
dnl The following commands are run on the build system when building
|
||
dnl Emacs.
|
||
|
||
if test "$XCONFIGURE" != "android"; then
|
||
dnl You might wonder (I did) why epaths.h is generated by running
|
||
dnl make, rather than just letting configure generate it from
|
||
dnl epaths.in. One reason is that the various paths are not fully
|
||
dnl expanded (see above); e.g.,
|
||
dnl gamedir='${localstatedir}/games/emacs'. Secondly, the GNU
|
||
dnl Coding standards require that one should be able to run 'make
|
||
dnl prefix=/some/where/else' and override the values set by
|
||
dnl configure. This also explains the 'move-if-change' test and the
|
||
dnl use of force in the 'epaths-force' rule in Makefile.in.
|
||
AC_CONFIG_COMMANDS([src/epaths.h], [
|
||
if test "${opsys}" = "mingw32"; then
|
||
${MAKE-make} MAKEFILE_NAME=do-not-make-Makefile epaths-force-w32
|
||
elif test "$HAVE_NS" = "yes" && test "$EN_NS_SELF_CONTAINED" = "yes"; then
|
||
${MAKE-make} MAKEFILE_NAME=do-not-make-Makefile epaths-force-ns-self-contained
|
||
else
|
||
${MAKE-make} MAKEFILE_NAME=do-not-make-Makefile epaths-force
|
||
fi || AC_MSG_ERROR(['src/epaths.h' could not be made.])
|
||
], [GCC="$GCC" CPPFLAGS="$CPPFLAGS" opsys="$opsys" HAVE_NS="$HAVE_NS"
|
||
EN_NS_SELF_CONTAINED="$EN_NS_SELF_CONTAINED"])
|
||
|
||
dnl NB we have to cheat and use the ac_... version because abs_top_srcdir
|
||
dnl is not yet set, sigh. Or we could use ../$srcdir/src/.gdbinit,
|
||
dnl or a symlink?
|
||
AC_CONFIG_COMMANDS([src/.gdbinit], [
|
||
if test ! -f src/.gdbinit && test -f "$srcdir/src/.gdbinit"; then
|
||
AS_ECHO(["source $ac_abs_top_srcdir/src/.gdbinit"]) > src/.gdbinit
|
||
fi
|
||
])
|
||
|
||
dnl Perhaps this would be better named doc-emacs-emacsver.texi?
|
||
dnl See comments for etc-refcards-emacsver.tex.
|
||
dnl Since we get a doc/emacs directory generated anyway, for the Makefile,
|
||
dnl it is not quite the same. But we are generating in $srcdir.
|
||
AC_CONFIG_COMMANDS([doc/emacs/emacsver.texi], [
|
||
${MAKE-make} -s --no-print-directory -C doc/emacs doc-emacsver || \
|
||
AC_MSG_ERROR(['doc/emacs/emacsver.texi' could not be made.])
|
||
])
|
||
|
||
dnl If we give this the more natural name, etc/refcards/emacsver.texi,
|
||
dnl then a directory etc/refcards is created in the build directory,
|
||
dnl which is probably harmless, but confusing (in out-of-tree builds).
|
||
dnl (If we were to generate etc/refcards/Makefile, this might change.)
|
||
dnl It is really $srcdir/etc/refcards/emacsver.tex that we generate.
|
||
AC_CONFIG_COMMANDS([etc-refcards-emacsver.tex], [
|
||
${MAKE-make} -s MAKEFILE_NAME=do-not-make-Makefile etc-emacsver || \
|
||
AC_MSG_ERROR(['etc/refcards/emacsver.tex' could not be made.])
|
||
])
|
||
|
||
if test $AUTO_DEPEND = yes; then
|
||
for dir in $AUTODEPEND_PARENTS; do
|
||
AS_MKDIR_P([$dir/deps])
|
||
AS_MKDIR_P([cross/$dir/deps])
|
||
done
|
||
fi
|
||
if $gl_gnulib_enabled_dynarray || $gl_gnulib_enabled_scratch_buffer; then
|
||
AS_MKDIR_P([lib/malloc])
|
||
AS_MKDIR_P([cross/lib/malloc])
|
||
if test $AUTO_DEPEND = yes; then
|
||
AS_MKDIR_P([lib/deps/malloc])
|
||
AS_MKDIR_P([cross/lib/deps/malloc])
|
||
fi
|
||
fi
|
||
|
||
dnl Make cross/lib, which various Makefiles in cross expect to
|
||
dnl always exist.
|
||
AS_MKDIR_P([cross/lib])
|
||
AS_MKDIR_P([cross/lib/malloc])
|
||
AS_MKDIR_P([cross/lib/sys])
|
||
AS_MKDIR_P([cross/lib-src])
|
||
|
||
dnl Make cross/etc; this directory will hold the documentation file
|
||
dnl holding doc strings for Android specific C files that aren't
|
||
dnl built during the initial compilation of Emacs for the build
|
||
dnl machine.
|
||
AS_MKDIR_P([cross/etc])
|
||
|
||
AS_IF([test "x$with_android" != "xno"], [
|
||
dnl Link gnulib files to cross/lib as well. af_alg.h and
|
||
dnl lib/save-cwd.h are copied manually from gnulib, and as such
|
||
dnl aren't specified in gl_FILE_LIST.
|
||
emacs_files='gl_FILE_LIST lib/af_alg.h lib/save-cwd.h'
|
||
dnl These files are specific to Emacs.
|
||
emacs_files="$emacs_files lib/fingerprint.c lib/fingerprint.h \
|
||
lib/save-cwd.c lib/openat-die.c lib/save-cwd.c \
|
||
lib/min-max.h"
|
||
for file in $emacs_files; do
|
||
AS_IF([expr "X${file}J" : "Xlib/.*[[ch]]J" >/dev/null],
|
||
[AS_IF([test -f "$srcdir/$file"],
|
||
[AC_CONFIG_LINKS([cross/$file:$file])])])
|
||
done])
|
||
fi
|
||
|
||
# Make java/Makefile
|
||
ARCH_INDEPENDENT_CONFIG_FILES([java/Makefile])
|
||
ARCH_INDEPENDENT_CONFIG_FILES([cross/Makefile])
|
||
|
||
# Make java/AndroidManifest.xml
|
||
ARCH_INDEPENDENT_CONFIG_FILES([java/AndroidManifest.xml])
|
||
|
||
# Make ndk-build Makefiles. This is only done inside the recursive
|
||
# configure.
|
||
ndk_CONFIG_FILES
|
||
|
||
AC_OUTPUT
|
||
|
||
if test ! "$with_mailutils"; then
|
||
if test "$with_pop" = yes; then
|
||
AC_MSG_WARN([This configuration installs a 'movemail' program
|
||
that retrieves POP3 email via only insecure channels.
|
||
To omit insecure POP3, you can use '$0 --without-pop'.])
|
||
elif test "$with_pop" = no-by-default; then
|
||
AC_MSG_WARN([This configuration installs a 'movemail' program
|
||
that does not retrieve POP3 email. By default, Emacs 25 and earlier
|
||
installed a 'movemail' program that retrieved POP3 email via only
|
||
insecure channels, a practice that is no longer recommended but that
|
||
you can continue to support by using '$0 --with-pop'.])
|
||
fi
|
||
|
||
case $opsys in
|
||
mingw32)
|
||
# Don't suggest GNU Mailutils, as it hasn't been ported.
|
||
;;
|
||
*)
|
||
emacs_fix_movemail="use '$0 --with-mailutils'"
|
||
case `(movemail --version) 2>/dev/null` in
|
||
*Mailutils*) ;;
|
||
*) emacs_fix_movemail="install GNU Mailutils
|
||
<https://mailutils.org> and $emacs_fix_movemail";;
|
||
esac
|
||
AC_MSG_NOTICE([You might want to $emacs_fix_movemail.]);;
|
||
esac
|
||
fi
|
||
|
||
if test "${HAVE_XFT}" = yes; then
|
||
AC_MSG_WARN([This configuration uses libXft, which has a number of
|
||
font rendering issues, and is being considered for removal in the
|
||
next release of Emacs. Please consider using Cairo graphics +
|
||
HarfBuzz text shaping instead (they are auto-detected if the
|
||
relevant development headers are installed).])
|
||
fi
|
||
|
||
if test "${HAVE_CAIRO}" = "yes" && test "${HAVE_HARFBUZZ}" = no; then
|
||
AC_MSG_WARN([This configuration uses the Cairo graphics library,
|
||
but not the HarfBuzz font shaping library (minimum version $harfbuzz_required_ver).
|
||
We recommend the use of HarfBuzz when using Cairo, please install
|
||
appropriate HarfBuzz development packages.])
|
||
fi
|
||
|
||
# Let plain 'make' work.
|
||
test "$MAKE" = make || test -f makefile || cat >makefile <<EOF
|
||
.POSIX:
|
||
MAKE = $MAKE
|
||
all:
|
||
\$(MAKE) -f Makefile \$?
|
||
.DEFAULT:
|
||
\$(MAKE) -f Makefile \$<
|
||
EOF
|