[apple/icu.git] / icuSources / acinclude.m4

# Copyright (C) 2016 and later: Unicode, Inc. and others.
# License & terms of use: http://www.unicode.org/copyright.html
# Copyright (c) 1999-2016, International Business Machines Corporation and
# others. All Rights Reserved.
# acinclude.m4 for ICU
# Don't edit aclocal.m4, do edit acinclude.m4
# Stephen F. Booth

# @TOP@

# ICU_CHECK_MH_FRAG
AC_DEFUN([ICU_CHECK_MH_FRAG], [
	AC_CACHE_CHECK(
		[which Makefile fragment to use for ${host}],
		[icu_cv_host_frag],
		[
case "${host}" in
*-*-solaris*)
	if test "$GCC" = yes; then	
		icu_cv_host_frag=mh-solaris-gcc
	else
		icu_cv_host_frag=mh-solaris
	fi ;;
alpha*-*-linux-gnu)
	if test "$GCC" = yes; then
		icu_cv_host_frag=mh-alpha-linux-gcc
	else
		icu_cv_host_frag=mh-alpha-linux-cc
	fi ;;
powerpc*-*-linux*)
	if test "$GCC" = yes; then
		icu_cv_host_frag=mh-linux
	else
		icu_cv_host_frag=mh-linux-va
	fi ;;
*-*-linux*|*-*-gnu|*-*-k*bsd*-gnu|*-*-kopensolaris*-gnu) icu_cv_host_frag=mh-linux ;;
i[[34567]]86-*-cygwin) 
	if test "$GCC" = yes; then
		icu_cv_host_frag=mh-cygwin
	else
		icu_cv_host_frag=mh-cygwin-msvc
	fi ;;
x86_64-*-cygwin) 
	if test "$GCC" = yes; then
		icu_cv_host_frag=mh-cygwin64
	else
		icu_cv_host_frag=mh-cygwin-msvc
	fi ;;
*-*-mingw*)
	if test "$GCC" = yes; then
                AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#ifndef __MINGW64__
#error This is not MinGW64
#endif]])],                        [icu_cv_host_frag=mh-mingw64],
                                   [icu_cv_host_frag=mh-mingw])
	else
	        case "${host}" in
		*-*-mingw*) icu_cv_host_frag=mh-msys-msvc ;;
		*-*-cygwin) icu_cv_host_frag=mh-cygwin-msvc ;;
		esac
	fi ;;
*-*-*bsd*|*-*-dragonfly*) 	icu_cv_host_frag=mh-bsd-gcc ;;
*-*-aix*)
	if test "$GCC" = yes; then
		icu_cv_host_frag=mh-aix-gcc
	else
		icu_cv_host_frag=mh-aix-va
	fi ;;
*-*-hpux*)
	if test "$GCC" = yes; then
		icu_cv_host_frag=mh-hpux-gcc
	else
		case "$CXX" in
		*aCC)    icu_cv_host_frag=mh-hpux-acc ;;
		esac
	fi ;;
*-*ibm-openedition*|*-*-os390*)	icu_cv_host_frag=mh-os390 ;;
*-*-os400*)	icu_cv_host_frag=mh-os400 ;;
*-apple-rhapsody*)	icu_cv_host_frag=mh-darwin ;;
*-apple-darwin*)	icu_cv_host_frag=mh-darwin ;;
*-*-beos)       icu_cv_host_frag=mh-beos ;; 
*-*-haiku)      icu_cv_host_frag=mh-haiku ;; 
*-*-irix*)	icu_cv_host_frag=mh-irix ;;
*-dec-osf*) icu_cv_host_frag=mh-alpha-osf ;;
*-*-nto*)	icu_cv_host_frag=mh-qnx ;;
*-ncr-*)	icu_cv_host_frag=mh-mpras ;;
*) 		icu_cv_host_frag=mh-unknown ;;
esac
		]
	)
])

# ICU_PROG_LINK - Make sure that the linker is usable
AC_DEFUN([ICU_PROG_LINK],
[
case "${host}" in
    *-*-cygwin*|*-*-mingw*)
        if test "$GCC" != yes && test -n "`link --version 2>&1 | grep 'GNU coreutils'`"; then
            AC_MSG_ERROR([link.exe is not a valid linker. Your PATH is incorrect.
                  Please follow the directions in ICU's readme.])
        fi;;
    *);;
esac])

# AC_SEARCH_LIBS_FIRST(FUNCTION, SEARCH-LIBS [, ACTION-IF-FOUND
#            [, ACTION-IF-NOT-FOUND [, OTHER-LIBRARIES]]])
# Search for a library defining FUNC, then see if it's not already available.

AC_DEFUN([AC_SEARCH_LIBS_FIRST],
[AC_PREREQ([2.13])
AC_CACHE_CHECK([for library containing $1], [ac_cv_search_$1],
[ac_func_search_save_LIBS="$LIBS"
ac_cv_search_$1="no"
for i in $2; do
LIBS="-l$i $5 $ac_func_search_save_LIBS"
AC_TRY_LINK_FUNC([$1],
[ac_cv_search_$1="-l$i"
break])
done
if test "$ac_cv_search_$1" = "no"; then
AC_TRY_LINK_FUNC([$1], [ac_cv_search_$1="none required"])
fi
LIBS="$ac_func_search_save_LIBS"])
if test "$ac_cv_search_$1" != "no"; then
  test "$ac_cv_search_$1" = "none required" || LIBS="$ac_cv_search_$1 $LIBS"
  $3
else :
  $4
fi])


