scuffed-code/icu4c/source/configure.in

# -*-autoconf-*-
AC_COPYRIGHT([ Copyright (c) 1999-2008, International Business Machines Corporation and others. All Rights Reserved. ])
# configure.in for ICU
# Stephen F. Booth, heavily modified by Yves and others

# Check for autoconf version
AC_PREREQ(2.63)


# Process this file with autoconf to produce a configure script
AC_INIT
AC_CONFIG_SRCDIR([common/unicode/utypes.h])

AC_CONFIG_HEADER(common/icucfg.h)
PACKAGE="icu"
AC_SUBST(PACKAGE)

AC_MSG_CHECKING(for ICU version numbers)

# Get the ICU version from uversion.h or other headers
geticuversion() {
    [sed -n 's/^[ 	]*#[ 	]*define[ 	]*U_ICU_VERSION[ 	]*"\([^"]*\)".*/\1/p' "$@"]
}
VERSION=`geticuversion $srcdir/common/unicode/uversion.h`
if test x"$VERSION" = x; then
    VERSION=`geticuversion $srcdir/common/unicode/*.h`
    if test x"$VERSION" = x; then
        AC_MSG_ERROR([Cannot determine ICU version number from header files])
    fi
fi
# Compute a reasonable library version from the release version. This is
# very bad, but that's wanted... We want to make sure that the LIB_VERSION
# has at least a dot in it, so we'll add a .0 if needed.
[LIB_VERSION=`echo $VERSION | sed -e 's/\.//' -e 's/^\([^.]*\)$/\1.0/'`]
LIB_VERSION_MAJOR=`echo $LIB_VERSION | sed 's/\..*//'`
AC_SUBST(VERSION)
AC_SUBST(LIB_VERSION)
AC_SUBST(LIB_VERSION_MAJOR)
AC_MSG_RESULT([release $VERSION, library $LIB_VERSION])

UNICODE_VERSION="5.1"
AC_SUBST(UNICODE_VERSION)

# Determine the host system
AC_CANONICAL_HOST

AC_SUBST(CPPFLAGS)

# This variable is needed on z/OS because the C++ compiler only recognizes .C
_CXX_CXXSUFFIX=cc
export _CXX_CXXSUFFIX
# Checks for programs
AC_PROG_CC
AC_PROG_CXX
AC_PROG_INSTALL

# make sure install is relative to srcdir - if a script
if test "$srcdir" = "."; then
  # If srcdir isn't just ., then (srcdir) is already prepended.
  if test "${ac_install_sh}" = "${INSTALL}"; then
   INSTALL="\\\$(top_srcdir)/${ac_install_sh}"
  fi
fi

#AC_CHECK_PROG(AUTOCONF, autoconf, autoconf, true)
#AC_CHECK_PROG(STRIP, strip, strip, true)

# Check for the platform make
AC_PATH_PROGS(U_MAKE, gmake gnumake, make)
AC_SUBST(U_MAKE)

# Check for doxygen to generate documentation
AC_PATH_PROG(DOXYGEN,doxygen,,$PATH:/usr/local/bin:/usr/bin)

# Check that the linker is usable
ICU_PROG_LINK

# Determine the executable suffix
# We don't use AC_EXEEXT because some compilers output separate debugging
# files, which confuses the AC_EXEEXT macro.
AC_MSG_CHECKING(checking for executable suffix)
case "${host}" in
    *-*-cygwin*|*-*-mingw*)  EXEEXT=.exe ;;
    *)      EXEEXT="" ;;
esac
ac_exeext=$EXEEXT
AC_MSG_RESULT($EXEEXT)
AC_SUBST(EXEEXT)

# Determine how strict we want to be when compiling
AC_CHECK_STRICT_COMPILE

# Check if we can build and use 64-bit libraries
AC_CHECK_64BIT_LIBS
AC_SUBST(ARFLAGS)
AC_SUBST(COMPILE_LINK_ENVVAR)

# Determine the Makefile fragment
ICU_CHECK_MH_FRAG

# Checks for libraries and other host specific stuff
# On HP/UX, don't link to -lm from a shared lib because it isn't
#  PIC (at least on 10.2)
case "${host}" in
	*-*-hpux*) 	AC_CHECK_LIB(m, floor, LIB_M="-lm") ;;
	
	*) 		AC_CHECK_LIB(m, floor) 
			LIB_M="" ;;
esac
AC_SUBST(LIB_M)

# Check whether to build shared libraries
AC_MSG_CHECKING([whether to build shared libraries])
enabled=no
AC_ARG_ENABLE(shared,
    [  --enable-shared         build shared libraries [default=yes]],
    [ case "${enableval}" in
	     yes|"") enabled=yes; ENABLE_SHARED=YES ;;
	     no);;
	     *) ;;
    esac],
    [enabled=yes; ENABLE_SHARED=YES]
)
AC_MSG_RESULT($enabled)
AC_SUBST(ENABLE_SHARED)

# Check whether to build static libraries
AC_MSG_CHECKING([whether to build static libraries])
enabled=no
AC_ARG_ENABLE(static,
    [  --enable-static         build static libraries [default=no]],
    [ case "${enableval}" in
	     yes|"") enabled=yes; ENABLE_STATIC=YES ;;
	     no) ;;
	     *) ;;
    esac],
)
AC_MSG_RESULT($enabled)
AC_SUBST(ENABLE_STATIC)

# Check whether to build debug libraries
AC_MSG_CHECKING([whether to build debug libraries])
enabled=no
ENABLE_DEBUG=0
AC_ARG_ENABLE(debug,
    [  --enable-debug          build debug libraries [default=no]],
    [ case "${enableval}" in
         yes|"") enabled=yes; ENABLE_DEBUG=1 ;;
         *) ;;
    esac],
)
AC_MSG_RESULT($enabled)
AC_SUBST(ENABLE_DEBUG)

