m4/curl-compilers.m4

   1 #***************************************************************************
   2 #                                  _   _ ____  _
   3 #  Project                     ___| | | |  _ \| |
   4 #                             / __| | | | |_) | |
   5 #                            | (__| |_| |  _ <| |___
   6 #                             \___|\___/|_| \_\_____|
   7 #
   8 # Copyright (C) 1998 - 2013, Daniel Stenberg, <daniel@haxx.se>, et al.
   9 #
  10 # This software is licensed as described in the file COPYING, which
  11 # you should have received as part of this distribution. The terms
  12 # are also available at http://curl.haxx.se/docs/copyright.html.
  13 #
  14 # You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15 # copies of the Software, and permit persons to whom the Software is
  16 # furnished to do so, under the terms of the COPYING file.
  17 #
  18 # This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19 # KIND, either express or implied.
  20 #
  21 #***************************************************************************
  22
  23 # File version for 'aclocal' use. Keep it a single number.
  24 # serial 66
  25
  26
  27 dnl CURL_CHECK_COMPILER
  28 dnl -------------------------------------------------
  29 dnl Verify if the C compiler being used is known.
  30
  31 AC_DEFUN([CURL_CHECK_COMPILER], [
  32   #
  33   compiler_id="unknown"
  34   compiler_num="0"
  35   #
  36   flags_dbg_all="unknown"
  37   flags_dbg_yes="unknown"
  38   flags_dbg_off="unknown"
  39   flags_opt_all="unknown"
  40   flags_opt_yes="unknown"
  41   flags_opt_off="unknown"
  42   #
  43   flags_prefer_cppflags="no"
  44   #
  45   CURL_CHECK_COMPILER_DEC_C
  46   CURL_CHECK_COMPILER_HPUX_C
  47   CURL_CHECK_COMPILER_IBM_C
  48   CURL_CHECK_COMPILER_INTEL_C
  49   CURL_CHECK_COMPILER_CLANG
  50   CURL_CHECK_COMPILER_GNU_C
  51   CURL_CHECK_COMPILER_LCC
  52   CURL_CHECK_COMPILER_SGI_MIPSPRO_C
  53   CURL_CHECK_COMPILER_SGI_MIPS_C
  54   CURL_CHECK_COMPILER_SUNPRO_C
  55   CURL_CHECK_COMPILER_TINY_C
  56   CURL_CHECK_COMPILER_WATCOM_C
  57   #
  58   if test "$compiler_id" = "unknown"; then
  59   cat <<_EOF 1>&2
  60 ***
  61 *** Warning: This configure script does not have information about the
  62 *** compiler you are using, relative to the flags required to enable or
  63 *** disable generation of debug info, optimization options or warnings.
  64 ***
  65 *** Whatever settings are present in CFLAGS will be used for this run.
  66 ***
  67 *** If you wish to help the cURL project to better support your compiler
  68 *** you can report this and the required info on the libcurl development
  69 *** mailing list: http://cool.haxx.se/mailman/listinfo/curl-library/
  70 ***
  71 _EOF
  72   fi
  73 ])
  74
  75
  76 dnl CURL_CHECK_COMPILER_CLANG
  77 dnl -------------------------------------------------
  78 dnl Verify if compiler being used is clang.
  79
  80 AC_DEFUN([CURL_CHECK_COMPILER_CLANG], [
  81   AC_BEFORE([$0],[CURL_CHECK_COMPILER_GNU_C])dnl
  82   AC_MSG_CHECKING([if compiler is clang])
  83   CURL_CHECK_DEF([__clang__], [], [silent])
  84   if test "$curl_cv_have_def___clang__" = "yes"; then
  85     AC_MSG_RESULT([yes])
  86     compiler_id="CLANG"
  87     clangver=`$CC -dumpversion`
  88     clangvhi=`echo $clangver | cut -d . -f1`
  89     clangvlo=`echo $clangver | cut -d . -f2`
  90     compiler_num=`(expr $clangvhi "*" 100 + $clangvlo) 2>/dev/null`
  91     flags_dbg_all="-g -g0 -g1 -g2 -g3"
  92     flags_dbg_all="$flags_dbg_all -ggdb"
  93     flags_dbg_all="$flags_dbg_all -gstabs"
  94     flags_dbg_all="$flags_dbg_all -gstabs+"
  95     flags_dbg_all="$flags_dbg_all -gcoff"
  96     flags_dbg_all="$flags_dbg_all -gxcoff"
  97     flags_dbg_all="$flags_dbg_all -gdwarf-2"
  98     flags_dbg_all="$flags_dbg_all -gvms"
  99     flags_dbg_yes="-g"
 100     flags_dbg_off=""
 101     flags_opt_all="-O -O0 -O1 -O2 -Os -O3 -O4"
 102     flags_opt_yes="-Os"
 103     flags_opt_off="-O0"
 104   else
 105     AC_MSG_RESULT([no])
 106   fi
 107 ])
 108
 109
 110 dnl CURL_CHECK_COMPILER_DEC_C
 111 dnl -------------------------------------------------
 112 dnl Verify if compiler being used is DEC C.
 113
 114 AC_DEFUN([CURL_CHECK_COMPILER_DEC_C], [
 115   AC_MSG_CHECKING([if compiler is DEC/Compaq/HP C])
 116   CURL_CHECK_DEF([__DECC], [], [silent])
 117   CURL_CHECK_DEF([__DECC_VER], [], [silent])
 118   if test "$curl_cv_have_def___DECC" = "yes" &&
 119     test "$curl_cv_have_def___DECC_VER" = "yes"; then
 120     AC_MSG_RESULT([yes])
 121     compiler_id="DEC_C"
 122     flags_dbg_all="-g -g0 -g1 -g2 -g3"
 123     flags_dbg_yes="-g2"
 124     flags_dbg_off=""
 125     flags_opt_all="-O -O0 -O1 -O2 -O3 -O4"
 126     flags_opt_yes="-O1"
 127     flags_opt_off="-O0"
 128   else
 129     AC_MSG_RESULT([no])
 130   fi
 131 ])
 132
 133
 134 dnl CURL_CHECK_COMPILER_GNU_C
 135 dnl -------------------------------------------------
 136 dnl Verify if compiler being used is GNU C.
 137
 138 AC_DEFUN([CURL_CHECK_COMPILER_GNU_C], [
 139   AC_REQUIRE([CURL_CHECK_COMPILER_INTEL_C])dnl
 140   AC_REQUIRE([CURL_CHECK_COMPILER_CLANG])dnl
 141   AC_MSG_CHECKING([if compiler is GNU C])
 142   CURL_CHECK_DEF([__GNUC__], [], [silent])
 143   if test "$curl_cv_have_def___GNUC__" = "yes" &&
 144     test "$compiler_id" = "unknown"; then
 145     AC_MSG_RESULT([yes])
 146     compiler_id="GNU_C"
 147     gccver=`$CC -dumpversion`
 148     gccvhi=`echo $gccver | cut -d . -f1`
 149     gccvlo=`echo $gccver | cut -d . -f2`
 150     compiler_num=`(expr $gccvhi "*" 100 + $gccvlo) 2>/dev/null`
 151     flags_dbg_all="-g -g0 -g1 -g2 -g3"
 152     flags_dbg_all="$flags_dbg_all -ggdb"
 153     flags_dbg_all="$flags_dbg_all -gstabs"
 154     flags_dbg_all="$flags_dbg_all -gstabs+"
 155     flags_dbg_all="$flags_dbg_all -gcoff"
 156     flags_dbg_all="$flags_dbg_all -gxcoff"
 157     flags_dbg_all="$flags_dbg_all -gdwarf-2"
 158     flags_dbg_all="$flags_dbg_all -gvms"
 159     flags_dbg_yes="-g"
 160     flags_dbg_off=""
 161     flags_opt_all="-O -O0 -O1 -O2 -O3 -Os"
 162     flags_opt_yes="-O2"
 163     flags_opt_off="-O0"
 164     CURL_CHECK_DEF([_WIN32], [], [silent])
 165   else
 166     AC_MSG_RESULT([no])
 167   fi
 168 ])
 169
 170
 171 dnl CURL_CHECK_COMPILER_HPUX_C
 172 dnl -------------------------------------------------
 173 dnl Verify if compiler being used is HP-UX C.
 174
 175 AC_DEFUN([CURL_CHECK_COMPILER_HPUX_C], [
 176   AC_MSG_CHECKING([if compiler is HP-UX C])
 177   CURL_CHECK_DEF([__HP_cc], [], [silent])
 178   if test "$curl_cv_have_def___HP_cc" = "yes"; then
 179     AC_MSG_RESULT([yes])
 180     compiler_id="HP_UX_C"
 181     flags_dbg_all="-g -s"
 182     flags_dbg_yes="-g"
 183     flags_dbg_off="-s"
 184     flags_opt_all="-O +O0 +O1 +O2 +O3 +O4"
 185     flags_opt_yes="+O2"
 186     flags_opt_off="+O0"
 187   else
 188     AC_MSG_RESULT([no])
 189   fi
 190 ])
 191
 192
 193 dnl CURL_CHECK_COMPILER_IBM_C
 194 dnl -------------------------------------------------
 195 dnl Verify if compiler being used is IBM C.
 196
 197 AC_DEFUN([CURL_CHECK_COMPILER_IBM_C], [
 198   AC_MSG_CHECKING([if compiler is IBM C])
 199   CURL_CHECK_DEF([__IBMC__], [], [silent])
 200   if test "$curl_cv_have_def___IBMC__" = "yes"; then
 201     AC_MSG_RESULT([yes])
 202     compiler_id="IBM_C"
 203     flags_dbg_all="-g -g0 -g1 -g2 -g3"
 204     flags_dbg_yes="-g"
 205     flags_dbg_off=""
 206     flags_opt_all="-O -O0 -O1 -O2 -O3 -O4 -O5"
 207     flags_opt_all="$flags_opt_all -qnooptimize"
 208     flags_opt_all="$flags_opt_all -qoptimize=0"
 209     flags_opt_all="$flags_opt_all -qoptimize=1"
 210     flags_opt_all="$flags_opt_all -qoptimize=2"
 211     flags_opt_all="$flags_opt_all -qoptimize=3"
 212     flags_opt_all="$flags_opt_all -qoptimize=4"
 213     flags_opt_all="$flags_opt_all -qoptimize=5"
 214     flags_opt_yes="-O2"
 215     flags_opt_off="-qnooptimize"
 216     flags_prefer_cppflags="yes"
 217   else
 218     AC_MSG_RESULT([no])
 219   fi
 220 ])
 221
 222
 223 dnl CURL_CHECK_COMPILER_INTEL_C
 224 dnl -------------------------------------------------
 225 dnl Verify if compiler being used is Intel C.
 226
 227 AC_DEFUN([CURL_CHECK_COMPILER_INTEL_C], [
 228   AC_BEFORE([$0],[CURL_CHECK_COMPILER_GNU_C])dnl
 229   AC_MSG_CHECKING([if compiler is Intel C])
 230   CURL_CHECK_DEF([__INTEL_COMPILER], [], [silent])
 231   if test "$curl_cv_have_def___INTEL_COMPILER" = "yes"; then
 232     AC_MSG_RESULT([yes])
 233     compiler_num="$curl_cv_def___INTEL_COMPILER"
 234     CURL_CHECK_DEF([__unix__], [], [silent])
 235     if test "$curl_cv_have_def___unix__" = "yes"; then
 236       compiler_id="INTEL_UNIX_C"
 237       flags_dbg_all="-g -g0"
 238       flags_dbg_yes="-g"
 239       flags_dbg_off=""
 240       flags_opt_all="-O -O0 -O1 -O2 -O3 -Os"
 241       flags_opt_yes="-O2"
 242       flags_opt_off="-O0"
 243     else
 244       compiler_id="INTEL_WINDOWS_C"
 245       flags_dbg_all="/ZI /Zi /zI /zi /ZD /Zd /zD /zd /Z7 /z7 /Oy /Oy-"
 246       flags_dbg_all="$flags_dbg_all /debug"
 247       flags_dbg_all="$flags_dbg_all /debug:none"
 248       flags_dbg_all="$flags_dbg_all /debug:minimal"
 249       flags_dbg_all="$flags_dbg_all /debug:partial"
 250       flags_dbg_all="$flags_dbg_all /debug:full"
 251       flags_dbg_all="$flags_dbg_all /debug:semantic_stepping"
 252       flags_dbg_all="$flags_dbg_all /debug:extended"
 253       flags_dbg_yes="/Zi /Oy-"
 254       flags_dbg_off="/debug:none /Oy-"
 255       flags_opt_all="/O /O0 /O1 /O2 /O3 /Od /Og /Og- /Oi /Oi-"
 256       flags_opt_yes="/O2"
 257       flags_opt_off="/Od"
 258     fi
 259   else
 260     AC_MSG_RESULT([no])
 261   fi
 262 ])
 263
 264
 265 dnl CURL_CHECK_COMPILER_LCC
 266 dnl -------------------------------------------------
 267 dnl Verify if compiler being used is LCC.
 268
 269 AC_DEFUN([CURL_CHECK_COMPILER_LCC], [
 270   AC_MSG_CHECKING([if compiler is LCC])
 271   CURL_CHECK_DEF([__LCC__], [], [silent])
 272   if test "$curl_cv_have_def___LCC__" = "yes"; then
 273     AC_MSG_RESULT([yes])
 274     compiler_id="LCC"
 275     flags_dbg_all="-g"
 276     flags_dbg_yes="-g"
 277     flags_dbg_off=""
 278     flags_opt_all=""
 279     flags_opt_yes=""
 280     flags_opt_off=""
 281   else
 282     AC_MSG_RESULT([no])
 283   fi
 284 ])
 285
 286
 287 dnl CURL_CHECK_COMPILER_SGI_MIPS_C
 288 dnl -------------------------------------------------
 289 dnl Verify if compiler being used is SGI MIPS C.
 290
 291 AC_DEFUN([CURL_CHECK_COMPILER_SGI_MIPS_C], [
 292   AC_REQUIRE([CURL_CHECK_COMPILER_SGI_MIPSPRO_C])dnl
 293   AC_MSG_CHECKING([if compiler is SGI MIPS C])
 294   CURL_CHECK_DEF([__GNUC__], [], [silent])
 295   CURL_CHECK_DEF([__sgi], [], [silent])
 296   if test "$curl_cv_have_def___GNUC__" = "no" &&
 297     test "$curl_cv_have_def___sgi" = "yes" &&
 298     test "$compiler_id" = "unknown"; then
 299     AC_MSG_RESULT([yes])
 300     compiler_id="SGI_MIPS_C"
 301     flags_dbg_all="-g -g0 -g1 -g2 -g3"
 302     flags_dbg_yes="-g"
 303     flags_dbg_off=""
 304     flags_opt_all="-O -O0 -O1 -O2 -O3 -Ofast"
 305     flags_opt_yes="-O2"
 306     flags_opt_off="-O0"
 307   else
 308     AC_MSG_RESULT([no])
 309   fi
 310 ])
 311
 312
 313 dnl CURL_CHECK_COMPILER_SGI_MIPSPRO_C
 314 dnl -------------------------------------------------
 315 dnl Verify if compiler being used is SGI MIPSpro C.
 316
 317 AC_DEFUN([CURL_CHECK_COMPILER_SGI_MIPSPRO_C], [
 318   AC_BEFORE([$0],[CURL_CHECK_COMPILER_SGI_MIPS_C])dnl
 319   AC_MSG_CHECKING([if compiler is SGI MIPSpro C])
 320   CURL_CHECK_DEF([__GNUC__], [], [silent])
 321   CURL_CHECK_DEF([_COMPILER_VERSION], [], [silent])
 322   CURL_CHECK_DEF([_SGI_COMPILER_VERSION], [], [silent])
 323   if test "$curl_cv_have_def___GNUC__" = "no" &&
 324     (test "$curl_cv_have_def__SGI_COMPILER_VERSION" = "yes" ||
 325      test "$curl_cv_have_def__COMPILER_VERSION" = "yes"); then
 326     AC_MSG_RESULT([yes])
 327     compiler_id="SGI_MIPSPRO_C"
 328     flags_dbg_all="-g -g0 -g1 -g2 -g3"
 329     flags_dbg_yes="-g"
 330     flags_dbg_off=""
 331     flags_opt_all="-O -O0 -O1 -O2 -O3 -Ofast"
 332     flags_opt_yes="-O2"
 333     flags_opt_off="-O0"
 334   else
 335     AC_MSG_RESULT([no])
 336   fi
 337 ])
 338
 339
 340 dnl CURL_CHECK_COMPILER_SUNPRO_C
 341 dnl -------------------------------------------------
 342 dnl Verify if compiler being used is SunPro C.
 343
 344 AC_DEFUN([CURL_CHECK_COMPILER_SUNPRO_C], [
 345   AC_MSG_CHECKING([if compiler is SunPro C])
 346   CURL_CHECK_DEF([__SUNPRO_C], [], [silent])
 347   if test "$curl_cv_have_def___SUNPRO_C" = "yes"; then
 348     AC_MSG_RESULT([yes])
 349     compiler_id="SUNPRO_C"
 350     flags_dbg_all="-g -s"
 351     flags_dbg_yes="-g"
 352     flags_dbg_off="-s"
 353     flags_opt_all="-O -xO -xO1 -xO2 -xO3 -xO4 -xO5"
 354     flags_opt_yes="-xO2"
 355     flags_opt_off=""
 356   else
 357     AC_MSG_RESULT([no])
 358   fi
 359 ])
 360
 361
 362 dnl CURL_CHECK_COMPILER_TINY_C
 363 dnl -------------------------------------------------
 364 dnl Verify if compiler being used is Tiny C.
 365
 366 AC_DEFUN([CURL_CHECK_COMPILER_TINY_C], [
 367   AC_MSG_CHECKING([if compiler is Tiny C])
 368   CURL_CHECK_DEF([__TINYC__], [], [silent])
 369   if test "$curl_cv_have_def___TINYC__" = "yes"; then
 370     AC_MSG_RESULT([yes])
 371     compiler_id="TINY_C"
 372     flags_dbg_all="-g -b"
 373     flags_dbg_yes="-g"
 374     flags_dbg_off=""
 375     flags_opt_all=""
 376     flags_opt_yes=""
 377     flags_opt_off=""
 378   else
 379     AC_MSG_RESULT([no])
 380   fi
 381 ])
 382
 383
 384 dnl CURL_CHECK_COMPILER_WATCOM_C
 385 dnl -------------------------------------------------
 386 dnl Verify if compiler being used is Watcom C.
 387
 388 AC_DEFUN([CURL_CHECK_COMPILER_WATCOM_C], [
 389   AC_MSG_CHECKING([if compiler is Watcom C])
 390   CURL_CHECK_DEF([__WATCOMC__], [], [silent])
 391   if test "$curl_cv_have_def___WATCOMC__" = "yes"; then
 392     AC_MSG_RESULT([yes])
 393     CURL_CHECK_DEF([__UNIX__], [], [silent])
 394     if test "$curl_cv_have_def___UNIX__" = "yes"; then
 395       compiler_id="WATCOM_UNIX_C"
 396       flags_dbg_all="-g1 -g1+ -g2 -g3"
 397       flags_dbg_yes="-g2"
 398       flags_dbg_off=""
 399       flags_opt_all="-O0 -O1 -O2 -O3"
 400       flags_opt_yes="-O2"
 401       flags_opt_off="-O0"
 402     else
 403       compiler_id="WATCOM_WINDOWS_C"
 404       flags_dbg_all=""
 405       flags_dbg_yes=""
 406       flags_dbg_off=""
 407       flags_opt_all=""
 408       flags_opt_yes=""
 409       flags_opt_off=""
 410     fi
 411   else
 412     AC_MSG_RESULT([no])
 413   fi
 414 ])
 415
 416
 417 dnl CURL_CONVERT_INCLUDE_TO_ISYSTEM
 418 dnl -------------------------------------------------
 419 dnl Changes standard include paths present in CFLAGS
 420 dnl and CPPFLAGS into isystem include paths. This is
 421 dnl done to prevent GNUC from generating warnings on
 422 dnl headers from these locations, although on ancient
 423 dnl GNUC versions these warnings are not silenced.
 424
 425 AC_DEFUN([CURL_CONVERT_INCLUDE_TO_ISYSTEM], [
 426   AC_REQUIRE([CURL_SHFUNC_SQUEEZE])dnl
 427   AC_REQUIRE([CURL_CHECK_COMPILER])dnl
 428   if test "$compiler_id" = "GNU_C" ||
 429     test "$compiler_id" = "CLANG"; then
 430     tmp_has_include="no"
 431     tmp_chg_FLAGS="$CFLAGS"
 432     for word1 in $tmp_chg_FLAGS; do
 433       case "$word1" in
 434         -I*)
 435           tmp_has_include="yes"
 436           ;;
 437       esac
 438     done
 439     if test "$tmp_has_include" = "yes"; then
 440       tmp_chg_FLAGS=`echo "$tmp_chg_FLAGS" | "$SED" 's/^-I/ -isystem /g'`
 441       tmp_chg_FLAGS=`echo "$tmp_chg_FLAGS" | "$SED" 's/ -I/ -isystem /g'`
 442       CFLAGS="$tmp_chg_FLAGS"
 443       squeeze CFLAGS
 444     fi
 445     tmp_has_include="no"
 446     tmp_chg_FLAGS="$CPPFLAGS"
 447     for word1 in $tmp_chg_FLAGS; do
 448       case "$word1" in
 449         -I*)
 450           tmp_has_include="yes"
 451           ;;
 452       esac
 453     done
 454     if test "$tmp_has_include" = "yes"; then
 455       tmp_chg_FLAGS=`echo "$tmp_chg_FLAGS" | "$SED" 's/^-I/ -isystem /g'`
 456       tmp_chg_FLAGS=`echo "$tmp_chg_FLAGS" | "$SED" 's/ -I/ -isystem /g'`
 457       CPPFLAGS="$tmp_chg_FLAGS"
 458       squeeze CPPFLAGS
 459     fi
 460   fi
 461 ])
 462
 463
 464 dnl CURL_COMPILER_WORKS_IFELSE ([ACTION-IF-WORKS], [ACTION-IF-NOT-WORKS])
 465 dnl -------------------------------------------------
 466 dnl Verify if the C compiler seems to work with the
 467 dnl settings that are 'active' at the time the test
 468 dnl is performed.
 469
 470 AC_DEFUN([CURL_COMPILER_WORKS_IFELSE], [
 471   dnl compilation capability verification
 472   tmp_compiler_works="unknown"
 473   AC_COMPILE_IFELSE([
 474     AC_LANG_PROGRAM([[
 475     ]],[[
 476       int i = 1;
 477       return i;
 478     ]])
 479   ],[
 480     tmp_compiler_works="yes"
 481   ],[
 482     tmp_compiler_works="no"
 483     echo " " >&6
 484     sed 's/^/cc-fail: /' conftest.err >&6
 485     echo " " >&6
 486   ])
 487   dnl linking capability verification
 488   if test "$tmp_compiler_works" = "yes"; then
 489     AC_LINK_IFELSE([
 490       AC_LANG_PROGRAM([[
 491       ]],[[
 492         int i = 1;
 493         return i;
 494       ]])
 495     ],[
 496       tmp_compiler_works="yes"
 497     ],[
 498       tmp_compiler_works="no"
 499       echo " " >&6
 500       sed 's/^/link-fail: /' conftest.err >&6
 501       echo " " >&6
 502     ])
 503   fi
 504   dnl only do runtime verification when not cross-compiling
 505   if test "x$cross_compiling" != "xyes" &&
 506     test "$tmp_compiler_works" = "yes"; then
 507     AC_RUN_IFELSE([
 508       AC_LANG_PROGRAM([[
 509 #       ifdef __STDC__
 510 #         include <stdlib.h>
 511 #       endif
 512       ]],[[
 513         int i = 0;
 514         exit(i);
 515       ]])
 516     ],[
 517       tmp_compiler_works="yes"
 518     ],[
 519       tmp_compiler_works="no"
 520       echo " " >&6
 521       echo "run-fail: test program exited with status $ac_status" >&6
 522       echo " " >&6
 523     ])
 524   fi
 525   dnl branch upon test result
 526   if test "$tmp_compiler_works" = "yes"; then
 527   ifelse($1,,:,[$1])
 528   ifelse($2,,,[else
 529     $2])
 530   fi
 531 ])
 532
 533
 534 dnl CURL_SET_COMPILER_BASIC_OPTS
 535 dnl -------------------------------------------------
 536 dnl Sets compiler specific options/flags which do not
 537 dnl depend on configure's debug, optimize or warnings
 538 dnl options.
 539
 540 AC_DEFUN([CURL_SET_COMPILER_BASIC_OPTS], [
 541   AC_REQUIRE([CURL_CHECK_COMPILER])dnl
 542   AC_REQUIRE([CURL_SHFUNC_SQUEEZE])dnl
 543   #
 544   if test "$compiler_id" != "unknown"; then
 545     #
 546     if test "$compiler_id" = "GNU_C" ||
 547       test "$compiler_id" = "CLANG"; then
 548       CURL_CONVERT_INCLUDE_TO_ISYSTEM
 549     fi
 550     #
 551     tmp_save_CPPFLAGS="$CPPFLAGS"
 552     tmp_save_CFLAGS="$CFLAGS"
 553     tmp_CPPFLAGS=""
 554     tmp_CFLAGS=""
 555     #
 556     case "$compiler_id" in
 557         #
 558       CLANG)
 559         #
 560         dnl Disable warnings for unused arguments, otherwise clang will
 561         dnl warn about compile-time arguments used during link-time, like
 562         dnl -O and -g and -pedantic.
 563         tmp_CFLAGS="$tmp_CFLAGS -Qunused-arguments"
 564         ;;
 565         #
 566       DEC_C)
 567         #
 568         dnl Select strict ANSI C compiler mode
 569         tmp_CFLAGS="$tmp_CFLAGS -std1"
 570         dnl Turn off optimizer ANSI C aliasing rules
 571         tmp_CFLAGS="$tmp_CFLAGS -noansi_alias"
 572         dnl Generate warnings for missing function prototypes
 573         tmp_CFLAGS="$tmp_CFLAGS -warnprotos"
 574         dnl Change some warnings into fatal errors
 575         tmp_CFLAGS="$tmp_CFLAGS -msg_fatal toofewargs,toomanyargs"
 576         ;;
 577         #
 578       GNU_C)
 579         #
 580         dnl Placeholder
 581         tmp_CFLAGS="$tmp_CFLAGS"
 582         ;;
 583         #
 584       HP_UX_C)
 585         #
 586         dnl Disallow run-time dereferencing of null pointers
 587         tmp_CFLAGS="$tmp_CFLAGS -z"
 588         dnl Disable some remarks
 589         dnl #4227: padding struct with n bytes to align member
 590         dnl #4255: padding size of struct with n bytes to alignment boundary
 591         tmp_CFLAGS="$tmp_CFLAGS +W 4227,4255"
 592         ;;
 593         #
 594       IBM_C)
 595         #
 596         dnl Ensure that compiler optimizations are always thread-safe.
 597         tmp_CPPFLAGS="$tmp_CPPFLAGS -qthreaded"
 598         dnl Disable type based strict aliasing optimizations, using worst
 599         dnl case aliasing assumptions when compiling. Type based aliasing
 600         dnl would restrict the lvalues that could be safely used to access
 601         dnl a data object.
 602         tmp_CPPFLAGS="$tmp_CPPFLAGS -qnoansialias"
 603         dnl Force compiler to stop after the compilation phase, without
 604         dnl generating an object code file when compilation has errors.
 605         tmp_CPPFLAGS="$tmp_CPPFLAGS -qhalt=e"
 606         ;;
 607         #
 608       INTEL_UNIX_C)
 609         #
 610         dnl On unix this compiler uses gcc's header files, so
 611         dnl we select ANSI C89 dialect plus GNU extensions.
 612         tmp_CFLAGS="$tmp_CFLAGS -std=gnu89"
 613         dnl Change some warnings into errors
 614         dnl #140: too many arguments in function call
 615         dnl #147: declaration is incompatible with 'previous one'
 616         dnl #165: too few arguments in function call
 617         dnl #266: function declared implicitly
 618         tmp_CPPFLAGS="$tmp_CPPFLAGS -we140,147,165,266"
 619         dnl Disable some remarks
 620         dnl #279: controlling expression is constant
 621         dnl #981: operands are evaluated in unspecified order
 622         dnl #1469: "cc" clobber ignored
 623         tmp_CPPFLAGS="$tmp_CPPFLAGS -wd279,981,1469"
 624         ;;
 625         #
 626       INTEL_WINDOWS_C)
 627         #
 628         dnl Placeholder
 629         tmp_CFLAGS="$tmp_CFLAGS"
 630         ;;
 631         #
 632       LCC)
 633         #
 634         dnl Disallow run-time dereferencing of null pointers
 635         tmp_CFLAGS="$tmp_CFLAGS -n"
 636         ;;
 637         #
 638       SGI_MIPS_C)
 639         #
 640         dnl Placeholder
 641         tmp_CFLAGS="$tmp_CFLAGS"
 642         ;;
 643         #
 644       SGI_MIPSPRO_C)
 645         #
 646         dnl Placeholder
 647         tmp_CFLAGS="$tmp_CFLAGS"
 648         ;;
 649         #
 650       SUNPRO_C)
 651         #
 652         dnl Placeholder
 653         tmp_CFLAGS="$tmp_CFLAGS"
 654         ;;
 655         #
 656       TINY_C)
 657         #
 658         dnl Placeholder
 659         tmp_CFLAGS="$tmp_CFLAGS"
 660         ;;
 661         #
 662       WATCOM_UNIX_C)
 663         #
 664         dnl Placeholder
 665         tmp_CFLAGS="$tmp_CFLAGS"
 666         ;;
 667         #
 668       WATCOM_WINDOWS_C)
 669         #
 670         dnl Placeholder
 671         tmp_CFLAGS="$tmp_CFLAGS"
 672         ;;
 673         #
 674     esac
 675     #
 676     squeeze tmp_CPPFLAGS
 677     squeeze tmp_CFLAGS
 678     #
 679     if test ! -z "$tmp_CFLAGS" || test ! -z "$tmp_CPPFLAGS"; then
 680       AC_MSG_CHECKING([if compiler accepts some basic options])
 681       CPPFLAGS="$tmp_save_CPPFLAGS $tmp_CPPFLAGS"
 682       CFLAGS="$tmp_save_CFLAGS $tmp_CFLAGS"
 683       squeeze CPPFLAGS
 684       squeeze CFLAGS
 685       CURL_COMPILER_WORKS_IFELSE([
 686         AC_MSG_RESULT([yes])
 687         AC_MSG_NOTICE([compiler options added: $tmp_CFLAGS $tmp_CPPFLAGS])
 688       ],[
 689         AC_MSG_RESULT([no])
 690         AC_MSG_WARN([compiler options rejected: $tmp_CFLAGS $tmp_CPPFLAGS])
 691         dnl restore initial settings
 692         CPPFLAGS="$tmp_save_CPPFLAGS"
 693         CFLAGS="$tmp_save_CFLAGS"
 694       ])
 695     fi
 696     #
 697   fi
 698 ])
 699
 700
 701 dnl CURL_SET_COMPILER_DEBUG_OPTS
 702 dnl -------------------------------------------------
 703 dnl Sets compiler specific options/flags which depend
 704 dnl on configure's debug option.
 705
 706 AC_DEFUN([CURL_SET_COMPILER_DEBUG_OPTS], [
 707   AC_REQUIRE([CURL_CHECK_OPTION_DEBUG])dnl
 708   AC_REQUIRE([CURL_CHECK_COMPILER])dnl
 709   AC_REQUIRE([CURL_SHFUNC_SQUEEZE])dnl
 710   #
 711   if test "$compiler_id" != "unknown"; then
 712     #
 713     tmp_save_CFLAGS="$CFLAGS"
 714     tmp_save_CPPFLAGS="$CPPFLAGS"
 715     #
 716     tmp_options=""
 717     tmp_CFLAGS="$CFLAGS"
 718     tmp_CPPFLAGS="$CPPFLAGS"
 719     CURL_VAR_STRIP([tmp_CFLAGS],[$flags_dbg_all])
 720     CURL_VAR_STRIP([tmp_CPPFLAGS],[$flags_dbg_all])
 721     #
 722     if test "$want_debug" = "yes"; then
 723       AC_MSG_CHECKING([if compiler accepts debug enabling options])
 724       tmp_options="$flags_dbg_yes"
 725     fi
 726     if test "$want_debug" = "no"; then
 727       AC_MSG_CHECKING([if compiler accepts debug disabling options])
 728       tmp_options="$flags_dbg_off"
 729     fi
 730     #
 731     if test "$flags_prefer_cppflags" = "yes"; then
 732       CPPFLAGS="$tmp_CPPFLAGS $tmp_options"
 733       CFLAGS="$tmp_CFLAGS"
 734     else
 735       CPPFLAGS="$tmp_CPPFLAGS"
 736       CFLAGS="$tmp_CFLAGS $tmp_options"
 737     fi
 738     squeeze CPPFLAGS
 739     squeeze CFLAGS
 740     CURL_COMPILER_WORKS_IFELSE([
 741       AC_MSG_RESULT([yes])
 742       AC_MSG_NOTICE([compiler options added: $tmp_options])
 743     ],[
 744       AC_MSG_RESULT([no])
 745       AC_MSG_WARN([compiler options rejected: $tmp_options])
 746       dnl restore initial settings
 747       CPPFLAGS="$tmp_save_CPPFLAGS"
 748       CFLAGS="$tmp_save_CFLAGS"
 749     ])
 750     #
 751   fi
 752 ])
 753
 754
 755 dnl CURL_SET_COMPILER_OPTIMIZE_OPTS
 756 dnl -------------------------------------------------
 757 dnl Sets compiler specific options/flags which depend
 758 dnl on configure's optimize option.
 759
 760 AC_DEFUN([CURL_SET_COMPILER_OPTIMIZE_OPTS], [
 761   AC_REQUIRE([CURL_CHECK_OPTION_OPTIMIZE])dnl
 762   AC_REQUIRE([CURL_CHECK_COMPILER])dnl
 763   AC_REQUIRE([CURL_SHFUNC_SQUEEZE])dnl
 764   #
 765   if test "$compiler_id" != "unknown"; then
 766     #
 767     tmp_save_CFLAGS="$CFLAGS"
 768     tmp_save_CPPFLAGS="$CPPFLAGS"
 769     #
 770     tmp_options=""
 771     tmp_CFLAGS="$CFLAGS"
 772     tmp_CPPFLAGS="$CPPFLAGS"
 773     honor_optimize_option="yes"
 774     #
 775     dnl If optimization request setting has not been explicitly specified,
 776     dnl it has been derived from the debug setting and initially assumed.
 777     dnl This initially assumed optimizer setting will finally be ignored
 778     dnl if CFLAGS or CPPFLAGS already hold optimizer flags. This implies
 779     dnl that an initially assumed optimizer setting might not be honored.
 780     #
 781     if test "$want_optimize" = "assume_no" ||
 782        test "$want_optimize" = "assume_yes"; then
 783       AC_MSG_CHECKING([if compiler optimizer assumed setting might be used])
 784       CURL_VAR_MATCH_IFELSE([tmp_CFLAGS],[$flags_opt_all],[
 785         honor_optimize_option="no"
 786       ])
 787       CURL_VAR_MATCH_IFELSE([tmp_CPPFLAGS],[$flags_opt_all],[
 788         honor_optimize_option="no"
 789       ])
 790       AC_MSG_RESULT([$honor_optimize_option])
 791       if test "$honor_optimize_option" = "yes"; then
 792         if test "$want_optimize" = "assume_yes"; then
 793           want_optimize="yes"
 794         fi
 795         if test "$want_optimize" = "assume_no"; then
 796           want_optimize="no"
 797         fi
 798       fi
 799     fi
 800     #
 801     if test "$honor_optimize_option" = "yes"; then
 802       CURL_VAR_STRIP([tmp_CFLAGS],[$flags_opt_all])
 803       CURL_VAR_STRIP([tmp_CPPFLAGS],[$flags_opt_all])
 804       if test "$want_optimize" = "yes"; then
 805         AC_MSG_CHECKING([if compiler accepts optimizer enabling options])
 806         tmp_options="$flags_opt_yes"
 807       fi
 808       if test "$want_optimize" = "no"; then
 809         AC_MSG_CHECKING([if compiler accepts optimizer disabling options])
 810         tmp_options="$flags_opt_off"
 811       fi
 812       if test "$flags_prefer_cppflags" = "yes"; then
 813         CPPFLAGS="$tmp_CPPFLAGS $tmp_options"
 814         CFLAGS="$tmp_CFLAGS"
 815       else
 816         CPPFLAGS="$tmp_CPPFLAGS"
 817         CFLAGS="$tmp_CFLAGS $tmp_options"
 818       fi
 819       squeeze CPPFLAGS
 820       squeeze CFLAGS
 821       CURL_COMPILER_WORKS_IFELSE([
 822         AC_MSG_RESULT([yes])
 823         AC_MSG_NOTICE([compiler options added: $tmp_options])
 824       ],[
 825         AC_MSG_RESULT([no])
 826         AC_MSG_WARN([compiler options rejected: $tmp_options])
 827         dnl restore initial settings
 828         CPPFLAGS="$tmp_save_CPPFLAGS"
 829         CFLAGS="$tmp_save_CFLAGS"
 830       ])
 831     fi
 832     #
 833   fi
 834 ])
 835
 836
 837 dnl CURL_SET_COMPILER_WARNING_OPTS
 838 dnl -------------------------------------------------
 839 dnl Sets compiler options/flags which depend on
 840 dnl configure's warnings given option.
 841
 842 AC_DEFUN([CURL_SET_COMPILER_WARNING_OPTS], [
 843   AC_REQUIRE([CURL_CHECK_OPTION_WARNINGS])dnl
 844   AC_REQUIRE([CURL_CHECK_COMPILER])dnl
 845   AC_REQUIRE([CURL_SHFUNC_SQUEEZE])dnl
 846   #
 847   if test "$compiler_id" != "unknown"; then
 848     #
 849     tmp_save_CPPFLAGS="$CPPFLAGS"
 850     tmp_save_CFLAGS="$CFLAGS"
 851     tmp_CPPFLAGS=""
 852     tmp_CFLAGS=""
 853     #
 854     case "$compiler_id" in
 855         #
 856       CLANG)
 857         #
 858         if test "$want_warnings" = "yes"; then
 859           tmp_CFLAGS="$tmp_CFLAGS -pedantic"
 860           tmp_CFLAGS="$tmp_CFLAGS -Wall -Wextra"
 861           tmp_CFLAGS="$tmp_CFLAGS -Wpointer-arith -Wwrite-strings"
 862           tmp_CFLAGS="$tmp_CFLAGS -Wshadow"
 863           tmp_CFLAGS="$tmp_CFLAGS -Winline -Wnested-externs"
 864           tmp_CFLAGS="$tmp_CFLAGS -Wmissing-declarations"
 865           tmp_CFLAGS="$tmp_CFLAGS -Wmissing-prototypes"
 866           tmp_CFLAGS="$tmp_CFLAGS -Wno-long-long"
 867           tmp_CFLAGS="$tmp_CFLAGS -Wfloat-equal"
 868           tmp_CFLAGS="$tmp_CFLAGS -Wno-multichar -Wsign-compare"
 869           tmp_CFLAGS="$tmp_CFLAGS -Wundef"
 870           tmp_CFLAGS="$tmp_CFLAGS -Wno-format-nonliteral"
 871           tmp_CFLAGS="$tmp_CFLAGS -Wendif-labels -Wstrict-prototypes"
 872           tmp_CFLAGS="$tmp_CFLAGS -Wdeclaration-after-statement"
 873           tmp_CFLAGS="$tmp_CFLAGS -Wcast-align"
 874           tmp_CFLAGS="$tmp_CFLAGS -Wno-system-headers"
 875           tmp_CFLAGS="$tmp_CFLAGS -Wshorten-64-to-32"
 876           #
 877           dnl Only clang 1.1 or later
 878           if test "$compiler_num" -ge "101"; then
 879             tmp_CFLAGS="$tmp_CFLAGS -Wunused"
 880           fi
 881         fi
 882         ;;
 883         #
 884       DEC_C)
 885         #
 886         if test "$want_warnings" = "yes"; then
 887           dnl Select a higher warning level than default level2
 888           tmp_CFLAGS="$tmp_CFLAGS -msg_enable level3"
 889         fi
 890         ;;
 891         #
 892       GNU_C)
 893         #
 894         if test "$want_warnings" = "yes"; then
 895           #
 896           dnl Do not enable -pedantic when cross-compiling with a gcc older
 897           dnl than 3.0, to avoid warnings from third party system headers.
 898           if test "x$cross_compiling" != "xyes" ||
 899             test "$compiler_num" -ge "300"; then
 900             tmp_CFLAGS="$tmp_CFLAGS -pedantic"
 901           fi
 902           #
 903           dnl Set of options we believe *ALL* gcc versions support:
 904           tmp_CFLAGS="$tmp_CFLAGS -Wall -W"
 905           #
 906           dnl Only gcc 1.4 or later
 907           if test "$compiler_num" -ge "104"; then
 908             tmp_CFLAGS="$tmp_CFLAGS -Wpointer-arith -Wwrite-strings"
 909             dnl If not cross-compiling with a gcc older than 3.0
 910             if test "x$cross_compiling" != "xyes" ||
 911               test "$compiler_num" -ge "300"; then
 912               tmp_CFLAGS="$tmp_CFLAGS -Wunused -Wshadow"
 913             fi
 914           fi
 915           #
 916           dnl Only gcc 2.7 or later
 917           if test "$compiler_num" -ge "207"; then
 918             tmp_CFLAGS="$tmp_CFLAGS -Winline -Wnested-externs"
 919             dnl If not cross-compiling with a gcc older than 3.0
 920             if test "x$cross_compiling" != "xyes" ||
 921               test "$compiler_num" -ge "300"; then
 922               tmp_CFLAGS="$tmp_CFLAGS -Wmissing-declarations"
 923               tmp_CFLAGS="$tmp_CFLAGS -Wmissing-prototypes"
 924             fi
 925           fi
 926           #
 927           dnl Only gcc 2.95 or later
 928           if test "$compiler_num" -ge "295"; then
 929             tmp_CFLAGS="$tmp_CFLAGS -Wno-long-long"
 930           fi
 931           #
 932           dnl Only gcc 2.96 or later
 933           if test "$compiler_num" -ge "296"; then
 934             tmp_CFLAGS="$tmp_CFLAGS -Wfloat-equal"
 935             tmp_CFLAGS="$tmp_CFLAGS -Wno-multichar -Wsign-compare"
 936             dnl -Wundef used only if gcc is 2.96 or later since we get
 937             dnl lots of "`_POSIX_C_SOURCE' is not defined" in system
 938             dnl headers with gcc 2.95.4 on FreeBSD 4.9
 939             tmp_CFLAGS="$tmp_CFLAGS -Wundef"
 940           fi
 941           #
 942           dnl Only gcc 2.97 or later
 943           if test "$compiler_num" -ge "297"; then
 944             tmp_CFLAGS="$tmp_CFLAGS -Wno-format-nonliteral"
 945           fi
 946           #
 947           dnl Only gcc 3.0 or later
 948           if test "$compiler_num" -ge "300"; then
 949             dnl -Wunreachable-code seems totally unreliable on my gcc 3.3.2 on
 950             dnl on i686-Linux as it gives us heaps with false positives.
 951             dnl Also, on gcc 4.0.X it is totally unbearable and complains all
 952             dnl over making it unusable for generic purposes. Let's not use it.
 953             tmp_CFLAGS="$tmp_CFLAGS"
 954           fi
 955           #
 956           dnl Only gcc 3.3 or later
 957           if test "$compiler_num" -ge "303"; then
 958             tmp_CFLAGS="$tmp_CFLAGS -Wendif-labels -Wstrict-prototypes"
 959           fi
 960           #
 961           dnl Only gcc 3.4 or later
 962           if test "$compiler_num" -ge "304"; then
 963             tmp_CFLAGS="$tmp_CFLAGS -Wdeclaration-after-statement"
 964           fi
 965           #
 966           dnl Only gcc 4.0 or later
 967           if test "$compiler_num" -ge "400"; then
 968             tmp_CFLAGS="$tmp_CFLAGS -Wstrict-aliasing=3"
 969           fi
 970           #
 971           dnl Only gcc 4.2 or later
 972           if test "$compiler_num" -ge "402"; then
 973             tmp_CFLAGS="$tmp_CFLAGS -Wcast-align"
 974           fi
 975           #
 976           dnl Only gcc 4.3 or later
 977           if test "$compiler_num" -ge "403"; then
 978             tmp_CFLAGS="$tmp_CFLAGS -Wtype-limits -Wold-style-declaration"
 979             tmp_CFLAGS="$tmp_CFLAGS -Wmissing-parameter-type -Wempty-body"
 980             tmp_CFLAGS="$tmp_CFLAGS -Wclobbered -Wignored-qualifiers"
 981             tmp_CFLAGS="$tmp_CFLAGS -Wconversion -Wno-sign-conversion -Wvla"
 982           fi
 983           #
 984           dnl Only gcc 4.5 or later
 985           if test "$compiler_num" -ge "405"; then
 986             dnl Only windows targets
 987             if test "$curl_cv_have_def__WIN32" = "yes"; then
 988               tmp_CFLAGS="$tmp_CFLAGS -Wno-pedantic-ms-format"
 989             fi
 990           fi
 991           #
 992         fi
 993         #
 994         dnl Do not issue warnings for code in system include paths.
 995         if test "$compiler_num" -ge "300"; then
 996           tmp_CFLAGS="$tmp_CFLAGS -Wno-system-headers"
 997         else
 998           dnl When cross-compiling with a gcc older than 3.0, disable
 999           dnl some warnings triggered on third party system headers.