# Check if we can build and use 64-bit libraries
AC_DEFUN([AC_CHECK_64BIT_LIBS],
[
    BITS_REQ=nochange
    ENABLE_64BIT_LIBS=unknown
    ## revisit this for cross-compile.
    
    AC_ARG_ENABLE(64bit-libs,
        [  --enable-64bit-libs     (deprecated, use --with-library-bits) build 64-bit libraries [default= platform default]],
        [echo "note, use --with-library-bits instead of --*-64bit-libs"
         case "${enableval}" in
            no|false|32) with_library_bits=32;  ;;
            yes|true|64) with_library_bits=64else32 ;;
            nochange) with_library_bits=nochange; ;;
            *) AC_MSG_ERROR(bad value ${enableval} for '--*-64bit-libs') ;;
            esac]    )
    

    AC_ARG_WITH(library-bits,
        [  --with-library-bits=bits specify how many bits to use for the library (32, 64, 64else32, nochange) [default=nochange]],
        [case "${withval}" in
            ""|nochange) BITS_REQ=$withval ;;
            32|64|64else32) BITS_REQ=$withval ;;
            *) AC_MSG_ERROR(bad value ${withval} for --with-library-bits) ;;
            esac])
        
    # don't use these for cross compiling
    if test "$cross_compiling" = "yes" -a "${BITS_REQ}" != "nochange"; then
        AC_MSG_ERROR([Don't specify bitness when cross compiling. See readme.html for help with cross compilation., and set compiler options manually.])
    fi
    AC_CHECK_SIZEOF([void *])
    AC_MSG_CHECKING([whether runnable 64 bit binaries are built by default])
    case $ac_cv_sizeof_void_p in
        8) DEFAULT_64BIT=yes ;;
        4) DEFAULT_64BIT=no ;;
        *) DEFAULT_64BIT=unknown
    esac
    BITS_GOT=unknown
    
    # 'OK' here means, we can exit any further checking, everything's copa
    BITS_OK=yes

    # do we need to check for buildable/runnable 32 or 64 bit?
    BITS_CHECK_32=no
    BITS_CHECK_64=no
    
    # later, can we run the 32/64 bit binaries so made?
    BITS_RUN_32=no
    BITS_RUN_64=no
    
    if test "$DEFAULT_64BIT" = "yes"; then
        # we get 64 bits by default.
        BITS_GOT=64
        case "$BITS_REQ" in
            32) 
                # need to look for 32 bit support. 
                BITS_CHECK_32=yes
                # not copa.
                BITS_OK=no;;
            # everyone else is happy.
            nochange) ;;
            *) ;;
        esac
    elif test "$DEFAULT_64BIT" = "no"; then
        # not 64 bit by default.
        BITS_GOT=32
        case "$BITS_REQ" in
            64|64else32)
                BITS_CHECK_64=yes
                #BITS_CHECK_32=yes
                BITS_OK=no;;
            nochange) ;;
            *) ;;
        esac
    elif test "$DEFAULT_64BIT" = "unknown"; then
        # cross compiling.
        BITS_GOT=unknown
        case "$BITS_REQ" in
            64|64else32) BITS_OK=no
            BITS_CHECK_32=yes
            BITS_CHECK_64=yes ;;
            32) BITS_OK=no;;
            nochange) ;;
            *) ;;
        esac
    fi
            
    AC_MSG_RESULT($DEFAULT_64BIT);

    if test "$BITS_OK" != "yes"; then
        # not copa. back these up.
        CFLAGS_OLD="${CFLAGS}"
        CXXFLAGS_OLD="${CXXFLAGS}"
        LDFLAGS_OLD="${LDFLAGS}"
        ARFLAGS_OLD="${ARFLAGS}"        
        
        CFLAGS_32="${CFLAGS}"
        CXXFLAGS_32="${CXXFLAGS}"
        LDFLAGS_32="${LDFLAGS}"
        ARFLAGS_32="${ARFLAGS}"        
        
        CFLAGS_64="${CFLAGS}"
        CXXFLAGS_64="${CXXFLAGS}"
        LDFLAGS_64="${LDFLAGS}"
        ARFLAGS_64="${ARFLAGS}"        
        
        CAN_BUILD_64=unknown
        CAN_BUILD_32=unknown
        # These results can't be cached because is sets compiler flags.
        if test "$BITS_CHECK_64" = "yes"; then
            AC_MSG_CHECKING([how to build 64-bit executables])
            CAN_BUILD_64=no
            ####
            # Find out if we think we can *build* for 64 bit. Doesn't check whether we can run it.
            #  Note, we don't have to actually check if the options work- we'll try them before using them.
            #  So, only try actually testing the options, if you are trying to decide between multiple options.
            # On exit from the following clauses:
            # if CAN_BUILD_64=yes:
            #    *FLAGS are assumed to contain the right settings for 64bit
            # else if CAN_BUILD_64=no: (default)
            #    *FLAGS are assumed to be trashed, and will be reset from *FLAGS_OLD
            
            if test "$GCC" = yes; then
                CFLAGS="${CFLAGS} -m64"
                CXXFLAGS="${CXXFLAGS} -m64"
                AC_COMPILE_IFELSE([AC_LANG_SOURCE([int main(void) {return (sizeof(void*)*8==64)?0:1;}])],
                   CAN_BUILD_64=yes, CAN_BUILD_64=no)
            else
                case "${host}" in
                sparc*-*-solaris*)
                    # 1. try -m64
                    CFLAGS="${CFLAGS} -m64"
                    CXXFLAGS="${CXXFLAGS} -m64"
                    AC_RUN_IFELSE([AC_LANG_SOURCE([int main(void) {return (sizeof(void*)*8==64)?0:1;}])],
                       CAN_BUILD_64=yes, CAN_BUILD_64=no, CAN_BUILD_64=unknown)
                    if test "$CAN_BUILD_64" != yes; then
                        # Nope. back out changes.
                        CFLAGS="${CFLAGS_OLD}"
                        CXXFLAGS="${CXXFLAGS_OLD}"
                        # 2. try xarch=v9 [deprecated]
                        ## TODO: cross compile: the following won't work.
                        SPARCV9=`isainfo -n 2>&1 | grep sparcv9`
                        SOL64=`$CXX -xarch=v9 2>&1 && $CC -xarch=v9 2>&1 | grep -v usage:`
                        # "Warning: -xarch=v9 is deprecated, use -m64 to create 64-bit programs"
                        if test -z "$SOL64" && test -n "$SPARCV9"; then
                            CFLAGS="${CFLAGS} -xtarget=ultra -xarch=v9"
                            CXXFLAGS="${CXXFLAGS} -xtarget=ultra -xarch=v9"
                            LDFLAGS="${LDFLAGS} -xtarget=ultra -xarch=v9"
                            CAN_BUILD_64=yes
                        fi
                    fi
                    ;;
                i386-*-solaris*)
                    # 1. try -m64
                    CFLAGS="${CFLAGS} -m64"
                    CXXFLAGS="${CXXFLAGS} -m64"
                    AC_RUN_IFELSE([AC_LANG_SOURCE([int main(void) {return (sizeof(void*)*8==64)?0:1;}])],
                       CAN_BUILD_64=yes, CAN_BUILD_64=no, CAN_BUILD_64=unknown)
                    if test "$CAN_BUILD_64" != yes; then
                        # Nope. back out changes.
                        CFLAGS="${CFLAGS_OLD}"
                        CXXFLAGS="${CXXFLAGS_OLD}"
                        # 2. try the older compiler option
                        ## TODO: cross compile problem
                        AMD64=`isainfo -n 2>&1 | grep amd64`
                        SOL64=`$CXX -xtarget=generic64 2>&1 && $CC -xtarget=generic64 2>&1 | grep -v usage:`
                        if test -z "$SOL64" && test -n "$AMD64"; then
                            CFLAGS="${CFLAGS} -xtarget=generic64"
                            CXXFLAGS="${CXXFLAGS} -xtarget=generic64"
                            CAN_BUILD_64=yes
                        fi
                    fi
                    ;;
                ia64-*-linux*)
                    # check for ecc/ecpc compiler support
                    ## TODO: cross compiler problem
                    if test -n "`$CXX --help 2>&1 && $CC --help 2>&1 | grep -v Intel`"; then
                        if test -n "`$CXX --help 2>&1 && $CC --help 2>&1 | grep -v Itanium`"; then
                            CAN_BUILD_64=yes
                        fi
                    fi
                    ;;
                *-*-cygwin)
                    # vcvarsamd64.bat should have been used to enable 64-bit builds.
                    # We only do this check to display the correct answer.
                    ## TODO: cross compiler problem
                    if test -n "`$CXX -help 2>&1 | grep 'for x64'`"; then
                        CAN_BUILD_64=yes
                    fi
                    ;;
                *-*-aix*|powerpc64-*-linux*)
                    CFLAGS="${CFLAGS} -q64"
                    CXXFLAGS="${CXXFLAGS} -q64"
                    LDFLAGS="${LDFLAGS} -q64"
                    AC_COMPILE_IFELSE([AC_LANG_SOURCE([int main(void) {return (sizeof(void*)*8==64)?0:1;}])],
                       CAN_BUILD_64=yes, CAN_BUILD_64=no)
                    if test "$CAN_BUILD_64" = yes; then
                        # worked- set other options.
                        case "${host}" in
                        *-*-aix*)
                            # tell AIX what executable mode to use.
                            ARFLAGS="${ARFLAGS} -X64"
                        esac
                    fi
                    ;;
                *-*-hpux*)
                    # First we try the newer +DD64, if that doesn't work,
                    # try other options.

                    CFLAGS="${CFLAGS} +DD64"
                    CXXFLAGS="${CXXFLAGS} +DD64"
                    AC_COMPILE_IFELSE([AC_LANG_SOURCE([int main(void) {return (sizeof(void*)*8==64)?0:1;}])],
                        CAN_BUILD_64=yes, CAN_BUILD_64=no)
                    if test "$CAN_BUILD_64" != yes; then
                        # reset
                        CFLAGS="${CFLAGS_OLD}"
                        CXXFLAGS="${CXXFLAGS_OLD}"
                        # append
                        CFLAGS="${CFLAGS} +DA2.0W"
                        CXXFLAGS="${CXXFLAGS} +DA2.0W"
                        AC_COMPILE_IFELSE([AC_LANG_SOURCE([int main(void) {return (sizeof(void*)*8==64)?0:1;}])],
                            CAN_BUILD_64=yes, CAN_BUILD_64=no)
                    fi
                    ;;
                *-*ibm-openedition*|*-*-os390*)
                    CFLAGS="${CFLAGS} -Wc,lp64"
                    CXXFLAGS="${CXXFLAGS} -Wc,lp64"
                    LDFLAGS="${LDFLAGS} -Wl,lp64"
                    AC_COMPILE_IFELSE([AC_LANG_SOURCE([int main(void) {return (sizeof(void*)*8==64)?0:1;}])],
                       CAN_BUILD_64=yes, CAN_BUILD_64=no)
                    ;;
                *)
                    # unknown platform.
                    ;;
                esac
            fi
            AC_MSG_RESULT($CAN_BUILD_64)
            if test "$CAN_BUILD_64" = yes; then
                AC_MSG_CHECKING([whether runnable 64-bit binaries are being built ])
                AC_RUN_IFELSE([AC_LANG_SOURCE([int main(void) {return (sizeof(void*)*8==64)?0:1;}])],
                   BITS_RUN_64=yes, BITS_RUN_64=no, BITS_RUN_64=unknown)
                AC_MSG_RESULT($BITS_RUN_64);

                CFLAGS_64="${CFLAGS}"
                CXXFLAGS_64="${CXXFLAGS}"
                LDFLAGS_64="${LDFLAGS}"
                ARFLAGS_64="${ARFLAGS}"        
            fi
            # put it back.
            CFLAGS="${CFLAGS_OLD}"
            CXXFLAGS="${CXXFLAGS_OLD}"
            LDFLAGS="${LDFLAGS_OLD}"
            ARFLAGS="${ARFLAGS_OLD}"     
        fi
        if test "$BITS_CHECK_32" = "yes"; then
            # see comment under 'if BITS_CHECK_64', above.
            AC_MSG_CHECKING([how to build 32-bit executables])
            if test "$GCC" = yes; then
                CFLAGS="${CFLAGS} -m32"
                CXXFLAGS="${CXXFLAGS} -m32"
                AC_COMPILE_IFELSE([AC_LANG_SOURCE([int main(void) {return (sizeof(void*)*8==32)?0:1;}])],
                   CAN_BUILD_32=yes, CAN_BUILD_32=no)
            fi
            AC_MSG_RESULT($CAN_BUILD_32)
            if test "$CAN_BUILD_32" = yes; then
                AC_MSG_CHECKING([whether runnable 32-bit binaries are being built ])
                AC_RUN_IFELSE([AC_LANG_SOURCE([int main(void) {return (sizeof(void*)*8==32)?0:1;}])],
                   BITS_RUN_32=yes, BITS_RUN_32=no, BITS_RUN_32=unknown)
                AC_MSG_RESULT($BITS_RUN_32);
                CFLAGS_32="${CFLAGS}"
                CXXFLAGS_32="${CXXFLAGS}"
                LDFLAGS_32="${LDFLAGS}"
                ARFLAGS_32="${ARFLAGS}"        
            fi
            # put it back.
            CFLAGS="${CFLAGS_OLD}"
            CXXFLAGS="${CXXFLAGS_OLD}"
            LDFLAGS="${LDFLAGS_OLD}"
            ARFLAGS="${ARFLAGS_OLD}"     
        fi
        
        ##
        # OK. Now, we've tested for 32 and 64 bitness. Let's see what we'll do.
        #
        
        # First, implement 64else32
        if test "$BITS_REQ" = "64else32"; then
            if test "$BITS_RUN_64" = "yes"; then
                BITS_REQ=64
            else
                # no changes.
                BITS_OK=yes 
            fi
        fi
        
        # implement.
        if test "$BITS_REQ" = "32" -a "$BITS_RUN_32" = "yes"; then
            CFLAGS="${CFLAGS_32}"
            CXXFLAGS="${CXXFLAGS_32}"
            LDFLAGS="${LDFLAGS_32}"
            ARFLAGS="${ARFLAGS_32}"     
            BITS_OK=yes
        elif test "$BITS_REQ" = "64" -a "$BITS_RUN_64" = "yes"; then
            CFLAGS="${CFLAGS_64}"
            CXXFLAGS="${CXXFLAGS_64}"
            LDFLAGS="${LDFLAGS_64}"
            ARFLAGS="${ARFLAGS_64}"     
            BITS_OK=yes
        elif test "$BITS_OK" != "yes"; then
            AC_MSG_ERROR([Requested $BITS_REQ bit binaries but could not compile and execute them. See readme.html for help with cross compilation., and set compiler options manually.])
        fi
     fi
])

