icuSources/configure.ac

   1 # -*-autoconf-*-
   2 AC_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
  10 AC_PREREQ(2.69)
  11
  12 # Process this file with autoreconf to produce a configure script
  13 AC_INIT([ICU],
  14         m4_esyscmd_s([sed -n 's/^[      ]*#[    ]*define[       ]*U_ICU_VERSION[        ]*"\([^"]*\)".*/\1/p' "./common/unicode/uvernum.h]"),
  15         [http://icu-project.org/bugs],
  16         [International Components for Unicode],
  17         [http://icu-project.org])
  18
  19 # Instruct Python to never write any byte code to the ICU source tree.
  20 PYTHONDONTWRITEBYTECODE=1
  21 export PYTHONDONTWRITEBYTECODE
  22
  23 AC_CONFIG_MACRO_DIR([config/m4])
  24 AC_CONFIG_SRCDIR([common/unicode/utypes.h])
  25
  26 PACKAGE="icu"
  27 AC_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)
  33 ICU_ECHO_C= ICU_ECHO_N= ICU_ECHO_T=
  34 case `/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';;
  42 esac
  43 AC_SUBST(ICU_ECHO_N)
  44 AC_SUBST(ICU_ECHO_C)
  45 AC_SUBST(ICU_ECHO_T)
  46
  47 AC_MSG_CHECKING(for ICU version numbers)
  48
  49 # Get the ICU version from uversion.h or other headers
  50 geticuversion() {
  51     [sed -n 's/^[       ]*#[    ]*define[       ]*U_ICU_VERSION[        ]*"\([^"]*\)".*/\1/p' "$@"]
  52 }
  53 getuversion() {
  54     [sed -n 's/^[       ]*#[    ]*define[       ]*U_UNICODE_VERSION[    ]*"\([^"]*\)".*/\1/p' "$@"]
  55 }
  56 VERSION=`geticuversion $srcdir/common/unicode/uvernum.h`
  57 if test x"$VERSION" = x; then
  58    as_fn_error $? "Cannot determine ICU version number from uvernum.h header file" "$LINENO" 5
  59 fi
  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
  66 UNICODE_VERSION=`getuversion $srcdir/common/unicode/uchar.h`
  67 if test x"$UNICODE_VERSION" = x; then
  68     AC_MSG_ERROR([Cannot determine Unicode version number from uchar.h header file])
  69 fi
  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/'`]
  74 LIB_VERSION=$VERSION
  75 LIB_VERSION_MAJOR=`echo $LIB_VERSION | sed 's/\..*//'`
  76 AC_SUBST(VERSION)
  77 AC_SUBST(LIB_VERSION)
  78 AC_SUBST(LIB_VERSION_MAJOR)
  79 AC_MSG_RESULT([release $VERSION, library $LIB_VERSION, unicode version $UNICODE_VERSION])
  80
  81 AC_SUBST(UNICODE_VERSION)
  82
  83 # Determine the host system
  84 AC_CANONICAL_HOST
  85
  86 AC_SUBST(CPPFLAGS)
  87
  88 # This variable is needed on z/OS because the C++ compiler only recognizes .C
  89 _CXX_CXXSUFFIX=cpp
  90 export _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
  96 CONFIG_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
 102 UCONFIG_CPPFLAGS=""
 103 # UCONFIG_CFLAGS: contains a copy of anything that needs to be set by end users
 104 # such as -std
 105 UCONFIG_CFLAGS=""
 106
 107 # Check whether to install icu-config
 108 AC_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])
 115 AC_SUBST(INSTALL_ICU_CONFIG, [$enable_icu_config])
 116
 117 # Check whether to build debug libraries
 118 AC_MSG_CHECKING([whether to build debug libraries])
 119 enabled=no
 120 ENABLE_DEBUG=0
 121 AC_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 )
 128 AC_MSG_RESULT($enabled)
 129 AC_SUBST(ENABLE_DEBUG)
 130
 131 # Check whether to build release libraries
 132 AC_MSG_CHECKING([whether to build release libraries])
 133 enabled=yes
 134 ENABLE_RELEASE=1
 135 AC_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 )
 142 AC_MSG_RESULT($enabled)
 143 AC_SUBST(ENABLE_RELEASE)
 144
 145 # Don't use the default C/CXXFLags
 146 : ${CFLAGS=""}
 147 : ${CXXFLAGS=""}
 148
 149 # Checks for compilers
 150 AC_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.
 153 AC_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
 156 PKG_PROG_PKG_CONFIG([0.20])
 157 PKG_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
 161 if 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
 178 fi
 179
 180 AC_PROG_CPP
 181
 182 AC_PROG_INSTALL
 183
 184 AC_SUBST(cross_compiling)
 185
 186 dnl use the pld hack to get ac_fn_cxx_try_link defined globally and not local
 187 AC_LANG_PUSH([C++])
 188 AC_LINK_IFELSE([AC_LANG_PROGRAM()])
 189 AC_LANG_POP([C++])
 190
 191 # make sure install is relative to srcdir - if a script
 192 if 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
 197 fi
 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.
 203 AC_CHECK_PROGS(PYTHON, python3 "py -3" python "py")
 204 AC_SUBST(PYTHON)
 205
 206 # Check for the platform make
 207 AC_PATH_PROGS(U_MAKE, gmake gnumake, make)
 208 AC_SUBST(U_MAKE)
 209
 210
 211 AC_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
 216 if 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
 221 else
 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
 231 fi
 232 AC_SUBST(cross_buildroot)
 233
 234 # Check for doxygen to generate documentation
 235 AC_PATH_PROG(DOXYGEN,doxygen,,$PATH:/usr/local/bin:/usr/bin)
 236
 237 # Check that the linker is usable
 238 ICU_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.
 243 AC_MSG_CHECKING(checking for executable suffix)
 244 case "${host}" in
 245     *-*-cygwin*|*-*-mingw*)  EXEEXT=.exe ;;
 246     *)      EXEEXT="" ;;
 247 esac
 248 ac_exeext=$EXEEXT
 249 AC_MSG_RESULT($EXEEXT)
 250 AC_SUBST(EXEEXT)
 251
 252 # Determine how strict we want to be when compiling
 253 AC_CHECK_STRICT_COMPILE
 254
 255 # Check if we can build and use 64-bit libraries
 256 AC_CHECK_64BIT_LIBS
 257 AC_SUBST(ARFLAGS)
 258 AC_SUBST(COMPILE_LINK_ENVVAR)
 259
 260 # Determine the Makefile fragment
 261 ICU_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)
 266 case "${host}" in
 267         *-*-hpux*)      AC_CHECK_LIB(m, floor, LIB_M="-lm") ;;
 268
 269         *)              AC_CHECK_LIB(m, floor)
 270                         LIB_M="" ;;
 271 esac
 272 AC_SUBST(LIB_M)
 273
 274 # Check whether to build shared libraries
 275 AC_MSG_CHECKING([whether to build shared libraries])
 276 enabled=no
 277 AC_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 )
 286 AC_MSG_RESULT($enabled)
 287 AC_SUBST(ENABLE_SHARED)
 288
 289 # Check whether to build static libraries
 290 AC_MSG_CHECKING([whether to build static libraries])
 291 enabled=no
 292 AC_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 )
 300 AC_MSG_RESULT($enabled)
 301 AC_SUBST(ENABLE_STATIC)
 302
 303 # When building release static library, there might be some optimization flags we can use
 304 if 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
 332 fi
 333
 334
 335 # Check whether to enable auto cleanup of libraries
 336 AC_MSG_CHECKING([whether to enable auto cleanup of libraries])
 337 enabled=no
 338 UCLN_NO_AUTO_CLEANUP=1
 339 AC_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 )
 349 AC_MSG_RESULT($enabled)
 350 AC_SUBST(UCLN_NO_AUTO_CLEANUP)
 351
 352 # MSVC floating-point option
 353 MSVC_RELEASE_FLAG=""
 354 if test $enabled = yes
 355 then
 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
 368 fi
 369
 370 # Check whether to enabled draft APIs
 371 AC_MSG_CHECKING([whether to enable draft APIs])
 372 enabled=yes
 373 U_DEFAULT_SHOW_DRAFT=1
 374 AC_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 )
 383 AC_MSG_RESULT($enabled)
 384 # Make sure that we can use draft API in ICU.
 385 if test "$U_DEFAULT_SHOW_DRAFT" = 0; then
 386     CONFIG_CPPFLAGS="$CONFIG_CPPFLAGS -DU_SHOW_DRAFT_API -DU_SHOW_INTERNAL_API"
 387 fi
 388 AC_SUBST(U_DEFAULT_SHOW_DRAFT)
 389
 390 AC_PROG_RANLIB
 391
 392 # need sed
 393 AC_PROG_SED
 394
 395 # look for 'ar' the proper way
 396 AC_CHECK_TOOL(AR, ar, false)
 397
 398 AC_MSG_CHECKING([whether to enable renaming of symbols])
 399 enabled=yes
 400 U_DISABLE_RENAMING=0
 401 AC_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 )
 411 AC_MSG_RESULT($enabled)
 412 AC_SUBST(U_DISABLE_RENAMING)
 413
 414 AC_MSG_CHECKING([whether to enable function and data tracing])
 415 enabled=no
 416 U_ENABLE_TRACING=0
 417 AC_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 )
 427 AC_MSG_RESULT($enabled)
 428 AC_SUBST(U_ENABLE_TRACING)
 429
 430 # check if elf.h is present.
 431 AC_CHECK_HEADERS([elf.h])
 432 if test "x$ac_cv_header_elf_h" = "xyes"; then
 433     CONFIG_CPPFLAGS="$CONFIG_CPPFLAGS -DU_HAVE_ELF_H=1";
 434 fi
 435
 436 # Enable/disable plugins
 437 AC_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)
 445 ICU_CONDITIONAL(PLUGINS, test "$plugins" = true)
 446
 447 if test "x$plugins" = "xtrue"; then
 448    UCONFIG_CPPFLAGS="$UCONFIG_CPPFLAGS -DUCONFIG_ENABLE_PLUGINS=1"
 449 fi
 450
 451
 452 U_ENABLE_DYLOAD=1
 453 enable=yes
 454 AC_MSG_CHECKING([whether to enable dynamic loading of plugins. Ignored if plugins disabled.])
 455 AC_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 )
 470 AC_MSG_RESULT($enable)
 471 AC_SUBST(U_ENABLE_DYLOAD)
 472
 473 if 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
 482 fi
 483
 484 # Check for miscellanous functions.
 485 # So, use for putil / tools only.
 486 # Note that this will generate HAVE_GETTIMEOFDAY, not U_HAVE_GETTIMEOFDAY
 487 AC_CHECK_FUNCS([gettimeofday])
 488
 489
 490 # Check whether to use the evil rpath or not
 491 AC_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 )
 500 AC_SUBST(ENABLE_RPATH)
 501
 502
 503
 504 AC_LANG_PUSH([C++])
 505 AC_MSG_CHECKING([[if we have a C++ compiler]])
 506 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],[[]])],[cxx_okay=yes],[cxx_okay=no])
 507 if test $cxx_okay = yes
 508 then
 509         AC_MSG_RESULT([[Good]])
 510 else
 511         AC_MSG_RESULT([[no]])
 512         AC_MSG_ERROR([[C++ compiler $CXX does not work or no compiler found]])
 513 fi
 514
 515 if [[ "$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
 536 fi
 537
 538 AC_LANG_POP([C++])
 539
 540 # Always build ICU with multi-threading support.
 541 OLD_LIBS=${LIBS}
 542
 543 # For Compaq Tru64 (OSF1), we must look for pthread_attr_init
 544 # and must do this before seaching 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
 549 AC_CHECK_LIB(pthread, pthread_attr_init)
 550 if test $ac_cv_lib_pthread_pthread_attr_init = yes; then
 551   :
 552 else
 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
 576 fi
 577 # Check to see if we are using CygWin with MSVC
 578 case "${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   ;;
 605 esac
 606
 607 AC_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])
 617 AC_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.
 623 HAVE_MMAP=0
 624 AC_MSG_CHECKING([for mmap])
 625 AC_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])] )
 630 AC_MSG_RESULT($ac_cv_func_mmap_ok)
 631 if test $ac_cv_func_mmap_ok = yes
 632 then
 633     HAVE_MMAP=1
 634 else
 635     CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_MMAP=0"
 636 fi
 637 AC_SUBST(HAVE_MMAP)
 638
 639 AC_MSG_CHECKING([for genccode assembly])
 640
 641 # Check to see if genccode can generate simple assembly.
 642 GENCCODE_ASSEMBLY=
 643 case "${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 ;;
 649 i*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 ;;
 663 sparc-*-solaris*)
 664     GENCCODE_ASSEMBLY="-a sun"
 665     ;;
 666 ia64-*-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     ;;
 672 esac
 673 AC_SUBST(GENCCODE_ASSEMBLY)
 674
 675 AC_MSG_RESULT($GENCCODE_ASSEMBLY)
 676
 677 # Checks for header files
 678 AC_CHECK_HEADERS(inttypes.h)
 679 if test $ac_cv_header_inttypes_h = no; then
 680  U_HAVE_INTTYPES_H=0
 681  CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_INTTYPES_H=0"
 682 else
 683  U_HAVE_INTTYPES_H=1
 684 fi
 685 if 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
 691 fi
 692
 693 AC_SUBST(U_HAVE_INTTYPES_H)
 694
 695 AC_CHECK_HEADERS(dirent.h)
 696 if test $ac_cv_header_dirent_h = no; then
 697  U_HAVE_DIRENT_H=0
 698  CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_DIRENT_H=0"
 699 else
 700  U_HAVE_DIRENT_H=1
 701 fi
 702
 703 AC_SUBST(U_HAVE_DIRENT_H)
 704
 705 # Check for endianness
 706 AC_C_BIGENDIAN()
 707 if test $ac_cv_c_bigendian = no; then
 708 U_IS_BIG_ENDIAN=0
 709 U_ENDIAN_CHAR="l"
 710 else
 711 U_IS_BIG_ENDIAN=1
 712 U_ENDIAN_CHAR="b"
 713 fi
 714 AC_SUBST(U_IS_BIG_ENDIAN)
 715
 716 # Do various POSIX related checks
 717 U_HAVE_NL_LANGINFO_CODESET=0
 718 U_NL_LANGINFO_CODESET=-1
 719 AC_CHECK_FUNC(nl_langinfo,[U_HAVE_NL_LANGINFO=1],[U_HAVE_NL_LANGINFO=0])
 720 dnl AC_SUBST(U_HAVE_NL_LANGINFO)
 721 if 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
 739 fi
 740 AC_SUBST(U_HAVE_NL_LANGINFO_CODESET)
 741 AC_SUBST(U_NL_LANGINFO_CODESET)
 742
 743 # Namespace support checks
 744 AC_LANG(C++)
 745 AC_MSG_CHECKING([for namespace support])
 746 AC_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])] )
 751 AC_MSG_RESULT($ac_cv_namespace_ok)
 752 if test $ac_cv_namespace_ok = no
 753 then
 754     AC_MSG_ERROR(Namespace support is required to build ICU.)
 755 fi
 756
 757 AC_MSG_CHECKING([for properly overriding new and delete])
 758 U_OVERRIDE_CXX_ALLOCATION=0
 759 U_HAVE_PLACEMENT_NEW=0
 760 AC_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])] )
 770 AC_MSG_RESULT($ac_cv_override_cxx_allocation_ok)
 771 if test $ac_cv_override_cxx_allocation_ok = yes
 772 then
 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
 794 else
 795     CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_OVERRIDE_CXX_ALLOCATION=0"
 796 fi
 797 AC_SUBST(U_OVERRIDE_CXX_ALLOCATION)
 798 AC_SUBST(U_HAVE_PLACEMENT_NEW)
 799
 800 AC_LANG(C)
 801 AC_CHECK_FUNC(popen)
 802 if test x$ac_cv_func_popen = xyes
 803 then
 804      U_HAVE_POPEN=1
 805 else
 806      CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_POPEN=0"
 807      U_HAVE_POPEN=0
 808 fi
 809 AC_SUBST(U_HAVE_POPEN)
 810
 811 AC_CHECK_FUNC(tzset)
 812 U_HAVE_TZSET=0
 813 if test x$ac_cv_func_tzset = xyes
 814 then
 815     U_TZSET=tzset
 816     U_HAVE_TZSET=1
 817 else
 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
 826 fi
 827 AC_SUBST(U_HAVE_TZSET)
 828 AC_SUBST(U_TZSET)
 829
 830 U_HAVE_TZNAME=0
 831 AC_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.  */
 838 extern char *tzname[]; /* RS6000 and others reject char **tzname.  */
 839 #endif]], [atoi(*tzname);])],[ac_cv_var_tzname=yes],[ac_cv_var_tzname=no])])
 840 if test $ac_cv_var_tzname = yes; then
 841   U_TZNAME=tzname
 842   U_HAVE_TZNAME=1
 843 else
 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
 854 fi
 855 AC_SUBST(U_HAVE_TZNAME)
 856 AC_SUBST(U_TZNAME)
 857
 858 AC_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])])
 864 U_HAVE_TIMEZONE=0
 865 if test $ac_cv_var_timezone = yes; then
 866   U_TIMEZONE=timezone
 867   U_HAVE_TIMEZONE=1
 868 else
 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
 884 fi
 885 AC_SUBST(U_HAVE_TIMEZONE)
 886 AC_SUBST(U_TIMEZONE)
 887
 888 AC_CHECK_FUNC(strtod_l)
 889 if test x$ac_cv_func_strtod_l = xyes
 890 then
 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
 900 else
 901     CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_STRTOD_L=0"
 902     U_HAVE_STRTOD_L=0
 903 fi
 904 AC_SUBST(U_HAVE_STRTOD_L)
 905
 906 # Check if C++17 std::string_view is available.
 907 AC_LANG_PUSH([C++])
 908 AC_CHECK_TYPE(std::string_view, [], [], [[#include <string_view>]])
 909 if test "x$ac_cv_type_std__string_view" = xyes; then :
 910   CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_STRING_VIEW=1"
 911 fi
 912 AC_LANG_POP([C++])
 913
 914 # Checks for typedefs
 915 AC_CHECK_TYPE(int8_t,signed char)
 916 AC_CHECK_TYPE(uint8_t,unsigned char)
 917 AC_CHECK_TYPE(int16_t,signed short)
 918 AC_CHECK_TYPE(uint16_t,unsigned short)
 919 AC_CHECK_TYPE(int32_t,signed long)
 920 AC_CHECK_TYPE(uint32_t,unsigned long)
 921 AC_CHECK_TYPE(int64_t,signed long long)
 922 AC_CHECK_TYPE(uint64_t,unsigned long long)
 923
 924 if test $ac_cv_type_int8_t = no; then
 925 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_INT8_T=0"
 926 fi
 927
 928 if test $ac_cv_type_uint8_t = no; then
 929 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_UINT8_T=0"
 930 fi
 931
 932 if test $ac_cv_type_int16_t = no; then
 933 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_INT16_T=0"
 934 fi
 935
 936 if test $ac_cv_type_uint16_t = no; then
 937 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_UINT16_T=0"
 938 fi
 939
 940 if test $ac_cv_type_int32_t = no; then
 941 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_INT32_T=0"
 942 fi
 943
 944 if test $ac_cv_type_uint32_t = no; then
 945 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_UINT32_T=0"
 946 fi
 947
 948 if test $ac_cv_type_int64_t = no; then
 949 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_INT64_T=0"
 950 fi
 951
 952 if test $ac_cv_type_uint64_t = no; then
 953 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_UINT64_T=0"
 954 fi
 955
 956 # Do various wchar_t related checks
 957 AC_CHECK_HEADER(wchar.h)
 958 if test "$ac_cv_header_wchar_h" = no
 959 then
 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"
 963 else
 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
 974 fi
 975 AC_SUBST(U_HAVE_WCHAR_H)
 976 AC_SUBST(U_HAVE_WCSCPY)
 977
 978 AC_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])
 987 U_SIZEOF_WCHAR_T=$ac_cv_sizeof_wchar_t
 988 # We do this check to verify that everything is okay.
 989 if 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
 993 fi
 994
 995 AC_MSG_CHECKING([for UTF-16 string literal support])
 996 U_CHECK_UTF16_STRING=1
 997 CHECK_UTF16_STRING_RESULT="unknown"
 998
 999 case "${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     ;;
1052 esac
1053
1054 # GCC >= 4.4 supports UTF16 string literals. As of ICU 62, both C and C++ files require them.
1055 if test "$CHECK_UTF16_STRING_RESULT" = "unknown"; then
1056     if test "$GCC" = yes; then
1057         AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1058 static 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([[
1068 static 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
1079 fi
1080 AC_MSG_RESULT($CHECK_UTF16_STRING_RESULT)
1081
1082 # Enable/disable extras
1083 AC_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)
1091 ICU_CONDITIONAL(EXTRAS, test "$extras" = true)
1092 AC_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)
1100 ICU_CONDITIONAL(ICUIO, test "$icuio" = true)
1101
1102 # Enable/disable layoutex
1103 AC_ARG_ENABLE(layoutex,
1104         [  --enable-layoutex         build ICU's Paragraph Layout library [default=yes].
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=$have_icu_le_hb)
1112 ICU_CONDITIONAL(LAYOUTEX, test "$layoutex" = true)
1113
1114 # Enable/disable layout
1115 AC_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
1125 AC_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)
1133 ICU_CONDITIONAL(TOOLS, test "$tools" = true)
1134
1135 # Enable/disable fuzzer target tests.
1136 AC_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)
1144 ICU_CONDITIONAL(FUZZER, test "$fuzzer" = true)
1145
1146 AC_ARG_WITH(data-packaging,
1147         [  --with-data-packaging     specify how to package ICU data. Possible values:
1148         files    raw files (.res, etc)
1149         archive  build a single icudtXX.dat file
1150         library  shared library (.dll/.so/etc.)
1151         static   static library (.a/.lib/etc.)
1152         auto     build shared if possible (default)
1153            See http://userguide.icu-project.org/icudata for more info.],
1154         [case "${withval}" in
1155                 files|archive|library) datapackaging=$withval ;;
1156                 auto) datapackaging=$withval ;;
1157                 common) datapackaging=archive ;;
1158                 dll) datapackaging=library ;;
1159                 static) datapackaging=static ;;
1160                 *) AC_MSG_ERROR(bad value ${withval} for --with-data-packaging) ;;
1161                 esac],
1162         [datapackaging=])
1163
1164 # Note:  'thesysconfdir' is an evaluated version, for Man pages, so also for thedatadir, thelibdir, etc..
1165 # thesysconfdir=`eval echo $sysconfdir`
1166 dnl# AC_SUBST(thesysconfdir)
1167 dnl# thelibdir=`test "x$exec_prefix" = xNONE && exec_prefix="$prefix"; eval echo $libdir`
1168 dnl# AC_SUBST(thelibdir)
1169 thedatadir=`eval echo $datadir`
1170 dnl# AC_SUBST(thedatadir)
1171 # 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}.
1172 pkgicudatadir=$datadir
1173 thepkgicudatadir=$thedatadir
1174 AC_SUBST(pkgicudatadir)
1175 AC_SUBST(thepkgicudatadir)
1176
1177 dnl# Shouldn't need the AC_SUBST
1178
1179 if test x"$datapackaging" = x -o x"$datapackaging" = xauto; then
1180         # default to library
1181         datapackaging=library
1182         if test "$ENABLE_STATIC" = "YES"; then
1183                 if test "$ENABLE_SHARED" != "YES"; then
1184                         datapackaging=static
1185                 fi
1186         fi
1187 fi
1188
1189 datapackaging_dir=`eval echo $thedatadir`"/icu/${VERSION}"
1190
1191 datapackaging_msg="(No explaination for mode $datapackaging.)"
1192
1193 datapackaging_msg_path="ICU will look in $datapackaging_dir which is the installation location. Call u_setDataDirectory() or use the ICU_DATA environment variable to override."
1194 datapackaging_msg_set="ICU will use the linked data library. If linked with the stub library located in stubdata/, the application can use udata_setCommonData() or set a data path to override."
1195 datapackaging_howfound="(unknown)"
1196
1197 case "$datapackaging" in
1198     files)
1199     DATA_PACKAGING_MODE=files
1200     datapackaging_msg="ICU data will be stored in individual files."
1201     datapackaging_howfound="$datapackaging_msg_path"
1202     ;;
1203     archive)
1204     DATA_PACKAGING_MODE=common
1205     datapackaging_msg="ICU data will be stored in a single .dat file."
1206     datapackaging_howfound="$datapackaging_msg_path"
1207     ;;
1208     library)
1209     DATA_PACKAGING_MODE=dll
1210     datapackaging_msg="ICU data will be linked with ICU."
1211     if test "$ENABLE_STATIC" = "YES"; then
1212         datapackaging_msg="$datapackaging_msg A static data library will be built. "
1213     fi
1214     if test "$ENABLE_SHARED" = "YES"; then
1215         datapackaging_msg="$datapackaging_msg A shared data library will be built. "
1216     fi
1217     datapackaging_howfound="$datapackaging_msg_set"
1218     ;;
1219     static)
1220     DATA_PACKAGING_MODE=static
1221     datapackaging_msg="ICU data will be stored in a static library."
1222     datapackaging_howfound="$datapackaging_msg_set"
1223     ;;
1224 esac
1225 AC_SUBST(DATA_PACKAGING_MODE)
1226
1227 # Sets a library suffix
1228 AC_MSG_CHECKING([for a library suffix to use])
1229 AC_ARG_WITH(library-suffix,
1230         [  --with-library-suffix=suffix    tag a suffix to the library names [default=]],
1231         [ICULIBSUFFIX="${withval}"],
1232         [ICULIBSUFFIX=])
1233 msg=$ICULIBSUFFIX
1234 if test "$msg" = ""; then
1235     msg=none
1236 fi
1237 AC_MSG_RESULT($msg)
1238 AC_SUBST(ICULIBSUFFIX)
1239 if test "$ICULIBSUFFIX" != ""
1240 then
1241     U_HAVE_LIB_SUFFIX=1
1242     ICULIBSUFFIXCNAME=`echo _$ICULIBSUFFIX | sed 's/[^A-Za-z0-9_]/_/g'`
1243     UCONFIG_CPPFLAGS="${UCONFIG_CPPFLAGS} -DU_HAVE_LIB_SUFFIX=1 -DU_LIB_SUFFIX_C_NAME=${ICULIBSUFFIXCNAME} "
1244 else
1245     U_HAVE_LIB_SUFFIX=0
1246 fi
1247 AC_SUBST(U_HAVE_LIB_SUFFIX)
1248 AC_SUBST(ICULIBSUFFIXCNAME)
1249
1250 # Enable/disable tests
1251 AC_ARG_ENABLE(tests,
1252         [  --enable-tests          build ICU tests [default=yes]],
1253         [case "${enableval}" in
1254                 yes) tests=true ;;
1255                 no)  tests=false ;;
1256                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-tests) ;;
1257                 esac],
1258         tests=true)
1259 ICU_CONDITIONAL(TESTS, test "$tests" = true)
1260
1261 # Enable/disable samples
1262 AC_ARG_ENABLE(samples,
1263         [  --enable-samples        build ICU samples [default=yes]
1264
1265 Additionally, the variable FORCE_LIBS may be set before calling configure.
1266 If set, it will REPLACE any automatic list of libraries.],
1267         [case "${enableval}" in
1268                 yes) samples=true ;;
1269                 no)  samples=false ;;
1270                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-samples) ;;
1271                 esac],
1272         samples=true)
1273 ICU_CONDITIONAL(SAMPLES, test "$samples" = true)
1274
1275 ICUDATA_CHAR=$U_ENDIAN_CHAR
1276
1277 # Platform-specific Makefile setup
1278 # set ICUDATA_CHAR to 'e' for any EBCDIC (which should be big endian) platform.
1279 case "${host}" in
1280         *-*-solaris*)   platform=U_SOLARIS ;;
1281         *-*-linux*|*-*-gnu|*-*-k*bsd*-gnu|*-*-kopensolaris*-gnu)        platform=U_LINUX ;;
1282         *-*-*bsd*|*-*-dragonfly*)       platform=U_BSD ;;
1283         *-*-aix*)       platform=U_AIX ;;
1284         *-*-hpux*)      platform=U_HPUX ;;
1285         *-apple-darwin*|*-apple-rhapsody*)      platform=U_DARWIN ;;
1286         *-*-cygwin*)    platform=U_CYGWIN ;;
1287         *-*-mingw*)     platform=U_MINGW ;;
1288         *-*ibm-openedition*|*-*-os390*) platform=OS390
1289                         if test "${ICU_ENABLE_ASCII_STRINGS}" != "1"; then
1290                                 ICUDATA_CHAR="e"
1291                         fi ;;
1292         *-*-os400*)     platform=OS400
1293                         if test "${ICU_ENABLE_ASCII_STRINGS}" != "1"; then
1294                                 ICUDATA_CHAR="e"
1295                         fi ;;
1296         *-*-nto*)       platform=U_QNX ;;
1297         *-dec-osf*)     platform=U_OSF ;;
1298         *-*-beos)               platform=U_BEOS ;;
1299         *-*-irix*)              platform=U_IRIX ;;
1300         *-ncr-*)                platform=U_MPRAS ;;
1301         *)              platform=U_UNKNOWN_PLATFORM ;;
1302 esac
1303 AC_SUBST(ICUDATA_CHAR)
1304 AC_SUBST(platform)
1305 platform_make_fragment_name="$icu_cv_host_frag"
1306 platform_make_fragment='$(top_srcdir)/config/'"$platform_make_fragment_name"
1307 AC_SUBST(platform_make_fragment_name)
1308 AC_SUBST(platform_make_fragment)
1309
1310 if test "${FORCE_LIBS}" != ""; then
1311    echo " *** Overriding automatically chosen [LIBS=$LIBS], using instead [FORCE_LIBS=${FORCE_LIBS}]"  1>&6
1312    LIBS=${FORCE_LIBS}
1313 fi
1314
1315 # Now that we're done using CPPFLAGS etc. for tests, we can change it
1316 # for build.
1317
1318 if test "${CC}" = "clang"; then
1319    CLANGCFLAGS="-Qunused-arguments -Wno-parentheses-equality"
1320 else
1321    CLANGCFLAGS=""
1322 fi
1323
1324 if test "${CXX}" = "clang++"; then
1325    CLANGCXXFLAGS="-Qunused-arguments -Wno-parentheses-equality"
1326    LIBCXXFLAGS="$LIBCXXFLAGS -Wglobal-constructors"
1327 else
1328    CLANGCXXFLAGS=""
1329 fi
1330
1331 CPPFLAGS="$CPPFLAGS \$(THREADSCPPFLAGS)"
1332 CFLAGS="$CFLAGS \$(THREADSCFLAGS) $CLANGCFLAGS"
1333 CXXFLAGS="$CXXFLAGS \$(THREADSCXXFLAGS) $CLANGCXXFLAGS"
1334
1335 AC_SUBST(LIBCFLAGS)
1336 AC_SUBST(LIBCXXFLAGS)
1337
1338 # append all config cppflags
1339 CPPFLAGS="$CPPFLAGS $CONFIG_CPPFLAGS $UCONFIG_CPPFLAGS"
1340
1341 echo "CPPFLAGS=$CPPFLAGS"
1342 echo "CFLAGS=$CFLAGS"
1343 echo "CXXFLAGS=$CXXFLAGS"
1344
1345
1346 # output the Makefiles
1347 AC_CONFIG_FILES([icudefs.mk \
1348                 Makefile \
1349                 data/pkgdataMakefile \
1350                 config/Makefile.inc \
1351                 config/icu.pc \
1352                 config/pkgdataMakefile \
1353                 data/Makefile \
1354                 stubdata/Makefile \
1355                 common/Makefile \
1356                 i18n/Makefile \
1357                 layoutex/Makefile \
1358                 io/Makefile \
1359                 extra/Makefile \
1360                 extra/uconv/Makefile \
1361                 extra/uconv/pkgdataMakefile \
1362                 extra/scrptrun/Makefile \
1363                 tools/Makefile \
1364                 tools/ctestfw/Makefile \
1365                 tools/toolutil/Makefile \
1366                 tools/makeconv/Makefile \
1367                 tools/genrb/Makefile \
1368                 tools/genccode/Makefile \
1369                 tools/gencmn/Makefile \
1370                 tools/gencnval/Makefile \
1371                 tools/gendict/Makefile \
1372                 tools/gentest/Makefile \
1373                 tools/gennorm2/Makefile \
1374                 tools/genbrk/Makefile \
1375                 tools/gensprep/Makefile \
1376                 tools/icuinfo/Makefile \
1377                 tools/icupkg/Makefile \
1378                 tools/icuswap/Makefile \
1379                 tools/pkgdata/Makefile \
1380                 tools/tzcode/Makefile \
1381                 tools/gencfu/Makefile \
1382                 tools/escapesrc/Makefile \
1383                 test/Makefile \
1384                 test/compat/Makefile \
1385                 test/testdata/Makefile \
1386                 test/testdata/pkgdataMakefile \
1387                 test/hdrtst/Makefile \
1388                 test/intltest/Makefile \
1389                 test/cintltst/Makefile \
1390                 test/iotest/Makefile \
1391                 test/letest/Makefile \
1392                 test/perf/Makefile \
1393                 test/perf/collationperf/Makefile \
1394                 test/perf/collperf/Makefile \
1395                 test/perf/collperf2/Makefile \
1396                 test/perf/dicttrieperf/Makefile \
1397                 test/perf/ubrkperf/Makefile \
1398                 test/perf/charperf/Makefile \
1399                 test/perf/convperf/Makefile \
1400                 test/perf/normperf/Makefile \
1401                 test/perf/DateFmtPerf/Makefile \
1402                 test/perf/howExpensiveIs/Makefile \
1403                 test/perf/strsrchperf/Makefile \
1404                 test/perf/unisetperf/Makefile \
1405                 test/perf/usetperf/Makefile \
1406                 test/perf/ustrperf/Makefile \
1407                 test/perf/utfperf/Makefile \
1408                 test/perf/utrie2perf/Makefile \
1409                 test/perf/leperf/Makefile \
1410                 test/fuzzer/Makefile \
1411                 samples/Makefile samples/date/Makefile \
1412                 samples/cal/Makefile samples/layout/Makefile])
1413 AC_OUTPUT
1414
1415 if test -z "$PYTHON";
1416 then
1417     echo "" > data/rules.mk
1418     echo "" > test/testdata/rules.mk
1419 else
1420     if test -f "$srcdir/data/locales/root.txt";
1421     then
1422         echo "Spawning Python to generate data/rules.mk..."
1423         PYTHONPATH="$srcdir/python" \
1424             $PYTHON -m icutools.databuilder \
1425             --mode gnumake \
1426             --seqmode parallel \
1427             --src_dir "$srcdir/data" \
1428             --filter_file "$ICU_DATA_FILTER_FILE" \
1429             $ICU_DATA_BUILDTOOL_OPTS \
1430             > data/rules.mk
1431         if test "$?" != "0"; then
1432             AC_MSG_ERROR(Python failed to run; see above error.)
1433         fi
1434     else
1435       echo "Not rebuilding data/rules.mk, assuming prebuilt data in data/in"
1436       touch data/rules.mk
1437     fi
1438     echo "Spawning Python to generate test/testdata/rules.mk..."
1439     PYTHONPATH="$srcdir/python" \
1440         $PYTHON -m icutools.databuilder \
1441         --mode gnumake \
1442         --seqmode parallel \
1443         --src_dir "$srcdir/test/testdata" \
1444         > test/testdata/rules.mk
1445     if test "$?" != "0"; then
1446         AC_MSG_ERROR(Python failed to run; see above error.)
1447     fi
1448 fi
1449
1450 echo
1451 echo "ICU for C/C++ $VERSION is ready to be built."
1452 echo "=== Important Notes: ==="
1453
1454 echo "Data Packaging: $datapackaging"
1455 echo " This means: $datapackaging_msg"
1456 echo " To locate data: $datapackaging_howfound"
1457
1458 if test -n "`$U_MAKE -v 2>&1 | grep '^GNU Make'`"; then
1459 echo "Building ICU: Use a GNU make such as $U_MAKE to build ICU."
1460 else
1461 echo "** WARNING: $U_MAKE may not be GNU make."
1462 echo "This may cause ICU to fail to build. Please make sure that GNU make"
1463 echo "is in your PATH so that the configure script can detect its location."
1464 fi
1465 if test "x$AR" = "xfalse"; then
1466   echo "*** WARNING: Archiver ar not found. Set AR= or fix PATH. Some builds (such as static) may fail."
1467 fi
1468
1469 AC_MSG_CHECKING([the version of "$U_MAKE"])
1470 if "$U_MAKE" -f "$srcdir/config/gmakever.mk" PLATFORM="$platform"; then
1471 AC_MSG_RESULT([ok])
1472 else
1473 AC_MSG_RESULT([too old or test failed - try upgrading GNU Make])
1474 fi
1475
1476 AC_SUBST(UCONFIG_CPPFLAGS)
1477 if test -n "$UCONFIG_CPPFLAGS"; then
1478    HDRFILE="uconfig.h.prepend"
1479    echo "*** WARNING: You must set the following flags before code compiled against this ICU will function properly:"
1480    echo
1481    echo "   ${UCONFIG_CPPFLAGS}"
1482    echo
1483    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.'
1484    echo "Creating the file ${HDRFILE}"
1485    echo
1486    echo '---------------   ' "${HDRFILE}"
1487    echo > "${HDRFILE}"
1488    echo '/* ICU customizations: put these lines at the top of uconfig.h */' >> "${HDRFILE}"
1489    echo >> "${HDRFILE}"
1490    for flag in ${UCONFIG_CPPFLAGS};
1491    do
1492         echo " /* $flag */" >> "${HDRFILE}"
1493         case "${flag}" in
1494         -D*=*)
1495           [ \echo "${flag}" | sed -n 's%-D\([^=]*\)=%#define \1 %p' >> "${HDRFILE}" ]
1496           \echo >> "${HDRFILE}"
1497           ;;
1498         -D*)
1499           [ \echo "${flag}" | sed -n 's%-D\([^=]*\)%#define \1 %p' >> "${HDRFILE}" ]
1500           \echo >> "${HDRFILE}"
1501           ;;
1502         *)
1503           \echo "/*  Not sure how to handle this argument: ${flag} */" >> "${HDRFILE}"
1504           \echo >> "${HDRFILE}"
1505           ;;
1506         esac
1507    done
1508    cat "${HDRFILE}"
1509    \echo  "/* End of ${HDRFILE} ------------ */" >> "${HDRFILE}"
1510    echo >> "${HDRFILE}"
1511    echo '--------------- end ' "${HDRFILE}"
1512 fi
1513
1514 AC_SUBST(UCONFIG_CFLAGS)
1515 if test -n "$UCONFIG_CFLAGS"; then
1516    echo "C   apps may want to build with CFLAGS   = ${UCONFIG_CFLAGS}"
1517 fi
1518 AC_SUBST(UCONFIG_CXXFLAGS)
1519 if test -n "$UCONFIG_CXXFLAGS"; then
1520    echo "C++ apps may want to build with CXXFLAGS = ${UCONFIG_CXXFLAGS}"
1521 fi
1522
1523 if test "$tools" = false;
1524 then
1525         echo "## Note: you have disabled ICU's tools. This ICU cannot build its own data or tests."
1526         echo "## Expect build failures in the 'data', 'test', and other directories."
1527 fi
1528
1529 if test -z "$PYTHON";
1530 then
1531     echo "** Note: Python not found. You will not be able to build data from source or run tests."
1532 fi
1533
1534 $as_unset _CXX_CXXSUFFIX