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