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