diff options
Diffstat (limited to 'Build/source/libs/icu/icu-xetex/configure.in')
| -rw-r--r-- | Build/source/libs/icu/icu-xetex/configure.in | 1106 |
1 files changed, 1106 insertions, 0 deletions
diff --git a/Build/source/libs/icu/icu-xetex/configure.in b/Build/source/libs/icu/icu-xetex/configure.in new file mode 100644 index 00000000000..30f773ecd8e --- /dev/null +++ b/Build/source/libs/icu/icu-xetex/configure.in @@ -0,0 +1,1106 @@ +dnl -*-m4-*- +dnl configure.in for ICU +dnl Copyright (c) 1999-2007, International Business Machines Corporation and +dnl others. All Rights Reserved. +dnl Stephen F. Booth, heavily modified by Yves and others + +dnl Process this file with autoconf to produce a configure script +AC_INIT(common/unicode/utypes.h) + +AC_CONFIG_HEADER(common/icucfg.h) +PACKAGE="icu" +AC_SUBST(PACKAGE) + +AC_MSG_CHECKING(for ICU version numbers) + +dnl 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 +dnl Compute a reasonable library version from the release version. This is +dnl very bad, but that's wanted... We want to make sure that the LIB_VERSION +dnl 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.0" +AC_SUBST(UNICODE_VERSION) + +dnl Determine the host system +AC_CANONICAL_HOST + +AC_SUBST(CPPFLAGS) + +dnl This variable is needed on z/OS because the C++ compiler only recognizes .C +_CXX_CXXSUFFIX=cc +export _CXX_CXXSUFFIX +dnl 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) + +dnl Check for the platform make +AC_PATH_PROGS(U_MAKE, gmake gnumake, make) +AC_SUBST(U_MAKE) + +dnl Check for doxygen to generate documentation +AC_PATH_PROG(DOXYGEN,doxygen,,$PATH:/usr/local/bin:/usr/bin) + +dnl Check that the linker is usable +ICU_PROG_LINK + +dnl Determine the executable suffix +dnl We don't use AC_EXEEXT because some compilers output separate debugging +dnl 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) + +dnl Determine how strict we want to be when compiling +AC_CHECK_STRICT_COMPILE + +dnl Check if we can build and use 64-bit libraries +AC_CHECK_64BIT_LIBS +AC_SUBST(ARFLAGS) +AC_SUBST(COMPILE_LINK_ENVVAR) + +dnl Determine the Makefile fragment +ICU_CHECK_MH_FRAG + +dnl Checks for libraries and other host specific stuff +dnl On HP/UX, don't link to -lm from a shared lib because it isn't +dnl 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) + +dnl 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) + +dnl 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) + +dnl 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) + +dnl 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) + +dnl 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) +dnl 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) + +dnl Check if we can hide variables from +AC_MSG_CHECKING([for library API export]) +SHAREDLIBEXPORT=no +U_USE_GCC_VISIBILITY_ATTRIBUTE=0 +if test "$ac_cv_c_compiler_gnu" = yes; then + OLD_CFLAGS="${CFLAGS}" + OLD_CXXFLAGS="${CXXFLAGS}" + LIBCFLAGS="-fvisibility=hidden" + LIBCXXFLAGS="-fvisibility=hidden" + CFLAGS="${CFLAGS} ${LIBCFLAGS}" + CXXFLAGS="${CXXFLAGS} ${LIBCXXFLAGS}" + AC_TRY_LINK([__attribute__ ((visibility ("default"))) void f(void); +#include <stdlib.h>],[exit(0);], + [SHAREDLIBEXPORT=yes],[SHAREDLIBEXPORT=no]) + # 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}" + if test "$SHAREDLIBEXPORT" = no; then + LIBCFLAGS= + LIBCXXFLAGS= + else + U_USE_GCC_VISIBILITY_ATTRIBUTE=1 + fi +fi +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) + +dnl 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) + + +dnl set up U_INLINE. +dnl Copy the definition of AC_C_INLINE, with slight mods. +dnl +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_TRY_COMPILE(, [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 + +dnl 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 + dnl For Compaq Tru64 (OSF1), we must look for pthread_attr_init + dnl and must do this before seaching for pthread_mutex_destroy, or + dnl we will pick up libpthreads.so not libpthread.so + dnl If this fails, then we must test for HPUX specials, before + dnl 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 + dnl Locate the right library for POSIX threads. We look for the + dnl symbols in the libraries first, because on Solaris libc provides + dnl pthread_create but libpthread has the real code :( + dnl AIX uses libpthreads instead of libpthread, and HP/UX uses libpthread + dnl 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 + dnl 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 + dnl Check to see if we are using CygWin with MSVC + case "${host}" in + *-pc-cygwin*|*-pc-mingw*) + dnl For gcc, the thread options are set by mh-mingw/mh-cygwin + ICU_USE_THREADS=1 + if test "$ac_cv_prog_gcc" = no; then + dnl We're using normal windows compilers. Threading is available. + ICU_USE_THREADS=1 + if test $ENABLE_DEBUG = 1; then + dnl /MDd means 'compiles and links a debugable multithreaded program with DLL' + CFLAGS="${CFLAGS} /MDd" + CXXFLAGS="${CXXFLAGS} /MDd" + else + dnl /MD means 'compiles and links a multithreaded program with DLL' + CFLAGS="${CFLAGS} /MD" + CXXFLAGS="${CXXFLAGS} /MD" + fi + fi ;; + *-*-hpux*) + dnl 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) + +dnl 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_TRY_LINK( + changequote(<<, >>)dnl + << +#include <unistd.h> +#include <sys/mman.h> +#include <sys/stat.h> +#include <fcntl.h> + >>, + changequote([, ])dnl + [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) + +dnl 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 + dnl 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 + dnl We're using gcc, and the simple -a gcc command line works for genccode + GENCCODE_ASSEMBLY="-a gcc" + 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) + + +dnl 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_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_SAVE + AC_LANG_CPLUSPLUS + OLD_CXXFLAGS="${CXXFLAGS}" + case "${icu_cv_host_frag}" in + mh-hpux-acc) + CXXFLAGS="${CXXFLAGS} -AA" + ;; + esac + AC_MSG_CHECKING([for iostream usability]) + AC_TRY_COMPILE([#include <iostream>],[], + [ac_cv_header_iostream=yes],[ac_cv_header_iostream=no]) + if test $icu_cv_host_frag = mh-cygwin-msvc + then + dnl <iostream> is always there on Windows. + dnl We do this to prevent the C++ preprocessor from being used because + dnl 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_TRY_LINK([#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_RESTORE + +dnl 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) + +dnl 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_TRY_LINK([#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) + +dnl Namespace support checks +AC_LANG_CPLUSPLUS +AC_MSG_CHECKING([for namespace support]) +AC_CACHE_VAL(ac_cv_namespace_ok, + [AC_TRY_LINK( + changequote(<<, >>)dnl + <<namespace x_version {void f(){}} + namespace x = x_version; + using namespace x_version; + >>, + changequote([, ])dnl + [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_TRY_LINK( + changequote(<<, >>)dnl + <<#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);} + }; + >>, + changequote([, ])dnl + [], 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_TRY_LINK( + changequote(<<, >>)dnl + <<#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 *) {} + }; + >>, + changequote([, ])dnl + [], 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_TRY_LINK( +changequote(<<, >>)dnl +<<#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>>, +changequote([, ])dnl +[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_TRY_LINK( + changequote(<<, >>)dnl + <<#include <stdlib.h> + #include <time.h> + extern char *_tzname[]; + >>, + changequote([, ])dnl + [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_TRY_LINK( +changequote(<<, >>)dnl +<<#ifndef __USE_POSIX +#define __USE_POSIX +#endif +#ifndef __USE_XOPEN +#define __USE_XOPEN +#endif +#include <time.h> +>>, +changequote([, ])dnl +[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_TRY_LINK([#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_TRY_LINK([#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) + +dnl 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) + +dnl 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 + dnl 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_prog_gcc" = no; then + OLD_CFLAGS="${CFLAGS}" + OLD_CXXFLAGS="${CXXFLAGS}" + CFLAGS="${CFLAGS} -qutf" + CXXFLAGS="${CXXFLAGS} -qutf" + AC_TRY_COMPILE([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_prog_gcc" = no; then + OLD_CFLAGS="${CFLAGS}" + OLD_CXXFLAGS="${CXXFLAGS}" + CFLAGS="${CFLAGS} -xustr=ascii_utf16_ushort" + CXXFLAGS="${CXXFLAGS} -xustr=ascii_utf16_ushort" + AC_TRY_COMPILE([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_prog_gcc" = no; then + dnl The option will be detected at compile time without additional compiler options. + CHECK_UTF16_STRING_RESULT="available" + fi + ;; +*-*-cygwin) + dnl wchar_t can be used + CHECK_UTF16_STRING_RESULT="available" + ;; +*) + ;; +esac +AC_MSG_RESULT($CHECK_UTF16_STRING_RESULT) +AC_SUBST(U_CHECK_UTF16_STRING) + +dnl 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) + +dnl 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=]) + +dnl Note: 'thesysconfdir' is an evaluated version, for Man pages, so also for thedatadir, thelibdir, etc.. +dnl 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) +dnl 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) + +dnl 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) +changequote(<<, >>)dnl +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 +changequote([, ])dnl +AC_SUBST(U_HAVE_LIB_SUFFIX) +AC_SUBST(ICULIBSUFFIXCNAME) + +dnl 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) + +dnl 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 + +dnl Platform-specific Makefile setup +dnl 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 + + +dnl Now that we're done using CPPFLAGS etc. for tests, we can change it +dnl for build. + +if test $ICU_USE_THREADS -ne 0 +then + CPPFLAGS="$CPPFLAGS \$(THREADSCPPFLAGS)" + CFLAGS="$CFLAGS \$(THREADSCFLAGS)" + CXXFLAGS="$CXXFLAGS \$(THREADSCXXFLAGS)" +fi + +dnl output the Makefiles +AC_OUTPUT([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 \ + samples/Makefile samples/date/Makefile \ + samples/cal/Makefile samples/layout/Makefile \ + common/unicode/platform.h]) + +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 |