# Strict compilation options.
AC_DEFUN([AC_CHECK_STRICT_COMPILE],
[
    AC_MSG_CHECKING([whether strict compiling is on])
    AC_ARG_ENABLE(strict,[  --enable-strict         compile with strict compiler options [default=yes]], [
        if test "$enableval" = no
        then
            ac_use_strict_options=no
        else
            ac_use_strict_options=yes
        fi
      ], [ac_use_strict_options=yes])
    AC_MSG_RESULT($ac_use_strict_options)

    if test "$ac_use_strict_options" = yes
    then
        if test "$GCC" = yes
        then
            case "${host}" in
            *-*-solaris*)
                # Don't use -std=c11 on Solaris because of timezone check fails
                ;;
            *)
                # Do not use -ansi. It limits us to C90, and it breaks some platforms.
                # We use -std=c11 to disable the gnu99 defaults and its associated warnings
                CFLAGS="$CFLAGS -std=c11"
                ;;
            esac
            
            CFLAGS="$CFLAGS -Wall -pedantic -Wshadow -Wpointer-arith -Wmissing-prototypes -Wwrite-strings"
        else
            case "${host}" in
            *-*-cygwin)
                if test "`$CC /help 2>&1 | head -c9`" = "Microsoft"
                then
                    CFLAGS="$CFLAGS /W4"
                fi ;;
            *-*-mingw*)
                CFLAGS="$CFLAGS -W4" ;;
            esac
        fi
        if test "$GXX" = yes
        then
            CXXFLAGS="$CXXFLAGS -W -Wall -pedantic -Wpointer-arith -Wwrite-strings -Wno-long-long"
        else
            case "${host}" in
            *-*-cygwin)
                if test "`$CXX /help 2>&1 | head -c9`" = "Microsoft"
                then
                    CXXFLAGS="$CXXFLAGS /W4"
                fi ;;
            *-*-mingw*)
                CFLAGS="$CFLAGS -W4" ;;
            esac
        fi
    fi
])
Commit	Line	Data
f3c0d7a5 A	1	# Copyright (C) 2016 and later: Unicode, Inc. and others.
	2	# License & terms of use: http://www.unicode.org/copyright.html
	3	# Copyright (c) 1999-2016, International Business Machines Corporation and