# Check whether to build release libraries
AC_MSG_CHECKING([whether to build release libraries])
enabled=yes
ENABLE_RELEASE=1
AC_ARG_ENABLE(release,
    [  --enable-release        build release libraries [default=yes]],
    [ case "${enableval}" in
         no) enabled=no; ENABLE_RELEASE=0 ;;
         *) ;;
    esac],
)
AC_MSG_RESULT($enabled)
AC_SUBST(ENABLE_RELEASE)

# Check whether to enabled draft APIs
AC_MSG_CHECKING([whether to enable draft APIs])
enabled=yes
U_DEFAULT_SHOW_DRAFT=1
AC_ARG_ENABLE(draft,
    [  --enable-draft          enable draft APIs [default=yes]],
    [ case "${enableval}" in
         no) enabled=no; U_DEFAULT_SHOW_DRAFT=0 ;;
         *) ;;
    esac],
)
AC_MSG_RESULT($enabled)
# Make sure that we can use draft API in ICU.
if test "$U_DEFAULT_SHOW_DRAFT" = 0; then
    CPPFLAGS="$CPPFLAGS -DU_SHOW_DRAFT_API"
fi
AC_SUBST(U_DEFAULT_SHOW_DRAFT)

# Check if we can hide variables from 
AC_MSG_CHECKING([for library API export])
SHAREDLIBEXPORT=no
U_USE_GCC_VISIBILITY_ATTRIBUTE=0
OLD_CFLAGS="${CFLAGS}"
OLD_CXXFLAGS="${CXXFLAGS}"
if test "$ac_cv_c_compiler_gnu" = yes; then
    LIBCFLAGS="-fvisibility=hidden"
    LIBCXXFLAGS="-fvisibility=hidden"
    CFLAGS="${CFLAGS} ${LIBCFLAGS}"
    CXXFLAGS="${CXXFLAGS} ${LIBCXXFLAGS}"
    AC_LINK_IFELSE([AC_LANG_PROGRAM([[__attribute__ ((visibility ("default"))) void f(void);
#include <stdlib.h>]], [[exit(0);]])],[SHAREDLIBEXPORT=yes],[SHAREDLIBEXPORT=no])
    if test "$SHAREDLIBEXPORT" = no; then
        LIBCFLAGS=
        LIBCXXFLAGS=
    else
        U_USE_GCC_VISIBILITY_ATTRIBUTE=1
    fi
else
    case "${host}" in
    *-*-solaris*)
        LIBCFLAGS="-xldscope=hidden"
        LIBCXXFLAGS="-xldscope=hidden"
        CFLAGS="${CFLAGS} ${LIBCFLAGS}"
        CXXFLAGS="${CXXFLAGS} ${LIBCXXFLAGS}"
        AC_LINK_IFELSE([AC_LANG_PROGRAM([[__global void f(void);
#include <stdlib.h>]], [[exit(0);]])],[SHAREDLIBEXPORT=yes],[SHAREDLIBEXPORT=no])
        if test "$SHAREDLIBEXPORT" = no; then
            LIBCFLAGS=
            LIBCXXFLAGS=
        fi
        ;;
    *-*-hpux*)
        # ICU isn't set up to follow the HP syntax yet.
        ;;
    *)
    esac
fi
# Restore to their original state because the Intel compiler chokes
# on this option when checking for the wchar_t size, but the
# option otherwise works.
CFLAGS="${OLD_CFLAGS}"
CXXFLAGS="${OLD_CXXFLAGS}"
AC_MSG_RESULT($SHAREDLIBEXPORT)
AC_SUBST(U_USE_GCC_VISIBILITY_ATTRIBUTE)
AC_SUBST(LIBCFLAGS)
AC_SUBST(LIBCXXFLAGS)

AC_PROG_RANLIB
AC_PATH_PROG(AR,ar,[echo archiver ar not found re-run configure ; false],$PATH:/bin:/usr/bin:/usr/ccs/bin)

AC_MSG_CHECKING([whether to enable renaming of symbols])
enabled=yes
U_DISABLE_RENAMING=0
AC_ARG_ENABLE(renaming,
    [  --enable-renaming       add a version suffix to symbols [default=yes]],
    [ case "${enableval}" in
	     yes|"") enabled=yes ;;
	     no) enabled=no; U_DISABLE_RENAMING=1 ;;
	     *) ;;
    esac],
)
AC_MSG_RESULT($enabled)
AC_SUBST(U_DISABLE_RENAMING)

AC_MSG_CHECKING([whether to enable function and data tracing])
enabled=yes
U_ENABLE_TRACING=0
AC_ARG_ENABLE(tracing,
    [  --enable-tracing        enable function and data tracing [default=no]],
    [ case "${enableval}" in
	     yes|"") enabled=yes ;;
	     no) enabled=no; U_ENABLE_TRACING=0 ;;
	     *) ;;
    esac],
)
AC_MSG_RESULT($enabled)
AC_SUBST(U_ENABLE_TRACING)

# Check whether to use the evil rpath or not
AC_ARG_ENABLE(rpath,
    [  --enable-rpath          use rpath when linking [default is only if necessary]],
    [ case "${enableval}" in
	     yes|"") ENABLE_RPATH=YES ;;
	     no) ;;
	     *) ;;
    esac],
    [ENABLE_RPATH=NO]
)
AC_SUBST(ENABLE_RPATH)


