# -*-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 ]], [[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 ]], [[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 works]]) AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include ]], [[]])], [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 #include #include #include ], [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 ]], [[]])],[ac_cv_header_iostream=yes],[ac_cv_header_iostream=no]) if test $icu_cv_host_frag = mh-cygwin-msvc then # 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 ]], [[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 ]], [[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 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 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 #include #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 #include 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 ], [[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 ]], [[__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 ]], [[_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 #endif #include #if HAVE_WCHAR_H #include #include #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