57a6839d A	4	# others. All Rights Reserved.
	5	# acinclude.m4 for ICU
	6	# Don't edit aclocal.m4, do edit acinclude.m4
	7	# Stephen F. Booth
	8
	9	# @TOP@
	10
	11	# ICU_CHECK_MH_FRAG
	12	AC_DEFUN([ICU_CHECK_MH_FRAG], [
	13	AC_CACHE_CHECK(
	14	[which Makefile fragment to use for ${host}],
	15	[icu_cv_host_frag],
	16	[
	17	case "${host}" in
	18	--solaris*)
	19	if test "$GCC" = yes; then
	20	icu_cv_host_frag=mh-solaris-gcc
	21	else
	22	icu_cv_host_frag=mh-solaris
	23	fi ;;
	24	alpha--linux-gnu)
	25	if test "$GCC" = yes; then
	26	icu_cv_host_frag=mh-alpha-linux-gcc
	27	else
	28	icu_cv_host_frag=mh-alpha-linux-cc
	29	fi ;;
	30	powerpc--linux*)
	31	if test "$GCC" = yes; then
	32	icu_cv_host_frag=mh-linux
	33	else
	34	icu_cv_host_frag=mh-linux-va
	35	fi ;;
	36	--linux\|--gnu\|--kbsd-gnu\|--kopensolaris-gnu) icu_cv_host_frag=mh-linux ;;
