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