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