b331163b	37	i[[34567]]86-*-cygwin)
57a6839d	38	if test "$GCC" = yes; then
b331163b A	39	icu_cv_host_frag=mh-cygwin
	40	else
	41	icu_cv_host_frag=mh-cygwin-msvc
	42	fi ;;
	43	x86_64-*-cygwin)
	44	if test "$GCC" = yes; then
	45	icu_cv_host_frag=mh-cygwin64
	46	else
	47	icu_cv_host_frag=mh-cygwin-msvc
	48	fi ;;
	49	--mingw*)
	50	if test "$GCC" = yes; then
	51	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
57a6839d A	52	#ifndef __MINGW64__
57a6839d A	53	#error This is not MinGW64
b331163b A	54	#endif]])], [icu_cv_host_frag=mh-mingw64],
b331163b A	55	[icu_cv_host_frag=mh-mingw])
57a6839d	56	else
b331163b A	57	case "${host}" in
	58	--mingw*) icu_cv_host_frag=mh-msys-msvc ;;
	59	--cygwin) icu_cv_host_frag=mh-cygwin-msvc ;;
	60	esac
57a6839d A	61	fi ;;
	62	--bsd\|--dragonfly*) icu_cv_host_frag=mh-bsd-gcc ;;
	63	--aix*)
	64	if test "$GCC" = yes; then
	65	icu_cv_host_frag=mh-aix-gcc
	66	else
	67	icu_cv_host_frag=mh-aix-va
	68	fi ;;
	69	--hpux*)
	70	if test "$GCC" = yes; then
	71	icu_cv_host_frag=mh-hpux-gcc
	72	else
	73	case "$CXX" in
	74	*aCC) icu_cv_host_frag=mh-hpux-acc ;;
	75	esac
	76	fi ;;
	77	-ibm-openedition\|--os390) icu_cv_host_frag=mh-os390 ;;
	78	--os400*) icu_cv_host_frag=mh-os400 ;;
	79	-apple-rhapsody) icu_cv_host_frag=mh-darwin ;;
	80	-apple-darwin) icu_cv_host_frag=mh-darwin ;;
	81	--beos) icu_cv_host_frag=mh-beos ;;
	82	--haiku) icu_cv_host_frag=mh-haiku ;;
	83	--irix*) icu_cv_host_frag=mh-irix ;;
	84	-dec-osf) icu_cv_host_frag=mh-alpha-osf ;;
	85	--nto*) icu_cv_host_frag=mh-qnx ;;
	86	-ncr-) icu_cv_host_frag=mh-mpras ;;
	87	*) icu_cv_host_frag=mh-unknown ;;
	88	esac
	89	]
	90	)
	91	])
	92
57a6839d A	93	# ICU_PROG_LINK - Make sure that the linker is usable
	94	AC_DEFUN([ICU_PROG_LINK],
	95	[
	96	case "${host}" in
	97	--cygwin\|--mingw)
	98	if test "$GCC" != yes && test -n "`link --version 2>&1 \| grep 'GNU coreutils'`"; then
	99	AC_MSG_ERROR([link.exe is not a valid linker. Your PATH is incorrect.
	100	Please follow the directions in ICU's readme.])
	101	fi;;
	102	*);;
	103	esac])
	104
	105	# AC_SEARCH_LIBS_FIRST(FUNCTION, SEARCH-LIBS [, ACTION-IF-FOUND
	106	# [, ACTION-IF-NOT-FOUND [, OTHER-LIBRARIES]]])
	107	# Search for a library defining FUNC, then see if it's not already available.
	108
	109	AC_DEFUN([AC_SEARCH_LIBS_FIRST],
	110	[AC_PREREQ([2.13])
	111	AC_CACHE_CHECK([for library containing $1], [ac_cv_search_$1],
	112	[ac_func_search_save_LIBS="$LIBS"
	113	ac_cv_search_$1="no"
	114	for i in $2; do
	115	LIBS="-l$i $5 $ac_func_search_save_LIBS"
	116	AC_TRY_LINK_FUNC([$1],
	117	[ac_cv_search_$1="-l$i"
	118	break])
	119	done
	120	if test "$ac_cv_search_$1" = "no"; then
	121	AC_TRY_LINK_FUNC([$1], [ac_cv_search_$1="none required"])
	122	fi
	123	LIBS="$ac_func_search_save_LIBS"])
	124	if test "$ac_cv_search_$1" != "no"; then
	125	test "$ac_cv_search_$1" = "none required" \|\| LIBS="$ac_cv_search_$1 $LIBS"
	126	$3
	127	else :
	128	$4
	129	fi])
	130
	131
	132
	133	# Check if we can build and use 64-bit libraries
	134	AC_DEFUN([AC_CHECK_64BIT_LIBS],
	135	[
	136	BITS_REQ=nochange
	137	ENABLE_64BIT_LIBS=unknown
	138	## revisit this for cross-compile.
	139
	140	AC_ARG_ENABLE(64bit-libs,
	141	[ --enable-64bit-libs (deprecated, use --with-library-bits) build 64-bit libraries [default= platform default]],
	142	[echo "note, use --with-library-bits instead of --*-64bit-libs"
	143	case "${enableval}" in
	144	no\|false\|32) with_library_bits=32; ;;
	145	yes\|true\|64) with_library_bits=64else32 ;;
	146	nochange) with_library_bits=nochange; ;;
	147	) AC_MSG_ERROR(bad value ${enableval} for '---64bit-libs') ;;
	148	esac] )
	149
	150
	151	AC_ARG_WITH(library-bits,
	152	[ --with-library-bits=bits specify how many bits to use for the library (32, 64, 64else32, nochange) [default=nochange]],
	153	[case "${withval}" in
	154	""\|nochange) BITS_REQ=$withval ;;
	155	32\|64\|64else32) BITS_REQ=$withval ;;
	156	*) AC_MSG_ERROR(bad value ${withval} for --with-library-bits) ;;
