icuSources/configure.ac

   1 # -*-autoconf-*-
   2 AC_COPYRIGHT([ Copyright (c) 1999-2015, International Business Machines Corporation and others. All Rights Reserved. ])
   3 # configure.in for ICU
   4 # Stephen F. Booth, heavily modified by Yves and others
   5
   6 # NOTE: please use 'autoreconf' to rebuild, otherwise 'aclocal && autoconf'.
   7
   8 # Check for autoconf version
   9 AC_PREREQ(2.69)
  10
  11 # Process this file with autoreconf to produce a configure script
  12 AC_INIT([ICU],
  13         m4_esyscmd_s([sed -n 's/^[      ]*#[    ]*define[       ]*U_ICU_VERSION[        ]*"\([^"]*\)".*/\1/p' "./common/unicode/uvernum.h]"),
  14         [http://icu-project.org/bugs],
  15         [International Components for Unicode],
  16         [http://icu-project.org])
  17
  18 AC_CONFIG_MACRO_DIR([config/m4])
  19 AC_CONFIG_SRCDIR([common/unicode/utypes.h])
  20
  21 PACKAGE="icu"
  22 AC_SUBST(PACKAGE)
  23
  24 # Use custom echo test for newline option
  25 # Current autoconf (2.65) gives incorrect echo newline option
  26 # for icu-config
  27 # This may be removed later - mow (June 17, 2010)
  28 ICU_ECHO_C= ICU_ECHO_N= ICU_ECHO_T=
  29 case `/bin/sh -c "echo -n x"` in
  30 -n*)
  31   case `/bin/sh -c "echo 'x\c'"` in
  32   *c*) ICU_ECHO_T=' ';;     # ECHO_T is single tab character.
  33   *)   ICU_ECHO_C='\c';;
  34   esac;;
  35 *)
  36   ICU_ECHO_N='-n';;
  37 esac
  38 AC_SUBST(ICU_ECHO_N)
  39 AC_SUBST(ICU_ECHO_C)
  40 AC_SUBST(ICU_ECHO_T)
  41
  42 AC_MSG_CHECKING(for ICU version numbers)
  43
  44 # Get the ICU version from uversion.h or other headers
  45 geticuversion() {
  46     [sed -n 's/^[       ]*#[    ]*define[       ]*U_ICU_VERSION[        ]*"\([^"]*\)".*/\1/p' "$@"]
  47 }
  48 getuversion() {
  49     [sed -n 's/^[       ]*#[    ]*define[       ]*U_UNICODE_VERSION[    ]*"\([^"]*\)".*/\1/p' "$@"]
  50 }
  51 VERSION=`geticuversion $srcdir/common/unicode/uvernum.h`
  52 if test x"$VERSION" = x; then
  53    as_fn_error $? "Cannot determine ICU version number from uvernum.h header file" "$LINENO" 5
  54 fi
  55
  56 #TODO: IcuBug:8502
  57 #if test "$VERSION" != "$PACKAGE_VERSION"; then
  58 #   AC_MSG_ERROR([configure was generated for $PACKAGE_VERSION but uvernum.h has $VERSION - please rerun autoconf])
  59 #fi
  60
  61 UNICODE_VERSION=`getuversion $srcdir/common/unicode/uchar.h`
  62 if test x"$UNICODE_VERSION" = x; then
  63     AC_MSG_ERROR([Cannot determine Unicode version number from uchar.h header file])
  64 fi
  65 # Compute a reasonable library version from the release version. This is
  66 # very bad, but that's wanted... We want to make sure that the LIB_VERSION
  67 # has at least a dot in it, so we'll add a .0 if needed.
  68 #[LIB_VERSION=`echo $VERSION | sed -e 's/\.//' -e 's/^\([^.]*\)$/\1.0/'`]
  69 LIB_VERSION=$VERSION
  70 LIB_VERSION_MAJOR=`echo $LIB_VERSION | sed 's/\..*//'`
  71 AC_SUBST(VERSION)
  72 AC_SUBST(LIB_VERSION)
  73 AC_SUBST(LIB_VERSION_MAJOR)
  74 AC_MSG_RESULT([release $VERSION, library $LIB_VERSION, unicode version $UNICODE_VERSION])
  75
  76 AC_SUBST(UNICODE_VERSION)
  77
  78 # Determine the host system
  79 AC_CANONICAL_HOST
  80
  81 AC_SUBST(CPPFLAGS)
  82
  83 # This variable is needed on z/OS because the C++ compiler only recognizes .C
  84 _CXX_CXXSUFFIX=cpp
  85 export _CXX_CXXSUFFIX
  86
  87 # Accumulate #defines
  88
  89 # CONFIG_CPPFLAGS: These are defines that are set for ICU Build time only.
  90 # They are only needed for building ICU itself. Example: platform stuff
  91 CONFIG_CPPFLAGS=""
  92 # UCONFIG_CPPFLAGS: These are defines which are set for ICU build time,
  93 # and also a notice is output that they need to be set
  94 # for end-users of ICU also. uconfig.h.prepend is generated
  95 # with, for example, "#define U_DISABLE_RENAMING 1"
  96 # Example: ICU configuration stuff
  97 UCONFIG_CPPFLAGS=""
  98 # UCONFIG_CFLAGS: contains a copy of anything that needs to be set by end users
  99 # such as -std
 100 UCONFIG_CFLAGS=""
 101
 102 # Check whether to build debug libraries
 103 AC_MSG_CHECKING([whether to build debug libraries])
 104 enabled=no
 105 ENABLE_DEBUG=0
 106 AC_ARG_ENABLE(debug,
 107     [  --enable-debug          build debug libraries and enable the U_DEBUG define [default=no]],
 108     [ case "${enableval}" in
 109          yes|"") enabled=yes; ENABLE_DEBUG=1; CONFIG_CPPFLAGS="$CONFIG_CPPFLAGS -DU_DEBUG=1" ;;
 110          *) ;;
 111     esac],
 112 )
 113 AC_MSG_RESULT($enabled)
 114 AC_SUBST(ENABLE_DEBUG)
 115
 116 # Check whether to build release libraries
 117 AC_MSG_CHECKING([whether to build release libraries])
 118 enabled=yes
 119 ENABLE_RELEASE=1
 120 AC_ARG_ENABLE(release,
 121     [  --enable-release        build release libraries [default=yes]],
 122     [ case "${enableval}" in
 123          no) enabled=no; ENABLE_RELEASE=0 ;;
 124          *) ;;
 125     esac],
 126 )
 127 AC_MSG_RESULT($enabled)
 128 AC_SUBST(ENABLE_RELEASE)
 129
 130 # Don't use the default C/CXXFLags
 131 : ${CFLAGS=""}
 132 : ${CXXFLAGS=""}
 133
 134 # Checks for compilers
 135 AC_PROG_CC([clang gcc cc c99 c89 xlc_r xlc cl.exe icc])
 136 # Make sure that we try clang++ first, which provides C++11 support.
 137 # The g++ compiler is less likely to support C++11.
 138 AC_PROG_CXX([clang++ g++ c++ gpp xlC_r xlC aCC CC cxx cc++ cl.exe icc FCC KCC RCC])
 139
 140 # pkg-config is needed for harfbuzz support
 141 PKG_PROG_PKG_CONFIG([0.20])
 142 PKG_CHECK_MODULES(ICULEHB, icu-le-hb, have_icu_le_hb=true, :)
 143
 144 # Ensure that if CXXFLAGS/CFLAGS were not set when calling configure, set it correctly based on (enable/disable) debug or release option
 145 # The release mode use is the default one for autoconf
 146 if test "$GCC" = yes; then
 147     if test "$CFLAGS" = ""; then
 148         if test "$ENABLE_DEBUG" = 1; then
 149             CFLAGS=-g
 150         fi
 151         if test "$ENABLE_RELEASE" = 1; then
 152             CFLAGS="$CFLAGS -O2"
 153         fi
 154     fi
 155     if test "$CXXFLAGS" = ""; then
 156         if test "$ENABLE_DEBUG" = 1; then
 157             CXXFLAGS=-g
 158         fi
 159         if test "$ENABLE_RELEASE" = 1; then
 160             CXXFLAGS="$CXXFLAGS -O2"
 161         fi
 162     fi
 163 fi
 164
 165 AC_PROG_CPP
 166
 167 AC_PROG_INSTALL
 168
 169 AC_SUBST(cross_compiling)
 170
 171 dnl use the pld hack to get ac_fn_cxx_try_link defined globally and not local
 172 AC_LANG_PUSH([C++])
 173 AC_LINK_IFELSE([AC_LANG_PROGRAM()])
 174 AC_LANG_POP([C++])
 175
 176 # make sure install is relative to srcdir - if a script
 177 if test "$srcdir" = "."; then
 178   # If srcdir isn't just ., then (srcdir) is already prepended.
 179   if test "${ac_install_sh}" = "${INSTALL}"; then
 180    INSTALL="\\\$(top_srcdir)/${ac_install_sh}"
 181   fi
 182 fi
 183
 184 #AC_CHECK_PROG(AUTOCONF, autoconf, autoconf, true)
 185 #AC_CHECK_PROG(STRIP, strip, strip, true)
 186
 187 # Check for the platform make
 188 AC_PATH_PROGS(U_MAKE, gmake gnumake, make)
 189 AC_SUBST(U_MAKE)
 190
 191
 192 AC_ARG_WITH(cross-build,
 193         [  --with-cross-build=dir specify an absolute path to the build directory of an ICU built for the current platform [default=no cross dir]],
 194         [cross_buildroot="${withval}"],
 195         [cross_buildroot=""])
 196
 197 if test "X$cross_buildroot" = "X"; then
 198     if test "$cross_compiling" = "yes"; then
 199         AC_MSG_ERROR([Error! Cross compiling but no --with-cross-build option specified - please supply the path to an executable ICU's build root])
 200         dnl '
 201     fi
 202 else
 203     if test -f "${cross_buildroot}/config/icucross.mk"; then
 204         AC_MSG_RESULT([Using cross buildroot: $cross_buildroot])
 205     else
 206         if test -d "${cross_buildroot}"; then
 207             AC_MSG_ERROR([${cross_buildroot}/config/icucross.mk not found. Please build ICU in ${cross_buildroot} first.])
 208         else
 209             AC_MSG_ERROR([No such directory ${cross_buildroot} supplied as the argument to --with-cross-build. Use an absolute path.])
 210         fi
 211     fi
 212 fi
 213 AC_SUBST(cross_buildroot)
 214
 215 # Check for doxygen to generate documentation
 216 AC_PATH_PROG(DOXYGEN,doxygen,,$PATH:/usr/local/bin:/usr/bin)
 217
 218 # Check that the linker is usable
 219 ICU_PROG_LINK
 220
 221 # Determine the executable suffix
 222 # We don't use AC_EXEEXT because some compilers output separate debugging
 223 # files, which confuses the AC_EXEEXT macro.
 224 AC_MSG_CHECKING(checking for executable suffix)
 225 case "${host}" in
 226     *-*-cygwin*|*-*-mingw*)  EXEEXT=.exe ;;
 227     *)      EXEEXT="" ;;
 228 esac
 229 ac_exeext=$EXEEXT
 230 AC_MSG_RESULT($EXEEXT)
 231 AC_SUBST(EXEEXT)
 232
 233 # Determine how strict we want to be when compiling
 234 AC_CHECK_STRICT_COMPILE
 235
 236 # Check if we can build and use 64-bit libraries
 237 AC_CHECK_64BIT_LIBS
 238 AC_SUBST(ARFLAGS)
 239 AC_SUBST(COMPILE_LINK_ENVVAR)
 240
 241 # Determine the Makefile fragment
 242 ICU_CHECK_MH_FRAG
 243
 244 # Checks for libraries and other host specific stuff
 245 # On HP/UX, don't link to -lm from a shared lib because it isn't
 246 #  PIC (at least on 10.2)
 247 case "${host}" in
 248         *-*-hpux*)      AC_CHECK_LIB(m, floor, LIB_M="-lm") ;;
 249
 250         *)              AC_CHECK_LIB(m, floor)
 251                         LIB_M="" ;;
 252 esac
 253 AC_SUBST(LIB_M)
 254
 255 # Check whether to build shared libraries
 256 AC_MSG_CHECKING([whether to build shared libraries])
 257 enabled=no
 258 AC_ARG_ENABLE(shared,
 259     [  --enable-shared         build shared libraries [default=yes]],
 260     [ case "${enableval}" in
 261              yes|"") enabled=yes; ENABLE_SHARED=YES ;;
 262              no);;
 263              *) ;;
 264     esac],
 265     [enabled=yes; ENABLE_SHARED=YES]
 266 )
 267 AC_MSG_RESULT($enabled)
 268 AC_SUBST(ENABLE_SHARED)
 269
 270 # Check whether to build static libraries
 271 AC_MSG_CHECKING([whether to build static libraries])
 272 enabled=no
 273 AC_ARG_ENABLE(static,
 274     [  --enable-static         build static libraries [default=no]],
 275     [ case "${enableval}" in
 276              yes|"") enabled=yes; ENABLE_STATIC=YES ;;
 277              no) ;;
 278              *) ;;
 279     esac],
 280 )
 281 AC_MSG_RESULT($enabled)
 282 AC_SUBST(ENABLE_STATIC)
 283
 284 # When building release static library, there might be some optimization flags we can use
 285 if test "$ENABLE_STATIC" = "YES"; then
 286     if test "$ENABLE_SHARED" != "YES"; then
 287         if test "$ENABLE_RELEASE" = 1; then
 288             AC_MSG_CHECKING([whether we can use static library optimization option])
 289             CHECK_STATIC_OPT_FLAG=no
 290
 291             OLD_CPPFLAGS="${CPPFLAGS}"
 292             OLD_LDFLAGS="${LDFLAGS}"
 293
 294             case "${host}" in
 295             *-linux*|i*86-*-*bsd*|i*86-pc-gnu)
 296                 if test "$GCC" = yes; then
 297                     CPPFLAGS="${CPPFLAGS} -ffunction-sections -fdata-sections"
 298                     LDFLAGS="${LDFLAGS} -Wl,--gc-sections"
 299                 fi
 300                 ;;
 301             *)
 302                 ;;
 303             esac
 304
 305             AC_LINK_IFELSE([AC_LANG_PROGRAM([], [])], [CHECK_STATIC_OPT_FLAG=yes], [CHECK_STATIC_OPT_FLAG=no])
 306             AC_MSG_RESULT($CHECK_STATIC_OPT_FLAG)
 307             if test "$CHECK_STATIC_OPT_FLAG" = no; then
 308                 CPPFLAGS="${OLD_CPPFLAGS}"
 309                 LDFLAGS="${OLD_LDFLAGS}"
 310             fi
 311         fi
 312     fi
 313 fi
 314
 315
 316 # Check whether to enable auto cleanup of libraries
 317 AC_MSG_CHECKING([whether to enable auto cleanup of libraries])
 318 enabled=no
 319 UCLN_NO_AUTO_CLEANUP=1
 320 AC_ARG_ENABLE(auto-cleanup,
 321     [  --enable-auto-cleanup   enable auto cleanup of libraries [default=no]],
 322     [ case "${enableval}" in
 323          yes) enabled=yes;
 324          CONFIG_CPPFLAGS="$CONFIG_CPPFLAGS -DUCLN_NO_AUTO_CLEANUP=0";
 325          UCLN_NO_AUTO_CLEANUP=0
 326           ;;
 327          *) ;;
 328     esac],
 329 )
 330 AC_MSG_RESULT($enabled)
 331 AC_SUBST(UCLN_NO_AUTO_CLEANUP)
 332
 333 # MSVC floating-point option
 334 MSVC_RELEASE_FLAG=""
 335 if test $enabled = yes
 336 then
 337     if test $icu_cv_host_frag = mh-cygwin-msvc -o $icu_cv_host_frag = mh-msys-msvc
 338     then
 339         AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 340     #if defined _MSC_VER && _MSC_VER >= 1400
 341     #else
 342     Microsoft Visual C++ < 2005
 343     #endif
 344         ]], [[]])],[MSVC_RELEASE_FLAG="/fp:precise"],[MSVC_RELEASE_FLAG="/Op"])
 345
 346         CFLAGS="${CFLAGS} ${MSVC_RELEASE_FLAG}"
 347         CXXFLAGS="${CXXFLAGS} ${MSVC_RELEASE_FLAG}"
 348     fi
 349 fi
 350
 351 # Check whether to enabled draft APIs
 352 AC_MSG_CHECKING([whether to enable draft APIs])
 353 enabled=yes
 354 U_DEFAULT_SHOW_DRAFT=1
 355 AC_ARG_ENABLE(draft,
 356     [  --enable-draft          enable draft APIs (and internal APIs) [default=yes]],
 357     [ case "${enableval}" in
 358          no) enabled=no; U_DEFAULT_SHOW_DRAFT=0;
 359          CONFIG_CPPFLAGS="$CONFIG_CPPFLAGS -DU_DEFAULT_SHOW_DRAFT=0"
 360           ;;
 361          *) ;;
 362     esac],
 363 )
 364 AC_MSG_RESULT($enabled)
 365 # Make sure that we can use draft API in ICU.
 366 if test "$U_DEFAULT_SHOW_DRAFT" = 0; then
 367     CONFIG_CPPFLAGS="$CONFIG_CPPFLAGS -DU_SHOW_DRAFT_API"
 368 fi
 369 AC_SUBST(U_DEFAULT_SHOW_DRAFT)
 370
 371 AC_PROG_RANLIB
 372
 373 # look for 'ar' the proper way
 374 AC_CHECK_TOOL(AR, ar, false)
 375
 376 AC_MSG_CHECKING([whether to enable renaming of symbols])
 377 enabled=yes
 378 U_DISABLE_RENAMING=0
 379 AC_ARG_ENABLE(renaming,
 380     [  --enable-renaming       add a version suffix to symbols [default=yes]],
 381     [ case "${enableval}" in
 382              yes|"") enabled=yes ;;
 383              no) enabled=no; U_DISABLE_RENAMING=1;
 384              UCONFIG_CPPFLAGS="${UCONFIG_CPPFLAGS} -DU_DISABLE_RENAMING=1"
 385               ;;
 386              *) ;;
 387     esac],
 388 )
 389 AC_MSG_RESULT($enabled)
 390 AC_SUBST(U_DISABLE_RENAMING)
 391
 392 AC_MSG_CHECKING([whether to enable function and data tracing])
 393 enabled=no
 394 U_ENABLE_TRACING=0
 395 AC_ARG_ENABLE(tracing,
 396     [  --enable-tracing        enable function and data tracing [default=no]],
 397     [ case "${enableval}" in
 398              yes|"") enabled=yes;
 399                      CONFIG_CPPFLAGS="$CONFIG_CPPFLAGS -DU_ENABLE_TRACING=1";
 400                      U_ENABLE_TRACING=1 ;;
 401              no) enabled=no; U_ENABLE_TRACING=0 ;;
 402              *) ;;
 403     esac],
 404 )
 405 AC_MSG_RESULT($enabled)
 406 AC_SUBST(U_ENABLE_TRACING)
 407
 408 # check if elf.h is present.
 409 AC_CHECK_HEADERS([elf.h])
 410 if test "x$ac_cv_header_elf_h" = "xyes"; then
 411     CONFIG_CPPFLAGS="$CONFIG_CPPFLAGS -DU_HAVE_ELF_H=1";
 412 fi
 413
 414 # Enable/disable plugins
 415 AC_ARG_ENABLE(plugins,
 416         [  --enable-plugins        enable plugins [default=no]],
 417         [case "${enableval}" in
 418                 yes) plugins=true ;;
 419                 no)  plugins=false ;;
 420                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-plugins) ;;
 421                 esac],
 422         plugins=false)
 423 ICU_CONDITIONAL(PLUGINS, test "$plugins" = true)
 424
 425 if test "x$plugins" = "xtrue"; then
 426    UCONFIG_CPPFLAGS="$UCONFIG_CPPFLAGS -DUCONFIG_ENABLE_PLUGINS=1"
 427 fi
 428
 429
 430 U_ENABLE_DYLOAD=1
 431 enable=yes
 432 AC_MSG_CHECKING([whether to enable dynamic loading of plugins. Ignored if plugins disabled.])
 433 AC_ARG_ENABLE(dyload,
 434     [  --disable-dyload        disable dynamic loading [default=no]],
 435     [ case "${enableval}" in
 436              yes|"")
 437                      U_ENABLE_DYLOAD=1
 438                      enable=yes
 439                      ;;
 440              no)
 441                  U_ENABLE_DYLOAD=0;
 442                  enable=no;
 443                  CONFIG_CPPFLAGS="$CONFIG_CPPFLAGS -DU_ENABLE_DYLOAD=0";
 444                  ;;
 445              *) ;;
 446     esac],
 447 )
 448 AC_MSG_RESULT($enable)
 449 AC_SUBST(U_ENABLE_DYLOAD)
 450
 451 if test "$enable" = "yes"; then
 452    AC_CHECK_HEADERS([dlfcn.h])
 453    #AC_MSG_RESULT($enabled)
 454    AC_SEARCH_LIBS([dlopen], [dl])
 455    AC_CHECK_FUNCS([dlopen])
 456
 457    if test "x$ac_cv_func_dlopen" != xyes; then
 458       CONFIG_CPPFLAGS="$CONFIG_CPPFLAGS -DHAVE_DLOPEN=0"
 459    fi
 460 fi
 461
 462 # Check for miscellanous functions.
 463 # So, use for putil / tools only.
 464 # Note that this will generate HAVE_GETTIMEOFDAY, not U_HAVE_GETTIMEOFDAY
 465 AC_CHECK_FUNCS([gettimeofday])
 466
 467
 468 # Check whether to use the evil rpath or not
 469 AC_ARG_ENABLE(rpath,
 470     [  --enable-rpath          use rpath when linking [default is only if necessary]],
 471     [ case "${enableval}" in
 472              yes|"") ENABLE_RPATH=YES ;;
 473              no) ;;
 474              *) ;;
 475     esac],
 476     [ENABLE_RPATH=NO]
 477 )
 478 AC_SUBST(ENABLE_RPATH)
 479
 480
 481
 482 AC_LANG_PUSH([C++])
 483 AC_MSG_CHECKING([[if we have a C++ compiler]])
 484 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],[[]])],[cxx_okay=yes],[cxx_okay=no])
 485 if test $cxx_okay = yes
 486 then
 487         AC_MSG_RESULT([[Good]])
 488 else
 489         AC_MSG_RESULT([[no]])
 490         AC_MSG_ERROR([[C++ compiler $CXX does not work or no compiler found]])
 491 fi
 492
 493 if [[ "$GXX" = yes ]]; then
 494     # if CXXFLAGS does not have a "-std=" setting, set it now to -std=c++0x,
 495     # and check that the compiler still works.
 496     if ! echo "$CXXFLAGS" | grep '\-std=' >/dev/null 2>&1; then
 497         OLD_CXXFLAGS="${CXXFLAGS}"
 498         CXXFLAGS="$CXXFLAGS --std=c++0x"
 499         AC_MSG_CHECKING([[if we have a C++11 compiler]])
 500         AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],[[]])],[cxx11_okay=yes],[cxx11_okay=no])
 501         AC_MSG_RESULT($cxx11_okay)
 502         if [[ $cxx11_okay = yes ]]; then
 503             AC_MSG_NOTICE([Adding CXXFLAGS option --std=c++0x])
 504             UCONFIG_CXXFLAGS="${UCONFIG_CXXFLAGS} --std=c++0x"
 505         else
 506             CXXFLAGS="$OLD_CXXFLAGS"
 507         fi
 508     fi
 509 fi
 510
 511 AC_MSG_CHECKING([[if #include <string> works]])
 512 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <string>]], [[]])], [ac_cv_header_stdstring=yes], [ac_cv_header_stdstring=no])
 513 AC_MSG_RESULT($ac_cv_header_stdstring)
 514 if test $ac_cv_header_stdstring = yes
 515 then
 516         U_HAVE_STD_STRING=1
 517 else
 518         U_HAVE_STD_STRING=0
 519         CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_STD_STRING=0"
 520 fi
 521 AC_SUBST(U_HAVE_STD_STRING)
 522
 523
 524 AC_MSG_CHECKING([[if #include <atomic> works]])
 525 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <atomic>]], [[]])], [ac_cv_header_atomic=yes], [ac_cv_header_atomic=no])
 526 AC_MSG_RESULT($ac_cv_header_atomic)
 527 if test $ac_cv_header_atomic = yes
 528 then
 529         U_HAVE_ATOMIC=1
 530 else
 531         U_HAVE_ATOMIC=0
 532 fi
 533 # Make this available via CPPFLAGS
 534 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_ATOMIC=${U_HAVE_ATOMIC}"
 535 AC_SUBST(U_HAVE_ATOMIC)
 536
 537 AC_LANG_POP([C++])
 538
 539 # Always build ICU with multi-threading support.
 540 OLD_LIBS=${LIBS}
 541
 542 # For Compaq Tru64 (OSF1), we must look for pthread_attr_init
 543 # and must do this before seaching for pthread_mutex_destroy, or
 544 # we will pick up libpthreads.so not libpthread.so
 545 # If this fails, then we must test for HPUX specials, before
 546 # moving on to a more generic test
 547
 548 AC_CHECK_LIB(pthread, pthread_attr_init)
 549 if test $ac_cv_lib_pthread_pthread_attr_init = yes; then
 550   :
 551 else
 552   # Locate the right library for POSIX threads. We look for the
 553   # symbols in the libraries first, because on Solaris libc provides
 554   # pthread_create but libpthread has the real code :(
 555   # AIX uses libpthreads instead of libpthread, and HP/UX uses libpthread
 556   # FreeBSD users may need libpthread if they do not have libc_r.
 557
 558   AC_SEARCH_LIBS_FIRST(pthread_mutex_destroy, pthread pthreads c_r )
 559
 560   if test "$ac_cv_search_pthread_mutex_destroy" != no; then
 561     :
 562   else
 563     # For HP 11
 564     AC_CHECK_LIB(pthread, pthread_mutex_init)
 565     if test $ac_cv_lib_pthread_pthread_mutex_init = yes; then
 566       :
 567     fi
 568   fi
 569
 570   AC_CHECK_FUNC(pthread_mutex_lock)
 571
 572   if test $ac_cv_func_pthread_mutex_lock = yes; then
 573     :
 574   fi
 575 fi
 576 # Check to see if we are using CygWin with MSVC
 577 case "${host}" in
 578 *-pc-cygwin*|*-pc-mingw*)
 579   # For gcc, the thread options are set by mh-mingw/mh-cygwin
 580   # For msvc, the thread options are set by runConfigureICU
 581   :
 582   ;;
 583 *-*-hpux*)
 584   # Add -mt because it does several nice things on newer compilers.
 585   case "${icu_cv_host_frag}" in
 586     mh-hpux-acc)
 587       OLD_CXXFLAGS="${CXXFLAGS}"
 588       CXXFLAGS="${CXXFLAGS} -mt"
 589       if test x"`${CXX} ${CXXFLAGS} 2>&1`" != x""; then
 590          CXXFLAGS="${OLD_CXXFLAGS}"
 591       else
 592          UCONFIG_CXXFLAGS="${UCONFIG_CXXFLAGS} -mt"
 593       fi
 594     ;;
 595   esac
 596   ;;
 597 *-*-solaris*)
 598   case "${icu_cv_host_frag}" in
 599     mh-solaris)
 600          LIBS="${LIBS} -mt"
 601     ;;
 602   esac
 603   ;;
 604 esac
 605
 606 AC_ARG_ENABLE(weak-threads,
 607         [  --enable-weak-threads   weakly reference the threading library [default=no]],
 608         [case "${enableval}" in
 609                 yes)
 610             LIB_THREAD="${LIBS%${OLD_LIBS}}"
 611             LIBS=${OLD_LIBS}
 612             ;;
 613                 no)  ;;
 614                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-weak-threads) ;;
 615                 esac])
 616 AC_SUBST(LIB_THREAD)
 617
 618 # Check for mmap()
 619
 620 # The AC_FUNC_MMAP macro doesn't work properly.  It seems to be too specific.
 621 # Do this check instead.
 622 HAVE_MMAP=0
 623 AC_MSG_CHECKING([for mmap])
 624 AC_CACHE_VAL(ac_cv_func_mmap_ok,
 625     [AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <unistd.h>
 626 #include <sys/mman.h>
 627 #include <sys/stat.h>
 628 #include <fcntl.h>], [mmap((void *)0, 0, PROT_READ, 0, 0, 0);])],[ac_cv_func_mmap_ok=yes],[ac_cv_func_mmap_ok=no])] )
 629 AC_MSG_RESULT($ac_cv_func_mmap_ok)
 630 if test $ac_cv_func_mmap_ok = yes
 631 then
 632     HAVE_MMAP=1
 633 else
 634     CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_MMAP=0"
 635 fi
 636 AC_SUBST(HAVE_MMAP)
 637
 638 AC_MSG_CHECKING([for genccode assembly])
 639
 640 # Check to see if genccode can generate simple assembly.
 641 GENCCODE_ASSEMBLY=
 642 case "${host}" in
 643 *-linux*|*-kfreebsd*-gnu*|i*86-*-*bsd*|i*86-pc-gnu)
 644     if test "$GCC" = yes; then
 645         # We're using gcc, and the simple -a gcc command line works for genccode
 646         GENCCODE_ASSEMBLY="-a gcc"
 647     fi ;;
 648 i*86-*-solaris*)
 649     if test "$GCC" = yes; then
 650         # When using gcc, look if we're also using GNU as.
 651         # When using GNU as, the simple -a gcc command line works for genccode.
 652         asv=`"${CC}" -print-prog-name=as 2>/dev/null`
 653         asv=`"${asv}" --version 2>/dev/null`
 654         case "X${asv}" in
 655         X*GNU*) GENCCODE_ASSEMBLY="-a gcc" ;;
 656         X*) GENCCODE_ASSEMBLY="-a sun-x86" ;;
 657         esac
 658         unset asv
 659     else
 660         GENCCODE_ASSEMBLY="-a sun-x86"
 661     fi ;;
 662 sparc-*-solaris*)
 663     GENCCODE_ASSEMBLY="-a sun"
 664     ;;
 665 ia64-*-hpux*)
 666 # There has been some issues with building ICU data on HPUX ia64 aCC
 667 # when using the assemble code setting below.  For now, build without
 668 # assemble code for this platform.  This will increase the build time.
 669 #    GENCCODE_ASSEMBLY="-a aCC-ia64"
 670     ;;
 671 esac
 672 AC_SUBST(GENCCODE_ASSEMBLY)
 673
 674 AC_MSG_RESULT($GENCCODE_ASSEMBLY)
 675
 676 # Checks for header files
 677 AC_CHECK_HEADERS(inttypes.h)
 678 if test $ac_cv_header_inttypes_h = no; then
 679  U_HAVE_INTTYPES_H=0
 680  CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_INTTYPES_H=0"
 681 else
 682  U_HAVE_INTTYPES_H=1
 683 fi
 684 if test "$CC" = ccc; then
 685  AC_MSG_RESULT("C compiler set to CCC ${CC}" )
 686  case "${host}" in
 687         alpha*-*-*) U_HAVE_INTTYPES_H=0;
 688         CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_INTTYPES_H=0"
 689  esac
 690 fi
 691
 692 AC_SUBST(U_HAVE_INTTYPES_H)
 693
 694 AC_CHECK_HEADERS(dirent.h)
 695 if test $ac_cv_header_dirent_h = no; then
 696  U_HAVE_DIRENT_H=0
 697  CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_DIRENT_H=0"
 698 else
 699  U_HAVE_DIRENT_H=1
 700 fi
 701
 702 AC_SUBST(U_HAVE_DIRENT_H)
 703
 704 # Check for endianness
 705 AC_C_BIGENDIAN()
 706 if test $ac_cv_c_bigendian = no; then
 707 U_IS_BIG_ENDIAN=0
 708 U_ENDIAN_CHAR="l"
 709 else
 710 U_IS_BIG_ENDIAN=1
 711 U_ENDIAN_CHAR="b"
 712 fi
 713 AC_SUBST(U_IS_BIG_ENDIAN)
 714
 715 # Do various POSIX related checks
 716 U_HAVE_NL_LANGINFO_CODESET=0
 717 U_NL_LANGINFO_CODESET=-1
 718 AC_CHECK_FUNC(nl_langinfo,[U_HAVE_NL_LANGINFO=1],[U_HAVE_NL_LANGINFO=0])
 719 dnl AC_SUBST(U_HAVE_NL_LANGINFO)
 720 if test $U_HAVE_NL_LANGINFO -eq 1; then
 721   AC_CACHE_CHECK([for nl_langinfo's argument to obtain the codeset],
 722   ac_cv_nl_langinfo_codeset,
 723   [ac_cv_nl_langinfo_codeset="unknown"
 724   for a in CODESET _NL_CTYPE_CODESET_NAME; do
 725   AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <langinfo.h>]], [[nl_langinfo($a);]])],[ac_cv_nl_langinfo_codeset="$a"; break],[])]
 726   done)
 727   if test x$ac_cv_nl_langinfo_codeset != xunknown
 728   then
 729       U_HAVE_NL_LANGINFO_CODESET=1
 730       U_NL_LANGINFO_CODESET=$ac_cv_nl_langinfo_codeset
 731       if test "x${ac_cv_nl_langinfo_codeset}" != "xCODESET"
 732       then
 733         CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DNL_LANGINFO_CODESET=${ac_cv_nl_langinfo_codeset}"
 734       fi
 735   else
 736       CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_NL_LANGINFO_CODESET=0"
 737   fi
 738 fi
 739 AC_SUBST(U_HAVE_NL_LANGINFO_CODESET)
 740 AC_SUBST(U_NL_LANGINFO_CODESET)
 741
 742 # Namespace support checks
 743 AC_LANG(C++)
 744 AC_MSG_CHECKING([for namespace support])
 745 AC_CACHE_VAL(ac_cv_namespace_ok,
 746     [AC_LINK_IFELSE([AC_LANG_PROGRAM([namespace x_version {void f(){}}
 747     namespace x = x_version;
 748     using namespace x_version;
 749     ], [f();])],[ac_cv_namespace_ok=yes],[ac_cv_namespace_ok=no])] )
 750 AC_MSG_RESULT($ac_cv_namespace_ok)
 751 if test $ac_cv_namespace_ok = no
 752 then
 753     AC_MSG_ERROR(Namespace support is required to build ICU.)
 754 fi
 755
 756 AC_MSG_CHECKING([for properly overriding new and delete])
 757 U_OVERRIDE_CXX_ALLOCATION=0
 758 U_HAVE_PLACEMENT_NEW=0
 759 AC_CACHE_VAL(ac_cv_override_cxx_allocation_ok,
 760     [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <stdlib.h>
 761     class UMemory {
 762     public:
 763     void *operator new(size_t size) {return malloc(size);}
 764     void *operator new[](size_t size) {return malloc(size);}
 765     void operator delete(void *p) {free(p);}
 766     void operator delete[](void *p) {free(p);}
 767     };
 768     ]], [])],[ac_cv_override_cxx_allocation_ok=yes],[ac_cv_override_cxx_allocation_ok=no])] )
 769 AC_MSG_RESULT($ac_cv_override_cxx_allocation_ok)
 770 if test $ac_cv_override_cxx_allocation_ok = yes
 771 then
 772     U_OVERRIDE_CXX_ALLOCATION=1
 773     AC_MSG_CHECKING([for placement new and delete])
 774     AC_CACHE_VAL(ac_cv_override_placement_new_ok,
 775         [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <stdlib.h>
 776         class UMemory {
 777         public:
 778         void *operator new(size_t size) {return malloc(size);}
 779         void *operator new[](size_t size) {return malloc(size);}
 780         void operator delete(void *p) {free(p);}
 781         void operator delete[](void *p) {free(p);}
 782         void * operator new(size_t, void *ptr) { return ptr; }
 783         void operator delete(void *, void *) {}
 784         };
 785         ]], [])],[ac_cv_override_placement_new_ok=yes],[ac_cv_override_placement_new_ok=no])] )
 786     AC_MSG_RESULT($ac_cv_override_placement_new_ok)
 787     if test $ac_cv_override_placement_new_ok = yes
 788     then
 789         U_HAVE_PLACEMENT_NEW=1
 790     else
 791         CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_PLACEMENT_NEW=0"
 792     fi
 793 else
 794     CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_OVERRIDE_CXX_ALLOCATION=0"
 795 fi
 796 AC_SUBST(U_OVERRIDE_CXX_ALLOCATION)
 797 AC_SUBST(U_HAVE_PLACEMENT_NEW)
 798
 799 AC_LANG(C)
 800 AC_CHECK_FUNC(popen)
 801 if test x$ac_cv_func_popen = xyes
 802 then
 803      U_HAVE_POPEN=1
 804 else
 805      CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_POPEN=0"
 806      U_HAVE_POPEN=0
 807 fi
 808 AC_SUBST(U_HAVE_POPEN)
 809
 810 AC_CHECK_FUNC(tzset)
 811 U_HAVE_TZSET=0
 812 if test x$ac_cv_func_tzset = xyes
 813 then
 814     U_TZSET=tzset
 815     U_HAVE_TZSET=1
 816 else
 817     AC_CHECK_FUNC(_tzset)
 818     if test x$ac_cv_func__tzset = xyes
 819     then
 820         U_TZSET=_tzset
 821         U_HAVE_TZSET=1
 822     else
 823       CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_TZSET=0"
 824     fi
 825 fi
 826 AC_SUBST(U_HAVE_TZSET)
 827 AC_SUBST(U_TZSET)
 828
 829 U_HAVE_TZNAME=0
 830 AC_CACHE_CHECK(for tzname,ac_cv_var_tzname,
 831 [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#ifndef __USE_POSIX
 832 #define __USE_POSIX
 833 #endif
 834 #include <stdlib.h>
 835 #include <time.h>
 836 #ifndef tzname /* For SGI.  */
 837 extern char *tzname[]; /* RS6000 and others reject char **tzname.  */
 838 #endif]], [atoi(*tzname);])],[ac_cv_var_tzname=yes],[ac_cv_var_tzname=no])])
 839 if test $ac_cv_var_tzname = yes; then
 840   U_TZNAME=tzname
 841   U_HAVE_TZNAME=1
 842 else
 843   AC_CACHE_CHECK(for _tzname,ac_cv_var__tzname,
 844   [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <stdlib.h>
 845   #include <time.h>
 846   extern char *_tzname[];]], [atoi(*_tzname);])],[ac_cv_var__tzname=yes],[ac_cv_var__tzname=no])])
 847     if test $ac_cv_var__tzname = yes; then
 848       U_TZNAME=_tzname
 849       U_HAVE_TZNAME=1
 850     else
 851      CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_TZNAME=0"
 852     fi
 853 fi
 854 AC_SUBST(U_HAVE_TZNAME)
 855 AC_SUBST(U_TZNAME)
 856
 857 AC_CACHE_CHECK(for timezone,ac_cv_var_timezone,
 858 [AC_LINK_IFELSE([AC_LANG_PROGRAM([#ifndef __USE_POSIX
 859 #define __USE_POSIX
 860 #endif
 861 #ifndef __USE_XOPEN
 862 #define __USE_XOPEN
 863 #endif
 864 #include <time.h>
 865 ], [[timezone = 1;]])],[ac_cv_var_timezone=yes],[ac_cv_var_timezone=no])])
 866 U_HAVE_TIMEZONE=0
 867 if test $ac_cv_var_timezone = yes; then
 868   U_TIMEZONE=timezone
 869   U_HAVE_TIMEZONE=1
 870 else
 871   AC_CACHE_CHECK(for __timezone,ac_cv_var___timezone,
 872   [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <time.h>]], [[__timezone = 1;]])],[ac_cv_var___timezone=yes],[ac_cv_var___timezone=no])])
 873   if test $ac_cv_var___timezone = yes; then
 874     U_TIMEZONE=__timezone
 875     U_HAVE_TIMEZONE=1
 876   else
 877     AC_CACHE_CHECK(for _timezone,ac_cv_var__timezone,
 878     [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <time.h>]], [[_timezone = 1;]])],[ac_cv_var__timezone=yes],[ac_cv_var__timezone=no])])
 879     if test $ac_cv_var__timezone = yes; then
 880       U_TIMEZONE=_timezone
 881       U_HAVE_TIMEZONE=1
 882     else
 883      CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_TIMEZONE=0"
 884     fi
 885   fi
 886 fi
 887 AC_SUBST(U_HAVE_TIMEZONE)
 888 AC_SUBST(U_TIMEZONE)
 889
 890 # Checks for typedefs
 891 AC_CHECK_TYPE(int8_t,signed char)
 892 AC_CHECK_TYPE(uint8_t,unsigned char)
 893 AC_CHECK_TYPE(int16_t,signed short)
 894 AC_CHECK_TYPE(uint16_t,unsigned short)
 895 AC_CHECK_TYPE(int32_t,signed long)
 896 AC_CHECK_TYPE(uint32_t,unsigned long)
 897 AC_CHECK_TYPE(int64_t,signed long long)
 898 AC_CHECK_TYPE(uint64_t,unsigned long long)
 899
 900 if test $ac_cv_type_int8_t = no; then
 901 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_INT8_T=0"
 902 fi
 903
 904 if test $ac_cv_type_uint8_t = no; then
 905 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_UINT8_T=0"
 906 fi
 907
 908 if test $ac_cv_type_int16_t = no; then
 909 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_INT16_T=0"
 910 fi
 911
 912 if test $ac_cv_type_uint16_t = no; then
 913 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_UINT16_T=0"
 914 fi
 915
 916 if test $ac_cv_type_int32_t = no; then
 917 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_INT32_T=0"
 918 fi
 919
 920 if test $ac_cv_type_uint32_t = no; then
 921 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_UINT32_T=0"
 922 fi
 923
 924 if test $ac_cv_type_int64_t = no; then
 925 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_INT64_T=0"
 926 fi
 927
 928 if test $ac_cv_type_uint64_t = no; then
 929 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_UINT64_T=0"
 930 fi
 931
 932 # Do various wchar_t related checks
 933 AC_CHECK_HEADER(wchar.h)
 934 if test "$ac_cv_header_wchar_h" = no
 935 then
 936     U_HAVE_WCHAR_H=0
 937     U_HAVE_WCSCPY=0
 938     CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_WCHAR_H=0 -DU_HAVE_WCSCPY=0"
 939 else
 940     AC_DEFINE([HAVE_WCHAR_H], [1], [wchar.h was found.])
 941     U_HAVE_WCHAR_H=1
 942     # Some broken systems have wchar.h but not some of its functions...
 943     AC_SEARCH_LIBS(wcscpy, wcs w)
 944     if test "$ac_cv_search_wcscpy" != no; then
 945       U_HAVE_WCSCPY=1
 946     else
 947       U_HAVE_WCSCPY=0
 948       CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_WCSCPY=0"
 949     fi
 950 fi
 951 AC_SUBST(U_HAVE_WCHAR_H)
 952 AC_SUBST(U_HAVE_WCSCPY)
 953
 954 AC_CHECK_SIZEOF([wchar_t], 0, [
 955 #if STDC_HEADERS
 956 #include <stddef.h>
 957 #endif
 958 #include <stdlib.h>
 959 #if HAVE_WCHAR_H
 960 #include <string.h>
 961 #include <wchar.h>
 962 #endif])
 963 U_SIZEOF_WCHAR_T=$ac_cv_sizeof_wchar_t
 964 # We do this check to verify that everything is okay.
 965 if test $U_SIZEOF_WCHAR_T = 0; then
 966     if test $U_HAVE_WCHAR_H=1; then
 967        AC_MSG_ERROR(There is wchar.h but the size of wchar_t is 0)
 968     fi
 969 fi
 970
 971 AC_MSG_CHECKING([for UTF-16 string literal support])
 972 U_CHECK_UTF16_STRING=1
 973 CHECK_UTF16_STRING_RESULT="unknown"
 974
 975 case "${host}" in
 976 *-*-aix*|powerpc64-*-linux*)
 977     if test "$GCC" = no; then
 978         OLD_CFLAGS="${CFLAGS}"
 979         OLD_CXXFLAGS="${CXXFLAGS}"
 980         CFLAGS="${CFLAGS} -qutf"
 981         CXXFLAGS="${CXXFLAGS} -qutf"
 982         AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[const unsigned short hello[] = u"hello";]], [[]])],[U_CHECK_UTF16_STRING=1],[U_CHECK_UTF16_STRING=0])
 983         if test "$U_CHECK_UTF16_STRING" = 0; then
 984             CFLAGS="${OLD_CFLAGS}"
 985             CXXFLAGS="${OLD_CXXFLAGS}"
 986         else
 987             UCONFIG_CXXFLAGS="${UCONFIG_CXXFLAGS} -qutf"
 988             CHECK_UTF16_STRING_RESULT="-qutf"
 989         fi
 990     fi
 991     ;;
 992 *-*-solaris*)
 993     if test "$GCC" = no; then
 994         OLD_CFLAGS="${CFLAGS}"
 995         OLD_CXXFLAGS="${CXXFLAGS}"
 996         CFLAGS="${CFLAGS} -xustr=ascii_utf16_ushort"
 997         CXXFLAGS="${CXXFLAGS} -xustr=ascii_utf16_ushort"
 998         AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[const unsigned short hello[] = U"hello";]], [[]])],[U_CHECK_UTF16_STRING=1],[U_CHECK_UTF16_STRING=0])
 999         if test "$U_CHECK_UTF16_STRING" = 0; then
