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