# set up U_INLINE.  
# Copy the definition of AC_C_INLINE, with slight mods.
#
AC_CACHE_CHECK([for definition of U_INLINE for C], ac_cv_c_inline,
[ac_cv_c_inline=no
for ac_kw in inline __inline__ __inline; do
  AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[return 0;} $ac_kw int foo() {]])],[ac_cv_c_inline=$ac_kw; break],[])
  done
  ])
case "$ac_cv_c_inline" in
      yes)       U_INLINE= "inline" ;;
	  no )       U_INLINE= ;;
	    *)       U_INLINE=$ac_cv_c_inline ;;
esac
AC_SUBST(U_INLINE)

threads=true

# Enable/disable threads
AC_ARG_ENABLE(threads,
	[  --enable-threads        build ICU with thread safety [default=yes]],
	[case "${enableval}" in
		yes) threads=true ;;
		no)  threads=false ;;
		*) AC_MSG_ERROR(bad value ${enableval} for --enable-threads) ;;
		esac], 
	threads=true)
ICU_CONDITIONAL(THREADS, test "$threads" = true)

ICU_USE_THREADS=0
OLD_LIBS=${LIBS}

if test $threads = true; then
  # For Compaq Tru64 (OSF1), we must look for pthread_attr_init
  # and must do this before seaching for pthread_mutex_destroy, or
  # we will pick up libpthreads.so not libpthread.so
  # If this fails, then we must test for HPUX specials, before
  # moving on to a more generic test
 
  AC_CHECK_LIB(pthread, pthread_attr_init)
  if test $ac_cv_lib_pthread_pthread_attr_init = yes; then
    ICU_USE_THREADS=1
  else
    # Locate the right library for POSIX threads. We look for the
    # symbols in the libraries first, because on Solaris libc provides
    # pthread_create but libpthread has the real code :(
    # AIX uses libpthreads instead of libpthread, and HP/UX uses libpthread
    # FreeBSD users may need libpthread if they do not have libc_r.

    AC_SEARCH_LIBS_FIRST(pthread_mutex_destroy, pthread pthreads c_r )

    if test "$ac_cv_search_pthread_mutex_destroy" != no; then
      ICU_USE_THREADS=1
    else
      # For HP 11
      AC_CHECK_LIB(pthread, pthread_mutex_init)
      if test $ac_cv_lib_pthread_pthread_mutex_init = yes; then
        ICU_USE_THREADS=1
      fi
    fi

    AC_CHECK_FUNC(pthread_mutex_lock)

    if test $ac_cv_func_pthread_mutex_lock = yes; then
      ICU_USE_THREADS=1
    fi
  fi
  # Check to see if we are using CygWin with MSVC
  case "${host}" in
  *-pc-cygwin*|*-pc-mingw*)
    # For gcc, the thread options are set by mh-mingw/mh-cygwin
    ICU_USE_THREADS=1
    if test "$ac_cv_c_compiler_gnu" = no; then
      # We're using normal windows compilers. Threading is available.
      ICU_USE_THREADS=1
      if test $ENABLE_DEBUG = 1; then
        # /MDd means 'compiles and links a debugable multithreaded program with DLL'
        CFLAGS="${CFLAGS} /MDd"
        CXXFLAGS="${CXXFLAGS} /MDd"
      else
        # /MD means 'compiles and links a multithreaded program with DLL'
        CFLAGS="${CFLAGS} /MD"
        CXXFLAGS="${CXXFLAGS} /MD"
      fi
    fi ;;
  *-*-hpux*)
    # Add -mt because it does several nice things on newer compilers.
    case "${icu_cv_host_frag}" in
      mh-hpux-acc)
        OLD_CXXFLAGS="${CXXFLAGS}"
        CXXFLAGS="${CXXFLAGS} -mt"
        if test x"`${CXX} ${CXXFLAGS} 2>&1`" != x""; then
           CXXFLAGS="${OLD_CXXFLAGS}"
       fi
      ;;
    esac
    ;;
  esac
fi

AC_SUBST(ICU_USE_THREADS)

AC_ARG_ENABLE(weak-threads,
	[  --enable-weak-threads   weakly reference the threading library [default=no]],
	[case "${enableval}" in
		yes)
            LIB_THREAD="${LIBS%${OLD_LIBS}}"
            LIBS=${OLD_LIBS}
            ;;
		no)  ;;
		*) AC_MSG_ERROR(bad value ${enableval} for --enable-weak-threads) ;;
		esac])
AC_SUBST(LIB_THREAD)

# Check for mmap()

# The AC_FUNC_MMAP macro doesn't work properly.  It seems to be too specific.
# Do this check instead.
HAVE_MMAP=0
AC_MSG_CHECKING([for mmap])
AC_CACHE_VAL(ac_cv_func_mmap_ok,
    [AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <unistd.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>], [mmap((void *)0, 0, PROT_READ, 0, 0, 0);])],[ac_cv_func_mmap_ok=yes],[ac_cv_func_mmap_ok=no])] )
AC_MSG_RESULT($ac_cv_func_mmap_ok)
if test $ac_cv_func_mmap_ok = yes
then
    HAVE_MMAP=1
fi
AC_SUBST(HAVE_MMAP)

# Check to see if genccode can generate simple assembly.
GENCCODE_ASSEMBLY=
case "${host}" in
i*86-*-linux*|x86_64-*-linux*|powerpc*-*-linux*|i*86-*-*bsd*|i*86-pc-gnu)
    if test "$GCC" = yes; then
        # We're using gcc, and the simple -a gcc command line works for genccode
        GENCCODE_ASSEMBLY="-a gcc"
    fi ;;
