The Tor Browser: intl/icu/source/configure.ac@b8a032363ba2 (annotated)

intl/icu/source/configure.ac@b8a032363ba2 (annotated)

intl/icu/source/configure.ac

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 # -*-autoconf-*-
 AC_COPYRIGHT([ Copyright (c) 1999-2013, 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.68)
 # Process this file with autoconf to produce a configure script
 AC_INIT([ICU])
 #TODO: IcuBug:8502
 #AC_INIT([ICU],
 #        m4_esyscmd_s([sed -n 's/^[ 	]*#[ 	]*define[ 	]*U_ICU_VERSION[ 	]*"\([^"]*\)".*/\1/p' "./common/unicode/uvernum.h]"),
 #        [http://icu-project.org/bugs],
 #        [International Components for Unicode],
 #        [http://icu-project.org])
 AC_CONFIG_SRCDIR([common/unicode/utypes.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
    as_fn_error $? "Cannot determine ICU version number from uvernum.h header file" "$LINENO" 5
 fi
 #TODO: IcuBug:8502
 #if test "$VERSION" != "$PACKAGE_VERSION"; then
 #   AC_MSG_ERROR([configure was generated for $PACKAGE_VERSION but uvernum.h has $VERSION - please rerun autoconf])
 #fi
 UNICODE_VERSION=`getuversion $srcdir/common/unicode/uchar.h`
 if test x"$UNICODE_VERSION" = x; then
     AC_MSG_ERROR([Cannot determine Unicode version number from uchar.h header file])
 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=$VERSION
 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_HOST
 AC_SUBST(CPPFLAGS)
 # This variable is needed on z/OS because the C++ compiler only recognizes .C
 _CXX_CXXSUFFIX=cpp
 export _CXX_CXXSUFFIX
 # Accumulate #defines
 # CONFIG_CPPFLAGS: These are defines that are set for ICU Build time only.
 # They are only needed for building ICU itself. Example: platform stuff
 CONFIG_CPPFLAGS=""
 # UCONFIG_CPPFLAGS: These are defines which are set for ICU build time,
 # and also a notice is output that they need to be set
 # for end-users of ICU also. uconfig.h.prepend is generated
 # with, for example, "#define U_DISABLE_RENAMING 1"
 # Example: ICU configuration stuff
 UCONFIG_CPPFLAGS=""
 # UCONFIG_CFLAGS: contains a copy of anything that needs to be set by end users
 # such as -std
 UCONFIG_CFLAGS=""
 # 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 and enable the U_DEBUG define [default=no]],
     [ case "${enableval}" in
          yes|"") enabled=yes; ENABLE_DEBUG=1; CONFIG_CPPFLAGS="$CONFIG_CPPFLAGS -DU_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 compilers
 AC_PROG_CC([clang gcc cc c99 c89 xlc_r xlc cl.exe icc])
 # Make sure that we try clang++ first, which provides C++11 support.
 # The g++ compiler is less likely to support C++11.
 AC_PROG_CXX([clang++ g++ c++ gpp xlC_r xlC aCC CC cxx cc++ cl.exe icc FCC KCC RCC])
 # 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)
 # When building release static library, there might be some optimization flags we can use
 if test "$ENABLE_STATIC" = "YES"; then
     if test "$ENABLE_SHARED" != "YES"; then
         if test "$ENABLE_RELEASE" = 1; then
             AC_MSG_CHECKING([whether we can use static library optimization option])
             CHECK_STATIC_OPT_FLAG=no
             OLD_CPPFLAGS="${CPPFLAGS}"
             OLD_LDFLAGS="${LDFLAGS}"
             case "${host}" in
             *-linux*|i*86-*-*bsd*|i*86-pc-gnu)
                 if test "$GCC" = yes; then
                     CPPFLAGS="${CPPFLAGS} -ffunction-sections -fdata-sections"
                     LDFLAGS="${LDFLAGS} -Wl,--gc-sections"
                 fi
                 ;;
             *)
                 ;;
             esac
             AC_LINK_IFELSE([AC_LANG_PROGRAM([], [])], [CHECK_STATIC_OPT_FLAG=yes], [CHECK_STATIC_OPT_FLAG=no])
             AC_MSG_RESULT($CHECK_STATIC_OPT_FLAG)
             if test "$CHECK_STATIC_OPT_FLAG" = no; then
                 CPPFLAGS="${OLD_CPPFLAGS}"
                 LDFLAGS="${OLD_LDFLAGS}"
             fi
         fi
     fi
 fi
 # 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;
          CONFIG_CPPFLAGS="$CONFIG_CPPFLAGS -DUCLN_NO_AUTO_CLEANUP=0";
          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 -o $icu_cv_host_frag = mh-msys-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;
          CONFIG_CPPFLAGS="$CONFIG_CPPFLAGS -DU_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
     CONFIG_CPPFLAGS="$CONFIG_CPPFLAGS -DU_SHOW_DRAFT_API"
 fi
 AC_SUBST(U_DEFAULT_SHOW_DRAFT)
 AC_PROG_RANLIB
 # look for 'ar' the proper way
 AC_CHECK_TOOL(AR, ar, false)
 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;
              UCONFIG_CPPFLAGS="${UCONFIG_CPPFLAGS} -DU_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;
                      CONFIG_CPPFLAGS="$CONFIG_CPPFLAGS -DU_ENABLE_TRACING=1";
                      U_ENABLE_TRACING=1 ;;
 	     no) enabled=no; U_ENABLE_TRACING=0 ;;
 	     *) ;;
     esac],
 )
 AC_MSG_RESULT($enabled)
 AC_SUBST(U_ENABLE_TRACING)
 # check if elf.h is present.
 AC_CHECK_HEADERS([elf.h])
 if test "x$ac_cv_header_elf_h" = "xyes"; then
     CONFIG_CPPFLAGS="$CONFIG_CPPFLAGS -DU_HAVE_ELF_H=1";
 fi
 U_ENABLE_DYLOAD=1
 enable=yes
 AC_MSG_CHECKING([whether to enable dynamic loading of plugins])
 AC_ARG_ENABLE(dyload,
     [  --disable-dyload        disable dynamic loading [default=no]],
     [ case "${enableval}" in
 	     yes|"")
 		     U_ENABLE_DYLOAD=1
                      enable=yes
                      ;;
 	     no)
 	     	 U_ENABLE_DYLOAD=0;
                  enable=no;
                  CONFIG_CPPFLAGS="$CONFIG_CPPFLAGS -DU_ENABLE_DYLOAD=0";
                  ;;
 	     *) ;;
     esac],
 )
 AC_MSG_RESULT($enable)
 AC_SUBST(U_ENABLE_DYLOAD)
 if test "$enable" = "yes"; then
    AC_CHECK_HEADERS([dlfcn.h])
    #AC_MSG_RESULT($enabled)
    AC_SEARCH_LIBS([dlopen], [dl])
    AC_CHECK_FUNCS([dlopen])
    if test "x$ac_cv_func_dlopen" != xyes; then
       CONFIG_CPPFLAGS="$CONFIG_CPPFLAGS -DHAVE_DLOPEN=0"
    fi
 fi
 # Check for miscellanous functions.
 # So, use for putil / tools only.
 # Note that this will generate HAVE_GETTIMEOFDAY, not U_HAVE_GETTIMEOFDAY
 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)
 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([[Good]])
 else
 	AC_MSG_RESULT([[no]])
 	AC_MSG_ERROR([[C++ compiler $CXX does not work or no compiler found]])
 fi
 if [[ "$GXX" = yes ]]; then
     # if CXXFLAGS does not have a "-std=" setting, set it now to -std=c++0x,
     # and check that the compiler still works.
     if ! echo "$CXXFLAGS" | grep '\-std=' >/dev/null 2>&1; then
         OLD_CXXFLAGS="${CXXFLAGS}"
         CXXFLAGS="$CXXFLAGS --std=c++0x"
         AC_MSG_CHECKING([[if we have a C++11 compiler]])
         AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],[[]])],[cxx11_okay=yes],[cxx11_okay=no])
         AC_MSG_RESULT($cxx11_okay)
         if [[ $cxx11_okay = yes ]]; then
             AC_MSG_NOTICE([Adding CXXFLAGS option --std=c++0x])
             UCONFIG_CXXFLAGS="${UCONFIG_CXXFLAGS} --std=c++0x"
         else
             CXXFLAGS="$OLD_CXXFLAGS"
         fi
     fi
 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
 else
         U_HAVE_STD_STRING=0
         CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_STD_STRING=0"
 fi
 AC_SUBST(U_HAVE_STD_STRING)
 AC_MSG_CHECKING([[if #include <atomic> works]])
 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <atomic>]], [[]])], [ac_cv_header_atomic=yes], [ac_cv_header_atomic=no])
 AC_MSG_RESULT($ac_cv_header_atomic)
 if test $ac_cv_header_atomic = yes
 then
 	U_HAVE_ATOMIC=1
 else
         U_HAVE_ATOMIC=0
 fi
 # Make this available via CPPFLAGS
 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_ATOMIC=${U_HAVE_ATOMIC}"
 AC_SUBST(U_HAVE_ATOMIC)
 AC_LANG_POP([C++])
 # Always build ICU with multi-threading support.
 threads=true
 ICU_USE_THREADS=1
 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}"
         else
            UCONFIG_CXXFLAGS="${UCONFIG_CXXFLAGS} -mt"
         fi
       ;;
     esac
     ;;
   *-*-solaris*)
     case "${icu_cv_host_frag}" in
       mh-solaris)
            LIBS="${LIBS} -mt"
       ;;
     esac
     ;;
   esac
 fi
 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
 else
     CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_MMAP=0"
 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*|*-kfreebsd*-gnu*|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
  CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_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;
         CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_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
  CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_DIRENT_H=0"
 else
  U_HAVE_DIRENT_H=1
 fi
 AC_SUBST(U_HAVE_DIRENT_H)
 # 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
       if test "x${ac_cv_nl_langinfo_codeset}" != "xCODESET"
       then
         CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DNL_LANGINFO_CODESET=${ac_cv_nl_langinfo_codeset}"
       fi
   else
       CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_NL_LANGINFO_CODESET=0"
   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)
 if test $ac_cv_namespace_ok = no
 then
     AC_MSG_ERROR(Namespace support is required to build ICU.)
 fi
 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
     else
         CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_PLACEMENT_NEW=0"
     fi
 else
     CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_OVERRIDE_CXX_ALLOCATION=0"
 fi
 AC_SUBST(U_OVERRIDE_CXX_ALLOCATION)
 AC_SUBST(U_HAVE_PLACEMENT_NEW)
 AC_LANG(C)
 AC_CHECK_FUNC(popen)
 if test x$ac_cv_func_popen = xyes
 then
      U_HAVE_POPEN=1
 else
      CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_POPEN=0"
      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
     else
       CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_TZSET=0"
     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
     else
      CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_TZNAME=0"
     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
     else
      CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_TIMEZONE=0"
     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
 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_INT8_T=0"
 fi
 if test $ac_cv_type_uint8_t = no; then
 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_UINT8_T=0"
 fi
 if test $ac_cv_type_int16_t = no; then
 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_INT16_T=0"
 fi
 if test $ac_cv_type_uint16_t = no; then
 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_UINT16_T=0"
 fi
 if test $ac_cv_type_int32_t = no; then
 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_INT32_T=0"
 fi
 if test $ac_cv_type_uint32_t = no; then
 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_UINT32_T=0"
 fi
 if test $ac_cv_type_int64_t = no; then
 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_INT64_T=0"
 fi
 if test $ac_cv_type_uint64_t = no; then
 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_UINT64_T=0"
 fi
 # 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
     CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_WCHAR_H=0 -DU_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
       CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_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_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 "$GCC" = 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
             UCONFIG_CXXFLAGS="${UCONFIG_CXXFLAGS} -qutf"
             CHECK_UTF16_STRING_RESULT="-qutf"
         fi
     fi
     ;;
 *-*-solaris*)
     if test "$GCC" = 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"
             UCONFIG_CXXFLAGS="${UCONFIG_CXXFLAGS} -xustr=ascii_utf16_ushort"
             UCONFIG_CFLAGS="${UCONFIG_CFLAGS} -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.
             CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_CHECK_UTF16_STRING=1"
             U_CHECK_UTF16_STRING=0
         fi
     fi
     ;;
 *-*-hpux*)
     if test "$GCC" = 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.
 if test "$CHECK_UTF16_STRING_RESULT" = "unknown"; then
     if test "$GCC" = yes; then
         OLD_CFLAGS="${CFLAGS}"
         CFLAGS="${CFLAGS} -std=gnu99"
         AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 static const char16_t test[] = u"This is a UTF16 literal string.";
         ]], [[]])],[CC_UTF16_STRING=1],[CC_UTF16_STRING=0])
         if test "$CC_UTF16_STRING" = 1; then
             UCONFIG_CFLAGS="${UCONFIG_CFLAGS} -std=gnu99"
             CHECK_UTF16_STRING_RESULT="C only";
         else
             CFLAGS="${OLD_CFLAGS}"
         fi
     fi
     if test "$GXX" = yes; then
         # -Wno-return-type-c-linkage is desired so that stable ICU API is not warned about.
         AC_LANG_PUSH([C++])
         AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 static const char16_t test[] = u"This is a UTF16 literal string.";
         ]], [[]])],[CXX_UTF16_STRING=1],[CXX_UTF16_STRING=0])
         AC_LANG_POP([C++])
         if test "$CXX_UTF16_STRING" = 1; then
             if test "$CC_UTF16_STRING" = 1; then
                 CHECK_UTF16_STRING_RESULT="available";
             else
                 CHECK_UTF16_STRING_RESULT="C++ only";
             fi
         fi
     fi
 fi
 AC_MSG_RESULT($CHECK_UTF16_STRING_RESULT)
 # 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)
 # Enable/disable tools
 AC_ARG_ENABLE(tools,
 	[  --enable-tools         build ICU's tools [default=yes]],
 	[case "${enableval}" in
 		yes) tools=true ;;
 		no)  tools=false ;;
 		*) AC_MSG_ERROR(bad value ${enableval} for --enable-tools) ;;
 		esac],
 	tools=true)
 ICU_CONDITIONAL(TOOLS, test "$tools" = 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'`
     UCONFIG_CPPFLAGS="${UCONFIG_CPPFLAGS} -DU_HAVE_LIB_SUFFIX=1 -DU_LIB_SUFFIX_C_NAME=${ICULIBSUFFIXCNAME} "
 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*)	platform=U_CYGWIN ;;
 	*-*-mingw*)	platform=U_MINGW ;;
 	*-*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 "${CC}" == "clang"; then
    CLANGCFLAGS="-Qunused-arguments -Wno-parentheses-equality"
 else
    CLANGCFLAGS=""
 fi
 if test "${CXX}" == "clang++"; then
    CLANGCXXFLAGS="-Qunused-arguments -Wno-parentheses-equality"
 else
    CLANGCXXFLAGS=""
 fi
 CPPFLAGS="$CPPFLAGS \$(THREADSCPPFLAGS)"
 CFLAGS="$CFLAGS \$(THREADSCFLAGS) $CLANGCFLAGS"
 CXXFLAGS="$CXXFLAGS \$(THREADSCXXFLAGS) $CLANGCXXFLAGS"
 AC_SUBST(LIBCFLAGS)
 AC_SUBST(LIBCXXFLAGS)
 # append all config cppflags
 CPPFLAGS="$CPPFLAGS $CONFIG_CPPFLAGS $UCONFIG_CPPFLAGS"
 echo "CPPFLAGS=$CPPFLAGS"
 echo "CFLAGS=$CFLAGS"
 echo "CXXFLAGS=$CXXFLAGS"
 # 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/gendict/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/collperf/Makefile \
 		test/perf/dicttrieperf/Makefile \
 		test/perf/ubrkperf/Makefile \
 		test/perf/charperf/Makefile \
 		test/perf/convperf/Makefile \
 		test/perf/normperf/Makefile \
 		test/perf/DateFmtPerf/Makefile \
 		test/perf/howExpensiveIs/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 \
                 test/perf/leperf/Makefile \
 		samples/Makefile samples/date/Makefile \
 		samples/cal/Makefile samples/layout/Makefile])
 AC_OUTPUT
 echo
 echo "ICU for C/C++ $VERSION is ready to be built."
 echo "=== Important Notes: ==="
 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
 if test "x$AR" = "xfalse"; then
   echo "*** WARNING: Archiver ar not found. Set AR= or fix PATH. Some builds (such as static) may fail."
 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
 AC_SUBST(UCONFIG_CPPFLAGS)
 if test -n "$UCONFIG_CPPFLAGS"; then
    HDRFILE="uconfig.h.prepend"
    echo "*** WARNING: You must set the following flags before code compiled against this ICU will function properly:"
    echo
    echo "   ${UCONFIG_CPPFLAGS}"
    echo
    echo 'The recommended way to do this is to prepend the following lines to source/common/unicode/uconfig.h or #include them near the top of that file.'
    echo "Creating the file ${HDRFILE}"
    echo
    echo '---------------   ' "${HDRFILE}"
    echo > "${HDRFILE}"
    echo '/* ICU customizations: put these lines at the top of uconfig.h */' >> "${HDRFILE}"
    echo >> "${HDRFILE}"
    for flag in ${UCONFIG_CPPFLAGS};
    do
         echo " /* $flag */" >> "${HDRFILE}"
         case "${flag}" in
         -D*=*)
           [ \echo "${flag}" | sed -n 's%-D\([^=]*\)=%#define \1 %p' >> "${HDRFILE}" ]
           \echo >> "${HDRFILE}"
           ;;
         -D*)
           [ \echo "${flag}" | sed -n 's%-D\([^=]*\)%#define \1 %p' >> "${HDRFILE}" ]
           \echo >> "${HDRFILE}"
           ;;
         *)
           \echo "/*  Not sure how to handle this argument: ${flag} */" >> "${HDRFILE}"
           \echo >> "${HDRFILE}"
           ;;
         esac
    done
    cat "${HDRFILE}"
    \echo  "/* End of ${HDRFILE} ------------ */" >> "${HDRFILE}"
    echo >> "${HDRFILE}"
    echo '--------------- end ' "${HDRFILE}"
 fi
 AC_SUBST(UCONFIG_CFLAGS)
 if test -n "$UCONFIG_CFLAGS"; then
    echo "C   apps may want to build with CFLAGS   = ${UCONFIG_CFLAGS}"
 fi
 AC_SUBST(UCONFIG_CXXFLAGS)
 if test -n "$UCONFIG_CXXFLAGS"; then
    echo "C++ apps may want to build with CXXFLAGS = ${UCONFIG_CXXFLAGS}"
 fi
 if test "$tools" = false;
 then
         echo "## Note: you have disabled ICU's tools. This ICU cannot build its own data or tests."
         echo "## Expect build failures in the 'data', 'test', and other directories."
 fi
 $as_unset _CXX_CXXSUFFIX

The Tor Browser / annotate

intl/icu/source/configure.ac@b8a032363ba2 (annotated)

intl/icu/source/configure.ac