icuSources/configure.ac

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