i*86-*-solaris*)
    if test "$GCC" = yes; then
        # When using gcc, look if we're also using GNU as.
        # When using GNU as, the simple -a gcc command line works for genccode.
        asv=`"${CC}" -print-prog-name=as 2>/dev/null`
        asv=`"${asv}" --version 2>/dev/null`
        case "X${asv}" in
        X*GNU*) GENCCODE_ASSEMBLY="-a gcc" ;;
        X*) GENCCODE_ASSEMBLY="-a sun-x86" ;;
        esac
        unset asv
    else
        GENCCODE_ASSEMBLY="-a sun-x86"
    fi ;;
sparc-*-solaris*)
    GENCCODE_ASSEMBLY="-a sun"
    ;;
ia64-*-hpux*)
    GENCCODE_ASSEMBLY="-a aCC-ia64"
    ;;
esac
AC_SUBST(GENCCODE_ASSEMBLY)


# Checks for header files
AC_CHECK_HEADERS(inttypes.h)
if test $ac_cv_header_inttypes_h = no; then
 U_HAVE_INTTYPES_H=0
else
 U_HAVE_INTTYPES_H=1
fi
if test "$CC" = ccc; then
 AC_MSG_RESULT("C compiler set to CCC ${CC}" )
 case "${host}" in
        alpha*-*-*) U_HAVE_INTTYPES_H=0;
 esac
fi

AC_SUBST(U_HAVE_INTTYPES_H)

AC_CHECK_HEADERS(dirent.h)
if test $ac_cv_header_dirent_h = no; then
 U_HAVE_DIRENT_H=0
else
 U_HAVE_DIRENT_H=1
fi

AC_SUBST(U_HAVE_DIRENT_H)


AC_ARG_WITH(iostream,
	[  --with-iostream=version specify the version of iostream to use (none, old, std, auto) [default=auto]],
	[case "${withval}" in
		none) streams=none ;;
		old) streams=198506 ;;
		std) streams=199711 ;;
		auto) streams= ;;
		*) AC_MSG_ERROR(bad value ${withval} for --with-iostream) ;;
		esac], 
        [streams=])

U_IOSTREAM_SOURCE=0
if test x$streams != xnone
then
    AC_LANG_PUSH(C++)
    OLD_CXXFLAGS="${CXXFLAGS}"
    case "${icu_cv_host_frag}" in
        mh-hpux-acc)
            CXXFLAGS="${CXXFLAGS} -AA"
        ;;
    esac
    AC_MSG_CHECKING([for iostream usability])
    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <iostream>]], [[]])],[ac_cv_header_iostream=yes],[ac_cv_header_iostream=no])
    if test $icu_cv_host_frag = mh-cygwin-msvc
    then
        # <iostream> is always there on Windows.
        # We do this to prevent the C++ preprocessor from being used because
        # autoconf can't deal with the Windows C++ preprocessor 
        ac_cv_header_iostream=yes
    fi
    AC_MSG_RESULT($ac_cv_header_iostream)
    if test $ac_cv_header_iostream = yes
    then
        U_IOSTREAM_SOURCE=199711
    else
        CXXFLAGS="${OLD_CXXFLAGS}"
        AC_MSG_CHECKING([whether ostream in iostream.h is really defined])
        AC_CACHE_VAL(ac_cv_iostream_ok,
            AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <iostream.h>]], [[ostream &testout = cout; testout << "test" << endl;]])],[ac_cv_iostream_ok=yes],[ac_cv_iostream_ok=no]))
        AC_MSG_RESULT($ac_cv_iostream_ok)
        if test $ac_cv_iostream_ok = yes
        then
            U_IOSTREAM_SOURCE=198506
        fi
    fi
    if test x$streams != x
    then
        if test $U_IOSTREAM_SOURCE -ge $streams
        then
            U_IOSTREAM_SOURCE=$streams
            case "${icu_cv_host_frag}" in
                mh-hpux-acc)
                    if test $U_IOSTREAM_SOURCE -lt 199711; then
                        CXXFLAGS=${OLD_CXXFLAGS}
                    fi
                ;;
            esac
        else
            AC_MSG_ERROR(${withval} iostream is not available)
        fi
    fi
fi
AC_SUBST(U_IOSTREAM_SOURCE)
AC_LANG_POP

# Check for endianness
AC_C_BIGENDIAN()
if test $ac_cv_c_bigendian = no; then
U_IS_BIG_ENDIAN=0
U_ENDIAN_CHAR="l"
else
U_IS_BIG_ENDIAN=1
U_ENDIAN_CHAR="b"
fi
AC_SUBST(U_IS_BIG_ENDIAN)

# Do various POSIX related checks
U_HAVE_NL_LANGINFO_CODESET=0
U_NL_LANGINFO_CODESET=-1
AC_CHECK_FUNC(nl_langinfo,[U_HAVE_NL_LANGINFO=1],[U_HAVE_NL_LANGINFO=0])
dnl AC_SUBST(U_HAVE_NL_LANGINFO)
if test $U_HAVE_NL_LANGINFO -eq 1; then
  AC_CACHE_CHECK([for nl_langinfo's argument to obtain the codeset],
  ac_cv_nl_langinfo_codeset,
  [ac_cv_nl_langinfo_codeset="unknown"
  for a in CODESET _NL_CTYPE_CODESET_NAME; do
  AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <langinfo.h>]], [[nl_langinfo($a);]])],[ac_cv_nl_langinfo_codeset="$a"; break],[])]
  done)
  if test x$ac_cv_nl_langinfo_codeset != xunknown
  then
      U_HAVE_NL_LANGINFO_CODESET=1
      U_NL_LANGINFO_CODESET=$ac_cv_nl_langinfo_codeset
  fi