157	esac])
158
159	# don't use these for cross compiling
160	if test "$cross_compiling" = "yes" -a "${BITS_REQ}" != "nochange"; then
161	AC_MSG_ERROR([Don't specify bitness when cross compiling. See readme.html for help with cross compilation., and set compiler options manually.])
162	fi
163	AC_CHECK_SIZEOF([void *])
164	AC_MSG_CHECKING([whether runnable 64 bit binaries are built by default])
165	case $ac_cv_sizeof_void_p in
166	8) DEFAULT_64BIT=yes ;;
167	4) DEFAULT_64BIT=no ;;
168	*) DEFAULT_64BIT=unknown
169	esac
170	BITS_GOT=unknown
171
172	# 'OK' here means, we can exit any further checking, everything's copa
173	BITS_OK=yes
174
175	# do we need to check for buildable/runnable 32 or 64 bit?
176	BITS_CHECK_32=no
177	BITS_CHECK_64=no
178
179	# later, can we run the 32/64 bit binaries so made?
180	BITS_RUN_32=no
181	BITS_RUN_64=no
182
183	if test "$DEFAULT_64BIT" = "yes"; then
184	# we get 64 bits by default.
185	BITS_GOT=64
186	case "$BITS_REQ" in
187	32)
188	# need to look for 32 bit support.
189	BITS_CHECK_32=yes
190	# not copa.
191	BITS_OK=no;;
192	# everyone else is happy.
193	nochange) ;;
194	*) ;;
195	esac
196	elif test "$DEFAULT_64BIT" = "no"; then
197	# not 64 bit by default.
198	BITS_GOT=32
199	case "$BITS_REQ" in
200	64\|64else32)
201	BITS_CHECK_64=yes
202	#BITS_CHECK_32=yes
203	BITS_OK=no;;
204	nochange) ;;
205	*) ;;
206	esac
207	elif test "$DEFAULT_64BIT" = "unknown"; then
208	# cross compiling.
209	BITS_GOT=unknown
210	case "$BITS_REQ" in
211	64\|64else32) BITS_OK=no
212	BITS_CHECK_32=yes
213	BITS_CHECK_64=yes ;;
214	32) BITS_OK=no;;
215	nochange) ;;
216	*) ;;
217	esac
218	fi
219
220	AC_MSG_RESULT($DEFAULT_64BIT);
221
222	if test "$BITS_OK" != "yes"; then
223	# not copa. back these up.
224	CFLAGS_OLD="${CFLAGS}"
225	CXXFLAGS_OLD="${CXXFLAGS}"
226	LDFLAGS_OLD="${LDFLAGS}"
227	ARFLAGS_OLD="${ARFLAGS}"
228
229	CFLAGS_32="${CFLAGS}"
230	CXXFLAGS_32="${CXXFLAGS}"
231	LDFLAGS_32="${LDFLAGS}"
232	ARFLAGS_32="${ARFLAGS}"
233
234	CFLAGS_64="${CFLAGS}"
235	CXXFLAGS_64="${CXXFLAGS}"
236	LDFLAGS_64="${LDFLAGS}"
237	ARFLAGS_64="${ARFLAGS}"
238
239	CAN_BUILD_64=unknown
240	CAN_BUILD_32=unknown
241	# These results can't be cached because is sets compiler flags.
242	if test "$BITS_CHECK_64" = "yes"; then
243	AC_MSG_CHECKING([how to build 64-bit executables])
244	CAN_BUILD_64=no
245	####
246	# Find out if we think we can build for 64 bit. Doesn't check whether we can run it.
247	# Note, we don't have to actually check if the options work- we'll try them before using them.
248	# So, only try actually testing the options, if you are trying to decide between multiple options.
249	# On exit from the following clauses:
250	# if CAN_BUILD_64=yes:
251	# *FLAGS are assumed to contain the right settings for 64bit
252	# else if CAN_BUILD_64=no: (default)
253	# FLAGS are assumed to be trashed, and will be reset from FLAGS_OLD
254
255	if test "$GCC" = yes; then
256	CFLAGS="${CFLAGS} -m64"
257	CXXFLAGS="${CXXFLAGS} -m64"
258	AC_COMPILE_IFELSE([AC_LANG_SOURCE([int main(void) {return (sizeof(void)8==64)?0:1;}])],
259	CAN_BUILD_64=yes, CAN_BUILD_64=no)
260	else
261	case "${host}" in
262	sparc--solaris*)
263	# 1. try -m64
264	CFLAGS="${CFLAGS} -m64"
265	CXXFLAGS="${CXXFLAGS} -m64"
266	AC_RUN_IFELSE([AC_LANG_SOURCE([int main(void) {return (sizeof(void)8==64)?0:1;}])],
267	CAN_BUILD_64=yes, CAN_BUILD_64=no, CAN_BUILD_64=unknown)
268	if test "$CAN_BUILD_64" != yes; then
269	# Nope. back out changes.
270	CFLAGS="${CFLAGS_OLD}"
b331163b	271	CXXFLAGS="${CXXFLAGS_OLD}"
57a6839d A	272	# 2. try xarch=v9 [deprecated]
	273	## TODO: cross compile: the following won't work.
	274	SPARCV9=`isainfo -n 2>&1 \| grep sparcv9`
	275	SOL64=`$CXX -xarch=v9 2>&1 && $CC -xarch=v9 2>&1 \| grep -v usage:`
	276	# "Warning: -xarch=v9 is deprecated, use -m64 to create 64-bit programs"
	277	if test -z "$SOL64" && test -n "$SPARCV9"; then
	278	CFLAGS="${CFLAGS} -xtarget=ultra -xarch=v9"
	279	CXXFLAGS="${CXXFLAGS} -xtarget=ultra -xarch=v9"
	280	LDFLAGS="${LDFLAGS} -xtarget=ultra -xarch=v9"
	281	CAN_BUILD_64=yes
	282	fi
	283	fi
	284	;;
	285	i386--solaris)
	286	# 1. try -m64
	287	CFLAGS="${CFLAGS} -m64"
	288	CXXFLAGS="${CXXFLAGS} -m64"
	289	AC_RUN_IFELSE([AC_LANG_SOURCE([int main(void) {return (sizeof(void)8==64)?0:1;}])],
	290	CAN_BUILD_64=yes, CAN_BUILD_64=no, CAN_BUILD_64=unknown)
	291	if test "$CAN_BUILD_64" != yes; then
	292	# Nope. back out changes.
	293	CFLAGS="${CFLAGS_OLD}"
	294	CXXFLAGS="${CXXFLAGS_OLD}"
	295	# 2. try the older compiler option
	296	## TODO: cross compile problem
	297	AMD64=`isainfo -n 2>&1 \| grep amd64`
	298	SOL64=`$CXX -xtarget=generic64 2>&1 && $CC -xtarget=generic64 2>&1 \| grep -v usage:`
	299	if test -z "$SOL64" && test -n "$AMD64"; then
	300	CFLAGS="${CFLAGS} -xtarget=generic64"
	301	CXXFLAGS="${CXXFLAGS} -xtarget=generic64"
	302	CAN_BUILD_64=yes
	303	fi
	304	fi
	305	;;
	306	ia64--linux)
	307	# check for ecc/ecpc compiler support
	308	## TODO: cross compiler problem
	309	if test -n "`$CXX --help 2>&1 && $CC --help 2>&1 \| grep -v Intel`"; then
	310	if test -n "`$CXX --help 2>&1 && $CC --help 2>&1 \| grep -v Itanium`"; then
	311	CAN_BUILD_64=yes
	312	fi
	313	fi
	314	;;
	315	--cygwin)
	316	# vcvarsamd64.bat should have been used to enable 64-bit builds.
	317	# We only do this check to display the correct answer.
	318	## TODO: cross compiler problem
	319	if test -n "`$CXX -help 2>&1 \| grep 'for x64'`"; then
	320	CAN_BUILD_64=yes
	321	fi
	322	;;
	323	--aix\|powerpc64--linux*)
	324	CFLAGS="${CFLAGS} -q64"
	325	CXXFLAGS="${CXXFLAGS} -q64"
	326	LDFLAGS="${LDFLAGS} -q64"
	327	AC_COMPILE_IFELSE([AC_LANG_SOURCE([int main(void) {return (sizeof(void)8==64)?0:1;}])],
	328	CAN_BUILD_64=yes, CAN_BUILD_64=no)
	329	if test "$CAN_BUILD_64" = yes; then
	330	# worked- set other options.
	331	case "${host}" in
	332	--aix*)
	333	# tell AIX what executable mode to use.
	334	ARFLAGS="${ARFLAGS} -X64"
	335	esac
