1403 lines
40 KiB
Plaintext
1403 lines
40 KiB
Plaintext
# -*-autoconf-*-
|
|
AC_COPYRIGHT([ Copyright (c) 1999-2010, International Business Machines Corporation and others. All Rights Reserved. ])
|
|
# configure.in for ICU
|
|
# Stephen F. Booth, heavily modified by Yves and others
|
|
|
|
# Check for autoconf version
|
|
AC_PREREQ(2.67)
|
|
|
|
|
|
# Process this file with autoconf to produce a configure script
|
|
AC_INIT
|
|
AC_CONFIG_SRCDIR([common/unicode/utypes.h])
|
|
|
|
AC_CONFIG_HEADERS(common/icucfg.h)
|
|
PACKAGE="icu"
|
|
AC_SUBST(PACKAGE)
|
|
|
|
# Use custom echo test for newline option
|
|
# Current autoconf (2.65) gives incorrect echo newline option
|
|
# for icu-config
|
|
# This may be removed later - mow (June 17, 2010)
|
|
ICU_ECHO_C= ICU_ECHO_N= ICU_ECHO_T=
|
|
case `/bin/sh -c "echo -n x"` in
|
|
-n*)
|
|
case `/bin/sh -c "echo 'x\c'"` in
|
|
*c*) ICU_ECHO_T=' ';; # ECHO_T is single tab character.
|
|
*) ICU_ECHO_C='\c';;
|
|
esac;;
|
|
*)
|
|
ICU_ECHO_N='-n';;
|
|
esac
|
|
AC_SUBST(ICU_ECHO_N)
|
|
AC_SUBST(ICU_ECHO_C)
|
|
AC_SUBST(ICU_ECHO_T)
|
|
|
|
AC_MSG_CHECKING(for ICU version numbers)
|
|
|
|
# Get the ICU version from uversion.h or other headers
|
|
geticuversion() {
|
|
[sed -n 's/^[ ]*#[ ]*define[ ]*U_ICU_VERSION[ ]*"\([^"]*\)".*/\1/p' "$@"]
|
|
}
|
|
getuversion() {
|
|
[sed -n 's/^[ ]*#[ ]*define[ ]*U_UNICODE_VERSION[ ]*"\([^"]*\)".*/\1/p' "$@"]
|
|
}
|
|
VERSION=`geticuversion $srcdir/common/unicode/uvernum.h`
|
|
if test x"$VERSION" = x; then
|
|
VERSION=`geticuversion $srcdir/common/unicode/*.h`
|
|
if test x"$VERSION" = x; then
|
|
AC_MSG_ERROR([Cannot determine ICU version number from uvernum.h header file])
|
|
fi
|
|
fi
|
|
|
|
UNICODE_VERSION=`getuversion $srcdir/common/unicode/uchar.h`
|
|
if test x"$UNICODE_VERSION" = x; then
|
|
UNICODE_VERSION=`getuversion $srcdir/common/unicode/*.h`
|
|
if test x"$UNICODE_VERSION" = x; then
|
|
AC_MSG_ERROR([Cannot determine Unicode version number from uchar.h header file])
|
|
fi
|
|
fi
|
|
# Compute a reasonable library version from the release version. This is
|
|
# very bad, but that's wanted... We want to make sure that the LIB_VERSION
|
|
# has at least a dot in it, so we'll add a .0 if needed.
|
|
[LIB_VERSION=`echo $VERSION | sed -e 's/\.//' -e 's/^\([^.]*\)$/\1.0/'`]
|
|
LIB_VERSION_MAJOR=`echo $LIB_VERSION | sed 's/\..*//'`
|
|
AC_SUBST(VERSION)
|
|
AC_SUBST(LIB_VERSION)
|
|
AC_SUBST(LIB_VERSION_MAJOR)
|
|
AC_MSG_RESULT([release $VERSION, library $LIB_VERSION, unicode version $UNICODE_VERSION])
|
|
|
|
AC_SUBST(UNICODE_VERSION)
|
|
|
|
# Determine the host system
|
|
AC_CANONICAL_SYSTEM
|
|
|
|
AC_SUBST(CPPFLAGS)
|
|
|
|
# This variable is needed on z/OS because the C++ compiler only recognizes .C
|
|
_CXX_CXXSUFFIX=cpp
|
|
export _CXX_CXXSUFFIX
|
|
|
|
# Check whether to build debug libraries
|
|
AC_MSG_CHECKING([whether to build debug libraries])
|
|
enabled=no
|
|
ENABLE_DEBUG=0
|
|
AC_ARG_ENABLE(debug,
|
|
[ --enable-debug build debug libraries [default=no]],
|
|
[ case "${enableval}" in
|
|
yes|"") enabled=yes; ENABLE_DEBUG=1 ;;
|
|
*) ;;
|
|
esac],
|
|
)
|
|
AC_MSG_RESULT($enabled)
|
|
AC_SUBST(ENABLE_DEBUG)
|
|
|
|
# Check whether to build release libraries
|
|
AC_MSG_CHECKING([whether to build release libraries])
|
|
enabled=yes
|
|
ENABLE_RELEASE=1
|
|
AC_ARG_ENABLE(release,
|
|
[ --enable-release build release libraries [default=yes]],
|
|
[ case "${enableval}" in
|
|
no) enabled=no; ENABLE_RELEASE=0 ;;
|
|
*) ;;
|
|
esac],
|
|
)
|
|
AC_MSG_RESULT($enabled)
|
|
AC_SUBST(ENABLE_RELEASE)
|
|
|
|
# Don't use the default C/CXXFLags
|
|
: ${CFLAGS=""}
|
|
: ${CXXFLAGS=""}
|
|
|
|
# Checks for programs
|
|
AC_PROG_CC
|
|
AC_PROG_CXX
|
|
|
|
# Ensure that if CXXFLAGS/CFLAGS were not set when calling configure, set it correctly based on (enable/disable) debug or release option
|
|
# The release mode use is the default one for autoconf
|
|
if test "$GCC" = yes; then
|
|
if test "$CFLAGS" = ""; then
|
|
if test "$ENABLE_DEBUG" = 1; then
|
|
CFLAGS=-g
|
|
fi
|
|
if test "$ENABLE_RELEASE" = 1; then
|
|
CFLAGS="$CFLAGS -O2"
|
|
fi
|
|
fi
|
|
if test "$CXXFLAGS" = ""; then
|
|
if test "$ENABLE_DEBUG" = 1; then
|
|
CXXFLAGS=-g
|
|
fi
|
|
if test "$ENABLE_RELEASE" = 1; then
|
|
CXXFLAGS="$CXXFLAGS -O2"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
AC_PROG_CPP
|
|
|
|
AC_PROG_INSTALL
|
|
|
|
AC_SUBST(cross_compiling)
|
|
|
|
dnl use the pld hack to get ac_fn_cxx_try_link defined globally and not local
|
|
AC_LANG_PUSH([C++])
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM()])
|
|
AC_LANG_POP([C++])
|
|
|
|
# make sure install is relative to srcdir - if a script
|
|
if test "$srcdir" = "."; then
|
|
# If srcdir isn't just ., then (srcdir) is already prepended.
|
|
if test "${ac_install_sh}" = "${INSTALL}"; then
|
|
INSTALL="\\\$(top_srcdir)/${ac_install_sh}"
|
|
fi
|
|
fi
|
|
|
|
#AC_CHECK_PROG(AUTOCONF, autoconf, autoconf, true)
|
|
#AC_CHECK_PROG(STRIP, strip, strip, true)
|
|
|
|
# Check for the platform make
|
|
AC_PATH_PROGS(U_MAKE, gmake gnumake, make)
|
|
AC_SUBST(U_MAKE)
|
|
|
|
|
|
AC_ARG_WITH(cross-build,
|
|
[ --with-cross-build=dir specify an absolute path to the build directory of an ICU built for the current platform [default=no cross dir]],
|
|
[cross_buildroot="${withval}"],
|
|
[cross_buildroot=""])
|
|
|
|
if test "X$cross_buildroot" = "X"; then
|
|
if test "$cross_compiling" = "yes"; then
|
|
AC_MSG_ERROR([Error! Cross compiling but no --with-cross-build option specified - please supply the path to an executable ICU's build root])
|
|
dnl '
|
|
fi
|
|
else
|
|
if test -f "${cross_buildroot}/config/icucross.mk"; then
|
|
AC_MSG_RESULT([Using cross buildroot: $cross_buildroot])
|
|
else
|
|
if test -d "${cross_buildroot}"; then
|
|
AC_MSG_ERROR([${cross_buildroot}/config/icucross.mk not found. Please build ICU in ${cross_buildroot} first.])
|
|
else
|
|
AC_MSG_ERROR([No such directory ${cross_buildroot} supplied as the argument to --with-cross-build. Use an absolute path.])
|
|
fi
|
|
fi
|
|
fi
|
|
AC_SUBST(cross_buildroot)
|
|
|
|
# Check for doxygen to generate documentation
|
|
AC_PATH_PROG(DOXYGEN,doxygen,,$PATH:/usr/local/bin:/usr/bin)
|
|
|
|
# Check that the linker is usable
|
|
ICU_PROG_LINK
|
|
|
|
# Determine the executable suffix
|
|
# We don't use AC_EXEEXT because some compilers output separate debugging
|
|
# files, which confuses the AC_EXEEXT macro.
|
|
AC_MSG_CHECKING(checking for executable suffix)
|
|
case "${host}" in
|
|
*-*-cygwin*|*-*-mingw*) EXEEXT=.exe ;;
|
|
*) EXEEXT="" ;;
|
|
esac
|
|
ac_exeext=$EXEEXT
|
|
AC_MSG_RESULT($EXEEXT)
|
|
AC_SUBST(EXEEXT)
|
|
|
|
# Determine how strict we want to be when compiling
|
|
AC_CHECK_STRICT_COMPILE
|
|
|
|
# Check if we can build and use 64-bit libraries
|
|
AC_CHECK_64BIT_LIBS
|
|
AC_SUBST(ARFLAGS)
|
|
AC_SUBST(COMPILE_LINK_ENVVAR)
|
|
|
|
# Determine the Makefile fragment
|
|
ICU_CHECK_MH_FRAG
|
|
|
|
# Checks for libraries and other host specific stuff
|
|
# On HP/UX, don't link to -lm from a shared lib because it isn't
|
|
# PIC (at least on 10.2)
|
|
case "${host}" in
|
|
*-*-hpux*) AC_CHECK_LIB(m, floor, LIB_M="-lm") ;;
|
|
|
|
*) AC_CHECK_LIB(m, floor)
|
|
LIB_M="" ;;
|
|
esac
|
|
AC_SUBST(LIB_M)
|
|
|
|
# Check whether to build shared libraries
|
|
AC_MSG_CHECKING([whether to build shared libraries])
|
|
enabled=no
|
|
AC_ARG_ENABLE(shared,
|
|
[ --enable-shared build shared libraries [default=yes]],
|
|
[ case "${enableval}" in
|
|
yes|"") enabled=yes; ENABLE_SHARED=YES ;;
|
|
no);;
|
|
*) ;;
|
|
esac],
|
|
[enabled=yes; ENABLE_SHARED=YES]
|
|
)
|
|
AC_MSG_RESULT($enabled)
|
|
AC_SUBST(ENABLE_SHARED)
|
|
|
|
# Check whether to build static libraries
|
|
AC_MSG_CHECKING([whether to build static libraries])
|
|
enabled=no
|
|
AC_ARG_ENABLE(static,
|
|
[ --enable-static build static libraries [default=no]],
|
|
[ case "${enableval}" in
|
|
yes|"") enabled=yes; ENABLE_STATIC=YES ;;
|
|
no) ;;
|
|
*) ;;
|
|
esac],
|
|
)
|
|
AC_MSG_RESULT($enabled)
|
|
AC_SUBST(ENABLE_STATIC)
|
|
|
|
# Check whether to enable auto cleanup of libraries
|
|
AC_MSG_CHECKING([whether to enable auto cleanup of libraries])
|
|
enabled=no
|
|
UCLN_NO_AUTO_CLEANUP=1
|
|
AC_ARG_ENABLE(auto-cleanup,
|
|
[ --enable-auto-cleanup enable auto cleanup of libraries [default=no]],
|
|
[ case "${enableval}" in
|
|
yes) enabled=yes; UCLN_NO_AUTO_CLEANUP=0 ;;
|
|
*) ;;
|
|
esac],
|
|
)
|
|
AC_MSG_RESULT($enabled)
|
|
AC_SUBST(UCLN_NO_AUTO_CLEANUP)
|
|
|
|
# MSVC floating-point option
|
|
MSVC_RELEASE_FLAG=""
|
|
if test $enabled = yes
|
|
then
|
|
if test $icu_cv_host_frag = mh-cygwin-msvc
|
|
then
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
#if defined _MSC_VER && _MSC_VER >= 1400
|
|
#else
|
|
Microsoft Visual C++ < 2005
|
|
#endif
|
|
]], [[]])],[MSVC_RELEASE_FLAG="/fp:precise"],[MSVC_RELEASE_FLAG="/Op"])
|
|
|
|
CFLAGS="${CFLAGS} ${MSVC_RELEASE_FLAG}"
|
|
CXXFLAGS="${CXXFLAGS} ${MSVC_RELEASE_FLAG}"
|
|
fi
|
|
fi
|
|
|
|
# Check whether to enabled draft APIs
|
|
AC_MSG_CHECKING([whether to enable draft APIs])
|
|
enabled=yes
|
|
U_DEFAULT_SHOW_DRAFT=1
|
|
AC_ARG_ENABLE(draft,
|
|
[ --enable-draft enable draft APIs (and internal APIs) [default=yes]],
|
|
[ case "${enableval}" in
|
|
no) enabled=no; U_DEFAULT_SHOW_DRAFT=0 ;;
|
|
*) ;;
|
|
esac],
|
|
)
|
|
AC_MSG_RESULT($enabled)
|
|
# Make sure that we can use draft API in ICU.
|
|
if test "$U_DEFAULT_SHOW_DRAFT" = 0; then
|
|
CPPFLAGS="$CPPFLAGS -DU_SHOW_DRAFT_API"
|
|
fi
|
|
AC_SUBST(U_DEFAULT_SHOW_DRAFT)
|
|
|
|
# Check if we can hide variables from
|
|
AC_MSG_CHECKING([for library API export])
|
|
SHAREDLIBEXPORT=no
|
|
U_USE_GCC_VISIBILITY_ATTRIBUTE=0
|
|
OLD_CFLAGS="${CFLAGS}"
|
|
OLD_CXXFLAGS="${CXXFLAGS}"
|
|
if test "$ac_cv_c_compiler_gnu" = yes; then
|
|
LIBCFLAGS="-fvisibility=hidden"
|
|
LIBCXXFLAGS="-fvisibility=hidden"
|
|
CFLAGS="${CFLAGS} ${LIBCFLAGS}"
|
|
CXXFLAGS="${CXXFLAGS} ${LIBCXXFLAGS}"
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[__attribute__ ((visibility ("default"))) void f(void);
|
|
#include <stdlib.h>]], [[exit(0);]])],[SHAREDLIBEXPORT=yes],[SHAREDLIBEXPORT=no])
|
|
if test "$SHAREDLIBEXPORT" = no; then
|
|
LIBCFLAGS=
|
|
LIBCXXFLAGS=
|
|
else
|
|
U_USE_GCC_VISIBILITY_ATTRIBUTE=1
|
|
fi
|
|
else
|
|
case "${host}" in
|
|
*-*-solaris*)
|
|
LIBCFLAGS="-xldscope=hidden"
|
|
LIBCXXFLAGS="-xldscope=hidden"
|
|
CFLAGS="${CFLAGS} ${LIBCFLAGS}"
|
|
CXXFLAGS="${CXXFLAGS} ${LIBCXXFLAGS}"
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[__global void f(void);
|
|
#include <stdlib.h>]], [[exit(0);]])],[SHAREDLIBEXPORT=yes],[SHAREDLIBEXPORT=no])
|
|
if test "$SHAREDLIBEXPORT" = no; then
|
|
LIBCFLAGS=
|
|
LIBCXXFLAGS=
|
|
fi
|
|
;;
|
|
*-*-hpux*)
|
|
# ICU isn't set up to follow the HP syntax yet.
|
|
;;
|
|
*)
|
|
esac
|
|
fi
|
|
# Restore to their original state because the Intel compiler chokes
|
|
# on this option when checking for the wchar_t size, but the
|
|
# option otherwise works.
|
|
CFLAGS="${OLD_CFLAGS}"
|
|
CXXFLAGS="${OLD_CXXFLAGS}"
|
|
AC_MSG_RESULT($SHAREDLIBEXPORT)
|
|
AC_SUBST(U_USE_GCC_VISIBILITY_ATTRIBUTE)
|
|
AC_SUBST(LIBCFLAGS)
|
|
AC_SUBST(LIBCXXFLAGS)
|
|
|
|
AC_PROG_RANLIB
|
|
|
|
# look for 'ar' the proper way
|
|
#AC_PATH_PROG(AR,ar,[echo archiver ar not found re-run configure ; false],$PATH:/bin:/usr/bin:/usr/ccs/bin)
|
|
AC_CHECK_TOOL(AR, ar)
|
|
if test "x$AR" = "x"; then
|
|
AC_MSG_ERROR(Archiver ar not found. Set AR= or fix PATH)
|
|
fi
|
|
|
|
|
|
AC_MSG_CHECKING([whether to enable renaming of symbols])
|
|
enabled=yes
|
|
U_DISABLE_RENAMING=0
|
|
AC_ARG_ENABLE(renaming,
|
|
[ --enable-renaming add a version suffix to symbols [default=yes]],
|
|
[ case "${enableval}" in
|
|
yes|"") enabled=yes ;;
|
|
no) enabled=no; U_DISABLE_RENAMING=1 ;;
|
|
*) ;;
|
|
esac],
|
|
)
|
|
AC_MSG_RESULT($enabled)
|
|
AC_SUBST(U_DISABLE_RENAMING)
|
|
|
|
AC_MSG_CHECKING([whether to enable function and data tracing])
|
|
enabled=no
|
|
U_ENABLE_TRACING=0
|
|
AC_ARG_ENABLE(tracing,
|
|
[ --enable-tracing enable function and data tracing [default=no]],
|
|
[ case "${enableval}" in
|
|
yes|"") enabled=yes; U_ENABLE_TRACING=1 ;;
|
|
no) enabled=no; U_ENABLE_TRACING=0 ;;
|
|
*) ;;
|
|
esac],
|
|
)
|
|
AC_MSG_RESULT($enabled)
|
|
AC_SUBST(U_ENABLE_TRACING)
|
|
|
|
|
|
U_ENABLE_DYLOAD=1
|
|
AC_MSG_CHECKING([whether to enable dynamic loading of plugins])
|
|
enabled=check
|
|
AC_ARG_ENABLE(dyload,
|
|
[ --disable-dyload disable dynamic loading [default=no]],
|
|
[ case "${enableval}" in
|
|
yes|"")
|
|
U_ENABLE_DYLOAD=1
|
|
enabled=check ;;
|
|
no)
|
|
U_ENABLE_DYLOAD=0;
|
|
enabled=disabled ;;
|
|
*) ;;
|
|
esac],
|
|
)
|
|
AC_SUBST(U_ENABLE_DYLOAD)
|
|
|
|
# goes into icucfg.h
|
|
AC_CHECK_HEADERS([dlfcn.h])
|
|
U_CHECK_DYLOAD=0
|
|
#AC_MSG_RESULT($enabled)
|
|
if test "$enabled" = "check"; then
|
|
AC_SEARCH_LIBS([dlopen], [dl])
|
|
AC_CHECK_FUNCS([dlopen])
|
|
U_CHECK_DYLOAD=1
|
|
fi
|
|
AC_SUBST(U_CHECK_DYLOAD)
|
|
|
|
# Check for miscellanous functions.
|
|
# These only go into common/icucfg.h and are NOT exported with ICU builds.
|
|
# So, use for putil / tools only.
|
|
# Note that this will generate HAVE_GETTIMEOFDAY, not U_HAVE_GETTIMEOFDAY
|
|
# rerun 'autoheader' to regenerate icucfg.h.in
|
|
AC_CHECK_FUNCS([gettimeofday])
|
|
|
|
# Check whether to use the evil rpath or not
|
|
AC_ARG_ENABLE(rpath,
|
|
[ --enable-rpath use rpath when linking [default is only if necessary]],
|
|
[ case "${enableval}" in
|
|
yes|"") ENABLE_RPATH=YES ;;
|
|
no) ;;
|
|
*) ;;
|
|
esac],
|
|
[ENABLE_RPATH=NO]
|
|
)
|
|
AC_SUBST(ENABLE_RPATH)
|
|
|
|
|
|
# set up U_INLINE.
|
|
# Copy the definition of AC_C_INLINE, with slight mods.
|
|
#
|
|
AC_CACHE_CHECK([for definition of U_INLINE for C], ac_cv_c_inline,
|
|
[ac_cv_c_inline=no
|
|
for ac_kw in inline __inline__ __inline; do
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[return 0;} $ac_kw int foo() {]])],[ac_cv_c_inline=$ac_kw; break],[])
|
|
done
|
|
])
|
|
case "$ac_cv_c_inline" in
|
|
yes) U_INLINE= "inline" ;;
|
|
no ) U_INLINE= ;;
|
|
*) U_INLINE=$ac_cv_c_inline ;;
|
|
esac
|
|
AC_SUBST(U_INLINE)
|
|
|
|
# set up U_HAVE_STD_STRING.
|
|
# Copy the definition of AC_C_INLINE, with slight mods.
|
|
#
|
|
U_HAVE_STD_STRING=0
|
|
AC_LANG_PUSH([C++])
|
|
AC_MSG_CHECKING([[if we have a C++ compiler]])
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],[[]])],[cxx_okay=yes],[cxx_okay=no])
|
|
if test $cxx_okay = yes
|
|
then
|
|
AC_MSG_RESULT([[congratulations]])
|
|
else
|
|
AC_MSG_RESULT([[no]])
|
|
AC_MSG_ERROR([[C++ compiler $CXX does not work or no compiler found]])
|
|
fi
|
|
|
|
AC_MSG_CHECKING([[if #include <string> works]])
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <string>]], [[]])], [ac_cv_header_stdstring=yes], [ac_cv_header_stdstring=no])
|
|
AC_MSG_RESULT($ac_cv_header_stdstring)
|
|
if test $ac_cv_header_stdstring = yes
|
|
then
|
|
U_HAVE_STD_STRING=1
|
|
fi
|
|
AC_SUBST(U_HAVE_STD_STRING)
|
|
AC_LANG_POP([C++])
|
|
|
|
threads=true
|
|
|
|
# Enable/disable threads
|
|
AC_ARG_ENABLE(threads,
|
|
[ --enable-threads build ICU with thread safety [default=yes]],
|
|
[case "${enableval}" in
|
|
yes) threads=true ;;
|
|
no) threads=false ;;
|
|
*) AC_MSG_ERROR(bad value ${enableval} for --enable-threads) ;;
|
|
esac],
|
|
threads=true)
|
|
ICU_CONDITIONAL(THREADS, test "$threads" = true)
|
|
|
|
ICU_USE_THREADS=0
|
|
OLD_LIBS=${LIBS}
|
|
|
|
if test $threads = true; then
|
|
# For Compaq Tru64 (OSF1), we must look for pthread_attr_init
|
|
# and must do this before seaching for pthread_mutex_destroy, or
|
|
# we will pick up libpthreads.so not libpthread.so
|
|
# If this fails, then we must test for HPUX specials, before
|
|
# moving on to a more generic test
|
|
|
|
AC_CHECK_LIB(pthread, pthread_attr_init)
|
|
if test $ac_cv_lib_pthread_pthread_attr_init = yes; then
|
|
ICU_USE_THREADS=1
|
|
else
|
|
# Locate the right library for POSIX threads. We look for the
|
|
# symbols in the libraries first, because on Solaris libc provides
|
|
# pthread_create but libpthread has the real code :(
|
|
# AIX uses libpthreads instead of libpthread, and HP/UX uses libpthread
|
|
# FreeBSD users may need libpthread if they do not have libc_r.
|
|
|
|
AC_SEARCH_LIBS_FIRST(pthread_mutex_destroy, pthread pthreads c_r )
|
|
|
|
if test "$ac_cv_search_pthread_mutex_destroy" != no; then
|
|
ICU_USE_THREADS=1
|
|
else
|
|
# For HP 11
|
|
AC_CHECK_LIB(pthread, pthread_mutex_init)
|
|
if test $ac_cv_lib_pthread_pthread_mutex_init = yes; then
|
|
ICU_USE_THREADS=1
|
|
fi
|
|
fi
|
|
|
|
AC_CHECK_FUNC(pthread_mutex_lock)
|
|
|
|
if test $ac_cv_func_pthread_mutex_lock = yes; then
|
|
ICU_USE_THREADS=1
|
|
fi
|
|
fi
|
|
# Check to see if we are using CygWin with MSVC
|
|
case "${host}" in
|
|
*-pc-cygwin*|*-pc-mingw*)
|
|
# For gcc, the thread options are set by mh-mingw/mh-cygwin
|
|
# For msvc, the thread options are set by runConfigureICU
|
|
ICU_USE_THREADS=1
|
|
;;
|
|
*-*-hpux*)
|
|
# Add -mt because it does several nice things on newer compilers.
|
|
case "${icu_cv_host_frag}" in
|
|
mh-hpux-acc)
|
|
OLD_CXXFLAGS="${CXXFLAGS}"
|
|
CXXFLAGS="${CXXFLAGS} -mt"
|
|
if test x"`${CXX} ${CXXFLAGS} 2>&1`" != x""; then
|
|
CXXFLAGS="${OLD_CXXFLAGS}"
|
|
fi
|
|
;;
|
|
esac
|
|
;;
|
|
*-*-solaris*)
|
|
case "${icu_cv_host_frag}" in
|
|
mh-solaris)
|
|
LIBS="${LIBS} -mt"
|
|
;;
|
|
esac
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
AC_SUBST(ICU_USE_THREADS)
|
|
|
|
AC_ARG_ENABLE(weak-threads,
|
|
[ --enable-weak-threads weakly reference the threading library [default=no]],
|
|
[case "${enableval}" in
|
|
yes)
|
|
LIB_THREAD="${LIBS%${OLD_LIBS}}"
|
|
LIBS=${OLD_LIBS}
|
|
;;
|
|
no) ;;
|
|
*) AC_MSG_ERROR(bad value ${enableval} for --enable-weak-threads) ;;
|
|
esac])
|
|
AC_SUBST(LIB_THREAD)
|
|
|
|
# Check for mmap()
|
|
|
|
# The AC_FUNC_MMAP macro doesn't work properly. It seems to be too specific.
|
|
# Do this check instead.
|
|
HAVE_MMAP=0
|
|
AC_MSG_CHECKING([for mmap])
|
|
AC_CACHE_VAL(ac_cv_func_mmap_ok,
|
|
[AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <unistd.h>
|
|
#include <sys/mman.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>], [mmap((void *)0, 0, PROT_READ, 0, 0, 0);])],[ac_cv_func_mmap_ok=yes],[ac_cv_func_mmap_ok=no])] )
|
|
AC_MSG_RESULT($ac_cv_func_mmap_ok)
|
|
if test $ac_cv_func_mmap_ok = yes
|
|
then
|
|
HAVE_MMAP=1
|
|
fi
|
|
AC_SUBST(HAVE_MMAP)
|
|
|
|
AC_MSG_CHECKING([for genccode assembly])
|
|
|
|
# Check to see if genccode can generate simple assembly.
|
|
GENCCODE_ASSEMBLY=
|
|
case "${host}" in
|
|
*-linux*|i*86-*-*bsd*|i*86-pc-gnu)
|
|
if test "$GCC" = yes; then
|
|
# We're using gcc, and the simple -a gcc command line works for genccode
|
|
GENCCODE_ASSEMBLY="-a gcc"
|
|
fi ;;
|
|
i*86-*-solaris*)
|
|
if test "$GCC" = yes; then
|
|
# When using gcc, look if we're also using GNU as.
|
|
# When using GNU as, the simple -a gcc command line works for genccode.
|
|
asv=`"${CC}" -print-prog-name=as 2>/dev/null`
|
|
asv=`"${asv}" --version 2>/dev/null`
|
|
case "X${asv}" in
|
|
X*GNU*) GENCCODE_ASSEMBLY="-a gcc" ;;
|
|
X*) GENCCODE_ASSEMBLY="-a sun-x86" ;;
|
|
esac
|
|
unset asv
|
|
else
|
|
GENCCODE_ASSEMBLY="-a sun-x86"
|
|
fi ;;
|
|
sparc-*-solaris*)
|
|
GENCCODE_ASSEMBLY="-a sun"
|
|
;;
|
|
ia64-*-hpux*)
|
|
GENCCODE_ASSEMBLY="-a aCC-ia64"
|
|
;;
|
|
esac
|
|
AC_SUBST(GENCCODE_ASSEMBLY)
|
|
|
|
AC_MSG_RESULT($GENCCODE_ASSEMBLY)
|
|
|
|
# Checks for header files
|
|
AC_CHECK_HEADERS(inttypes.h)
|
|
if test $ac_cv_header_inttypes_h = no; then
|
|
U_HAVE_INTTYPES_H=0
|
|
else
|
|
U_HAVE_INTTYPES_H=1
|
|
fi
|
|
if test "$CC" = ccc; then
|
|
AC_MSG_RESULT("C compiler set to CCC ${CC}" )
|
|
case "${host}" in
|
|
alpha*-*-*) U_HAVE_INTTYPES_H=0;
|
|
esac
|
|
fi
|
|
|
|
AC_SUBST(U_HAVE_INTTYPES_H)
|
|
|
|
AC_CHECK_HEADERS(dirent.h)
|
|
if test $ac_cv_header_dirent_h = no; then
|
|
U_HAVE_DIRENT_H=0
|
|
else
|
|
U_HAVE_DIRENT_H=1
|
|
fi
|
|
|
|
AC_SUBST(U_HAVE_DIRENT_H)
|
|
|
|
|
|
AC_ARG_WITH(iostream,
|
|
[ --with-iostream=version specify the version of iostream to use (none, old, std, auto) [default=auto]],
|
|
[case "${withval}" in
|
|
none) streams=none ;;
|
|
old) streams=198506 ;;
|
|
std) streams=199711 ;;
|
|
auto) streams= ;;
|
|
*) AC_MSG_ERROR(bad value ${withval} for --with-iostream) ;;
|
|
esac],
|
|
[streams=])
|
|
|
|
U_IOSTREAM_SOURCE=0
|
|
if test x$streams != xnone
|
|
then
|
|
AC_LANG_PUSH(C++)
|
|
OLD_CXXFLAGS="${CXXFLAGS}"
|
|
case "${icu_cv_host_frag}" in
|
|
mh-hpux-acc)
|
|
CXXFLAGS="${CXXFLAGS} -AA"
|
|
;;
|
|
esac
|
|
AC_MSG_CHECKING([for iostream usability])
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <iostream>]], [[]])],[ac_cv_header_iostream=yes],[ac_cv_header_iostream=no])
|
|
if test $icu_cv_host_frag = mh-cygwin-msvc
|
|
then
|
|
# <iostream> is always there on Windows.
|
|
# We do this to prevent the C++ preprocessor from being used because
|
|
# autoconf can't deal with the Windows C++ preprocessor
|
|
ac_cv_header_iostream=yes
|
|
fi
|
|
AC_MSG_RESULT($ac_cv_header_iostream)
|
|
if test $ac_cv_header_iostream = yes
|
|
then
|
|
U_IOSTREAM_SOURCE=199711
|
|
else
|
|
CXXFLAGS="${OLD_CXXFLAGS}"
|
|
AC_MSG_CHECKING([whether ostream in iostream.h is really defined])
|
|
AC_CACHE_VAL(ac_cv_iostream_ok,
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <iostream.h>]], [[ostream &testout = cout; testout << "test" << endl;]])],[ac_cv_iostream_ok=yes],[ac_cv_iostream_ok=no]))
|
|
AC_MSG_RESULT($ac_cv_iostream_ok)
|
|
if test $ac_cv_iostream_ok = yes
|
|
then
|
|
U_IOSTREAM_SOURCE=198506
|
|
fi
|
|
fi
|
|
if test x$streams != x
|
|
then
|
|
if test $U_IOSTREAM_SOURCE -ge $streams
|
|
then
|
|
U_IOSTREAM_SOURCE=$streams
|
|
case "${icu_cv_host_frag}" in
|
|
mh-hpux-acc)
|
|
if test $U_IOSTREAM_SOURCE -lt 199711; then
|
|
CXXFLAGS=${OLD_CXXFLAGS}
|
|
fi
|
|
;;
|
|
esac
|
|
else
|
|
AC_MSG_ERROR(${withval} iostream is not available)
|
|
fi
|
|
fi
|
|
fi
|
|
AC_SUBST(U_IOSTREAM_SOURCE)
|
|
AC_LANG_POP
|
|
|
|
# Check for endianness
|
|
AC_C_BIGENDIAN()
|
|
if test $ac_cv_c_bigendian = no; then
|
|
U_IS_BIG_ENDIAN=0
|
|
U_ENDIAN_CHAR="l"
|
|
else
|
|
U_IS_BIG_ENDIAN=1
|
|
U_ENDIAN_CHAR="b"
|
|
fi
|
|
AC_SUBST(U_IS_BIG_ENDIAN)
|
|
|
|
# Do various POSIX related checks
|
|
U_HAVE_NL_LANGINFO_CODESET=0
|
|
U_NL_LANGINFO_CODESET=-1
|
|
AC_CHECK_FUNC(nl_langinfo,[U_HAVE_NL_LANGINFO=1],[U_HAVE_NL_LANGINFO=0])
|
|
dnl AC_SUBST(U_HAVE_NL_LANGINFO)
|
|
if test $U_HAVE_NL_LANGINFO -eq 1; then
|
|
AC_CACHE_CHECK([for nl_langinfo's argument to obtain the codeset],
|
|
ac_cv_nl_langinfo_codeset,
|
|
[ac_cv_nl_langinfo_codeset="unknown"
|
|
for a in CODESET _NL_CTYPE_CODESET_NAME; do
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <langinfo.h>]], [[nl_langinfo($a);]])],[ac_cv_nl_langinfo_codeset="$a"; break],[])]
|
|
done)
|
|
if test x$ac_cv_nl_langinfo_codeset != xunknown
|
|
then
|
|
U_HAVE_NL_LANGINFO_CODESET=1
|
|
U_NL_LANGINFO_CODESET=$ac_cv_nl_langinfo_codeset
|
|
fi
|
|
fi
|
|
AC_SUBST(U_HAVE_NL_LANGINFO_CODESET)
|
|
AC_SUBST(U_NL_LANGINFO_CODESET)
|
|
|
|
# Namespace support checks
|
|
AC_LANG(C++)
|
|
AC_MSG_CHECKING([for namespace support])
|
|
AC_CACHE_VAL(ac_cv_namespace_ok,
|
|
[AC_LINK_IFELSE([AC_LANG_PROGRAM([namespace x_version {void f(){}}
|
|
namespace x = x_version;
|
|
using namespace x_version;
|
|
], [f();])],[ac_cv_namespace_ok=yes],[ac_cv_namespace_ok=no])] )
|
|
AC_MSG_RESULT($ac_cv_namespace_ok)
|
|
U_HAVE_NAMESPACE=1
|
|
if test $ac_cv_namespace_ok = no
|
|
then
|
|
U_HAVE_NAMESPACE=0
|
|
fi
|
|
AC_SUBST(U_HAVE_NAMESPACE)
|
|
|
|
AC_MSG_CHECKING([for properly overriding new and delete])
|
|
U_OVERRIDE_CXX_ALLOCATION=0
|
|
U_HAVE_PLACEMENT_NEW=0
|
|
AC_CACHE_VAL(ac_cv_override_cxx_allocation_ok,
|
|
[AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <stdlib.h>
|
|
class UMemory {
|
|
public:
|
|
void *operator new(size_t size) {return malloc(size);}
|
|
void *operator new[](size_t size) {return malloc(size);}
|
|
void operator delete(void *p) {free(p);}
|
|
void operator delete[](void *p) {free(p);}
|
|
};
|
|
]], [])],[ac_cv_override_cxx_allocation_ok=yes],[ac_cv_override_cxx_allocation_ok=no])] )
|
|
AC_MSG_RESULT($ac_cv_override_cxx_allocation_ok)
|
|
if test $ac_cv_override_cxx_allocation_ok = yes
|
|
then
|
|
U_OVERRIDE_CXX_ALLOCATION=1
|
|
AC_MSG_CHECKING([for placement new and delete])
|
|
AC_CACHE_VAL(ac_cv_override_placement_new_ok,
|
|
[AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <stdlib.h>
|
|
class UMemory {
|
|
public:
|
|
void *operator new(size_t size) {return malloc(size);}
|
|
void *operator new[](size_t size) {return malloc(size);}
|
|
void operator delete(void *p) {free(p);}
|
|
void operator delete[](void *p) {free(p);}
|
|
void * operator new(size_t, void *ptr) { return ptr; }
|
|
void operator delete(void *, void *) {}
|
|
};
|
|
]], [])],[ac_cv_override_placement_new_ok=yes],[ac_cv_override_placement_new_ok=no])] )
|
|
AC_MSG_RESULT($ac_cv_override_placement_new_ok)
|
|
if test $ac_cv_override_placement_new_ok = yes
|
|
then
|
|
U_HAVE_PLACEMENT_NEW=1
|
|
fi
|
|
fi
|
|
AC_SUBST(U_OVERRIDE_CXX_ALLOCATION)
|
|
AC_SUBST(U_HAVE_PLACEMENT_NEW)
|
|
|
|
# gcc atomic built-in functions check
|
|
# AC_TRY_LINK([], [int foo, bar; bar = __sync_val_compare_and_swap(&foo, 0, 1);],,
|
|
AC_LANG(C)
|
|
AC_MSG_CHECKING([for gcc atomic functions])
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM(
|
|
[[
|
|
void *p;
|
|
int i;
|
|
]],
|
|
[[
|
|
__sync_fetch_and_add(&i, 1);
|
|
__sync_fetch_and_sub(&i, 1);
|
|
__sync_val_compare_and_swap(&p, 0, 0);
|
|
]]
|
|
)],
|
|
[U_HAVE_GCC_ATOMICS=1; AC_MSG_RESULT([yes])],
|
|
[U_HAVE_GCC_ATOMICS=0; AC_MSG_RESULT([no])])
|
|
AC_SUBST(U_HAVE_GCC_ATOMICS)
|
|
|
|
AC_LANG(C)
|
|
AC_CHECK_FUNC(popen)
|
|
if test x$ac_cv_func_popen = xyes
|
|
then
|
|
U_HAVE_POPEN=1
|
|
else
|
|
U_HAVE_POPEN=0
|
|
fi
|
|
AC_SUBST(U_HAVE_POPEN)
|
|
|
|
AC_CHECK_FUNC(tzset)
|
|
U_HAVE_TZSET=0
|
|
if test x$ac_cv_func_tzset = xyes
|
|
then
|
|
U_TZSET=tzset
|
|
U_HAVE_TZSET=1
|
|
else
|
|
AC_CHECK_FUNC(_tzset)
|
|
if test x$ac_cv_func__tzset = xyes
|
|
then
|
|
U_TZSET=_tzset
|
|
U_HAVE_TZSET=1
|
|
fi
|
|
fi
|
|
AC_SUBST(U_HAVE_TZSET)
|
|
AC_SUBST(U_TZSET)
|
|
|
|
U_HAVE_TZNAME=0
|
|
AC_CACHE_CHECK(for tzname,ac_cv_var_tzname,
|
|
[AC_LINK_IFELSE([AC_LANG_PROGRAM([[#ifndef __USE_POSIX
|
|
#define __USE_POSIX
|
|
#endif
|
|
#include <stdlib.h>
|
|
#include <time.h>
|
|
#ifndef tzname /* For SGI. */
|
|
extern char *tzname[]; /* RS6000 and others reject char **tzname. */
|
|
#endif]], [atoi(*tzname);])],[ac_cv_var_tzname=yes],[ac_cv_var_tzname=no])])
|
|
if test $ac_cv_var_tzname = yes; then
|
|
U_TZNAME=tzname
|
|
U_HAVE_TZNAME=1
|
|
else
|
|
AC_CACHE_CHECK(for _tzname,ac_cv_var__tzname,
|
|
[AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <stdlib.h>
|
|
#include <time.h>
|
|
extern char *_tzname[];]], [atoi(*_tzname);])],[ac_cv_var__tzname=yes],[ac_cv_var__tzname=no])])
|
|
if test $ac_cv_var__tzname = yes; then
|
|
U_TZNAME=_tzname
|
|
U_HAVE_TZNAME=1
|
|
fi
|
|
fi
|
|
AC_SUBST(U_HAVE_TZNAME)
|
|
AC_SUBST(U_TZNAME)
|
|
|
|
AC_CACHE_CHECK(for timezone,ac_cv_var_timezone,
|
|
[AC_LINK_IFELSE([AC_LANG_PROGRAM([#ifndef __USE_POSIX
|
|
#define __USE_POSIX
|
|
#endif
|
|
#ifndef __USE_XOPEN
|
|
#define __USE_XOPEN
|
|
#endif
|
|
#include <time.h>
|
|
], [[timezone = 1;]])],[ac_cv_var_timezone=yes],[ac_cv_var_timezone=no])])
|
|
U_HAVE_TIMEZONE=0
|
|
if test $ac_cv_var_timezone = yes; then
|
|
U_TIMEZONE=timezone
|
|
U_HAVE_TIMEZONE=1
|
|
else
|
|
AC_CACHE_CHECK(for __timezone,ac_cv_var___timezone,
|
|
[AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <time.h>]], [[__timezone = 1;]])],[ac_cv_var___timezone=yes],[ac_cv_var___timezone=no])])
|
|
if test $ac_cv_var___timezone = yes; then
|
|
U_TIMEZONE=__timezone
|
|
U_HAVE_TIMEZONE=1
|
|
else
|
|
AC_CACHE_CHECK(for _timezone,ac_cv_var__timezone,
|
|
[AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <time.h>]], [[_timezone = 1;]])],[ac_cv_var__timezone=yes],[ac_cv_var__timezone=no])])
|
|
if test $ac_cv_var__timezone = yes; then
|
|
U_TIMEZONE=_timezone
|
|
U_HAVE_TIMEZONE=1
|
|
fi
|
|
fi
|
|
fi
|
|
AC_SUBST(U_HAVE_TIMEZONE)
|
|
AC_SUBST(U_TIMEZONE)
|
|
|
|
# Checks for typedefs
|
|
AC_CHECK_TYPE(int8_t,signed char)
|
|
AC_CHECK_TYPE(uint8_t,unsigned char)
|
|
AC_CHECK_TYPE(int16_t,signed short)
|
|
AC_CHECK_TYPE(uint16_t,unsigned short)
|
|
AC_CHECK_TYPE(int32_t,signed long)
|
|
AC_CHECK_TYPE(uint32_t,unsigned long)
|
|
AC_CHECK_TYPE(int64_t,signed long long)
|
|
AC_CHECK_TYPE(uint64_t,unsigned long long)
|
|
|
|
if test $ac_cv_type_int8_t = no; then
|
|
HAVE_INT8_T=0
|
|
else
|
|
HAVE_INT8_T=1
|
|
fi
|
|
AC_SUBST(HAVE_INT8_T)
|
|
|
|
if test $ac_cv_type_uint8_t = no; then
|
|
HAVE_UINT8_T=0
|
|
else
|
|
HAVE_UINT8_T=1
|
|
fi
|
|
AC_SUBST(HAVE_UINT8_T)
|
|
|
|
if test $ac_cv_type_int16_t = no; then
|
|
HAVE_INT16_T=0
|
|
else
|
|
HAVE_INT16_T=1
|
|
fi
|
|
AC_SUBST(HAVE_INT16_T)
|
|
|
|
if test $ac_cv_type_uint16_t = no; then
|
|
HAVE_UINT16_T=0
|
|
else
|
|
HAVE_UINT16_T=1
|
|
fi
|
|
AC_SUBST(HAVE_UINT16_T)
|
|
|
|
if test $ac_cv_type_int32_t = no; then
|
|
HAVE_INT32_T=0
|
|
else
|
|
HAVE_INT32_T=1
|
|
fi
|
|
AC_SUBST(HAVE_INT32_T)
|
|
|
|
if test $ac_cv_type_uint32_t = no; then
|
|
HAVE_UINT32_T=0
|
|
else
|
|
HAVE_UINT32_T=1
|
|
fi
|
|
AC_SUBST(HAVE_UINT32_T)
|
|
|
|
if test $ac_cv_type_int64_t = no; then
|
|
HAVE_INT64_T=0
|
|
else
|
|
HAVE_INT64_T=1
|
|
fi
|
|
AC_SUBST(HAVE_INT64_T)
|
|
|
|
if test $ac_cv_type_uint64_t = no; then
|
|
HAVE_UINT64_T=0
|
|
else
|
|
HAVE_UINT64_T=1
|
|
fi
|
|
AC_SUBST(HAVE_UINT64_T)
|
|
|
|
# Do various wchar_t related checks
|
|
AC_CHECK_HEADER(wchar.h)
|
|
if test "$ac_cv_header_wchar_h" = no
|
|
then
|
|
U_HAVE_WCHAR_H=0
|
|
U_HAVE_WCSCPY=0
|
|
else
|
|
AC_DEFINE([HAVE_WCHAR_H], [1], [wchar.h was found.])
|
|
U_HAVE_WCHAR_H=1
|
|
# Some broken systems have wchar.h but not some of its functions...
|
|
AC_SEARCH_LIBS(wcscpy, wcs w)
|
|
if test "$ac_cv_search_wcscpy" != no; then
|
|
U_HAVE_WCSCPY=1
|
|
else
|
|
U_HAVE_WCSCPY=0
|
|
fi
|
|
fi
|
|
AC_SUBST(U_HAVE_WCHAR_H)
|
|
AC_SUBST(U_HAVE_WCSCPY)
|
|
|
|
AC_CHECK_SIZEOF([wchar_t], 0, [
|
|
#if STDC_HEADERS
|
|
#include <stddef.h>
|
|
#endif
|
|
#include <stdlib.h>
|
|
#if HAVE_WCHAR_H
|
|
#include <string.h>
|
|
#include <wchar.h>
|
|
#endif])
|
|
U_SIZEOF_WCHAR_T=$ac_cv_sizeof_wchar_t
|
|
# We do this check to verify that everything is okay.
|
|
if test $U_SIZEOF_WCHAR_T = 0; then
|
|
if test $U_HAVE_WCHAR_H=1; then
|
|
AC_MSG_ERROR(There is wchar.h but the size of wchar_t is 0)
|
|
fi
|
|
fi
|
|
AC_SUBST(U_SIZEOF_WCHAR_T)
|
|
|
|
AC_MSG_CHECKING([for UTF-16 string literal support])
|
|
U_CHECK_UTF16_STRING=1
|
|
CHECK_UTF16_STRING_RESULT="unknown"
|
|
|
|
case "${host}" in
|
|
*-*-aix*|powerpc64-*-linux*)
|
|
if test "$ac_cv_c_compiler_gnu" = no; then
|
|
OLD_CFLAGS="${CFLAGS}"
|
|
OLD_CXXFLAGS="${CXXFLAGS}"
|
|
CFLAGS="${CFLAGS} -qutf"
|
|
CXXFLAGS="${CXXFLAGS} -qutf"
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[const unsigned short hello[] = u"hello";]], [[]])],[U_CHECK_UTF16_STRING=1],[U_CHECK_UTF16_STRING=0])
|
|
if test "$U_CHECK_UTF16_STRING" = 0; then
|
|
CFLAGS="${OLD_CFLAGS}"
|
|
CXXFLAGS="${OLD_CXXFLAGS}"
|
|
else
|
|
CHECK_UTF16_STRING_RESULT="-qutf"
|
|
fi
|
|
fi
|
|
;;
|
|
*-*-solaris*)
|
|
if test "$ac_cv_c_compiler_gnu" = no; then
|
|
OLD_CFLAGS="${CFLAGS}"
|
|
OLD_CXXFLAGS="${CXXFLAGS}"
|
|
CFLAGS="${CFLAGS} -xustr=ascii_utf16_ushort"
|
|
CXXFLAGS="${CXXFLAGS} -xustr=ascii_utf16_ushort"
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[const unsigned short hello[] = U"hello";]], [[]])],[U_CHECK_UTF16_STRING=1],[U_CHECK_UTF16_STRING=0])
|
|
if test "$U_CHECK_UTF16_STRING" = 0; then
|
|
CFLAGS="${OLD_CFLAGS}"
|
|
CXXFLAGS="${OLD_CXXFLAGS}"
|
|
else
|
|
CHECK_UTF16_STRING_RESULT="-xustr=ascii_utf16_ushort"
|
|
|
|
# Since we can't detect the availability of this UTF-16 syntax at compile time,
|
|
# we depend on configure telling us that we can use it.
|
|
# Since we can't ensure ICU users use -xustr=ascii_utf16_ushort,
|
|
# we only use this macro within ICU.
|
|
# If an ICU user uses icu-config, this feature will be enabled.
|
|
CPPFLAGS="${CPPFLAGS} -DU_CHECK_UTF16_STRING=1"
|
|
U_CHECK_UTF16_STRING=0
|
|
fi
|
|
fi
|
|
;;
|
|
*-*-hpux*)
|
|
if test "$ac_cv_c_compiler_gnu" = no; then
|
|
# The option will be detected at compile time without additional compiler options.
|
|
CHECK_UTF16_STRING_RESULT="available"
|
|
fi
|
|
;;
|
|
*-*-cygwin)
|
|
# wchar_t can be used
|
|
CHECK_UTF16_STRING_RESULT="available"
|
|
;;
|
|
*)
|
|
;;
|
|
esac
|
|
|
|
# GCC >= 4.4 supports UTF16 string literals. The CFLAGS and CXXFLAGS may change in the future.
|
|
# Since we have to use a different standard, if strict is enable, don't enable UTF16 string literals.
|
|
U_CHECK_GNUC_UTF16_STRING=0
|
|
if test "$ac_use_strict_options" = no && test "$CHECK_UTF16_STRING_RESULT" = "unknown"; then
|
|
if test "$ac_cv_c_compiler_gnu" = yes; then
|
|
OLD_CFLAGS="${CFLAGS}"
|
|
OLD_CXXFLAGS="${CXXFLAGS}"
|
|
CFLAGS="${CFLAGS} -std=gnu99 -D_GCC_"
|
|
CXXFLAGS="${CXXFLAGS} -std=c++0x"
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)
|
|
#ifdef _GCC_
|
|
typedef __CHAR16_TYPE__ char16_t;
|
|
#endif
|
|
char16_t test[] = u"This is a UTF16 literal string.";
|
|
#else
|
|
GCC IS TOO OLD!
|
|
#endif
|
|
]], [[]])],[U_CHECK_UTF16_STRING=1],[U_CHECK_UTF16_STRING=0])
|
|
if test "$U_CHECK_UTF16_STRING" = 1; then
|
|
CHECK_UTF16_STRING_RESULT="available";
|
|
U_CHECK_GNUC_UTF16_STRING=1
|
|
else
|
|
CFLAGS="${OLD_CFLAGS}"
|
|
CXXFLAGS="${OLD_CXXFLAGS}"
|
|
fi
|
|
fi
|
|
fi
|
|
AC_SUBST(U_CHECK_GNUC_UTF16_STRING)
|
|
|
|
AC_MSG_RESULT($CHECK_UTF16_STRING_RESULT)
|
|
AC_SUBST(U_CHECK_UTF16_STRING)
|
|
|
|
# Enable/disable extras
|
|
AC_ARG_ENABLE(extras,
|
|
[ --enable-extras build ICU extras [default=yes]],
|
|
[case "${enableval}" in
|
|
yes) extras=true ;;
|
|
no) extras=false ;;
|
|
*) AC_MSG_ERROR(bad value ${enableval} for --enable-extras) ;;
|
|
esac],
|
|
extras=true)
|
|
ICU_CONDITIONAL(EXTRAS, test "$extras" = true)
|
|
AC_ARG_ENABLE(icuio,
|
|
[ --enable-icuio build ICU's icuio library [default=yes]],
|
|
[case "${enableval}" in
|
|
yes) icuio=true ;;
|
|
no) icuio=false ;;
|
|
*) AC_MSG_ERROR(bad value ${enableval} for --enable-icuio) ;;
|
|
esac],
|
|
icuio=true)
|
|
ICU_CONDITIONAL(ICUIO, test "$icuio" = true)
|
|
|
|
# Enable/disable layout
|
|
AC_ARG_ENABLE(layout,
|
|
[ --enable-layout build ICU's layout library [default=yes]],
|
|
[case "${enableval}" in
|
|
yes) layout=true ;;
|
|
no) layout=false ;;
|
|
*) AC_MSG_ERROR(bad value ${enableval} for --enable-layout) ;;
|
|
esac],
|
|
layout=true)
|
|
ICU_CONDITIONAL(LAYOUT, test "$layout" = true)
|
|
|
|
AC_ARG_WITH(data-packaging,
|
|
[ --with-data-packaging=type specify how to package ICU data (files, archive, library, static, auto) [default=auto]],
|
|
[case "${withval}" in
|
|
files|archive|library) datapackaging=$withval ;;
|
|
auto) datapackaging=$withval ;;
|
|
common) datapackaging=archive ;;
|
|
dll) datapackaging=library ;;
|
|
static) datapackaging=static ;;
|
|
*) AC_MSG_ERROR(bad value ${withval} for --with-data-packaging) ;;
|
|
esac],
|
|
[datapackaging=])
|
|
|
|
# Note: 'thesysconfdir' is an evaluated version, for Man pages, so also for thedatadir, thelibdir, etc..
|
|
# thesysconfdir=`eval echo $sysconfdir`
|
|
dnl# AC_SUBST(thesysconfdir)
|
|
dnl# thelibdir=`test "x$exec_prefix" = xNONE && exec_prefix="$prefix"; eval echo $libdir`
|
|
dnl# AC_SUBST(thelibdir)
|
|
thedatadir=`eval echo $datadir`
|
|
dnl# AC_SUBST(thedatadir)
|
|
# Always put raw data files in share/icu/{version}, etc. Never use lib/icu/{version} for data files.. Actual shared libraries will go in {libdir}.
|
|
pkgicudatadir=$datadir
|
|
thepkgicudatadir=$thedatadir
|
|
AC_SUBST(pkgicudatadir)
|
|
AC_SUBST(thepkgicudatadir)
|
|
|
|
dnl# Shouldn't need the AC_SUBST
|
|
|
|
if test x"$datapackaging" = x -o x"$datapackaging" = xauto; then
|
|
# default to library
|
|
datapackaging=library
|
|
if test "$ENABLE_STATIC" = "YES"; then
|
|
if test "$ENABLE_SHARED" != "YES"; then
|
|
datapackaging=static
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
datapackaging_dir=`eval echo $thedatadir`"/icu/${VERSION}"
|
|
|
|
datapackaging_msg="(No explaination for mode $datapackaging.)"
|
|
|
|
datapackaging_msg_path="ICU will look in $datapackaging_dir which is the installation location. Call u_setDataDirectory() or use the ICU_DATA environment variable to override."
|
|
datapackaging_msg_set="ICU will use the linked data library. If linked with the stub library located in stubdata/, the application can use udata_setCommonData() or set a data path to override."
|
|
datapackaging_howfound="(unknown)"
|
|
|
|
case "$datapackaging" in
|
|
files)
|
|
DATA_PACKAGING_MODE=files
|
|
datapackaging_msg="ICU data will be stored in individual files."
|
|
datapackaging_howfound="$datapackaging_msg_path"
|
|
;;
|
|
archive)
|
|
DATA_PACKAGING_MODE=common
|
|
datapackaging_msg="ICU data will be stored in a single .dat file."
|
|
datapackaging_howfound="$datapackaging_msg_path"
|
|
;;
|
|
library)
|
|
DATA_PACKAGING_MODE=dll
|
|
datapackaging_msg="ICU data will be linked with ICU."
|
|
if test "$ENABLE_STATIC" = "YES"; then
|
|
datapackaging_msg="$datapackaging_msg A static data library will be built. "
|
|
fi
|
|
if test "$ENABLE_SHARED" = "YES"; then
|
|
datapackaging_msg="$datapackaging_msg A shared data library will be built. "
|
|
fi
|
|
datapackaging_howfound="$datapackaging_msg_set"
|
|
;;
|
|
static)
|
|
DATA_PACKAGING_MODE=static
|
|
datapackaging_msg="ICU data will be stored in a static library."
|
|
datapackaging_howfound="$datapackaging_msg_set"
|
|
;;
|
|
esac
|
|
AC_SUBST(DATA_PACKAGING_MODE)
|
|
|
|
# Sets a library suffix
|
|
AC_MSG_CHECKING([for a library suffix to use])
|
|
AC_ARG_WITH(library-suffix,
|
|
[ --with-library-suffix=suffix tag a suffix to the library names [default=]],
|
|
[ICULIBSUFFIX="${withval}"],
|
|
[ICULIBSUFFIX=])
|
|
msg=$ICULIBSUFFIX
|
|
if test "$msg" = ""; then
|
|
msg=none
|
|
fi
|
|
AC_MSG_RESULT($msg)
|
|
AC_SUBST(ICULIBSUFFIX)
|
|
if test "$ICULIBSUFFIX" != ""
|
|
then
|
|
U_HAVE_LIB_SUFFIX=1
|
|
ICULIBSUFFIXCNAME=`echo _$ICULIBSUFFIX | sed 's/[^A-Za-z0-9_]/_/g'`
|
|
else
|
|
U_HAVE_LIB_SUFFIX=0
|
|
fi
|
|
AC_SUBST(U_HAVE_LIB_SUFFIX)
|
|
AC_SUBST(ICULIBSUFFIXCNAME)
|
|
|
|
# Enable/disable tests
|
|
AC_ARG_ENABLE(tests,
|
|
[ --enable-tests build ICU tests [default=yes]],
|
|
[case "${enableval}" in
|
|
yes) tests=true ;;
|
|
no) tests=false ;;
|
|
*) AC_MSG_ERROR(bad value ${enableval} for --enable-tests) ;;
|
|
esac],
|
|
tests=true)
|
|
ICU_CONDITIONAL(TESTS, test "$tests" = true)
|
|
|
|
# Enable/disable samples
|
|
AC_ARG_ENABLE(samples,
|
|
[ --enable-samples build ICU samples [default=yes]
|
|
|
|
Additionally, the variable FORCE_LIBS may be set before calling configure.
|
|
If set, it will REPLACE any automatic list of libraries.],
|
|
[case "${enableval}" in
|
|
yes) samples=true ;;
|
|
no) samples=false ;;
|
|
*) AC_MSG_ERROR(bad value ${enableval} for --enable-samples) ;;
|
|
esac],
|
|
samples=true)
|
|
ICU_CONDITIONAL(SAMPLES, test "$samples" = true)
|
|
|
|
ICUDATA_CHAR=$U_ENDIAN_CHAR
|
|
|
|
# Platform-specific Makefile setup
|
|
# set ICUDATA_CHAR to 'e' for any EBCDIC (which should be big endian) platform.
|
|
case "${host}" in
|
|
*-*-solaris*) platform=U_SOLARIS ;;
|
|
*-*-linux*|*-*-gnu|*-*-k*bsd*-gnu|*-*-kopensolaris*-gnu) platform=U_LINUX ;;
|
|
*-*-*bsd*|*-*-dragonfly*) platform=U_BSD ;;
|
|
*-*-aix*) platform=U_AIX ;;
|
|
*-*-hpux*) platform=U_HPUX ;;
|
|
*-apple-darwin*|*-apple-rhapsody*) platform=U_DARWIN ;;
|
|
*-*-cygwin*|*-*-mingw*) platform=U_CYGWIN ;;
|
|
*-*ibm-openedition*|*-*-os390*) platform=OS390
|
|
if test "${ICU_ENABLE_ASCII_STRINGS}" != "1"; then
|
|
ICUDATA_CHAR="e"
|
|
fi ;;
|
|
*-*-os400*) platform=OS400
|
|
if test "${ICU_ENABLE_ASCII_STRINGS}" != "1"; then
|
|
ICUDATA_CHAR="e"
|
|
fi ;;
|
|
*-*-nto*) platform=U_QNX ;;
|
|
*-dec-osf*) platform=U_OSF ;;
|
|
*-*-beos) platform=U_BEOS ;;
|
|
*-*-irix*) platform=U_IRIX ;;
|
|
*-ncr-*) platform=U_MPRAS ;;
|
|
*) platform=U_UNKNOWN_PLATFORM ;;
|
|
esac
|
|
AC_SUBST(ICUDATA_CHAR)
|
|
AC_SUBST(platform)
|
|
platform_make_fragment_name="$icu_cv_host_frag"
|
|
platform_make_fragment='$(top_srcdir)/config/'"$platform_make_fragment_name"
|
|
AC_SUBST(platform_make_fragment_name)
|
|
AC_SUBST(platform_make_fragment)
|
|
|
|
if test "${FORCE_LIBS}" != ""; then
|
|
echo " *** Overriding automatically chosen [LIBS=$LIBS], using instead [FORCE_LIBS=${FORCE_LIBS}]" 1>&6
|
|
LIBS=${FORCE_LIBS}
|
|
fi
|
|
|
|
|
|
# Now that we're done using CPPFLAGS etc. for tests, we can change it
|
|
# for build.
|
|
|
|
if test $ICU_USE_THREADS -ne 0
|
|
then
|
|
CPPFLAGS="$CPPFLAGS \$(THREADSCPPFLAGS)"
|
|
CFLAGS="$CFLAGS \$(THREADSCFLAGS)"
|
|
CXXFLAGS="$CXXFLAGS \$(THREADSCXXFLAGS)"
|
|
fi
|
|
|
|
# output the Makefiles
|
|
AC_CONFIG_FILES([icudefs.mk \
|
|
Makefile \
|
|
data/pkgdataMakefile \
|
|
config/Makefile.inc \
|
|
config/icu.pc \
|
|
config/pkgdataMakefile \
|
|
data/Makefile \
|
|
stubdata/Makefile \
|
|
common/Makefile \
|
|
i18n/Makefile \
|
|
layout/Makefile \
|
|
layoutex/Makefile \
|
|
io/Makefile \
|
|
extra/Makefile \
|
|
extra/uconv/Makefile \
|
|
extra/uconv/pkgdataMakefile \
|
|
extra/scrptrun/Makefile \
|
|
tools/Makefile \
|
|
tools/ctestfw/Makefile \
|
|
tools/toolutil/Makefile \
|
|
tools/makeconv/Makefile \
|
|
tools/genrb/Makefile \
|
|
tools/genccode/Makefile \
|
|
tools/gencmn/Makefile \
|
|
tools/gencnval/Makefile \
|
|
tools/genctd/Makefile \
|
|
tools/gentest/Makefile \
|
|
tools/gennorm2/Makefile \
|
|
tools/genbrk/Makefile \
|
|
tools/gensprep/Makefile \
|
|
tools/icuinfo/Makefile \
|
|
tools/icupkg/Makefile \
|
|
tools/icuswap/Makefile \
|
|
tools/pkgdata/Makefile \
|
|
tools/tzcode/Makefile \
|
|
tools/gencfu/Makefile \
|
|
test/Makefile \
|
|
test/compat/Makefile \
|
|
test/testdata/Makefile \
|
|
test/testdata/pkgdataMakefile \
|
|
test/hdrtst/Makefile \
|
|
test/intltest/Makefile \
|
|
test/cintltst/Makefile \
|
|
test/iotest/Makefile \
|
|
test/letest/Makefile \
|
|
test/perf/Makefile \
|
|
test/perf/collationperf/Makefile \
|
|
test/perf/ubrkperf/Makefile \
|
|
test/perf/charperf/Makefile \
|
|
test/perf/convperf/Makefile \
|
|
test/perf/normperf/Makefile \
|
|
test/perf/DateFmtPerf/Makefile \
|
|
test/perf/strsrchperf/Makefile \
|
|
test/perf/unisetperf/Makefile \
|
|
test/perf/usetperf/Makefile \
|
|
test/perf/ustrperf/Makefile \
|
|
test/perf/utfperf/Makefile \
|
|
test/perf/utrie2perf/Makefile \
|
|
samples/Makefile samples/date/Makefile \
|
|
samples/cal/Makefile samples/layout/Makefile \
|
|
common/unicode/platform.h])
|
|
AC_OUTPUT
|
|
|
|
echo
|
|
echo "ICU for C/C++ $VERSION is ready to be built."
|
|
echo "=== Important Notes: ==="
|
|
|
|
if test $ICU_USE_THREADS = 0; then
|
|
echo
|
|
echo "** ICU was configured without mutex or thread support. Multithread-safe operation will not be tested. If this is unexpected, then run configure with --enable-threads=yes or check the messages [above] to see why thread support was not found." 1>&6
|
|
echo
|
|
fi
|
|
|
|
echo "Data Packaging: $datapackaging"
|
|
echo " This means: $datapackaging_msg"
|
|
echo " To locate data: $datapackaging_howfound"
|
|
|
|
if test -n "`$U_MAKE -v 2>&1 | grep '^GNU Make'`"; then
|
|
echo "Building ICU: Use a GNU make such as $U_MAKE to build ICU."
|
|
else
|
|
echo "** WARNING: $U_MAKE may not be GNU make."
|
|
echo "This may cause ICU to fail to build. Please make sure that GNU make"
|
|
echo "is in your PATH so that the configure script can detect its location."
|
|
fi
|
|
|
|
AC_MSG_CHECKING([the version of "$U_MAKE"])
|
|
if "$U_MAKE" -f "$srcdir/config/gmakever.mk" PLATFORM="$platform"; then
|
|
AC_MSG_RESULT([ok])
|
|
else
|
|
AC_MSG_RESULT([too old or test failed - try upgrading GNU Make])
|
|
fi
|
|
|
|
$as_unset _CXX_CXXSUFFIX
|