• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1#***************************************************************************
2#
3# Copyright (C) 2009-2013 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://cool.haxx.se/mailman/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_CURLDEBUG
1183dnl -------------------------------------------------
1184dnl Settings which depend on configure's curldebug given
1185dnl option, and other additional configure pre-requisites.
1186dnl Using the curl debug memory tracking feature in c-ares
1187dnl is a hack that actually can only be used/enabled when
1188dnl c-ares is built directly in curl's CVS tree, as a static
1189dnl library or as a shared one on those systems on which
1190dnl shared libraries support undefined symbols, along with
1191dnl an equally configured libcurl.
1192
1193AC_DEFUN([CARES_CHECK_CURLDEBUG], [
1194  AC_REQUIRE([XC_LIBTOOL])dnl
1195  AC_REQUIRE([CARES_SHFUNC_SQUEEZE])dnl
1196  cares_builddir=`pwd`
1197  supports_curldebug="unknown"
1198  if test "$want_curldebug" = "yes"; then
1199    if test "x$enable_shared" != "xno" &&
1200      test "x$enable_shared" != "xyes"; then
1201      AC_MSG_WARN([unknown enable_shared setting.])
1202      supports_curldebug="no"
1203    fi
1204    if test "x$enable_static" != "xno" &&
1205      test "x$enable_static" != "xyes"; then
1206      AC_MSG_WARN([unknown enable_static setting.])
1207      supports_curldebug="no"
1208    fi
1209    if test "$supports_curldebug" != "no"; then
1210      if test "$enable_shared" = "yes" &&
1211        test "x$xc_lt_shlib_use_no_undefined" = 'xyes'; then
1212        supports_curldebug="no"
1213        AC_MSG_WARN([shared library does not support undefined symbols.])
1214      fi
1215      if test ! -f "$srcdir/../include/curl/curlbuild.h.dist"; then
1216        AC_MSG_WARN([c-ares source not embedded in curl's CVS tree.])
1217        supports_curldebug="no"
1218      elif test ! -f "$srcdir/../include/curl/Makefile.in"; then
1219        AC_MSG_WARN([curl's buildconf has not been run.])
1220        supports_curldebug="no"
1221      elif test ! -f "$cares_builddir/../libcurl.pc" ||
1222        test ! -f "$cares_builddir/../include/curl/curlbuild.h"; then
1223        AC_MSG_WARN([curl's configure has not been run.])
1224        supports_curldebug="no"
1225      elif test ! -f "$cares_builddir/../lib/curl_config.h"; then
1226        AC_MSG_WARN([libcurl's curl_config.h is missing.])
1227        supports_curldebug="no"
1228      elif test ! -f "$cares_builddir/../config.status"; then
1229        AC_MSG_WARN([curl's config.status is missing.])
1230        supports_curldebug="no"
1231      fi
1232      if test "$supports_curldebug" != "no"; then
1233        grep '^#define USE_ARES' "$cares_builddir/../lib/curl_config.h" >/dev/null
1234        if test "$?" -ne "0"; then
1235          AC_MSG_WARN([libcurl configured without c-ares support.])
1236          supports_curldebug="no"
1237        fi
1238      fi
1239      if test "$supports_curldebug" != "no"; then
1240        grep 'CPPFLAGS.*CURLDEBUG' "$cares_builddir/../config.status" >/dev/null
1241        if test "$?" -ne "0"; then
1242          AC_MSG_WARN([libcurl configured without curldebug support.])
1243          supports_curldebug="no"
1244        fi
1245      fi
1246    fi
1247  fi
1248  #
1249  if test "$want_curldebug" = "yes"; then
1250    AC_MSG_CHECKING([if curl debug memory tracking can be enabled])
1251    test "$supports_curldebug" = "no" || supports_curldebug="yes"
1252    AC_MSG_RESULT([$supports_curldebug])
1253    if test "$supports_curldebug" = "no"; then
1254      AC_MSG_WARN([cannot enable curl debug memory tracking.])
1255      want_curldebug="no"
1256    fi
1257  fi
1258  #
1259  if test "$want_curldebug" = "yes"; then
1260    dnl TODO: Verify if the BUILDING_LIBCURL definition is still required.
1261    AC_DEFINE(BUILDING_LIBCURL, 1, [when building as static part of libcurl])
1262    CPPFLAGS="-DCURLDEBUG $CPPFLAGS"
1263    squeeze CPPFLAGS
1264  fi
1265  #
1266  if test "$want_debug" = "yes"; then
1267    CPPFLAGS="-DDEBUGBUILD $CPPFLAGS"
1268    squeeze CPPFLAGS
1269  fi
1270])
1271
1272
1273dnl CARES_CHECK_COMPILER_HALT_ON_ERROR
1274dnl -------------------------------------------------
1275dnl Verifies if the compiler actually halts after the
1276dnl compilation phase without generating any object
1277dnl code file, when the source compiles with errors.
1278
1279AC_DEFUN([CARES_CHECK_COMPILER_HALT_ON_ERROR], [
1280  AC_MSG_CHECKING([if compiler halts on compilation errors])
1281  AC_COMPILE_IFELSE([
1282    AC_LANG_PROGRAM([[
1283    ]],[[
1284      force compilation error
1285    ]])
1286  ],[
1287    AC_MSG_RESULT([no])
1288    AC_MSG_ERROR([compiler does not halt on compilation errors.])
1289  ],[
1290    AC_MSG_RESULT([yes])
1291  ])
1292])
1293
1294
1295dnl CARES_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE
1296dnl -------------------------------------------------
1297dnl Verifies if the compiler actually halts after the
1298dnl compilation phase without generating any object
1299dnl code file, when the source code tries to define a
1300dnl type for a constant array with negative dimension.
1301
1302AC_DEFUN([CARES_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE], [
1303  AC_REQUIRE([CARES_CHECK_COMPILER_HALT_ON_ERROR])dnl
1304  AC_MSG_CHECKING([if compiler halts on negative sized arrays])
1305  AC_COMPILE_IFELSE([
1306    AC_LANG_PROGRAM([[
1307      typedef char bad_t[sizeof(char) == sizeof(int) ? -1 : -1 ];
1308    ]],[[
1309      bad_t dummy;
1310    ]])
1311  ],[
1312    AC_MSG_RESULT([no])
1313    AC_MSG_ERROR([compiler does not halt on negative sized arrays.])
1314  ],[
1315    AC_MSG_RESULT([yes])
1316  ])
1317])
1318
1319
1320dnl CARES_CHECK_COMPILER_STRUCT_MEMBER_SIZE
1321dnl -------------------------------------------------
1322dnl Verifies if the compiler is capable of handling the
1323dnl size of a struct member, struct which is a function
1324dnl result, as a compilation-time condition inside the
1325dnl type definition of a constant array.
1326
1327AC_DEFUN([CARES_CHECK_COMPILER_STRUCT_MEMBER_SIZE], [
1328  AC_REQUIRE([CARES_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE])dnl
1329  AC_MSG_CHECKING([if compiler struct member size checking works])
1330  tst_compiler_check_one_works="unknown"
1331  AC_COMPILE_IFELSE([
1332    AC_LANG_PROGRAM([[
1333      struct mystruct {
1334        int  mi;
1335        char mc;
1336        struct mystruct *next;
1337      };
1338      struct mystruct myfunc();
1339      typedef char good_t1[sizeof(myfunc().mi) == sizeof(int)  ? 1 : -1 ];
1340      typedef char good_t2[sizeof(myfunc().mc) == sizeof(char) ? 1 : -1 ];
1341    ]],[[
1342      good_t1 dummy1;
1343      good_t2 dummy2;
1344    ]])
1345  ],[
1346    tst_compiler_check_one_works="yes"
1347  ],[
1348    tst_compiler_check_one_works="no"
1349    sed 's/^/cc-src: /' conftest.$ac_ext >&6
1350    sed 's/^/cc-err: /' conftest.err >&6
1351  ])
1352  tst_compiler_check_two_works="unknown"
1353  AC_COMPILE_IFELSE([
1354    AC_LANG_PROGRAM([[
1355      struct mystruct {
1356        int  mi;
1357        char mc;
1358        struct mystruct *next;
1359      };
1360      struct mystruct myfunc();
1361      typedef char bad_t1[sizeof(myfunc().mi) != sizeof(int)  ? 1 : -1 ];
1362      typedef char bad_t2[sizeof(myfunc().mc) != sizeof(char) ? 1 : -1 ];
1363    ]],[[
1364      bad_t1 dummy1;
1365      bad_t2 dummy2;
1366    ]])
1367  ],[
1368    tst_compiler_check_two_works="no"
1369  ],[
1370    tst_compiler_check_two_works="yes"
1371  ])
1372  if test "$tst_compiler_check_one_works" = "yes" &&
1373    test "$tst_compiler_check_two_works" = "yes"; then
1374    AC_MSG_RESULT([yes])
1375  else
1376    AC_MSG_RESULT([no])
1377    AC_MSG_ERROR([compiler fails struct member size checking.])
1378  fi
1379])
1380
1381
1382dnl CARES_CHECK_COMPILER_SYMBOL_HIDING
1383dnl -------------------------------------------------
1384dnl Verify if compiler supports hiding library internal symbols, setting
1385dnl shell variable supports_symbol_hiding value as appropriate, as well as
1386dnl variables symbol_hiding_CFLAGS and symbol_hiding_EXTERN when supported.
1387
1388AC_DEFUN([CARES_CHECK_COMPILER_SYMBOL_HIDING], [
1389  AC_REQUIRE([CARES_CHECK_COMPILER])dnl
1390  AC_BEFORE([$0],[CARES_CONFIGURE_SYMBOL_HIDING])dnl
1391  AC_MSG_CHECKING([if compiler supports hiding library internal symbols])
1392  supports_symbol_hiding="no"
1393  symbol_hiding_CFLAGS=""
1394  symbol_hiding_EXTERN=""
1395  tmp_CFLAGS=""
1396  tmp_EXTERN=""
1397  case "$compiler_id" in
1398    CLANG)
1399      dnl All versions of clang support -fvisibility=
1400      tmp_EXTERN="__attribute__ ((__visibility__ (\"default\")))"
1401      tmp_CFLAGS="-fvisibility=hidden"
1402      supports_symbol_hiding="yes"
1403      ;;
1404    GNU_C)
1405      dnl Only gcc 3.4 or later
1406      if test "$compiler_num" -ge "304"; then
1407        if $CC --help --verbose 2>&1 | grep fvisibility= > /dev/null ; then
1408          tmp_EXTERN="__attribute__ ((__visibility__ (\"default\")))"
1409          tmp_CFLAGS="-fvisibility=hidden"
1410          supports_symbol_hiding="yes"
1411        fi
1412      fi
1413      ;;
1414    INTEL_UNIX_C)
1415      dnl Only icc 9.0 or later
1416      if test "$compiler_num" -ge "900"; then
1417        if $CC --help --verbose 2>&1 | grep fvisibility= > /dev/null ; then
1418          tmp_save_CFLAGS="$CFLAGS"
1419          CFLAGS="$CFLAGS -fvisibility=hidden"
1420          AC_LINK_IFELSE([
1421            AC_LANG_PROGRAM([[
1422#             include <stdio.h>
1423            ]],[[
1424              printf("icc fvisibility bug test");
1425            ]])
1426          ],[
1427            tmp_EXTERN="__attribute__ ((__visibility__ (\"default\")))"
1428            tmp_CFLAGS="-fvisibility=hidden"
1429            supports_symbol_hiding="yes"
1430          ])
1431          CFLAGS="$tmp_save_CFLAGS"
1432        fi
1433      fi
1434      ;;
1435    SUNPRO_C)
1436      if $CC 2>&1 | grep flags >/dev/null && $CC -flags | grep xldscope= >/dev/null ; then
1437        tmp_EXTERN="__global"
1438        tmp_CFLAGS="-xldscope=hidden"
1439        supports_symbol_hiding="yes"
1440      fi
1441      ;;
1442  esac
1443  if test "$supports_symbol_hiding" = "yes"; then
1444    tmp_save_CFLAGS="$CFLAGS"
1445    CFLAGS="$tmp_save_CFLAGS $tmp_CFLAGS"
1446    squeeze CFLAGS
1447    AC_COMPILE_IFELSE([
1448      AC_LANG_PROGRAM([[
1449        $tmp_EXTERN char *dummy(char *buff);
1450        char *dummy(char *buff)
1451        {
1452         if(buff)
1453           return ++buff;
1454         else
1455           return buff;
1456        }
1457      ]],[[
1458        char b[16];
1459        char *r = dummy(&b[0]);
1460        if(r)
1461          return (int)*r;
1462      ]])
1463    ],[
1464      supports_symbol_hiding="yes"
1465      if test -f conftest.err; then
1466        grep 'visibility' conftest.err >/dev/null
1467        if test "$?" -eq "0"; then
1468          supports_symbol_hiding="no"
1469        fi
1470      fi
1471    ],[
1472      supports_symbol_hiding="no"
1473      echo " " >&6
1474      sed 's/^/cc-src: /' conftest.$ac_ext >&6
1475      sed 's/^/cc-err: /' conftest.err >&6
1476      echo " " >&6
1477    ])
1478    CFLAGS="$tmp_save_CFLAGS"
1479  fi
1480  if test "$supports_symbol_hiding" = "yes"; then
1481    AC_MSG_RESULT([yes])
1482    symbol_hiding_CFLAGS="$tmp_CFLAGS"
1483    symbol_hiding_EXTERN="$tmp_EXTERN"
1484  else
1485    AC_MSG_RESULT([no])
1486  fi
1487])
1488
1489
1490dnl CARES_CHECK_COMPILER_PROTOTYPE_MISMATCH
1491dnl -------------------------------------------------
1492dnl Verifies if the compiler actually halts after the
1493dnl compilation phase without generating any object
1494dnl code file, when the source code tries to redefine
1495dnl a prototype which does not match previous one.
1496
1497AC_DEFUN([CARES_CHECK_COMPILER_PROTOTYPE_MISMATCH], [
1498  AC_REQUIRE([CARES_CHECK_COMPILER_HALT_ON_ERROR])dnl
1499  AC_MSG_CHECKING([if compiler halts on function prototype mismatch])
1500  AC_COMPILE_IFELSE([
1501    AC_LANG_PROGRAM([[
1502#     include <stdlib.h>
1503      int rand(int n);
1504      int rand(int n)
1505      {
1506        if(n)
1507          return ++n;
1508        else
1509          return n;
1510      }
1511    ]],[[
1512      int i[2];
1513      int j = rand(i[0]);
1514      if(j)
1515        return j;
1516    ]])
1517  ],[
1518    AC_MSG_RESULT([no])
1519    AC_MSG_ERROR([compiler does not halt on function prototype mismatch.])
1520  ],[
1521    AC_MSG_RESULT([yes])
1522  ])
1523])
1524
1525
1526dnl CARES_VAR_MATCH (VARNAME, VALUE)
1527dnl -------------------------------------------------
1528dnl Verifies if shell variable VARNAME contains VALUE.
1529dnl Contents of variable VARNAME and VALUE are handled
1530dnl as whitespace separated lists of words. If at least
1531dnl one word of VALUE is present in VARNAME the match
1532dnl is considered positive, otherwise false.
1533
1534AC_DEFUN([CARES_VAR_MATCH], [
1535  ac_var_match_word="no"
1536  for word1 in $[$1]; do
1537    for word2 in [$2]; do
1538      if test "$word1" = "$word2"; then
1539        ac_var_match_word="yes"
1540      fi
1541    done
1542  done
1543])
1544
1545
1546dnl CARES_VAR_MATCH_IFELSE (VARNAME, VALUE,
1547dnl                        [ACTION-IF-MATCH], [ACTION-IF-NOT-MATCH])
1548dnl -------------------------------------------------
1549dnl This performs a CURL_VAR_MATCH check and executes
1550dnl first branch if the match is positive, otherwise
1551dnl the second branch is executed.
1552
1553AC_DEFUN([CARES_VAR_MATCH_IFELSE], [
1554  CARES_VAR_MATCH([$1],[$2])
1555  if test "$ac_var_match_word" = "yes"; then
1556  ifelse($3,,:,[$3])
1557  ifelse($4,,,[else
1558    $4])
1559  fi
1560])
1561
1562
1563dnl CARES_VAR_STRIP (VARNAME, VALUE)
1564dnl -------------------------------------------------
1565dnl Contents of variable VARNAME and VALUE are handled
1566dnl as whitespace separated lists of words. Each word
1567dnl from VALUE is removed from VARNAME when present.
1568
1569AC_DEFUN([CARES_VAR_STRIP], [
1570  AC_REQUIRE([CARES_SHFUNC_SQUEEZE])dnl
1571  ac_var_stripped=""
1572  for word1 in $[$1]; do
1573    ac_var_strip_word="no"
1574    for word2 in [$2]; do
1575      if test "$word1" = "$word2"; then
1576        ac_var_strip_word="yes"
1577      fi
1578    done
1579    if test "$ac_var_strip_word" = "no"; then
1580      ac_var_stripped="$ac_var_stripped $word1"
1581    fi
1582  done
1583  dnl squeeze whitespace out of result
1584  [$1]="$ac_var_stripped"
1585  squeeze [$1]
1586])
1587
1588