fi
AC_SUBST(U_HAVE_NL_LANGINFO_CODESET)
AC_SUBST(U_NL_LANGINFO_CODESET)

# Namespace support checks
AC_LANG(C++)
AC_MSG_CHECKING([for namespace support])
AC_CACHE_VAL(ac_cv_namespace_ok,
    [AC_LINK_IFELSE([AC_LANG_PROGRAM([namespace x_version {void f(){}}
    namespace x = x_version;
    using namespace x_version;
    ], [f();])],[ac_cv_namespace_ok=yes],[ac_cv_namespace_ok=no])] )
AC_MSG_RESULT($ac_cv_namespace_ok)
U_HAVE_NAMESPACE=1
if test $ac_cv_namespace_ok = no
then
    U_HAVE_NAMESPACE=0
fi
AC_SUBST(U_HAVE_NAMESPACE)

AC_MSG_CHECKING([for properly overriding new and delete])
U_OVERRIDE_CXX_ALLOCATION=0
U_HAVE_PLACEMENT_NEW=0
AC_CACHE_VAL(ac_cv_override_cxx_allocation_ok,
    [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <stdlib.h>
    class UMemory {
    public:
    void *operator new(size_t size) {return malloc(size);}
    void *operator new[](size_t size) {return malloc(size);}
    void operator delete(void *p) {free(p);}
    void operator delete[](void *p) {free(p);}
    };
    ]], [])],[ac_cv_override_cxx_allocation_ok=yes],[ac_cv_override_cxx_allocation_ok=no])] )
AC_MSG_RESULT($ac_cv_override_cxx_allocation_ok)
if test $ac_cv_override_cxx_allocation_ok = yes
then
    U_OVERRIDE_CXX_ALLOCATION=1
    AC_MSG_CHECKING([for placement new and delete])
    AC_CACHE_VAL(ac_cv_override_placement_new_ok,
        [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <stdlib.h>
        class UMemory {
        public:
        void *operator new(size_t size) {return malloc(size);}
        void *operator new[](size_t size) {return malloc(size);}
        void operator delete(void *p) {free(p);}
        void operator delete[](void *p) {free(p);}
        void * operator new(size_t, void *ptr) { return ptr; }
        void operator delete(void *, void *) {}
        };
        ]], [])],[ac_cv_override_placement_new_ok=yes],[ac_cv_override_placement_new_ok=no])] )
    AC_MSG_RESULT($ac_cv_override_placement_new_ok)
    if test $ac_cv_override_placement_new_ok = yes
    then
        U_HAVE_PLACEMENT_NEW=1
    fi
fi
AC_SUBST(U_OVERRIDE_CXX_ALLOCATION)
AC_SUBST(U_HAVE_PLACEMENT_NEW)

AC_LANG(C)
AC_CHECK_FUNC(popen)
if test x$ac_cv_func_popen = xyes
then
     U_HAVE_POPEN=1
else
     U_HAVE_POPEN=0
fi
AC_SUBST(U_HAVE_POPEN)

AC_CHECK_FUNC(tzset)
U_HAVE_TZSET=0
if test x$ac_cv_func_tzset = xyes
then
    U_TZSET=tzset
    U_HAVE_TZSET=1
else
    AC_CHECK_FUNC(_tzset)
    if test x$ac_cv_func__tzset = xyes
    then
        U_TZSET=_tzset
        U_HAVE_TZSET=1
    fi
fi
AC_SUBST(U_HAVE_TZSET)
AC_SUBST(U_TZSET)

U_HAVE_TZNAME=0
AC_CACHE_CHECK(for tzname,ac_cv_var_tzname,
[AC_LINK_IFELSE([AC_LANG_PROGRAM([[#ifndef __USE_POSIX
#define __USE_POSIX
#endif
#include <stdlib.h>
#include <time.h>
#ifndef tzname /* For SGI.  */
extern char *tzname[]; /* RS6000 and others reject char **tzname.  */
#endif]], [atoi(*tzname);])],[ac_cv_var_tzname=yes],[ac_cv_var_tzname=no])])
if test $ac_cv_var_tzname = yes; then
  U_TZNAME=tzname
  U_HAVE_TZNAME=1
else
  AC_CACHE_CHECK(for _tzname,ac_cv_var__tzname,
  [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <stdlib.h>
  #include <time.h>
  extern char *_tzname[];]], [atoi(*_tzname);])],[ac_cv_var__tzname=yes],[ac_cv_var__tzname=no])])
    if test $ac_cv_var__tzname = yes; then
      U_TZNAME=_tzname
      U_HAVE_TZNAME=1
    fi
fi
AC_SUBST(U_HAVE_TZNAME)
AC_SUBST(U_TZNAME)

AC_CACHE_CHECK(for timezone,ac_cv_var_timezone,
[AC_LINK_IFELSE([AC_LANG_PROGRAM([#ifndef __USE_POSIX
#define __USE_POSIX
#endif
#ifndef __USE_XOPEN
#define __USE_XOPEN
#endif
#include <time.h>
], [[timezone = 1;]])],[ac_cv_var_timezone=yes],[ac_cv_var_timezone=no])])
U_HAVE_TIMEZONE=0
if test $ac_cv_var_timezone = yes; then
  U_TIMEZONE=timezone
  U_HAVE_TIMEZONE=1
else
  AC_CACHE_CHECK(for __timezone,ac_cv_var___timezone,
  [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <time.h>]], [[__timezone = 1;]])],[ac_cv_var___timezone=yes],[ac_cv_var___timezone=no])])
  if test $ac_cv_var___timezone = yes; then
    U_TIMEZONE=__timezone
    U_HAVE_TIMEZONE=1
  else
    AC_CACHE_CHECK(for _timezone,ac_cv_var__timezone,
    [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <time.h>]], [[_timezone = 1;]])],[ac_cv_var__timezone=yes],[ac_cv_var__timezone=no])])
    if test $ac_cv_var__timezone = yes; then
      U_TIMEZONE=_timezone
      U_HAVE_TIMEZONE=1
    fi
  fi
