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