336	fi
337	;;
338	--hpux*)
339	# First we try the newer +DD64, if that doesn't work,
340	# try other options.
341
342	CFLAGS="${CFLAGS} +DD64"
343	CXXFLAGS="${CXXFLAGS} +DD64"
344	AC_COMPILE_IFELSE([AC_LANG_SOURCE([int main(void) {return (sizeof(void)8==64)?0:1;}])],
345	CAN_BUILD_64=yes, CAN_BUILD_64=no)
346	if test "$CAN_BUILD_64" != yes; then
347	# reset
348	CFLAGS="${CFLAGS_OLD}"
349	CXXFLAGS="${CXXFLAGS_OLD}"
350	# append
351	CFLAGS="${CFLAGS} +DA2.0W"
352	CXXFLAGS="${CXXFLAGS} +DA2.0W"
353	AC_COMPILE_IFELSE([AC_LANG_SOURCE([int main(void) {return (sizeof(void)8==64)?0:1;}])],
354	CAN_BUILD_64=yes, CAN_BUILD_64=no)
355	fi
356	;;
357	-ibm-openedition\|--os390)
358	CFLAGS="${CFLAGS} -Wc,lp64"
359	CXXFLAGS="${CXXFLAGS} -Wc,lp64"
360	LDFLAGS="${LDFLAGS} -Wl,lp64"
361	AC_COMPILE_IFELSE([AC_LANG_SOURCE([int main(void) {return (sizeof(void)8==64)?0:1;}])],
362	CAN_BUILD_64=yes, CAN_BUILD_64=no)
363	;;
364	*)
365	# unknown platform.
366	;;
367	esac
368	fi
369	AC_MSG_RESULT($CAN_BUILD_64)
370	if test "$CAN_BUILD_64" = yes; then
371	AC_MSG_CHECKING([whether runnable 64-bit binaries are being built ])
372	AC_RUN_IFELSE([AC_LANG_SOURCE([int main(void) {return (sizeof(void)8==64)?0:1;}])],
373	BITS_RUN_64=yes, BITS_RUN_64=no, BITS_RUN_64=unknown)
374	AC_MSG_RESULT($BITS_RUN_64);
375
376	CFLAGS_64="${CFLAGS}"
377	CXXFLAGS_64="${CXXFLAGS}"
378	LDFLAGS_64="${LDFLAGS}"
379	ARFLAGS_64="${ARFLAGS}"
380	fi
381	# put it back.
382	CFLAGS="${CFLAGS_OLD}"
383	CXXFLAGS="${CXXFLAGS_OLD}"
384	LDFLAGS="${LDFLAGS_OLD}"
385	ARFLAGS="${ARFLAGS_OLD}"
386	fi
387	if test "$BITS_CHECK_32" = "yes"; then
388	# see comment under 'if BITS_CHECK_64', above.
389	AC_MSG_CHECKING([how to build 32-bit executables])
390	if test "$GCC" = yes; then
391	CFLAGS="${CFLAGS} -m32"
392	CXXFLAGS="${CXXFLAGS} -m32"
393	AC_COMPILE_IFELSE([AC_LANG_SOURCE([int main(void) {return (sizeof(void)8==32)?0:1;}])],
394	CAN_BUILD_32=yes, CAN_BUILD_32=no)
395	fi
396	AC_MSG_RESULT($CAN_BUILD_32)
397	if test "$CAN_BUILD_32" = yes; then
398	AC_MSG_CHECKING([whether runnable 32-bit binaries are being built ])
399	AC_RUN_IFELSE([AC_LANG_SOURCE([int main(void) {return (sizeof(void)8==32)?0:1;}])],
400	BITS_RUN_32=yes, BITS_RUN_32=no, BITS_RUN_32=unknown)
401	AC_MSG_RESULT($BITS_RUN_32);
402	CFLAGS_32="${CFLAGS}"
403	CXXFLAGS_32="${CXXFLAGS}"
404	LDFLAGS_32="${LDFLAGS}"
405	ARFLAGS_32="${ARFLAGS}"
406	fi
407	# put it back.
408	CFLAGS="${CFLAGS_OLD}"
409	CXXFLAGS="${CXXFLAGS_OLD}"
410	LDFLAGS="${LDFLAGS_OLD}"
411	ARFLAGS="${ARFLAGS_OLD}"
412	fi
413
414	##
415	# OK. Now, we've tested for 32 and 64 bitness. Let's see what we'll do.
416	#
417
418	# First, implement 64else32
419	if test "$BITS_REQ" = "64else32"; then
420	if test "$BITS_RUN_64" = "yes"; then
421	BITS_REQ=64
422	else
423	# no changes.
424	BITS_OK=yes
425	fi
426	fi
427
428	# implement.
429	if test "$BITS_REQ" = "32" -a "$BITS_RUN_32" = "yes"; then
430	CFLAGS="${CFLAGS_32}"
431	CXXFLAGS="${CXXFLAGS_32}"
432	LDFLAGS="${LDFLAGS_32}"
433	ARFLAGS="${ARFLAGS_32}"
434	BITS_OK=yes
435	elif test "$BITS_REQ" = "64" -a "$BITS_RUN_64" = "yes"; then
436	CFLAGS="${CFLAGS_64}"
437	CXXFLAGS="${CXXFLAGS_64}"
438	LDFLAGS="${LDFLAGS_64}"
439	ARFLAGS="${ARFLAGS_64}"
440	BITS_OK=yes
441	elif test "$BITS_OK" != "yes"; then
442	AC_MSG_ERROR([Requested $BITS_REQ bit binaries but could not compile and execute them. See readme.html for help with cross compilation., and set compiler options manually.])
443	fi
444	fi
445	])
446
447	# Strict compilation options.
448	AC_DEFUN([AC_CHECK_STRICT_COMPILE],
449	[
450	AC_MSG_CHECKING([whether strict compiling is on])
451	AC_ARG_ENABLE(strict,[ --enable-strict compile with strict compiler options [default=yes]], [
452	if test "$enableval" = no
453	then
454	ac_use_strict_options=no
455	else
456	ac_use_strict_options=yes
457	fi
458	], [ac_use_strict_options=yes])
459	AC_MSG_RESULT($ac_use_strict_options)
460
461	if test "$ac_use_strict_options" = yes
462	then
463	if test "$GCC" = yes
464	then
465	case "${host}" in
f3c0d7a5	466	--solaris*)
0f5d89e8	467	# Don't use -std=c11 on Solaris because of timezone check fails
f3c0d7a5	468	;;
57a6839d A	469	*)
57a6839d A	470	# Do not use -ansi. It limits us to C90, and it breaks some platforms.
0f5d89e8 A	471	# We use -std=c11 to disable the gnu99 defaults and its associated warnings
0f5d89e8 A	472	CFLAGS="$CFLAGS -std=c11"
57a6839d A	473	;;
	474	esac
	475
	476	CFLAGS="$CFLAGS -Wall -pedantic -Wshadow -Wpointer-arith -Wmissing-prototypes -Wwrite-strings"
	477	else
	478	case "${host}" in
	479	--cygwin)
	480	if test "`$CC /help 2>&1 \| head -c9`" = "Microsoft"
	481	then
	482	CFLAGS="$CFLAGS /W4"
b331163b A	483	fi ;;
	484	--mingw*)
	485	CFLAGS="$CFLAGS -W4" ;;
57a6839d A	486	esac
	487	fi
	488	if test "$GXX" = yes
	489	then
	490	CXXFLAGS="$CXXFLAGS -W -Wall -pedantic -Wpointer-arith -Wwrite-strings -Wno-long-long"
	491	else
	492	case "${host}" in
	493	--cygwin)
	494	if test "`$CXX /help 2>&1 \| head -c9`" = "Microsoft"
	495	then
	496	CXXFLAGS="$CXXFLAGS /W4"
b331163b A	497	fi ;;
	498	--mingw*)
	499	CFLAGS="$CFLAGS -W4" ;;
57a6839d A	500	esac
	501	fi
	502	fi
	503	])
	504
	505