mirror of
https://git.savannah.gnu.org/git/emacs.git
synced 2024-11-25 07:28:20 +00:00
a48f062e36
* build-aux/ndk-build-helper-1.mk: * build-aux/ndk-build-helper-2.mk: * cross/ndk-build/ndk-build-shared-library.mk: * cross/ndk-build/ndk-build-static-library.mk: * cross/ndk-build/ndk-resolve.mk (NDK_SO_EXTRA_FLAGS_$(LOCAL_MODULE)): (NDK_LOCAL_SO_NAMES_$(LOCAL_MODULE)): (NDK_LOCAL_A_NAMES_$(LOCAL_MODULE)): Reinforce tests for string prefixes. * m4/ndk-build.m4 (ndk_INIT): Guarantee that a module's dependencies are recorded. * configure.ac (XCONFIGURE): Prepare for building librsvg.
664 lines
22 KiB
Plaintext
664 lines
22 KiB
Plaintext
dnl Copyright (C) 2023-2024 Free Software Foundation, Inc.
|
|
dnl This file is part of GNU Emacs.
|
|
|
|
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 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 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/>.
|
|
|
|
# Support for building Emacs with dependencies using the Android NDK
|
|
# build system.
|
|
|
|
AC_ARG_WITH([ndk_path],
|
|
[AS_HELP_STRING([--with-ndk-path],
|
|
[find Android libraries in these directories])])
|
|
|
|
AC_ARG_WITH([ndk_cxx],
|
|
[AS_HELP_STRING([--with-ndk-cxx],
|
|
[name of the C++ compiler included with the NDK])])
|
|
|
|
# ndk_INIT(ABI, API, DIR, CFLAGS)
|
|
# -------------------------------
|
|
# Initialize the Android NDK. ABI is the ABI being built for.
|
|
# API is the API version being built for.
|
|
# CFLAGS is a list of compiler flags.
|
|
# As a side effect, set the variable ndk_INITIALIZED to true.
|
|
# DIR should be a directory containing the Makefile.in actually
|
|
# implementing the Android NDK build system.
|
|
|
|
AC_DEFUN([ndk_INIT],
|
|
[
|
|
# Look for Android.mk files.
|
|
ndk_module_files=
|
|
for file in $with_ndk_path; do
|
|
if test -f $file/Android.mk; then
|
|
ndk_module_files="$ndk_module_files$file/Android.mk "
|
|
fi
|
|
done
|
|
|
|
AC_REQUIRE_AUX_FILE([ndk-build-helper.mk])
|
|
ndk_AUX_DIR=$ac_aux_dir
|
|
ndk_ABI=$1
|
|
ndk_MODULES=
|
|
ndk_MAKEFILES=
|
|
ndk_INITIALIZED=yes
|
|
ndk_API=$2
|
|
ndk_DIR=$3
|
|
ndk_ANY_CXX=
|
|
ndk_BUILD_CFLAGS="$4"
|
|
ndk_working_cxx=no
|
|
ndk_CXX_SHARED=
|
|
|
|
AS_CASE(["$ndk_ABI"],
|
|
[*arm64*], [ndk_ARCH=arm64],
|
|
[*arm*], [ndk_ARCH=arm],
|
|
[*x86_64*], [ndk_ARCH=x86_64],
|
|
[*x86*], [ndk_ARCH=x86],
|
|
[*mips64*], [ndk_ARCH=mips64],
|
|
[*mips*], [ndk_ARCH=mips],
|
|
[AC_MSG_ERROR([Failed to determine Android device architecture])])
|
|
|
|
# This is a map between pkg-config style package names and Android
|
|
# ones.
|
|
|
|
ndk_package_map="libwebpdemux:webpdemux libxml-2.0:libxml2"
|
|
ndk_package_map="$ndk_package_map sqlite3:libsqlite_static_minimal"
|
|
ndk_package_map="$ndk_package_map MagickWand:libmagickwand-7 lcms2:liblcms2"
|
|
|
|
# Replace ndk_module with the appropriate Android module name if it is
|
|
# found in ndk_package_map.
|
|
|
|
ndk_replace_pkg_config_package () {
|
|
for ndk_stuff in $ndk_package_map; do
|
|
ndk_key=`AS_ECHO([$ndk_stuff]) | cut -d: -f1`
|
|
ndk_value=`AS_ECHO([$ndk_stuff]) | cut -d: -f2`
|
|
|
|
if test "$ndk_key" = "$ndk_module"; then
|
|
ndk_module="$ndk_value"
|
|
break
|
|
fi
|
|
done
|
|
}
|
|
|
|
# Run the Makefile helper script for the Android.mk file.
|
|
|
|
ndk_run_test () {
|
|
# Figure out where the helper Makefile is.
|
|
ndk_build_helper_file="${ndk_AUX_DIR}ndk-build-helper.mk"
|
|
ndk_module_extract_awk="${ndk_AUX_DIR}ndk-module-extract.awk"
|
|
ndk_dir=`AS_DIRNAME([$ndk_android_mk])`
|
|
|
|
# Now call Make with the right arguments.
|
|
"$MAKE" -s -f "$ndk_build_helper_file" EMACS_SRCDIR=`pwd` \
|
|
EMACS_ABI="$ndk_ABI" ANDROID_MAKEFILE="$ndk_android_mk" \
|
|
NDK_BUILD_DIR="$ndk_DIR" NDK_ROOT="/tmp" \
|
|
ANDROID_MODULE_DIRECTORY="$ndk_dir" BUILD_AUXDIR=$ndk_AUX_DIR \
|
|
NDK_BUILD_ARCH="$ndk_ARCH" 2>&AS_MESSAGE_LOG_FD >conftest.ndk
|
|
|
|
# Read the output.
|
|
cat conftest.ndk | awk -f "$ndk_module_extract_awk" MODULE="$ndk_module"
|
|
|
|
# Remove the temporary file.
|
|
rm -f conftest.ndk
|
|
}
|
|
|
|
# ndk_parse_pkg_config_string PKG_CONFIG_STRING
|
|
# ---------------------------------------------
|
|
# Parse a pkg-config style list of modules. Place the resulting list
|
|
# in ndk_modules.
|
|
|
|
ndk_parse_pkg_config_string () {
|
|
ndk_input=[$]1
|
|
ndk_modules=
|
|
while test -n "$ndk_input"; do
|
|
ndk_str=`AS_ECHO_N(["$ndk_input"]) | cut -f1 -d' '`
|
|
ndk_input=`AS_ECHO_N(["$ndk_input"]) | cut -s -f2- -d' '`
|
|
|
|
if test "$ndk_str" = ">=" || test "$ndk_str" = "<=" \
|
|
|| test "$ndk_str" = ">" || test "$ndk_str" = "<" \
|
|
|| test "$ndk_str" = "!="; then
|
|
ndk_input=`AS_ECHO_N(["$ndk_input"]) | cut -s -f2- -d' '`
|
|
else
|
|
ndk_modules="$ndk_modules$ndk_str "
|
|
fi
|
|
done
|
|
}
|
|
|
|
# ndk_resolve_import_module MODULE
|
|
# --------------------------------
|
|
# Resolve MODULE, a single import. Prepend its makefile to
|
|
# ndk_MAKEFILES if found. Also, prepend all includes to the variable
|
|
# ndk_import_includes.
|
|
|
|
ndk_resolve_import_module () {
|
|
module_name=
|
|
ndk_module=[$]1
|
|
|
|
AC_MSG_CHECKING([for imported $ndk_module])
|
|
|
|
for ndk_android_mk in $ndk_module_files; do
|
|
# Read this Android.mk file. Set NDK_ROOT to /tmp: the Android in
|
|
# tree build system sets it to a meaningful value, but build files
|
|
# just use it to test whether or not the NDK is being used.
|
|
ndk_commands=`ndk_run_test`
|
|
eval "$ndk_commands"
|
|
|
|
if test -n "$module_name"; then
|
|
break;
|
|
fi
|
|
done
|
|
|
|
AS_IF([test -z "$module_name"],
|
|
[AC_MSG_RESULT([no])
|
|
AC_MSG_ERROR([The module currently being built depends on [$]1, but \
|
|
that could not be found in the list of directories specified in \
|
|
`--with-ndk-path'.])])
|
|
|
|
if test -n "$module_cxx_deps"; then
|
|
ndk_ANY_CXX=yes
|
|
fi
|
|
|
|
AS_IF([test "$module_cxx_deps" = "yes" && test -z "$ndk_CXX_STL" \
|
|
&& test -z "$ndk_CXX_LDFLAGS"],
|
|
[AC_MSG_ERROR([The module $1 requires a C++ standard library,
|
|
but none were found.])])
|
|
|
|
AS_IF([test "$module_cxx_deps" = "yes" && test "$ndk_working_cxx" != "yes"],
|
|
[AC_MSG_ERROR([The module [$]1 requires the C++ standard library,
|
|
but a working C++ compiler was not found.])])
|
|
|
|
AC_MSG_RESULT([yes])
|
|
|
|
# Make sure the module is prepended.
|
|
ndk_MODULES="$ndk_MODULES $module_target"
|
|
ndk_MAKEFILES="$ndk_android_mk $ndk_MAKEFILES"
|
|
ndk_import_includes="$module_includes $ndk_import_includes"
|
|
|
|
# Now recursively resolve this module's imports.
|
|
for ndk_module in $module_imports; do
|
|
ndk_resolve_import_module $ndk_module
|
|
done
|
|
}
|
|
|
|
# ndk_filter_cc_for_cxx
|
|
# ---------------------
|
|
# Run through $CC, removing any options that are not suitable for
|
|
# use in a C++ compiler.
|
|
|
|
ndk_filter_cc_for_cxx () {
|
|
for ndk_word in $CC; do
|
|
AS_CASE([$ndk_word], [*-std=*], [],
|
|
[AS_ECHO_N(["$ndk_word "])])
|
|
done
|
|
}
|
|
|
|
# ndk_subst_cc_onto_cxx
|
|
# ---------------------
|
|
# Print the value of $CXX, followed by any innocent looking options
|
|
# in $CC.
|
|
|
|
ndk_subst_cc_onto_cxx () {
|
|
AS_ECHO_N(["$CXX "])
|
|
ndk_flag=
|
|
for ndk_word in `AS_ECHO_N(["$CC"]) | cut -s -f2- -d' '`; do
|
|
AS_IF([test "$ndk_flag" = "yes"],
|
|
[AS_ECHO_N(["$ndk_word "])
|
|
ndk_flag=no],
|
|
[AS_CASE([$ndk_word],
|
|
[*-sysroot=*],
|
|
[AS_ECHO_N(["$ndk_word "])],
|
|
[*-isystem*],
|
|
[AS_ECHO_N(["$ndk_word "])
|
|
ndk_flag=yes],
|
|
[*-sysroot*],
|
|
[AS_ECHO_N(["$ndk_word "])
|
|
ndk_flag=yes],
|
|
[-D__ANDROID_API__*],
|
|
[AS_ECHO_N(["$ndk_word "])])])
|
|
done
|
|
}
|
|
|
|
# ndk_subst_cflags_onto_cxx
|
|
# ---------------------
|
|
# Print any options in CFLAGS also suitable for a C++ compiler.
|
|
|
|
ndk_subst_cflags_onto_cxx () {
|
|
ndk_flag=
|
|
for ndk_word in $CFLAGS; do
|
|
AS_IF([test "$ndk_flag" = "yes"],
|
|
[AS_ECHO_N(["$ndk_word "])
|
|
ndk_flag=no],
|
|
[AS_CASE([$ndk_word],
|
|
[*-sysroot=*],
|
|
[AS_ECHO_N(["$ndk_word "])],
|
|
[*-isystem*],
|
|
[AS_ECHO_N(["$ndk_word "])
|
|
ndk_flag=yes],
|
|
[*-I*],
|
|
[AS_ECHO_N(["$ndk_word "])
|
|
ndk_flag=yes],
|
|
[*-sysroot*],
|
|
[AS_ECHO_N(["$ndk_word "])
|
|
ndk_flag=yes],
|
|
[-D__ANDROID_API__*],
|
|
[AS_ECHO_N(["$ndk_word "])])])
|
|
done
|
|
}
|
|
|
|
# Detect the installation directory and type of the NDK being used.
|
|
|
|
ndk_install_dir=
|
|
ndk_toolchain_type=
|
|
|
|
AC_MSG_CHECKING([for the directory where the NDK is installed])
|
|
|
|
dnl If the install directory isn't available, repeat the search over
|
|
dnl each entry in the programs directory.
|
|
ndk_programs_dirs=`$CC -print-search-dirs | sed -n "s/^programs:[[\t ]]*=\?\(.*\)/\1/p"`
|
|
ndk_save_IFS=$IFS; IFS=:
|
|
for ndk_dir in $ndk_programs_dirs; do
|
|
if test -d "$ndk_dir"; then :; else
|
|
continue
|
|
fi
|
|
ndk_dir=`cd "$ndk_dir"; pwd`
|
|
while test "$ndk_dir" != "/" && test -z "$ndk_toolchain_type"; do
|
|
ndk_dir=`AS_DIRNAME([$ndk_dir])`
|
|
AS_IF([test -d "$ndk_dir/bin" && test -d "$ndk_dir/lib"],
|
|
[dnl The directory reached is most likely either the directory
|
|
dnl holding prebuilt binaries in a combined toolchain or the
|
|
dnl directory holding a standalone toolchain itself.
|
|
dnl
|
|
dnl Distinguish between the two by verifying the name of the
|
|
dnl parent directory (and its parent).
|
|
ndk_dir1=`AS_DIRNAME(["$ndk_dir"])`
|
|
ndk_basename=`AS_BASENAME(["$ndk_dir1"])`
|
|
AS_IF([test "$ndk_basename" = "prebuilt"],
|
|
[dnl Directories named "prebuilt" are exclusively present in
|
|
dnl combined toolchains, where they are children of the
|
|
dnl base directory or, in recent releases, a directory
|
|
dnl within the base directory. Continue searching for the
|
|
dnl base directory.
|
|
ndk_toolchain_type=combined
|
|
while test "$ndk_dir1" != "/"; do
|
|
AS_IF([test -d "$ndk_dir1/toolchains" \
|
|
&& test -d "$ndk_dir1/sources"],
|
|
[ndk_install_dir=$ndk_dir1
|
|
break])
|
|
ndk_dir1=`AS_DIRNAME(["$ndk_dir1"])`
|
|
done],
|
|
[ndk_toolchain_type=standalone
|
|
ndk_install_dir=$ndk_dir])])
|
|
done
|
|
AS_IF([test -n "$ndk_toolchain_type"],
|
|
[break])
|
|
done
|
|
IFS=$ndk_save_IFS
|
|
|
|
AS_IF([test -z "$ndk_install_dir"],
|
|
[AC_MSG_RESULT([unknown])
|
|
AC_MSG_WARN([The NDK installation directory could not be \
|
|
derived from the compiler.])],
|
|
[AC_MSG_RESULT([$ndk_install_dir ($ndk_toolchain_type)])])
|
|
|
|
# Look for a suitable ar and ranlib in the same directory as the C
|
|
# compiler.
|
|
ndk_cc_firstword=`AS_ECHO(["$CC"]) | cut -d' ' -f1`
|
|
ndk_where_cc=`which $ndk_cc_firstword`
|
|
ndk_ar_search_path=$PATH
|
|
ndk_ranlib_search_path=$RANLIB
|
|
|
|
# First, try to find $host_alias-ar in PATH.
|
|
AC_PATH_PROGS([AR], [$host_alias-ar], [], [$ndk_ar_search_path])
|
|
|
|
AS_IF([test -z "$AR"],[
|
|
# Next, try finding either that or llvm-ar in the directory holding
|
|
# CC.
|
|
ndk_ar_search_path="`AS_DIRNAME([$ndk_where_cc])`:$ndk_ar_search_path"
|
|
AC_PATH_PROGS([AR], [$host_alias-ar llvm-ar], [], [$ndk_ar_search_path])])
|
|
|
|
# First, try to find $host_alias-ranlib in PATH.
|
|
AC_PATH_PROGS([RANLIB], [$host_alias-ranlib], [], [$ndk_ranlib_search_path])
|
|
|
|
AS_IF([test -z "$RANLIB"],[
|
|
# Next, try finding either that or llvm-ranlib in the directory
|
|
# holding CC.
|
|
ndk_ranlib_search_path="`AS_DIRNAME([$ndk_where_cc])`:$ndk_ranlib_search_path"
|
|
AC_PATH_PROGS([RANLIB], [$host_alias-ranlib llvm-ranlib], [],
|
|
[$ndk_ranlib_search_path])])
|
|
|
|
NDK_BUILD_NASM=
|
|
|
|
# Next, try to find nasm on x86. This doesn't ship with the NDK.
|
|
AS_IF([test "$ndk_ARCH" = "x86" || test "$ndk_ARCH" = "x86_64"],
|
|
[AC_CHECK_PROGS([NDK_BUILD_NASM], [nasm])])
|
|
|
|
# Search for a suitable readelf binary, which is required to generate
|
|
# the shared library list loaded on old Android systems.
|
|
AC_PATH_PROGS([READELF], [readelf llvm-readelf $host_alias-readelf],
|
|
[], [$ndk_ranlib_search_path:$PATH])
|
|
AS_IF([test -z "$READELF"],
|
|
[AC_MSG_ERROR([A suitable `readelf' utility cannot be located.
|
|
Please verify that the Android NDK has been installed correctly,
|
|
or install a functioning `readelf' yourself.])])
|
|
NDK_BUILD_READELF="$READELF"
|
|
|
|
# Search for a C++ compiler. Upon failure, pretend the C compiler is a
|
|
# C++ compiler and use that instead.
|
|
|
|
ndk_cc_name=`AS_BASENAME(["${ndk_cc_firstword}"])`
|
|
ndk_cxx_name=
|
|
|
|
AS_CASE([$ndk_cc_name], [*-gcc],
|
|
[ndk_cxx_name=`AS_ECHO([$ndk_cc_name]) | sed 's/gcc/g++/'`],
|
|
[ndk_cxx_name="${ndk_cc_name}++"])
|
|
|
|
AS_IF([test -n "$with_ndk_cxx"], [CXX=$with_ndk_cxx],
|
|
[AC_PATH_PROGS([CXX], [$ndk_cxx_name],
|
|
[], [`AS_DIRNAME(["$ndk_where_cc"])`:$PATH])
|
|
AS_IF([test -z "$CXX"], [CXX=`ndk_filter_cc_for_cxx`],
|
|
[CXX=`ndk_subst_cc_onto_cxx`])])
|
|
|
|
# None of the C++ standard libraries installed with Android are
|
|
# available to NDK programs, which are expected to select one of several
|
|
# standard libraries distributed with the NDK. This library must be
|
|
# extracted from the NDK by the program's build system and copied into
|
|
# the application directory, and the build system is also expected to
|
|
# provide the compiler with suitable options to enable it.
|
|
#
|
|
# Emacs, on recent releases of the NDK, prefers the libc++ library, the
|
|
# most complete of the libraries available, when it detects the presence
|
|
# of its headers and libraries in the compiler's search path. Next in
|
|
# line are the several libraries located in a directory named `cxx-stl'
|
|
# inside the NDK distribution, of which Emacs prefers, in this order,
|
|
# the GNU libstdc++, stlport, gabi and the system C++ library. The
|
|
# scope of the last two is confined to providing runtime support for
|
|
# basic C++ operations, and is useless for compiling most C++
|
|
# dependencies whose requirements go beyond such operations.
|
|
#
|
|
# The NDK comes in two forms. In a "combined toolchain", all C++
|
|
# libraries are present in the NDK directory and the responsibility is
|
|
# left to the build system to locate and select the best C++ library,
|
|
# whereas in a "standalone toolchain" an STL will have already been
|
|
# specified a C++ library, besides which no others will be present.
|
|
#
|
|
# Though Android.mk files are provided by the NDK for each such library,
|
|
# Emacs cannot use any of these, both for lack of prebuilt support in
|
|
# its ndk-build implementation, and since they are absent from combined
|
|
# toolchains.
|
|
|
|
ndk_CXX_SHARED=
|
|
ndk_CXX_STL=
|
|
ndk_CXX_LDFLAGS=
|
|
|
|
AS_IF([test -n "$CXX" && test -n "$ndk_install_dir"],
|
|
[ndk_library_dirs=`$CXX -print-search-dirs \
|
|
| sed -n "s/^libraries:[[\t ]]*=\?\(.*\)/\1/p"`
|
|
AS_IF([test "$ndk_toolchain_type" = "standalone"],
|
|
[dnl With a standalone toolchain, just use the first C++ library
|
|
dnl present in the compiler's library search path, that being the
|
|
dnl only C++ library that will ever be present.
|
|
ndk_save_IFS=$IFS; IFS=:
|
|
for ndk_dir in $ndk_library_dirs; do
|
|
if test -d "$ndk_dir"; then :; else
|
|
continue
|
|
fi
|
|
ndk_dir=`cd "$ndk_dir"; pwd`
|
|
if test -f "$ndk_dir/libc++_shared.so"; then
|
|
ndk_CXX_SHARED="$ndk_dir/libc++_shared.so"
|
|
ndk_CXX_LDFLAGS=-lc++_shared; break
|
|
elif test -f "$ndk_dir/libgnustl_shared.so"; then
|
|
ndk_CXX_SHARED="$ndk_dir/libgnustl_shared.so"
|
|
ndk_CXX_LDFLAGS=-lgnustl_shared; break
|
|
elif test -f "$ndk_dir/libstlport_shared.so"; then
|
|
ndk_CXX_SHARED="$ndk_dir/libstlport_shared.so"
|
|
ndk_CXX_LDFLAGS=-lstlport_shared; break
|
|
fi
|
|
done
|
|
IFS=$ndk_save_IFS],
|
|
[dnl Otherwise, search for a suitable standard library
|
|
dnl in the order stated above.
|
|
dnl
|
|
dnl Detect if this compiler is configured to link against libc++ by
|
|
dnl default.
|
|
AC_MSG_CHECKING([whether compiler defaults to libc++])
|
|
cat <<_ACEOF >conftest.cc
|
|
#include <string>
|
|
#ifndef _LIBCPP_VERSION
|
|
Not libc++!
|
|
#endif /* _LIBCPP_VERSION */
|
|
|
|
int
|
|
main (void)
|
|
{
|
|
|
|
}
|
|
_ACEOF
|
|
AS_IF([$CXX conftest.cc -o conftest.o >&AS_MESSAGE_LOG_FD 2>&1],
|
|
[dnl The compiler defaults to libc++.
|
|
AC_MSG_RESULT([yes])
|
|
ndk_save_IFS=$IFS; IFS=:
|
|
for ndk_dir in $ndk_library_dirs; do
|
|
if test -f "$ndk_dir/libc++_shared.so"; then
|
|
ndk_CXX_SHARED="$ndk_dir/libc++_shared.so"
|
|
ndk_CXX_LDFLAGS=-lc++_shared; break
|
|
fi
|
|
done
|
|
IFS=$ndk_save_IFS],
|
|
[dnl Search for gnustl, stlport, gabi, and failing that, system.
|
|
dnl The name of the gabi system root directory varies by GCC
|
|
dnl version.
|
|
AC_MSG_RESULT([no])
|
|
ndk_gcc_version=`($CXX -v 2>&1) \
|
|
| sed -n "s/^gcc version \([[0123456789]\+.[0123456789]\+]\).*/\1/p"`
|
|
cxx_stl="$ndk_install_dir/sources/cxx-stl"
|
|
ndk_cxx_stl_base="$cxx_stl/gnu-libstdc++/$ndk_gcc_version"
|
|
AS_IF([test -n "$ndk_gcc_version" \
|
|
&& test -d "$ndk_cxx_stl_base/libs/$ndk_ABI"],
|
|
[ndk_CXX_LDFLAGS="-L$ndk_cxx_stl_base/libs/$ndk_ABI -lgnustl_shared"
|
|
ndk_CXX_LDFLAGS="$ndk_CXX_LDFLAGS -lsupc++"
|
|
ndk_CXX_STL="-isystem $ndk_cxx_stl_base/include"
|
|
ndk_CXX_STL="$ndk_CXX_STL -isystem $ndk_cxx_stl_base/libs/$ndk_ABI/include"
|
|
ndk_CXX_SHARED="$ndk_cxx_stl_base/libs/$ndk_ABI/libgnustl_shared.so"])
|
|
AS_IF([test -f "$ndk_CXX_SHARED"], [],
|
|
[dnl No STL was located or the library is not reachable.
|
|
dnl Search for alternatives.
|
|
ndk_CXX_STL=
|
|
ndk_CXX_SHARED=
|
|
ndk_CXX_LDFLAGS=
|
|
ndk_cxx_stl_base="$cxx_stl/stlport"
|
|
AS_IF([test -d "$ndk_cxx_stl_base"],
|
|
[ndk_CXX_LDFLAGS="-L$ndk_cxx_stl_base/libs/$ndk_ABI -lstlport_shared"
|
|
ndk_CXX_STL="-isystem $ndk_cxx_stl_base/stlport"
|
|
ndk_CXX_SHARED="$ndk_cxx_stl_base/libs/$ndk_ABI/libstlport_shared.so"])
|
|
AS_IF([test -f "$ndk_CXX_SHARED"], [],
|
|
[ndk_CXX_STL=
|
|
ndk_CXX_SHARED=
|
|
ndk_CXX_LDFLAGS=
|
|
ndk_cxx_stl_base="$cxx_stl/gabi++"
|
|
AS_IF([test -d "$ndk_cxx_stl_base"],
|
|
[ndk_CXX_LDFLAGS="-L$ndk_cxx_stl_base/libs/$ndk_ABI -lgabi++_shared"
|
|
ndk_CXX_STL="$ndk_CXX_STL -isystem $ndk_cxx_stl_base/include"
|
|
ndk_CXX_SHARED="$ndk_cxx_stl_base/libs/$ndk_ABI/lgabi++_shared.so"])])
|
|
AS_IF([test -f "$ndk_CXX_SHARED"], [],
|
|
[ndk_CXX_STL=
|
|
ndk_CXX_SHARED=
|
|
ndk_CXX_LDFLAGS=
|
|
ndk_cxx_stl_base="$cxx_stl/system"
|
|
AS_IF([test -d "$ndk_cxx_stl_base"],
|
|
[ndk_CXX_LDFLAGS="-L$ndk_cxx_stl_base/libs/$ndk_ABI -lstdc++"
|
|
ndk_CXX_STL="-isystem $ndk_cxx_stl_base/include"
|
|
dnl The "system" library is distributed with Android and
|
|
dnl need not be present in app packages.
|
|
ndk_CXX_SHARED=
|
|
dnl Done.
|
|
])])])])
|
|
rm -f conftest.o])])
|
|
|
|
AS_ECHO([])
|
|
AS_ECHO(["C++ compiler configuration: "])
|
|
AS_ECHO([])
|
|
AS_ECHO(["Library includes : $ndk_CXX_STL"])
|
|
AS_ECHO(["Linker options : $ndk_CXX_LDFLAGS"])
|
|
AS_ECHO(["Library file (if any) : $ndk_CXX_SHARED"])
|
|
AS_ECHO([])
|
|
])
|
|
|
|
# ndk_LATE_EARLY
|
|
# --------------
|
|
# Call before ndk_LATE to establish certain variables in time for
|
|
# ndk_LATE's C++ compiler detection.
|
|
|
|
AC_DEFUN([ndk_LATE_EARLY],
|
|
[ndk_save_LDFLAGS="$LDFLAGS"
|
|
LDFLAGS="$LDFLAGS $ndk_CXX_LDFLAGS"
|
|
CXXFLAGS="$CXXFLAGS `ndk_subst_cflags_onto_cxx` $ndk_CXX_STL"])
|
|
|
|
# ndk_LATE
|
|
# --------
|
|
# Perform late initialization of the ndk-build system by checking for
|
|
# required C and C++ headers.
|
|
|
|
AC_DEFUN([ndk_LATE],
|
|
[dnl
|
|
AS_IF([test "$ndk_INITIALIZED" = "yes"],[
|
|
AS_IF([test -n "$CXX"], [
|
|
AC_LANG_PUSH([C++])
|
|
AC_CHECK_HEADER([string], [ndk_working_cxx=yes],
|
|
[AC_MSG_WARN([Your C++ compiler is not properly configured, as \
|
|
the standard library headers could not be found.])])
|
|
AC_LANG_POP([C++])])])
|
|
LDFLAGS="$ndk_save_LDFLAGS"
|
|
])
|
|
|
|
# ndk_SEARCH_MODULE(MODULE, NAME, ACTION-IF-FOUND, [ACTION-IF-NOT-FOUND])
|
|
# -----------------------------------------------------------------------
|
|
# Search for a module named MODULE in `with_ndk_path'. Add the file
|
|
# name of the module's Android.mk file to the variable ndk_MAKEFILES.
|
|
# Set NAME_CFLAGS and NAME_LIBS to the appropriate values. Then, call
|
|
# ACTION-IF-FOUND, or ACTION-IF-NOT-FOUND upon failure.
|
|
#
|
|
# Resolve any imports specified by MODULE, and expand AC_MSG_ERROR
|
|
# with a suitable error message if imports were not found.
|
|
AC_DEFUN([ndk_SEARCH_MODULE],
|
|
[
|
|
module_name=
|
|
ndk_module=$1
|
|
ndk_replace_pkg_config_package
|
|
AC_MSG_CHECKING([for Android.mk that builds $ndk_module])
|
|
|
|
for ndk_android_mk in $ndk_module_files; do
|
|
# Read this Android.mk file. Set NDK_ROOT to /tmp: the Android in
|
|
# tree build system sets it to a meaning value, but build files just
|
|
# use it to test whether or not the NDK is being used.
|
|
ndk_commands=`ndk_run_test`
|
|
|
|
eval "$ndk_commands"
|
|
if test -n "$module_name"; then
|
|
break;
|
|
fi
|
|
done
|
|
|
|
if test -z "$module_name"; then
|
|
AC_MSG_RESULT([no])
|
|
$4
|
|
else
|
|
if test -n "$module_cxx_deps"; then
|
|
ndk_ANY_CXX=yes
|
|
fi
|
|
|
|
AS_IF([test "$module_cxx_deps" = "yes" && test -z "$ndk_CXX_STL" \
|
|
&& test -z "$ndk_CXX_LDFLAGS"],
|
|
[AC_MSG_ERROR([The module $1 requires a C++ standard library,
|
|
but none were found.])])
|
|
|
|
AS_IF([test "$module_cxx_deps" = "yes" && test "$ndk_working_cxx" != "yes"],
|
|
[AC_MSG_ERROR([The module [$]1 requires the C++ standard library,
|
|
but a working C++ compiler was not found.])])
|
|
|
|
$2[]_CFLAGS="[$]$2[]_CFLAGS $module_cflags $module_includes"
|
|
$2[]_LIBS="[$]$2[]_LIBS $module_ldflags"
|
|
ndk_MAKEFILES="$ndk_MAKEFILES $ndk_android_mk"
|
|
ndk_MODULES="$ndk_MODULES $module_target"
|
|
AC_MSG_RESULT([yes])
|
|
$3
|
|
|
|
# Now, resolve imports. Make sure the imports' Makefiles comes
|
|
# before ndk_MAKEFILES; likewise for its includes.
|
|
ndk_import_includes=
|
|
for ndk_module in $module_imports; do
|
|
ndk_resolve_import_module $ndk_module
|
|
$2[]_CFLAGS="$ndk_import_includes [$]$2[]_CFLAGS"
|
|
done
|
|
fi
|
|
])
|
|
|
|
# ndk_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
|
|
# [ACTION-IF-NOT-FOUND])
|
|
# --------------------------------------------------------------
|
|
# Just like `PKG_CHECK_MODULES'. However, it uses the ndk-build
|
|
# system instead.
|
|
|
|
AC_DEFUN([ndk_CHECK_MODULES],
|
|
[
|
|
ndk_modules=
|
|
ndk_parse_pkg_config_string "$2"
|
|
ndk_found=no
|
|
|
|
for module in $ndk_modules; do
|
|
ndk_SEARCH_MODULE([$module], [$1], [ndk_found=yes], [ndk_found=no])
|
|
done
|
|
|
|
AS_IF([test "$ndk_found" = "yes"],[$3],[$4])
|
|
])
|
|
|
|
# ndk_CONFIG_FILES
|
|
# -------------------------------------------------------------
|
|
# Write out the NDK build Makefile with the appropriate variables
|
|
# set if the NDK has been initialized.
|
|
|
|
AC_DEFUN_ONCE([ndk_CONFIG_FILES],
|
|
[
|
|
if test "$ndk_INITIALIZED" = "yes"; then
|
|
NDK_BUILD_ANDROID_MK="$ndk_MAKEFILES"
|
|
NDK_BUILD_ARCH=$ndk_ARCH
|
|
NDK_BUILD_ABI=$ndk_ABI
|
|
NDK_BUILD_SDK=$ndk_API
|
|
NDK_BUILD_CC=$CC
|
|
NDK_BUILD_CXX=$CXX
|
|
NDK_BUILD_AR=$AR
|
|
NDK_BUILD_MODULES="$ndk_MODULES"
|
|
NDK_BUILD_CXX_SHARED="$ndk_CXX_SHARED"
|
|
NDK_BUILD_CXX_STL="$ndk_CXX_STL"
|
|
NDK_BUILD_CXX_LDFLAGS="$ndk_CXX_LDFLAGS"
|
|
NDK_BUILD_ANY_CXX_MODULE=$ndk_ANY_CXX
|
|
NDK_BUILD_CFLAGS="$ndk_BUILD_CFLAGS"
|
|
|
|
AC_SUBST([NDK_BUILD_ANDROID_MK])
|
|
AC_SUBST([NDK_BUILD_ARCH])
|
|
AC_SUBST([NDK_BUILD_ABI])
|
|
AC_SUBST([NDK_BUILD_SDK])
|
|
AC_SUBST([NDK_BUILD_CC])
|
|
AC_SUBST([NDK_BUILD_CXX])
|
|
AC_SUBST([NDK_BUILD_AR])
|
|
AC_SUBST([NDK_BUILD_NASM])
|
|
AC_SUBST([NDK_BUILD_MODULES])
|
|
AC_SUBST([NDK_BUILD_CXX_SHARED])
|
|
AC_SUBST([NDK_BUILD_CXX_STL])
|
|
AC_SUBST([NDK_BUILD_CXX_LDFLAGS])
|
|
AC_SUBST([NDK_BUILD_ANY_CXX_MODULE])
|
|
AC_SUBST([NDK_BUILD_CFLAGS])
|
|
AC_SUBST([NDK_BUILD_READELF])
|
|
|
|
AC_CONFIG_FILES([$ndk_DIR/Makefile])
|
|
AC_CONFIG_FILES([$ndk_DIR/ndk-build.mk])
|
|
fi
|
|
])
|