intl/icu/source/acinclude.m4

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