| dnl -*-m4-*- |
| dnl configure.in for ICU |
| dnl Copyright (c) 1999-2000, International Business Machines Corporation and |
| dnl others. All Rights Reserved. |
| dnl Stephen F. Booth, heavily modified by Yves and others |
| |
| dnl $Id: configure.in,v 1.174 2002/08/09 17:20:56 grhoten-oss Exp $ |
| |
| 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="3.2" |
| AC_SUBST(UNICODE_VERSION) |
| |
| AC_SUBST(CPPFLAGS) |
| |
| 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 Determine the host system and Makefile fragment |
| AC_CANONICAL_HOST |
| AC_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) |
| |
| ICU_CHECK_MH_FRAG |
| |
| hpuxcma=false |
| |
| 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 |
| *-*-hpux10*) hpuxcma=true |
| AC_CHECK_LIB(m, floor, LIB_M="-lm") ;; |
| *-*-hpux*) AC_CHECK_LIB(m, floor, LIB_M="-lm") ;; |
| |
| *) AC_CHECK_LIB(m, floor) |
| LIB_M="" ;; |
| esac |
| AC_SUBST(LIB_M) |
| |
| dnl Enable/disable hpuxcma |
| |
| if test $hpuxcma = false; then |
| AC_ARG_ENABLE(hpuxcma, |
| [ --enable-hpuxcma build ICU with HPUX CMA threads (only ver>=11) [default=no]], |
| [case "${enableval}" in |
| yes) hpuxcma=true;; |
| no) hpuxcma=false;; |
| *) AC_MSG_ERROR(bad value ${enableval} for --enable-hpuxcma) ;; |
| esac], |
| ) |
| fi |
| |
| dnl Note, we set the conditional outside of IF for non hpux plats |
| ICU_CONDITIONAL(HPUX_CMA, test "$hpuxcma" = true) |
| |
| dnl Should this be a nested CASE? |
| if test $hpuxcma = true; then |
| case "${host}" in |
| *-*-hpux*) hpuxcma=true ;; |
| *) AC_MSG_ERROR(--enable-hpuxcma is not valid on this platform ${host}) ;; |
| esac |
| fi |
| |
| dnl Check whether to build shared libraries |
| AC_MSG_CHECKING([whether to build shared libraries]) |
| enabled=no |
| AC_ARG_ENABLE(shared, |
| [ --enable-shared[=PKGS] 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[=PKGS] build static libraries [default=no]], |
| [ case "${enableval}" in |
| yes|"") enabled=yes; ENABLE_STATIC=YES ;; |
| no) ;; |
| *) ;; |
| esac], |
| ) |
| AC_MSG_RESULT($enabled) |
| AC_SUBST(ENABLE_STATIC) |
| |
| 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) |
| |
| 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(, [} $ac_kw 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 threads [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 |
| |
| if test $threads = true; then |
| dnl Test for HPUX cma threads first.. |
| if test $hpuxcma = true; then |
| dnl HPUX cma case |
| AC_CHECK_LIB(cma, pthread_create) |
| if test $ac_cv_lib_cma_pthread_create = yes; then |
| ICU_USE_THREADS=1 |
| fi |
| else |
| 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 libcma |
| dnl (but that was checked above). |
| dnl FreeBSD users may need libpthread if they do not have libc_r. |
| |
| AC_SEARCH_LIBS_FIRST(pthread_mutex_destroy, pthread pthreads c_r cma) |
| |
| 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 |
| fi |
| fi |
| |
| AC_SUBST(ICU_USE_THREADS) |
| |
| 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 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 |
| AC_MSG_CHECKING([iostream usability]) |
| AC_TRY_COMPILE([#include <iostream>],[], |
| [ac_cv_header_iostream=yes],[ac_cv_header_iostream=no]) |
| AC_MSG_RESULT($ac_cv_header_iostream) |
| if test $ac_cv_header_iostream = yes |
| then |
| U_IOSTREAM_SOURCE=199711 |
| else |
| AC_CHECK_HEADER(iostream.h) |
| if test $ac_cv_header_iostream_h = yes; then |
| AC_MSG_CHECKING([whether ostream 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 |
| fi |
| if test x$streams != x |
| then |
| if test $U_IOSTREAM_SOURCE -ge $streams |
| then |
| U_IOSTREAM_SOURCE=$streams |
| 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(unknown) |
| 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]) |
| 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]) |
| AC_CACHE_VAL(ac_cv_override_cxx_allocation_ok, |
| [AC_TRY_LINK( |
| changequote(<<, >>)dnl |
| <<#include <stdlib.h> |
| class UObject { |
| void *operator new(size_t size) {return malloc(size);} |
| void *operator new[](size_t size) {return malloc(size);} |
| void operator delete(void *p) {delete(p);} |
| void operator delete[](void *p) {delete(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) |
| U_OVERRIDE_CXX_ALLOCATION=1 |
| if test $ac_cv_override_cxx_allocation_ok = no |
| then |
| U_OVERRIDE_CXX_ALLOCATION=0 |
| fi |
| AC_SUBST(U_OVERRIDE_CXX_ALLOCATION) |
| |
| 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) |
| if test x$ac_cv_func_tzset = xyes |
| then |
| U_TZSET=tzset |
| else |
| AC_CHECK_FUNC(_tzset) |
| if test x$ac_cv_func__tzset = xyes |
| then |
| U_TZSET=_tzset |
| fi |
| fi |
| AC_SUBST(U_TZSET) |
| AC_CACHE_CHECK(for tzname,ac_cv_var_tzname, |
| [AC_TRY_LINK( |
| changequote(<<, >>)dnl |
| <<#ifndef __USE_POSIX |
| #define __USE_POSIX |
| #endif |
| #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 |
| else |
| AC_CACHE_CHECK(for _tzname,ac_cv_var__tzname, |
| [AC_TRY_LINK( |
| changequote(<<, >>)dnl |
| <<#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 |
| fi |
| fi |
| 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( |
| changequote(<<, >>)dnl |
| <<#include <time.h> |
| >>, |
| changequote([, ])dnl |
| [__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( |
| changequote(<<, >>)dnl |
| <<#include <time.h> |
| >>, |
| changequote([, ])dnl |
| [_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) |
| 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_default_sizeof_wchar_t=4 |
| AC_DO_CHECK_SIZEOF(wchar_t,$ac_default_sizeof_wchar_t,[ |
| #if STDC_HEADERS |
| #include <stddef.h> |
| #endif |
| #if HAVE_WCHAR_H |
| #include <string.h> |
| #include <wchar.h> |
| #endif]) |
| dnl We could set ac_cv_sizeof_wchar_t to the default if the check returned |
| dnl 0 (unknown) but we'd rather do it in the headers, so we know we had no |
| dnl clue at configure time. |
| U_SIZEOF_WCHAR_T=$ac_cv_sizeof_wchar_t |
| 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) |
| |
| dnl Echo |
| ECHO_N=$ac_n |
| ECHO_C=$ac_c |
| AC_SUBST(ECHO_N) |
| AC_SUBST(ECHO_C) |
| |
| 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(extras, |
| [ --enable-ustdio build ICU's ustdio library [default=yes]], |
| [case "${enableval}" in |
| yes) ustdio=true ;; |
| no) ustdio=false ;; |
| *) AC_MSG_ERROR(bad value ${enableval} for --enable-ustdio) ;; |
| esac], |
| ustdio=true) |
| ICU_CONDITIONAL(USTDIO, test "$ustdio" = true) |
| |
| dnl Enable/disable layout |
| AC_ARG_ENABLE(layout, |
| [ --enable-layout build ICU's layout library [default=no]], |
| [case "${enableval}" in |
| yes) layout=true ;; |
| no) layout=false ;; |
| *) AC_MSG_ERROR(bad value ${enableval} for --enable-layout) ;; |
| esac], |
| layout=false) |
| 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 ;; |
| *) AC_MSG_ERROR(bad value ${withval} for --with-iostream) ;; |
| esac], |
| [datapackaging=]) |
| |
| thesysconfdir=`eval echo $sysconfdir` |
| AC_SUBST(thesysconfdir) |
| thedatadir=`eval echo $datadir` |
| AC_SUBST(thedatadir) |
| thelibdir=`test "x$exec_prefix" = xNONE && exec_prefix="$prefix"; eval echo $libdir` |
| AC_SUBST(thelibdir) |
| case $datapackaging in |
| common) |
| pkgicudatadir=$datadir |
| thepkgicudatadir=$thedatadir |
| ;; |
| *) |
| pkgicudatadir=$libdir |
| thepkgicudatadir=$thelibdir |
| ;; |
| esac |
| AC_SUBST(pkgicudatadir) |
| AC_SUBST(thepkgicudatadir) |
| |
| dnl Shouldn't need the AC_SUBST |
| dnl Deprecated support for --enable-mapped |
| |
| AC_ARG_ENABLE(mapped,, |
| [case "${enableval}" in |
| yes) mapped=archive ;; |
| no) mapped=library ;; |
| *) AC_MSG_ERROR(bad value ${enableval} for --enable-mapped; use --with-data-packaging now) ;; |
| esac], |
| [mapped=]) |
| |
| if test x"$mapped" != x; then |
| case $mapped in |
| archive) |
| AC_MSG_WARN(use --with-data-packaging=archive instead of --enable-mapped) |
| ;; |
| library) |
| AC_MSG_WARN(use --with-data-packaging=library instead of --disable-mapped) |
| ;; |
| esac |
| if test x"$datapackaging" != x -a x"$mapped" != x"$datapackaging"; then |
| AC_MSG_ERROR(conflicting values used for --with-data-packaging and deprecated --enable-mapped) |
| fi |
| datapackaging=$mapped |
| fi |
| |
| if test x"$datapackaging" = x -o x"$datapackaging" = xauto; then |
| datapackaging=library |
| fi |
| |
| case "$datapackaging" in |
| files) |
| DATA_PACKAGING_CPPFLAGS=-DUDATA_FILES |
| DATA_PACKAGING_MODE=files |
| ;; |
| archive) |
| DATA_PACKAGING_CPPFLAGS=-DUDATA_MAP |
| DATA_PACKAGING_MODE=common |
| ;; |
| library) |
| DATA_PACKAGING_CPPFLAGS=-DUDATA_DLL |
| DATA_PACKAGING_MODE=dll |
| ;; |
| esac |
| AC_SUBST(DATA_PACKAGING_CPPFLAGS) |
| 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 ;; |
| *-*-*bsd*) platform=U_BSD ;; |
| *-*-aix*) platform=AIX ;; |
| *-sequent-*) platform=PTX ;; |
| *-*-hpux*) platform=HPUX ;; |
| *-dec-osf*) platform=U_OSF ;; |
| *-*-irix*) platform=IRIX ;; |
| *-*ibm-openedition*|*-*-os390*) platform=OS390 |
| ICUDATA_CHAR="e" ;; |
| *-*-os400*) platform=OS400 |
| ICUDATA_CHAR="e" ;; |
| *-apple-darwin*|*-apple-rhapsody*) platform=U_DARWIN ;; |
| *-*-cygwin*) platform=U_CYGWIN ;; |
| *) 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) |
| |
| dnl Handle -rpath options for shared library paths |
| case "${host}" in |
| *-*-solaris*) ld_rpath_suf=":" ;; |
| *-*-linux*) ld_rpath_suf=" " ;; |
| *-*-*bsd*) ld_rpath_suf=" " ;; |
| *-*-aix*) ld_rpath_suf="" ;; |
| *-sequent-*) ld_rpath_suf="" ;; |
| *-*-hpux*) ld_rpath_suf=":" ;; |
| *-*-irix*) ld_rpath_suf=" " ;; |
| *-*ibm-openedition*|*-*-os390*) ld_rpath_suf="" ;; |
| *-*-os400*) ld_rpath_suf=" " ;; |
| *) ld_rpath_suf="" ;; |
| esac |
| AC_SUBST(ld_rpath_suf) |
| |
| dnl On HP/UX, main() functions compiled in C don't invoke |
| dnl static constructors in C++ libs. Hack around that here |
| dnl by renaming some .c files to .cpp |
| case "${host}" in |
| *-*-hpux*) |
| for file in samples/date/date \ |
| samples/cal/cal test/cintltst/cintltst \ |
| tools/makeconv/makeconv tools/genrb/genrb \ |
| tools/genrb/derb tools/genccode/genccode \ |
| tools/gencmn/gencmn tools/gencmn/decmn \ |
| tools/gencnval/gencnval tools/gennorm/gennorm \ |
| tools/gennames/gennames tools/gentest/gentest \ |
| tools/pkgdata/pkgdata tools/genprops/genprops |
| do |
| if test -f $file.c; then |
| mv $file.c $file.cpp |
| else |
| echo "# $file.c does not exist or is already renamed [warning]" |
| fi |
| done |
| ;; |
| esac |
| |
| if test "${FORCE_LIBS}" != ""; then |
| echo " *** Overriding automatically chosen [LIBS=$LIBS], using instead [FORCE_LIBS=${FORCE_LIBS}]" 1>&6 |
| LIBS=${FORCE_LIBS} |
| fi |
| |
| |
| if test "${AIX_SHLIB}" != ""; then |
| echo " *** setting AIX_SHLIB (AIX only) to ${AIX_SHLIB}]" 1>&6 |
| else |
| AIX_SHLIB=makeC++SharedLib_r |
| fi |
| |
| AC_SUBST(AIX_SHLIB) |
| |
| |
| dnl SPECIAL handling for HPUX 10 and also '11 & --enable-hpuxcma=true' |
| if test $hpuxcma = true; then |
| CPPFLAGS="${CPPFLAGS} -D_PTHREADS_DRAFT_4 -DHPUX_CMA" |
| fi |
| dnl END special |
| |
| 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 |
| |
| if test "$ac_cv_lib_dld_shl_load" = "yes"; then |
| CPPFLAGS="${CPPFLAGS} -DICU_USE_SHL_LOAD" |
| fi |
| |
| dnl added for s/390 DLL loading detection |
| |
| if test "$ac_cv_func_dllload" = "yes"; then |
| CPPFLAGS="${CPPFLAGS} -DICU_USE_SHL_LOAD" |
| fi |
| |
| dnl output the Makefiles |
| AC_OUTPUT([README icudefs.mk \ |
| Makefile \ |
| data/Makefile data/icupkg.inc \ |
| common/Makefile config/Makefile.inc i18n/Makefile \ |
| layout/Makefile \ |
| extra/Makefile extra/ustdio/Makefile \ |
| extra/uconv/Makefile extra/scrptrun/Makefile |
| stubdata/Makefile \ |
| tools/Makefile tools/ctestfw/Makefile tools/makeconv/Makefile \ |
| tools/genrb/Makefile \ |
| tools/genuca/Makefile \ |
| tools/pkgdata/Makefile \ |
| tools/genccode/Makefile tools/gencmn/Makefile \ |
| tools/gencnval/Makefile tools/gentz/Makefile \ |
| tools/gennames/Makefile tools/toolutil/Makefile \ |
| tools/gentest/Makefile \ |
| tools/gennorm/Makefile \ |
| tools/genprops/Makefile \ |
| tools/genbrk/Makefile \ |
| tools/dumpce/Makefile \ |
| test/Makefile test/testdata/Makefile test/intltest/Makefile \ |
| test/cintltst/Makefile test/iotest/Makefile \ |
| test/ieeetest/Makefile \ |
| test/collperf/Makefile \ |
| test/thaitest/Makefile \ |
| test/letest/Makefile \ |
| test/threadtest/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 |
| |
| echo "You must use $U_MAKE to build ICU." |