1000             CFLAGS="${OLD_CFLAGS}"
1001             CXXFLAGS="${OLD_CXXFLAGS}"
1002         else
1003             CHECK_UTF16_STRING_RESULT="-xustr=ascii_utf16_ushort"
1004             UCONFIG_CXXFLAGS="${UCONFIG_CXXFLAGS} -xustr=ascii_utf16_ushort"
1005             UCONFIG_CFLAGS="${UCONFIG_CFLAGS} -xustr=ascii_utf16_ushort"
1006             # Since we can't detect the availability of this UTF-16 syntax at compile time,
1007             # we depend on configure telling us that we can use it.
1008             # Since we can't ensure ICU users use -xustr=ascii_utf16_ushort,
1009             # we only use this macro within ICU.
1010             # If an ICU user uses icu-config, this feature will be enabled.
1011             CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_CHECK_UTF16_STRING=1"
1012             U_CHECK_UTF16_STRING=0
1013         fi
1014     fi
1015     ;;
1016 *-*-hpux*)
1017     if test "$GCC" = no; then
1018         # The option will be detected at compile time without additional compiler options.
1019         CHECK_UTF16_STRING_RESULT="available"
1020     fi
1021     ;;
1022 *-*-cygwin)
1023     # wchar_t can be used
1024     CHECK_UTF16_STRING_RESULT="available"
1025     ;;
1026 *)
1027     ;;
1028 esac
1029
1030 # GCC >= 4.4 supports UTF16 string literals. The CFLAGS and CXXFLAGS may change in the future.
1031 if test "$CHECK_UTF16_STRING_RESULT" = "unknown"; then
1032     if test "$GCC" = yes; then
1033         OLD_CFLAGS="${CFLAGS}"
1034         CFLAGS="${CFLAGS} -std=gnu99"
1035         AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1036 static const char16_t test[] = u"This is a UTF16 literal string.";
1037         ]], [[]])],[CC_UTF16_STRING=1],[CC_UTF16_STRING=0])
1038         if test "$CC_UTF16_STRING" = 1; then
1039             UCONFIG_CFLAGS="${UCONFIG_CFLAGS} -std=gnu99"
1040             CHECK_UTF16_STRING_RESULT="C only";
1041         else
1042             CFLAGS="${OLD_CFLAGS}"
1043         fi
1044     fi
1045     if test "$GXX" = yes; then
1046         # -Wno-return-type-c-linkage is desired so that stable ICU API is not warned about.
1047         AC_LANG_PUSH([C++])
1048         AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1049 static const char16_t test[] = u"This is a UTF16 literal string.";
1050         ]], [[]])],[CXX_UTF16_STRING=1],[CXX_UTF16_STRING=0])
1051         AC_LANG_POP([C++])
1052         if test "$CXX_UTF16_STRING" = 1; then
1053             if test "$CC_UTF16_STRING" = 1; then
1054                 CHECK_UTF16_STRING_RESULT="available";
1055             else
1056                 CHECK_UTF16_STRING_RESULT="C++ only";
1057             fi
1058         fi
1059     fi
1060 fi
1061 AC_MSG_RESULT($CHECK_UTF16_STRING_RESULT)
1062
1063 # Enable/disable extras
1064 AC_ARG_ENABLE(extras,
1065         [  --enable-extras         build ICU extras [default=yes]],
1066         [case "${enableval}" in
1067                 yes) extras=true ;;
1068                 no)  extras=false ;;
1069                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-extras) ;;
1070                 esac],
1071         extras=true)
1072 ICU_CONDITIONAL(EXTRAS, test "$extras" = true)
1073 AC_ARG_ENABLE(icuio,
1074         [  --enable-icuio          build ICU's icuio library [default=yes]],
1075         [case "${enableval}" in
1076                 yes) icuio=true ;;
1077                 no)  icuio=false ;;
1078                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-icuio) ;;
1079                 esac],
1080         icuio=true)
1081 ICU_CONDITIONAL(ICUIO, test "$icuio" = true)
1082
1083 # Enable/disable layout
1084 AC_ARG_ENABLE(layout,
1085         [  --enable-layout         build ICU's DEPRECATED layout library [default=yes]],
1086         [case "${enableval}" in
1087                 yes) layout=true ;;
1088                 no)  layout=false ;;
1089                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-layout) ;;
1090                 esac],
1091         layout=true)
1092 ICU_CONDITIONAL(LAYOUT, test "$layout" = true)
1093
1094 # Enable/disable layoutex
1095 AC_ARG_ENABLE(layoutex,
1096         [  --enable-layoutex         build ICU's Paragraph Layout library [default=same-as-layout].
1097             If not building with the ICU Layout library, then icu-le-hb must be installed via pkg-config.
1098             See http://harfbuzz.org],
1099         [case "${enableval}" in
1100                 yes) layoutex=true ;;
1101                 no)  layoutex=false ;;
1102                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-layoutex) ;;
1103                 esac],
1104         layoutex=$layout)
1105 ICU_CONDITIONAL(LAYOUTEX, test "$layoutex" = true)
1106
1107 # Enable/disable tools
1108 AC_ARG_ENABLE(tools,
1109         [  --enable-tools         build ICU's tools [default=yes]],
1110         [case "${enableval}" in
1111                 yes) tools=true ;;
1112                 no)  tools=false ;;
1113                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-tools) ;;
1114                 esac],
1115         tools=true)
1116 ICU_CONDITIONAL(TOOLS, test "$tools" = true)
1117
1118 AC_ARG_WITH(data-packaging,
1119         [  --with-data-packaging     specify how to package ICU data. Possible values:
1120         files    raw files (.res, etc)
1121         archive  build a single icudtXX.dat file
1122         library  shared library (.dll/.so/etc.)
1123         static   static library (.a/.lib/etc.)
1124         auto     build shared if possible (default)
1125            See http://userguide.icu-project.org/icudata for more info.],
1126         [case "${withval}" in
1127                 files|archive|library) datapackaging=$withval ;;
1128                 auto) datapackaging=$withval ;;
1129                 common) datapackaging=archive ;;
1130                 dll) datapackaging=library ;;
1131                 static) datapackaging=static ;;
1132                 *) AC_MSG_ERROR(bad value ${withval} for --with-data-packaging) ;;
1133                 esac],
1134         [datapackaging=])
1135
1136 # Note:  'thesysconfdir' is an evaluated version, for Man pages, so also for thedatadir, thelibdir, etc..
1137 # thesysconfdir=`eval echo $sysconfdir`
1138 dnl# AC_SUBST(thesysconfdir)
1139 dnl# thelibdir=`test "x$exec_prefix" = xNONE && exec_prefix="$prefix"; eval echo $libdir`
1140 dnl# AC_SUBST(thelibdir)
1141 thedatadir=`eval echo $datadir`
1142 dnl# AC_SUBST(thedatadir)
1143 # 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}.
1144 pkgicudatadir=$datadir
1145 thepkgicudatadir=$thedatadir
1146 AC_SUBST(pkgicudatadir)
1147 AC_SUBST(thepkgicudatadir)
1148
1149 dnl# Shouldn't need the AC_SUBST
1150
1151 if test x"$datapackaging" = x -o x"$datapackaging" = xauto; then
1152         # default to library
1153         datapackaging=library
1154         if test "$ENABLE_STATIC" = "YES"; then
1155                 if test "$ENABLE_SHARED" != "YES"; then
1156                         datapackaging=static
1157                 fi
1158         fi
1159 fi
1160
1161 datapackaging_dir=`eval echo $thedatadir`"/icu/${VERSION}"
1162
1163 datapackaging_msg="(No explaination for mode $datapackaging.)"
1164
1165 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."
1166 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."
1167 datapackaging_howfound="(unknown)"
1168
1169 case "$datapackaging" in
1170     files)
1171     DATA_PACKAGING_MODE=files
1172     datapackaging_msg="ICU data will be stored in individual files."
1173     datapackaging_howfound="$datapackaging_msg_path"
1174     ;;
1175     archive)
1176     DATA_PACKAGING_MODE=common
1177     datapackaging_msg="ICU data will be stored in a single .dat file."
1178     datapackaging_howfound="$datapackaging_msg_path"
1179     ;;
1180     library)
1181     DATA_PACKAGING_MODE=dll
1182     datapackaging_msg="ICU data will be linked with ICU."
1183     if test "$ENABLE_STATIC" = "YES"; then
1184         datapackaging_msg="$datapackaging_msg A static data library will be built. "
1185     fi
1186     if test "$ENABLE_SHARED" = "YES"; then
1187         datapackaging_msg="$datapackaging_msg A shared data library will be built. "
1188     fi
1189     datapackaging_howfound="$datapackaging_msg_set"
1190     ;;
1191     static)
1192     DATA_PACKAGING_MODE=static
1193     datapackaging_msg="ICU data will be stored in a static library."
1194     datapackaging_howfound="$datapackaging_msg_set"
1195     ;;
1196 esac
1197 AC_SUBST(DATA_PACKAGING_MODE)
1198
1199 # Sets a library suffix
1200 AC_MSG_CHECKING([for a library suffix to use])
1201 AC_ARG_WITH(library-suffix,
1202         [  --with-library-suffix=suffix    tag a suffix to the library names [default=]],
1203         [ICULIBSUFFIX="${withval}"],
1204         [ICULIBSUFFIX=])
1205 msg=$ICULIBSUFFIX
1206 if test "$msg" = ""; then
1207     msg=none
1208 fi
1209 AC_MSG_RESULT($msg)
1210 AC_SUBST(ICULIBSUFFIX)
1211 if test "$ICULIBSUFFIX" != ""
1212 then
1213     U_HAVE_LIB_SUFFIX=1
1214     ICULIBSUFFIXCNAME=`echo _$ICULIBSUFFIX | sed 's/[^A-Za-z0-9_]/_/g'`
1215     UCONFIG_CPPFLAGS="${UCONFIG_CPPFLAGS} -DU_HAVE_LIB_SUFFIX=1 -DU_LIB_SUFFIX_C_NAME=${ICULIBSUFFIXCNAME} "
1216 else
1217     U_HAVE_LIB_SUFFIX=0
1218 fi
1219 AC_SUBST(U_HAVE_LIB_SUFFIX)
1220 AC_SUBST(ICULIBSUFFIXCNAME)
1221
1222 # Enable/disable tests
1223 AC_ARG_ENABLE(tests,
1224         [  --enable-tests          build ICU tests [default=yes]],
1225         [case "${enableval}" in
1226                 yes) tests=true ;;
1227                 no)  tests=false ;;
1228                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-tests) ;;
1229                 esac],
1230         tests=true)
1231 ICU_CONDITIONAL(TESTS, test "$tests" = true)
1232
1233 # Enable/disable samples
1234 AC_ARG_ENABLE(samples,
1235         [  --enable-samples        build ICU samples [default=yes]
1236
1237 Additionally, the variable FORCE_LIBS may be set before calling configure.
1238 If set, it will REPLACE any automatic list of libraries.],
1239         [case "${enableval}" in
1240                 yes) samples=true ;;
1241                 no)  samples=false ;;
1242                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-samples) ;;
1243                 esac],
1244         samples=true)
1245 ICU_CONDITIONAL(SAMPLES, test "$samples" = true)
1246
1247 ICUDATA_CHAR=$U_ENDIAN_CHAR
1248
1249 # Platform-specific Makefile setup
1250 # set ICUDATA_CHAR to 'e' for any EBCDIC (which should be big endian) platform.
1251 case "${host}" in
1252         *-*-solaris*)   platform=U_SOLARIS ;;
1253         *-*-linux*|*-*-gnu|*-*-k*bsd*-gnu|*-*-kopensolaris*-gnu)        platform=U_LINUX ;;
1254         *-*-*bsd*|*-*-dragonfly*)       platform=U_BSD ;;
1255         *-*-aix*)       platform=U_AIX ;;
1256         *-*-hpux*)      platform=U_HPUX ;;
1257         *-apple-darwin*|*-apple-rhapsody*)      platform=U_DARWIN ;;
1258         *-*-cygwin*)    platform=U_CYGWIN ;;
1259         *-*-mingw*)     platform=U_MINGW ;;
1260         *-*ibm-openedition*|*-*-os390*) platform=OS390
1261                         if test "${ICU_ENABLE_ASCII_STRINGS}" != "1"; then
1262                                 ICUDATA_CHAR="e"
1263                         fi ;;
1264         *-*-os400*)     platform=OS400
1265                         if test "${ICU_ENABLE_ASCII_STRINGS}" != "1"; then
1266                                 ICUDATA_CHAR="e"
1267                         fi ;;
1268         *-*-nto*)       platform=U_QNX ;;
1269         *-dec-osf*)     platform=U_OSF ;;
1270         *-*-beos)               platform=U_BEOS ;;
1271         *-*-irix*)              platform=U_IRIX ;;
1272         *-ncr-*)                platform=U_MPRAS ;;
1273         *)              platform=U_UNKNOWN_PLATFORM ;;
1274 esac
1275 AC_SUBST(ICUDATA_CHAR)
1276 AC_SUBST(platform)
1277 platform_make_fragment_name="$icu_cv_host_frag"
1278 platform_make_fragment='$(top_srcdir)/config/'"$platform_make_fragment_name"
1279 AC_SUBST(platform_make_fragment_name)
1280 AC_SUBST(platform_make_fragment)
1281
1282 if test "${FORCE_LIBS}" != ""; then
1283    echo " *** Overriding automatically chosen [LIBS=$LIBS], using instead [FORCE_LIBS=${FORCE_LIBS}]"  1>&6
1284    LIBS=${FORCE_LIBS}
1285 fi
1286
1287 # Now that we're done using CPPFLAGS etc. for tests, we can change it
1288 # for build.
1289
1290 if test "${CC}" == "clang"; then
1291    CLANGCFLAGS="-Qunused-arguments -Wno-parentheses-equality"
1292 else
1293    CLANGCFLAGS=""
1294 fi
1295
1296 if test "${CXX}" == "clang++"; then
1297    CLANGCXXFLAGS="-Qunused-arguments -Wno-parentheses-equality"
1298 else
1299    CLANGCXXFLAGS=""
1300 fi
1301
1302 CPPFLAGS="$CPPFLAGS \$(THREADSCPPFLAGS)"
1303 CFLAGS="$CFLAGS \$(THREADSCFLAGS) $CLANGCFLAGS"
1304 CXXFLAGS="$CXXFLAGS \$(THREADSCXXFLAGS) $CLANGCXXFLAGS"
1305
1306 AC_SUBST(LIBCFLAGS)
1307 AC_SUBST(LIBCXXFLAGS)
1308
1309 # append all config cppflags
1310 CPPFLAGS="$CPPFLAGS $CONFIG_CPPFLAGS $UCONFIG_CPPFLAGS"
1311
1312 echo "CPPFLAGS=$CPPFLAGS"
1313 echo "CFLAGS=$CFLAGS"
1314 echo "CXXFLAGS=$CXXFLAGS"
1315
1316
1317 # output the Makefiles
1318 AC_CONFIG_FILES([icudefs.mk \
1319                 Makefile \
1320                 data/pkgdataMakefile \
1321                 config/Makefile.inc \
1322                 config/icu.pc \
1323                 config/pkgdataMakefile \
1324                 data/Makefile \
1325                 stubdata/Makefile \
1326                 common/Makefile \
1327                 i18n/Makefile \
1328                 layout/Makefile \
1329                 layoutex/Makefile \
1330                 io/Makefile \
1331                 extra/Makefile \
1332                 extra/uconv/Makefile \
1333                 extra/uconv/pkgdataMakefile \
1334                 extra/scrptrun/Makefile \
1335                 tools/Makefile \
1336                 tools/ctestfw/Makefile \
1337                 tools/toolutil/Makefile \
1338                 tools/makeconv/Makefile \
1339                 tools/genrb/Makefile \
1340                 tools/genccode/Makefile \
1341                 tools/gencmn/Makefile \
1342                 tools/gencnval/Makefile \
1343                 tools/gendict/Makefile \
1344                 tools/gentest/Makefile \
1345                 tools/gennorm2/Makefile \
1346                 tools/genbrk/Makefile \
1347                 tools/gensprep/Makefile \
1348                 tools/icuinfo/Makefile \
1349                 tools/icupkg/Makefile \
1350                 tools/icuswap/Makefile \
1351                 tools/pkgdata/Makefile \
1352                 tools/tzcode/Makefile \
1353                 tools/gencfu/Makefile \
1354                 test/Makefile \
1355                 test/compat/Makefile \
1356                 test/testdata/Makefile \
1357                 test/testdata/pkgdataMakefile \
1358                 test/hdrtst/Makefile \
1359                 test/intltest/Makefile \
1360                 test/cintltst/Makefile \
1361                 test/iotest/Makefile \
1362                 test/letest/Makefile \
1363                 test/perf/Makefile \
1364                 test/perf/collationperf/Makefile \
1365                 test/perf/collperf/Makefile \
1366                 test/perf/collperf2/Makefile \
1367                 test/perf/dicttrieperf/Makefile \
1368                 test/perf/ubrkperf/Makefile \
1369                 test/perf/charperf/Makefile \
1370                 test/perf/convperf/Makefile \
1371                 test/perf/normperf/Makefile \
1372                 test/perf/DateFmtPerf/Makefile \
1373                 test/perf/howExpensiveIs/Makefile \
1374                 test/perf/strsrchperf/Makefile \
1375                 test/perf/unisetperf/Makefile \
1376                 test/perf/usetperf/Makefile \
1377                 test/perf/ustrperf/Makefile \
1378                 test/perf/utfperf/Makefile \
1379                 test/perf/utrie2perf/Makefile \
1380                 test/perf/leperf/Makefile \
1381                 samples/Makefile samples/date/Makefile \
1382                 samples/cal/Makefile samples/layout/Makefile])
1383 AC_OUTPUT
1384
1385 echo
1386 echo "ICU for C/C++ $VERSION is ready to be built."
1387 echo "=== Important Notes: ==="
1388
1389 echo "Data Packaging: $datapackaging"
1390 echo " This means: $datapackaging_msg"
1391 echo " To locate data: $datapackaging_howfound"
1392
1393 if test -n "`$U_MAKE -v 2>&1 | grep '^GNU Make'`"; then
1394 echo "Building ICU: Use a GNU make such as $U_MAKE to build ICU."
1395 else
1396 echo "** WARNING: $U_MAKE may not be GNU make."
1397 echo "This may cause ICU to fail to build. Please make sure that GNU make"
1398 echo "is in your PATH so that the configure script can detect its location."
1399 fi
1400 if test "x$AR" = "xfalse"; then
1401   echo "*** WARNING: Archiver ar not found. Set AR= or fix PATH. Some builds (such as static) may fail."
1402 fi
1403
1404 AC_MSG_CHECKING([the version of "$U_MAKE"])
1405 if "$U_MAKE" -f "$srcdir/config/gmakever.mk" PLATFORM="$platform"; then
1406 AC_MSG_RESULT([ok])
1407 else
1408 AC_MSG_RESULT([too old or test failed - try upgrading GNU Make])
1409 fi
1410
1411 AC_SUBST(UCONFIG_CPPFLAGS)
1412 if test -n "$UCONFIG_CPPFLAGS"; then
1413    HDRFILE="uconfig.h.prepend"
1414    echo "*** WARNING: You must set the following flags before code compiled against this ICU will function properly:"
1415    echo
1416    echo "   ${UCONFIG_CPPFLAGS}"
1417    echo
1418    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.'
1419    echo "Creating the file ${HDRFILE}"
1420    echo
1421    echo '---------------   ' "${HDRFILE}"
1422    echo > "${HDRFILE}"
1423    echo '/* ICU customizations: put these lines at the top of uconfig.h */' >> "${HDRFILE}"
1424    echo >> "${HDRFILE}"
1425    for flag in ${UCONFIG_CPPFLAGS};
1426    do
1427         echo " /* $flag */" >> "${HDRFILE}"
1428         case "${flag}" in
1429         -D*=*)
1430           [ \echo "${flag}" | sed -n 's%-D\([^=]*\)=%#define \1 %p' >> "${HDRFILE}" ]
1431           \echo >> "${HDRFILE}"
1432           ;;
1433         -D*)
1434           [ \echo "${flag}" | sed -n 's%-D\([^=]*\)%#define \1 %p' >> "${HDRFILE}" ]
1435           \echo >> "${HDRFILE}"
1436           ;;
1437         *)
1438           \echo "/*  Not sure how to handle this argument: ${flag} */" >> "${HDRFILE}"
1439           \echo >> "${HDRFILE}"
1440           ;;
1441         esac
1442    done
1443    cat "${HDRFILE}"
1444    \echo  "/* End of ${HDRFILE} ------------ */" >> "${HDRFILE}"
1445    echo >> "${HDRFILE}"
1446    echo '--------------- end ' "${HDRFILE}"
1447 fi
1448
1449 AC_SUBST(UCONFIG_CFLAGS)
1450 if test -n "$UCONFIG_CFLAGS"; then
1451    echo "C   apps may want to build with CFLAGS   = ${UCONFIG_CFLAGS}"
1452 fi
1453 AC_SUBST(UCONFIG_CXXFLAGS)
1454 if test -n "$UCONFIG_CXXFLAGS"; then
1455    echo "C++ apps may want to build with CXXFLAGS = ${UCONFIG_CXXFLAGS}"
1456 fi
1457
1458 if test "$tools" = false;
1459 then
1460         echo "## Note: you have disabled ICU's tools. This ICU cannot build its own data or tests."
1461         echo "## Expect build failures in the 'data', 'test', and other directories."
1462 fi
1463
1464 $as_unset _CXX_CXXSUFFIX