1000           if test "x$cross_compiling" = "xyes"; then
1001             if test "$compiler_num" -ge "104"; then
1002               dnl gcc 1.4 or later
1003               tmp_CFLAGS="$tmp_CFLAGS -Wno-unused -Wno-shadow"
1004             fi
1005             if test "$compiler_num" -ge "207"; then
1006               dnl gcc 2.7 or later
1007               tmp_CFLAGS="$tmp_CFLAGS -Wno-missing-declarations"
1008               tmp_CFLAGS="$tmp_CFLAGS -Wno-missing-prototypes"
1009             fi
1010           fi
1011         fi
1012         ;;
1013         #
1014       HP_UX_C)
1015         #
1016         if test "$want_warnings" = "yes"; then
1017           dnl Issue all warnings
1018           tmp_CFLAGS="$tmp_CFLAGS +w1"
1019         fi
1020         ;;
1021         #
1022       IBM_C)
1023         #
1024         dnl Placeholder
1025         tmp_CFLAGS="$tmp_CFLAGS"
1026         ;;
1027         #
1028       INTEL_UNIX_C)
1029         #
1030         if test "$want_warnings" = "yes"; then
1031           if test "$compiler_num" -gt "600"; then
1032             dnl Show errors, warnings, and remarks
1033             tmp_CPPFLAGS="$tmp_CPPFLAGS -Wall -w2"
1034             dnl Perform extra compile-time code checking
1035             tmp_CPPFLAGS="$tmp_CPPFLAGS -Wcheck"
1036             dnl Warn on nested comments
1037             tmp_CPPFLAGS="$tmp_CPPFLAGS -Wcomment"
1038             dnl Show warnings relative to deprecated features
1039             tmp_CPPFLAGS="$tmp_CPPFLAGS -Wdeprecated"
1040             dnl Enable warnings for missing prototypes
1041             tmp_CPPFLAGS="$tmp_CPPFLAGS -Wmissing-prototypes"
1042             dnl Enable warnings for 64-bit portability issues
1043             tmp_CPPFLAGS="$tmp_CPPFLAGS -Wp64"
1044             dnl Enable warnings for questionable pointer arithmetic
1045             tmp_CPPFLAGS="$tmp_CPPFLAGS -Wpointer-arith"
1046             dnl Check for function return typw issues
1047             tmp_CPPFLAGS="$tmp_CPPFLAGS -Wreturn-type"
1048             dnl Warn on variable declarations hiding a previous one
1049             tmp_CPPFLAGS="$tmp_CPPFLAGS -Wshadow"
1050             dnl Warn when a variable is used before initialized
1051             tmp_CPPFLAGS="$tmp_CPPFLAGS -Wuninitialized"
1052             dnl Warn if a declared function is not used
1053             tmp_CPPFLAGS="$tmp_CPPFLAGS -Wunused-function"
1054           fi
1055         fi
1056         dnl Disable using EBP register in optimizations
1057         tmp_CFLAGS="$tmp_CFLAGS -fno-omit-frame-pointer"
1058         dnl Disable use of ANSI C aliasing rules in optimizations
1059         tmp_CFLAGS="$tmp_CFLAGS -fno-strict-aliasing"
1060         dnl Value-safe optimizations on floating-point data
1061         tmp_CFLAGS="$tmp_CFLAGS -fp-model precise"
1062         dnl Only icc 10.0 or later
1063         if test "$compiler_num" -ge "1000"; then
1064           dnl Disable vectorizer diagnostic information
1065           tmp_CFLAGS="$tmp_CFLAGS -vec-report0"
1066         fi
1067         ;;
1068         #
1069       INTEL_WINDOWS_C)
1070         #
1071         dnl Placeholder
1072         tmp_CFLAGS="$tmp_CFLAGS"
1073         ;;
1074         #
1075       LCC)
1076         #
1077         if test "$want_warnings" = "yes"; then
1078           dnl Highest warning level is double -A, next is single -A.
1079           dnl Due to the big number of warnings these trigger on third
1080           dnl party header files it is impractical for us to use any of
1081           dnl them here. If you want them simply define it in CPPFLAGS.
1082           tmp_CFLAGS="$tmp_CFLAGS"
1083         fi
1084         ;;
1085         #
1086       SGI_MIPS_C)
1087         #
1088         if test "$want_warnings" = "yes"; then
1089           dnl Perform stricter semantic and lint-like checks
1090           tmp_CFLAGS="$tmp_CFLAGS -fullwarn"
1091         fi
1092         ;;
1093         #
1094       SGI_MIPSPRO_C)
1095         #
1096         if test "$want_warnings" = "yes"; then
1097           dnl Perform stricter semantic and lint-like checks
1098           tmp_CFLAGS="$tmp_CFLAGS -fullwarn"
1099           dnl Disable some remarks
1100           dnl #1209: controlling expression is constant
1101           tmp_CFLAGS="$tmp_CFLAGS -woff 1209"
1102         fi
1103         ;;
1104         #
1105       SUNPRO_C)
1106         #
1107         if test "$want_warnings" = "yes"; then
1108           dnl Perform stricter semantic and lint-like checks
1109           tmp_CFLAGS="$tmp_CFLAGS -v"
1110         fi
1111         ;;
1112         #
1113       TINY_C)
1114         #
1115         if test "$want_warnings" = "yes"; then
1116           dnl Activate all warnings
1117           tmp_CFLAGS="$tmp_CFLAGS -Wall"
1118           dnl Make string constants be of type const char *
1119           tmp_CFLAGS="$tmp_CFLAGS -Wwrite-strings"
1120           dnl Warn use of unsupported GCC features ignored by TCC
1121           tmp_CFLAGS="$tmp_CFLAGS -Wunsupported"
1122         fi
1123         ;;
1124         #
1125       WATCOM_UNIX_C)
1126         #
1127         if test "$want_warnings" = "yes"; then
1128           dnl Issue all warnings
1129           tmp_CFLAGS="$tmp_CFLAGS -Wall -Wextra"
1130         fi
1131         ;;
1132         #
1133       WATCOM_WINDOWS_C)
1134         #
1135         dnl Placeholder
1136         tmp_CFLAGS="$tmp_CFLAGS"
1137         ;;
1138         #
1139     esac
1140     #
1141     squeeze tmp_CPPFLAGS
1142     squeeze tmp_CFLAGS
1143     #
1144     if test ! -z "$tmp_CFLAGS" || test ! -z "$tmp_CPPFLAGS"; then
1145       AC_MSG_CHECKING([if compiler accepts strict warning options])
1146       CPPFLAGS="$tmp_save_CPPFLAGS $tmp_CPPFLAGS"
1147       CFLAGS="$tmp_save_CFLAGS $tmp_CFLAGS"
1148       squeeze CPPFLAGS
1149       squeeze CFLAGS
1150       CURL_COMPILER_WORKS_IFELSE([
1151         AC_MSG_RESULT([yes])
1152         AC_MSG_NOTICE([compiler options added: $tmp_CFLAGS $tmp_CPPFLAGS])
1153       ],[
1154         AC_MSG_RESULT([no])
1155         AC_MSG_WARN([compiler options rejected: $tmp_CFLAGS $tmp_CPPFLAGS])
1156         dnl restore initial settings
1157         CPPFLAGS="$tmp_save_CPPFLAGS"
1158         CFLAGS="$tmp_save_CFLAGS"
1159       ])
1160     fi
1161     #
1162   fi
1163 ])
1164
1165
1166 dnl CURL_SHFUNC_SQUEEZE
1167 dnl -------------------------------------------------
1168 dnl Declares a shell function squeeze() which removes
1169 dnl redundant whitespace out of a shell variable.
1170
1171 AC_DEFUN([CURL_SHFUNC_SQUEEZE], [
1172 squeeze() {
1173   _sqz_result=""
1174   eval _sqz_input=\[$][$]1
1175   for _sqz_token in $_sqz_input; do
1176     if test -z "$_sqz_result"; then
1177       _sqz_result="$_sqz_token"
1178     else
1179       _sqz_result="$_sqz_result $_sqz_token"
1180     fi
1181   done
1182   eval [$]1=\$_sqz_result
1183   return 0
1184 }
1185 ])
1186
1187
1188 dnl CURL_CHECK_CURLDEBUG
1189 dnl -------------------------------------------------
1190 dnl Settings which depend on configure's curldebug given
1191 dnl option, and other additional configure pre-requisites.
1192 dnl Actually the curl debug memory tracking feature can
1193 dnl only be used/enabled when libcurl is built as a static
1194 dnl library or as a shared one on those systems on which
1195 dnl shared libraries support undefined symbols.
1196
1197 AC_DEFUN([CURL_CHECK_CURLDEBUG], [
1198   AC_REQUIRE([XC_LIBTOOL])dnl
1199   AC_REQUIRE([CURL_SHFUNC_SQUEEZE])dnl
1200   supports_curldebug="unknown"
1201   if test "$want_curldebug" = "yes"; then
1202     if test "x$enable_shared" != "xno" &&
1203       test "x$enable_shared" != "xyes"; then
1204       AC_MSG_WARN([unknown enable_shared setting.])
1205       supports_curldebug="no"
1206     fi
1207     if test "x$enable_static" != "xno" &&
1208       test "x$enable_static" != "xyes"; then
1209       AC_MSG_WARN([unknown enable_static setting.])
1210       supports_curldebug="no"
1211     fi
1212     if test "$supports_curldebug" != "no"; then
1213       if test "$enable_shared" = "yes" &&
1214         test "x$xc_lt_shlib_use_no_undefined" = 'xyes'; then
1215         supports_curldebug="no"
1216         AC_MSG_WARN([shared library does not support undefined symbols.])
1217       fi
1218     fi
1219   fi
1220   #
1221   if test "$want_curldebug" = "yes"; then
1222     AC_MSG_CHECKING([if curl debug memory tracking can be enabled])
1223     test "$supports_curldebug" = "no" || supports_curldebug="yes"
1224     AC_MSG_RESULT([$supports_curldebug])
1225     if test "$supports_curldebug" = "no"; then
1226       AC_MSG_WARN([cannot enable curl debug memory tracking.])
1227       want_curldebug="no"
1228     fi
1229   fi
1230   #
1231   if test "$want_curldebug" = "yes"; then
1232     CPPFLAGS="-DCURLDEBUG $CPPFLAGS"
1233     squeeze CPPFLAGS
1234   fi
1235   if test "$want_debug" = "yes"; then
1236     CPPFLAGS="-DDEBUGBUILD $CPPFLAGS"
1237     squeeze CPPFLAGS
1238   fi
1239 ])
1240
1241
1242
1243 dnl CURL_CHECK_COMPILER_HALT_ON_ERROR
1244 dnl -------------------------------------------------
1245 dnl Verifies if the compiler actually halts after the
1246 dnl compilation phase without generating any object
1247 dnl code file, when the source compiles with errors.
1248
1249 AC_DEFUN([CURL_CHECK_COMPILER_HALT_ON_ERROR], [
1250   AC_MSG_CHECKING([if compiler halts on compilation errors])
1251   AC_COMPILE_IFELSE([
1252     AC_LANG_PROGRAM([[
1253     ]],[[
1254       force compilation error
1255     ]])
1256   ],[
1257     AC_MSG_RESULT([no])
1258     AC_MSG_ERROR([compiler does not halt on compilation errors.])
1259   ],[
1260     AC_MSG_RESULT([yes])
1261   ])
1262 ])
1263
1264
1265 dnl CURL_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE
1266 dnl -------------------------------------------------
1267 dnl Verifies if the compiler actually halts after the
1268 dnl compilation phase without generating any object
1269 dnl code file, when the source code tries to define a
1270 dnl type for a constant array with negative dimension.
1271
1272 AC_DEFUN([CURL_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE], [
1273   AC_REQUIRE([CURL_CHECK_COMPILER_HALT_ON_ERROR])dnl
1274   AC_MSG_CHECKING([if compiler halts on negative sized arrays])
1275   AC_COMPILE_IFELSE([
1276     AC_LANG_PROGRAM([[
1277       typedef char bad_t[sizeof(char) == sizeof(int) ? -1 : -1 ];
1278     ]],[[
1279       bad_t dummy;
1280     ]])
1281   ],[
1282     AC_MSG_RESULT([no])
1283     AC_MSG_ERROR([compiler does not halt on negative sized arrays.])
1284   ],[
1285     AC_MSG_RESULT([yes])
1286   ])
1287 ])
1288
1289
1290 dnl CURL_CHECK_COMPILER_STRUCT_MEMBER_SIZE
1291 dnl -------------------------------------------------
1292 dnl Verifies if the compiler is capable of handling the
1293 dnl size of a struct member, struct which is a function
1294 dnl result, as a compilation-time condition inside the
1295 dnl type definition of a constant array.
1296
1297 AC_DEFUN([CURL_CHECK_COMPILER_STRUCT_MEMBER_SIZE], [
1298   AC_REQUIRE([CURL_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE])dnl
1299   AC_MSG_CHECKING([if compiler struct member size checking works])
1300   tst_compiler_check_one_works="unknown"
1301   AC_COMPILE_IFELSE([
1302     AC_LANG_PROGRAM([[
1303       struct mystruct {
1304         int  mi;
1305         char mc;
1306         struct mystruct *next;
1307       };
1308       struct mystruct myfunc();
1309       typedef char good_t1[sizeof(myfunc().mi) == sizeof(int)  ? 1 : -1 ];
1310       typedef char good_t2[sizeof(myfunc().mc) == sizeof(char) ? 1 : -1 ];
1311     ]],[[
1312       good_t1 dummy1;
1313       good_t2 dummy2;
1314     ]])
1315   ],[
1316     tst_compiler_check_one_works="yes"
1317   ],[
1318     tst_compiler_check_one_works="no"
1319     sed 's/^/cc-src: /' conftest.$ac_ext >&6
1320     sed 's/^/cc-err: /' conftest.err >&6
1321   ])
1322   tst_compiler_check_two_works="unknown"
1323   AC_COMPILE_IFELSE([
1324     AC_LANG_PROGRAM([[
1325       struct mystruct {
1326         int  mi;
1327         char mc;
1328         struct mystruct *next;
1329       };
1330       struct mystruct myfunc();
1331       typedef char bad_t1[sizeof(myfunc().mi) != sizeof(int)  ? 1 : -1 ];
1332       typedef char bad_t2[sizeof(myfunc().mc) != sizeof(char) ? 1 : -1 ];
1333     ]],[[
1334       bad_t1 dummy1;
1335       bad_t2 dummy2;
1336     ]])
1337   ],[
1338     tst_compiler_check_two_works="no"
1339   ],[
1340     tst_compiler_check_two_works="yes"
1341   ])
1342   if test "$tst_compiler_check_one_works" = "yes" &&
1343     test "$tst_compiler_check_two_works" = "yes"; then
1344     AC_MSG_RESULT([yes])
1345   else
1346     AC_MSG_RESULT([no])
1347     AC_MSG_ERROR([compiler fails struct member size checking.])
1348   fi
1349 ])
1350
1351
1352 dnl CURL_CHECK_COMPILER_SYMBOL_HIDING
1353 dnl -------------------------------------------------
1354 dnl Verify if compiler supports hiding library internal symbols, setting
1355 dnl shell variable supports_symbol_hiding value as appropriate, as well as
1356 dnl variables symbol_hiding_CFLAGS and symbol_hiding_EXTERN when supported.
1357
1358 AC_DEFUN([CURL_CHECK_COMPILER_SYMBOL_HIDING], [
1359   AC_REQUIRE([CURL_CHECK_COMPILER])dnl
1360   AC_BEFORE([$0],[CURL_CONFIGURE_SYMBOL_HIDING])dnl
1361   AC_MSG_CHECKING([if compiler supports hiding library internal symbols])
1362   supports_symbol_hiding="no"
1363   symbol_hiding_CFLAGS=""
1364   symbol_hiding_EXTERN=""
1365   tmp_CFLAGS=""
1366   tmp_EXTERN=""
1367   case "$compiler_id" in
1368     CLANG)
1369       dnl All versions of clang support -fvisibility=
1370       tmp_EXTERN="__attribute__ ((__visibility__ (\"default\")))"
1371       tmp_CFLAGS="-fvisibility=hidden"
1372       supports_symbol_hiding="yes"
1373       ;;
1374     GNU_C)
1375       dnl Only gcc 3.4 or later
1376       if test "$compiler_num" -ge "304"; then
1377         if $CC --help --verbose 2>&1 | grep fvisibility= > /dev/null ; then
1378           tmp_EXTERN="__attribute__ ((__visibility__ (\"default\")))"
1379           tmp_CFLAGS="-fvisibility=hidden"
1380           supports_symbol_hiding="yes"
1381         fi
1382       fi
1383       ;;
1384     INTEL_UNIX_C)
1385       dnl Only icc 9.0 or later
1386       if test "$compiler_num" -ge "900"; then
1387         if $CC --help --verbose 2>&1 | grep fvisibility= > /dev/null ; then
1388           tmp_save_CFLAGS="$CFLAGS"
1389           CFLAGS="$CFLAGS -fvisibility=hidden"
1390           AC_LINK_IFELSE([
1391             AC_LANG_PROGRAM([[
1392 #             include <stdio.h>
1393             ]],[[
1394               printf("icc fvisibility bug test");
1395             ]])
1396           ],[
1397             tmp_EXTERN="__attribute__ ((__visibility__ (\"default\")))"
1398             tmp_CFLAGS="-fvisibility=hidden"
1399             supports_symbol_hiding="yes"
1400           ])
1401           CFLAGS="$tmp_save_CFLAGS"
1402         fi
1403       fi
1404       ;;
1405     SUNPRO_C)
1406       if $CC 2>&1 | grep flags >/dev/null && $CC -flags | grep xldscope= >/dev/null ; then
1407         tmp_EXTERN="__global"
1408         tmp_CFLAGS="-xldscope=hidden"
1409         supports_symbol_hiding="yes"
1410       fi
1411       ;;
1412   esac
1413   if test "$supports_symbol_hiding" = "yes"; then
1414     tmp_save_CFLAGS="$CFLAGS"
1415     CFLAGS="$tmp_save_CFLAGS $tmp_CFLAGS"
1416     squeeze CFLAGS
1417     AC_COMPILE_IFELSE([
1418       AC_LANG_PROGRAM([[
1419         $tmp_EXTERN char *dummy(char *buff);
1420         char *dummy(char *buff)
1421         {
1422          if(buff)
1423            return ++buff;
1424          else
1425            return buff;
1426         }
1427       ]],[[
1428         char b[16];
1429         char *r = dummy(&b[0]);
1430         if(r)
1431           return (int)*r;
1432       ]])
1433     ],[
1434       supports_symbol_hiding="yes"
1435       if test -f conftest.err; then
1436         grep 'visibility' conftest.err >/dev/null
1437         if test "$?" -eq "0"; then
1438           supports_symbol_hiding="no"
1439         fi
1440       fi
1441     ],[
1442       supports_symbol_hiding="no"
1443       echo " " >&6
1444       sed 's/^/cc-src: /' conftest.$ac_ext >&6
1445       sed 's/^/cc-err: /' conftest.err >&6
1446       echo " " >&6
1447     ])
1448     CFLAGS="$tmp_save_CFLAGS"
1449   fi
1450   if test "$supports_symbol_hiding" = "yes"; then
1451     AC_MSG_RESULT([yes])
1452     symbol_hiding_CFLAGS="$tmp_CFLAGS"
1453     symbol_hiding_EXTERN="$tmp_EXTERN"
1454   else
1455     AC_MSG_RESULT([no])
1456   fi
1457 ])
1458
1459
1460 dnl CURL_CHECK_COMPILER_PROTOTYPE_MISMATCH
1461 dnl -------------------------------------------------
1462 dnl Verifies if the compiler actually halts after the
1463 dnl compilation phase without generating any object
1464 dnl code file, when the source code tries to redefine
1465 dnl a prototype which does not match previous one.
1466
1467 AC_DEFUN([CURL_CHECK_COMPILER_PROTOTYPE_MISMATCH], [
1468   AC_REQUIRE([CURL_CHECK_COMPILER_HALT_ON_ERROR])dnl
1469   AC_MSG_CHECKING([if compiler halts on function prototype mismatch])
1470   AC_COMPILE_IFELSE([
1471     AC_LANG_PROGRAM([[
1472 #     include <stdlib.h>
1473       int rand(int n);
1474       int rand(int n)
1475       {
1476         if(n)
1477           return ++n;
1478         else
1479           return n;
1480       }
1481     ]],[[
1482       int i[2]={0,0};
1483       int j = rand(i[0]);
1484       if(j)
1485         return j;
1486     ]])
1487   ],[
1488     AC_MSG_RESULT([no])
1489     AC_MSG_ERROR([compiler does not halt on function prototype mismatch.])
1490   ],[
1491     AC_MSG_RESULT([yes])
1492   ])
1493 ])
1494
1495
1496 dnl CURL_VAR_MATCH (VARNAME, VALUE)
1497 dnl -------------------------------------------------
1498 dnl Verifies if shell variable VARNAME contains VALUE.
1499 dnl Contents of variable VARNAME and VALUE are handled
1500 dnl as whitespace separated lists of words. If at least
1501 dnl one word of VALUE is present in VARNAME the match
1502 dnl is considered positive, otherwise false.
1503
1504 AC_DEFUN([CURL_VAR_MATCH], [
1505   ac_var_match_word="no"
1506   for word1 in $[$1]; do
1507     for word2 in [$2]; do
1508       if test "$word1" = "$word2"; then
1509         ac_var_match_word="yes"
1510       fi
1511     done
1512   done
1513 ])
1514
1515
1516 dnl CURL_VAR_MATCH_IFELSE (VARNAME, VALUE,
1517 dnl                        [ACTION-IF-MATCH], [ACTION-IF-NOT-MATCH])
1518 dnl -------------------------------------------------
1519 dnl This performs a CURL_VAR_MATCH check and executes
1520 dnl first branch if the match is positive, otherwise
1521 dnl the second branch is executed.
1522
1523 AC_DEFUN([CURL_VAR_MATCH_IFELSE], [
1524   CURL_VAR_MATCH([$1],[$2])
1525   if test "$ac_var_match_word" = "yes"; then
1526   ifelse($3,,:,[$3])
1527   ifelse($4,,,[else
1528     $4])
1529   fi
1530 ])
1531
1532
1533 dnl CURL_VAR_STRIP (VARNAME, VALUE)
1534 dnl -------------------------------------------------
1535 dnl Contents of variable VARNAME and VALUE are handled
1536 dnl as whitespace separated lists of words. Each word
1537 dnl from VALUE is removed from VARNAME when present.
1538
1539 AC_DEFUN([CURL_VAR_STRIP], [
1540   AC_REQUIRE([CURL_SHFUNC_SQUEEZE])dnl
1541   ac_var_stripped=""
1542   for word1 in $[$1]; do
1543     ac_var_strip_word="no"
1544     for word2 in [$2]; do
1545       if test "$word1" = "$word2"; then
1546         ac_var_strip_word="yes"
1547       fi
1548     done
1549     if test "$ac_var_strip_word" = "no"; then
1550       ac_var_stripped="$ac_var_stripped $word1"
1551     fi
1552   done
1553   dnl squeeze whitespace out of result
1554   [$1]="$ac_var_stripped"
1555   squeeze [$1]
1556 ])
1557