fi
AC_SUBST(U_HAVE_TIMEZONE)
AC_SUBST(U_TIMEZONE)

# Checks for typedefs
AC_CHECK_TYPE(int8_t,signed char)
AC_CHECK_TYPE(uint8_t,unsigned char)
AC_CHECK_TYPE(int16_t,signed short)
AC_CHECK_TYPE(uint16_t,unsigned short)
AC_CHECK_TYPE(int32_t,signed long)
AC_CHECK_TYPE(uint32_t,unsigned long)
AC_CHECK_TYPE(int64_t,signed long long)
AC_CHECK_TYPE(uint64_t,unsigned long long)

if test $ac_cv_type_int8_t = no; then
HAVE_INT8_T=0
else
HAVE_INT8_T=1
fi
AC_SUBST(HAVE_INT8_T)

if test $ac_cv_type_uint8_t = no; then
HAVE_UINT8_T=0
else
HAVE_UINT8_T=1
fi
AC_SUBST(HAVE_UINT8_T)

if test $ac_cv_type_int16_t = no; then
HAVE_INT16_T=0
else
HAVE_INT16_T=1
fi
AC_SUBST(HAVE_INT16_T)

if test $ac_cv_type_uint16_t = no; then
HAVE_UINT16_T=0
else
HAVE_UINT16_T=1
fi
AC_SUBST(HAVE_UINT16_T)

if test $ac_cv_type_int32_t = no; then
HAVE_INT32_T=0
else
HAVE_INT32_T=1
fi
AC_SUBST(HAVE_INT32_T)

if test $ac_cv_type_uint32_t = no; then
HAVE_UINT32_T=0
else
HAVE_UINT32_T=1
fi
AC_SUBST(HAVE_UINT32_T)

if test $ac_cv_type_int64_t = no; then
HAVE_INT64_T=0
else
HAVE_INT64_T=1
fi
AC_SUBST(HAVE_INT64_T)

if test $ac_cv_type_uint64_t = no; then
HAVE_UINT64_T=0
else
HAVE_UINT64_T=1
fi
AC_SUBST(HAVE_UINT64_T)

# Do various wchar_t related checks
AC_CHECK_HEADER(wchar.h)
if test "$ac_cv_header_wchar_h" = no
then
    U_HAVE_WCHAR_H=0
    U_HAVE_WCSCPY=0
else
    AC_DEFINE(HAVE_WCHAR_H)
    U_HAVE_WCHAR_H=1
    # Some broken systems have wchar.h but not some of its functions...
    AC_SEARCH_LIBS(wcscpy, wcs w)
    if test "$ac_cv_search_wcscpy" != no; then
      U_HAVE_WCSCPY=1
    else
      U_HAVE_WCSCPY=0
    fi
fi
AC_SUBST(U_HAVE_WCHAR_H)
AC_SUBST(U_HAVE_WCSCPY)

AC_CHECK_SIZEOF([wchar_t], 0, [
#if STDC_HEADERS
#include <stddef.h>
#endif
#include <stdlib.h>
#if HAVE_WCHAR_H
#include <string.h>
#include <wchar.h>
#endif])
U_SIZEOF_WCHAR_T=$ac_cv_sizeof_wchar_t
# We do this check to verify that everything is okay.
if test $U_SIZEOF_WCHAR_T = 0; then
    if test $U_HAVE_WCHAR_H=1; then
       AC_MSG_ERROR(There is wchar.h but the size of wchar_t is 0)
    fi
fi
AC_SUBST(U_SIZEOF_WCHAR_T)

AC_MSG_CHECKING([for UTF-16 string literal support])
U_CHECK_UTF16_STRING=1
CHECK_UTF16_STRING_RESULT="unknown"
case "${host}" in
*-*-aix*|powerpc64-*-linux*)
    if test "$ac_cv_c_compiler_gnu" = no; then
        OLD_CFLAGS="${CFLAGS}"
        OLD_CXXFLAGS="${CXXFLAGS}"
        CFLAGS="${CFLAGS} -qutf"
        CXXFLAGS="${CXXFLAGS} -qutf"
        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[const unsigned short hello[] = u"hello";]], [[]])],[U_CHECK_UTF16_STRING=1],[U_CHECK_UTF16_STRING=0])
        if test "$U_CHECK_UTF16_STRING" = 0; then
            CFLAGS="${OLD_CFLAGS}"
            CXXFLAGS="${OLD_CXXFLAGS}"
        else
            CHECK_UTF16_STRING_RESULT="-qutf"
        fi
    fi
    ;;
*-*-solaris*)
    if test "$ac_cv_c_compiler_gnu" = no; then
        OLD_CFLAGS="${CFLAGS}"
        OLD_CXXFLAGS="${CXXFLAGS}"
        CFLAGS="${CFLAGS} -xustr=ascii_utf16_ushort"
        CXXFLAGS="${CXXFLAGS} -xustr=ascii_utf16_ushort"
        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[const unsigned short hello[] = U"hello";]], [[]])],[U_CHECK_UTF16_STRING=1],[U_CHECK_UTF16_STRING=0])
        if test "$U_CHECK_UTF16_STRING" = 0; then
            CFLAGS="${OLD_CFLAGS}"
            CXXFLAGS="${OLD_CXXFLAGS}"
        else
            CHECK_UTF16_STRING_RESULT="-xustr=ascii_utf16_ushort"

            # Since we can't detect the availability of this UTF-16 syntax at compile time,
            # we depend on configure telling us that we can use it.
            # Since we can't ensure ICU users use -xustr=ascii_utf16_ushort,
            # we only use this macro within ICU.
            # If an ICU user uses icu-config, this feature will be enabled.
            CPPFLAGS="${CPPFLAGS} -DU_CHECK_UTF16_STRING=1"
            U_CHECK_UTF16_STRING=0
        fi
    fi
    ;;
