icuSources/configure.in

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