*-*-hpux*)
    if test "$ac_cv_c_compiler_gnu" = no; then
        # The option will be detected at compile time without additional compiler options.
        CHECK_UTF16_STRING_RESULT="available"
    fi
    ;;
*-*-cygwin)
    # wchar_t can be used
    CHECK_UTF16_STRING_RESULT="available"
    ;;
*)
    ;;
esac
AC_MSG_RESULT($CHECK_UTF16_STRING_RESULT)
AC_SUBST(U_CHECK_UTF16_STRING)

# Enable/disable extras
AC_ARG_ENABLE(extras,
	[  --enable-extras         build ICU extras [default=yes]],
	[case "${enableval}" in
		yes) extras=true ;;
		no)  extras=false ;;
		*) AC_MSG_ERROR(bad value ${enableval} for --enable-extras) ;;
		esac], 
	extras=true)
ICU_CONDITIONAL(EXTRAS, test "$extras" = true)
AC_ARG_ENABLE(icuio,
	[  --enable-icuio          build ICU's icuio library [default=yes]],
	[case "${enableval}" in
		yes) icuio=true ;;
		no)  icuio=false ;;
		*) AC_MSG_ERROR(bad value ${enableval} for --enable-icuio) ;;
		esac], 
	icuio=true)
ICU_CONDITIONAL(ICUIO, test "$icuio" = true)

# Enable/disable layout
AC_ARG_ENABLE(layout,
	[  --enable-layout         build ICU's layout library [default=yes]],
	[case "${enableval}" in
		yes) layout=true ;;
		no)  layout=false ;;
		*) AC_MSG_ERROR(bad value ${enableval} for --enable-layout) ;;
		esac], 
	layout=true)
ICU_CONDITIONAL(LAYOUT, test "$layout" = true)

AC_ARG_WITH(data-packaging,
	[  --with-data-packaging=type specify how to package ICU data (files, archive, library, auto) [default=auto]],
	[case "${withval}" in
                files|archive|library) datapackaging=$withval ;;
		auto) datapackaging=$withval ;;
		common) datapackaging=archive ;;
		dll) datapackaging=library ;;
		static) datapackaging=static ;;
		*) AC_MSG_ERROR(bad value ${withval} for --with-data-packaging) ;;
		esac], 
        [datapackaging=])

# Note:  'thesysconfdir' is an evaluated version, for Man pages, so also for thedatadir, thelibdir, etc.. 
# thesysconfdir=`eval echo $sysconfdir`
dnl# AC_SUBST(thesysconfdir)
dnl# thelibdir=`test "x$exec_prefix" = xNONE && exec_prefix="$prefix"; eval echo $libdir`
dnl# AC_SUBST(thelibdir)
thedatadir=`eval echo $datadir`
dnl# AC_SUBST(thedatadir)
# 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}. 
pkgicudatadir=$datadir
thepkgicudatadir=$thedatadir
AC_SUBST(pkgicudatadir)
AC_SUBST(thepkgicudatadir)

dnl# Shouldn't need the AC_SUBST

if test x"$datapackaging" = x -o x"$datapackaging" = xauto; then
	datapackaging=library
fi

case "$datapackaging" in
    files)
	DATA_PACKAGING_MODE=files
	;;
    archive)
	DATA_PACKAGING_MODE=common
	;;
    library)
	DATA_PACKAGING_MODE=dll
	;;
esac
AC_SUBST(DATA_PACKAGING_MODE)

# Sets a library suffix
AC_MSG_CHECKING([for a library suffix to use])
AC_ARG_WITH(library-suffix,
	[  --with-library-suffix=suffix    tag a suffix to the library names [default=]],
	[ICULIBSUFFIX="${withval}"],
	[ICULIBSUFFIX=])
msg=$ICULIBSUFFIX
if test "$msg" = ""; then
    msg=none
fi
AC_MSG_RESULT($msg)
AC_SUBST(ICULIBSUFFIX)
if test "$ICULIBSUFFIX" != ""
then
    U_HAVE_LIB_SUFFIX=1
    ICULIBSUFFIXCNAME=`echo _$ICULIBSUFFIX | sed 's/[^A-Za-z0-9_]/_/g'`
else
    U_HAVE_LIB_SUFFIX=0
fi
AC_SUBST(U_HAVE_LIB_SUFFIX)
AC_SUBST(ICULIBSUFFIXCNAME)

# Enable/disable tests
AC_ARG_ENABLE(tests,
	[  --enable-tests          build ICU tests [default=yes]],
	[case "${enableval}" in
		yes) tests=true ;;
		no)  tests=false ;;
		*) AC_MSG_ERROR(bad value ${enableval} for --enable-tests) ;;
		esac], 
	tests=true)
ICU_CONDITIONAL(TESTS, test "$tests" = true)

# Enable/disable samples
AC_ARG_ENABLE(samples,
	[  --enable-samples        build ICU samples [default=yes]  

Additionally, the variable FORCE_LIBS may be set before calling configure.
If set, it will REPLACE any automatic list of libraries.],
	[case "${enableval}" in
		yes) samples=true ;;
		no)  samples=false ;;
		*) AC_MSG_ERROR(bad value ${enableval} for --enable-samples) ;;
		esac], 
	samples=true)
ICU_CONDITIONAL(SAMPLES, test "$samples" = true)

ICUDATA_CHAR=$U_ENDIAN_CHAR

# Platform-specific Makefile setup
# set ICUDATA_CHAR to 'e' for any EBCDIC (which should be big endian) platform.
case "${host}" in
	*-*-solaris*) 	platform=U_SOLARIS ;;
	*-*-linux*) 	platform=U_LINUX ;;
	*-pc-gnu) 	platform=U_HURD ;;
	*-*-*bsd*|*-*-dragonfly*) 	platform=U_BSD ;;
	*-*-aix*) 	platform=U_AIX ;;
	*-*-hpux*) 	platform=U_HPUX ;;
	*-apple-darwin*|*-apple-rhapsody*)	platform=U_DARWIN ;;
	*-*-cygwin*|*-*-mingw*)	platform=U_CYGWIN ;;
	*-*ibm-openedition*|*-*-os390*)	platform=OS390
			if test "${ICU_ENABLE_ASCII_STRINGS}" != "1"; then
				ICUDATA_CHAR="e"
			fi ;;
	*-*-os400*)	platform=OS400
			if test "${ICU_ENABLE_ASCII_STRINGS}" != "1"; then
				ICUDATA_CHAR="e"
			fi ;;
	*-*-nto*)	platform=U_QNX ;;
	*-dec-osf*) 	platform=U_OSF ;;
	*-*-beos)		platform=U_BEOS ;;
	*-*-irix*)		platform=U_IRIX ;;
	*-ncr-*)		platform=U_MPRAS ;;
	*) 		platform=U_UNKNOWN_PLATFORM ;;
esac
AC_SUBST(ICUDATA_CHAR)
AC_SUBST(platform)
platform_make_fragment_name="$icu_cv_host_frag"
platform_make_fragment='$(top_srcdir)/config/'"$platform_make_fragment_name"
AC_SUBST(platform_make_fragment_name)
AC_SUBST(platform_make_fragment)

if test "${FORCE_LIBS}" != ""; then
   echo " *** Overriding automatically chosen [LIBS=$LIBS], using instead [FORCE_LIBS=${FORCE_LIBS}]"  1>&6
   LIBS=${FORCE_LIBS}
fi


# Now that we're done using CPPFLAGS etc. for tests, we can change it
# for build.

if test $ICU_USE_THREADS -ne 0
then
    CPPFLAGS="$CPPFLAGS \$(THREADSCPPFLAGS)"
    CFLAGS="$CFLAGS \$(THREADSCFLAGS)"
    CXXFLAGS="$CXXFLAGS \$(THREADSCXXFLAGS)"
fi

# output the Makefiles
AC_CONFIG_FILES([icudefs.mk \
		Makefile \
		data/icupkg.inc \
		config/Makefile.inc \
		data/Makefile \
		stubdata/Makefile \
		common/Makefile \
		i18n/Makefile \
		layout/Makefile \
		layoutex/Makefile \
		io/Makefile \
		extra/Makefile \
		extra/uconv/Makefile \
		extra/scrptrun/Makefile \
		tools/Makefile \
		tools/ctestfw/Makefile \
		tools/toolutil/Makefile \
		tools/makeconv/Makefile \
		tools/genrb/Makefile \
		tools/genuca/Makefile \
		tools/genccode/Makefile \
		tools/gencmn/Makefile \
		tools/gencnval/Makefile \
		tools/genctd/Makefile \
		tools/gennames/Makefile \
		tools/gentest/Makefile \
		tools/gennorm/Makefile \
		tools/genprops/Makefile \
		tools/gencase/Makefile \
		tools/genbidi/Makefile \
		tools/genpname/Makefile \
		tools/genbrk/Makefile \
		tools/gensprep/Makefile \
		tools/icupkg/Makefile \
		tools/icuswap/Makefile \
		tools/pkgdata/Makefile \
		tools/tzcode/Makefile \
		test/Makefile \
		test/compat/Makefile \
		test/testdata/Makefile \
		test/testdata/pkgdata.inc \
		test/hdrtst/Makefile \
		test/intltest/Makefile \
		test/cintltst/Makefile \
		test/iotest/Makefile \
		test/letest/Makefile \
		test/perf/Makefile \
		test/perf/collationperf/Makefile \
		test/perf/ubrkperf/Makefile \
		test/perf/charperf/Makefile \
		test/perf/convperf/Makefile \
		test/perf/normperf/Makefile \
		test/perf/strsrchperf/Makefile \
		test/perf/unisetperf/Makefile \
		test/perf/usetperf/Makefile \
		test/perf/ustrperf/Makefile \
		test/perf/utfperf/Makefile \
		test/perf/utrie2perf/Makefile \
		samples/Makefile samples/date/Makefile \
		samples/cal/Makefile samples/layout/Makefile \
		common/unicode/platform.h])
AC_OUTPUT

if test $ICU_USE_THREADS = 0; then
  echo  " *** Note: configuring the ICU without pthread support or testing. If this isn't what you want, then run configure with --enable-threads=yes or check the messages [above] to see why we couldn't find pthread_create()" 1>&6
fi

if test -n "`$U_MAKE -v 2>&1 | grep '^GNU Make'`"; then
echo "You must use $U_MAKE to build ICU."
else
echo "WARNING: $U_MAKE may not be GNU make."
echo "This may cause ICU to fail to build. Please make sure that GNU make"
echo "is in your PATH so that this configure script can detect its location."
fi

$as_unset _CXX_CXXSUFFIX