ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/branches/newio/configure
(Generate patch)

Comparing branches/newio/configure (file contents):
Revision 2504 by michael, Sun Aug 11 13:30:04 2013 UTC vs.
Revision 2505 by michael, Sun Oct 27 15:07:19 2013 UTC

# Line 3280 | Line 3280 | fi
3280    MAINT=$MAINTAINER_MODE_TRUE
3281  
3282  
3283 +
3284   ac_config_headers="$ac_config_headers config.h"
3285  
3286  
# Line 8756 | Line 8757 | _lt_linker_boilerplate=`cat conftest.err
8757   $RM -r conftest*
8758  
8759  
8760 + ## CAVEAT EMPTOR:
8761 + ## There is no encapsulation within the following macros, do not change
8762 + ## the running order or otherwise move them around unless you know exactly
8763 + ## what you are doing...
8764   if test -n "$compiler"; then
8765  
8766   lt_prog_compiler_no_builtin_flag=
# Line 13728 | Line 13733 | fi
13733  
13734   # Checks for libraries.
13735  
13736 +
13737 +  if test "X$CC" != "X"; then
13738 +    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -fstack-protector" >&5
13739 + $as_echo_n "checking whether ${CC} accepts -fstack-protector... " >&6; }
13740 + if ${ssp_cv_cc+:} false; then :
13741 +  $as_echo_n "(cached) " >&6
13742 + else
13743 +  ssp_old_cflags="$CFLAGS"
13744 +       CFLAGS="$CFLAGS -fstack-protector"
13745 +       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13746 + /* end confdefs.h.  */
13747 +
13748 + int
13749 + main ()
13750 + {
13751 +
13752 +  ;
13753 +  return 0;
13754 + }
13755 + _ACEOF
13756 + if ac_fn_c_try_compile "$LINENO"; then :
13757 +  ssp_cv_cc=yes
13758 + else
13759 +  ssp_cv_cc=no
13760 + fi
13761 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13762 +       CFLAGS="$ssp_old_cflags"
13763 +
13764 + fi
13765 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ssp_cv_cc" >&5
13766 + $as_echo "$ssp_cv_cc" >&6; }
13767 +    if test $ssp_cv_cc = yes; then
13768 +      CFLAGS="$CFLAGS -fstack-protector"
13769 +
13770 + $as_echo "#define ENABLE_SSP_CC 1" >>confdefs.h
13771 +
13772 +    fi
13773 +  fi
13774 +
13775 +
13776 +
13777    ac_fn_c_check_func "$LINENO" "getaddrinfo" "ac_cv_func_getaddrinfo"
13778   if test "x$ac_cv_func_getaddrinfo" = xyes; then :
13779  
# Line 14389 | Line 14435 | fi
14435   fi
14436  
14437  
14438 +
14439 +
14440   # Check whether --enable-openssl was given.
14441   if test "${enable_openssl+set}" = set; then :
14442    enableval=$enable_openssl;  cf_enable_openssl=$enableval
# Line 14586 | Line 14634 | fi
14634  
14635  
14636  
14637 +
14638   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable the poll() event engine" >&5
14639   $as_echo_n "checking whether to enable the poll() event engine... " >&6; }
14640   # Check whether --enable-poll was given.
# Line 14892 | Line 14941 | fi
14941      CFLAGS="-Wall -g -O0"
14942    fi
14943  
14944 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts " >&5
14945 + $as_echo_n "checking whether C compiler accepts ... " >&6; }
14946 + if ${ax_cv_check_cflags__+:} false; then :
14947 +  $as_echo_n "(cached) " >&6
14948 + else
14949 +
14950 +  ax_check_save_flags=$CFLAGS
14951 +  CFLAGS="$CFLAGS  "
14952 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14953 + /* end confdefs.h.  */
14954 +
14955 + int
14956 + main ()
14957 + {
14958 +
14959 +  ;
14960 +  return 0;
14961 + }
14962 + _ACEOF
14963 + if ac_fn_c_try_compile "$LINENO"; then :
14964 +  ax_cv_check_cflags__=yes
14965 + else
14966 +  ax_cv_check_cflags__=no
14967 + fi
14968 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14969 +  CFLAGS=$ax_check_save_flags
14970 + fi
14971 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_check_cflags__" >&5
14972 + $as_echo "$ax_cv_check_cflags__" >&6; }
14973 + if test x"$ax_cv_check_cflags__" = xyes; then :
14974 +  :
14975 + else
14976 +  :
14977 + fi
14978 +
14979 + if ${CFLAGS+:} false; then :
14980 +  case " $CFLAGS " in
14981 +    *"  "*)
14982 +      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains "; } >&5
14983 +  (: CFLAGS already contains ) 2>&5
14984 +  ac_status=$?
14985 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14986 +  test $ac_status = 0; }
14987 +      ;;
14988 +    *)
14989 +      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \""; } >&5
14990 +  (: CFLAGS="$CFLAGS ") 2>&5
14991 +  ac_status=$?
14992 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14993 +  test $ac_status = 0; }
14994 +      CFLAGS="$CFLAGS "
14995 +      ;;
14996 +   esac
14997 + else
14998 +  CFLAGS=""
14999 + fi
15000 +
15001  
15002    # Check whether --enable-warnings was given.
15003   if test "${enable_warnings+set}" = set; then :
# Line 14901 | Line 15007 | else
15007   fi
15008  
15009    if test "$warnings" = "yes" ; then
15010 <    CFLAGS="-Wall -Wextra -Wno-unused -Wcast-qual -Wcast-align -Wbad-function-cast -Wmissing-declarations -Wmissing-prototypes -Wnested-externs -Wredundant-decls -Wshadow -Wwrite-strings -Wundef"
15010 >
15011 >
15012 > for flag in -Wall; do
15013 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
15014 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
15015 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
15016 > if eval \${$as_CACHEVAR+:} false; then :
15017 >  $as_echo_n "(cached) " >&6
15018 > else
15019 >
15020 >  ax_check_save_flags=$CFLAGS
15021 >  CFLAGS="$CFLAGS  $flag"
15022 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
15023 > /* end confdefs.h.  */
15024 >
15025 > int
15026 > main ()
15027 > {
15028 >
15029 >  ;
15030 >  return 0;
15031 > }
15032 > _ACEOF
15033 > if ac_fn_c_try_compile "$LINENO"; then :
15034 >  eval "$as_CACHEVAR=yes"
15035 > else
15036 >  eval "$as_CACHEVAR=no"
15037 > fi
15038 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
15039 >  CFLAGS=$ax_check_save_flags
15040 > fi
15041 > eval ac_res=\$$as_CACHEVAR
15042 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
15043 > $as_echo "$ac_res" >&6; }
15044 > if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
15045 >  if ${CFLAGS+:} false; then :
15046 >  case " $CFLAGS " in
15047 >    *" $flag "*)
15048 >      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
15049 >  (: CFLAGS already contains $flag) 2>&5
15050 >  ac_status=$?
15051 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15052 >  test $ac_status = 0; }
15053 >      ;;
15054 >    *)
15055 >      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
15056 >  (: CFLAGS="$CFLAGS $flag") 2>&5
15057 >  ac_status=$?
15058 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15059 >  test $ac_status = 0; }
15060 >      CFLAGS="$CFLAGS $flag"
15061 >      ;;
15062 >   esac
15063 > else
15064 >  CFLAGS="$flag"
15065 > fi
15066 >
15067 > else
15068 >  :
15069 > fi
15070 >
15071 > done
15072 >
15073 >
15074 >
15075 > for flag in -Wextra; do
15076 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
15077 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
15078 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
15079 > if eval \${$as_CACHEVAR+:} false; then :
15080 >  $as_echo_n "(cached) " >&6
15081 > else
15082 >
15083 >  ax_check_save_flags=$CFLAGS
15084 >  CFLAGS="$CFLAGS  $flag"
15085 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
15086 > /* end confdefs.h.  */
15087 >
15088 > int
15089 > main ()
15090 > {
15091 >
15092 >  ;
15093 >  return 0;
15094 > }
15095 > _ACEOF
15096 > if ac_fn_c_try_compile "$LINENO"; then :
15097 >  eval "$as_CACHEVAR=yes"
15098 > else
15099 >  eval "$as_CACHEVAR=no"
15100 > fi
15101 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
15102 >  CFLAGS=$ax_check_save_flags
15103 > fi
15104 > eval ac_res=\$$as_CACHEVAR
15105 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
15106 > $as_echo "$ac_res" >&6; }
15107 > if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
15108 >  if ${CFLAGS+:} false; then :
15109 >  case " $CFLAGS " in
15110 >    *" $flag "*)
15111 >      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
15112 >  (: CFLAGS already contains $flag) 2>&5
15113 >  ac_status=$?
15114 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15115 >  test $ac_status = 0; }
15116 >      ;;
15117 >    *)
15118 >      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
15119 >  (: CFLAGS="$CFLAGS $flag") 2>&5
15120 >  ac_status=$?
15121 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15122 >  test $ac_status = 0; }
15123 >      CFLAGS="$CFLAGS $flag"
15124 >      ;;
15125 >   esac
15126 > else
15127 >  CFLAGS="$flag"
15128 > fi
15129 >
15130 > else
15131 >  :
15132 > fi
15133 >
15134 > done
15135 >
15136 >
15137 >
15138 > for flag in -Wno-unused; do
15139 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
15140 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
15141 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
15142 > if eval \${$as_CACHEVAR+:} false; then :
15143 >  $as_echo_n "(cached) " >&6
15144 > else
15145 >
15146 >  ax_check_save_flags=$CFLAGS
15147 >  CFLAGS="$CFLAGS  $flag"
15148 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
15149 > /* end confdefs.h.  */
15150 >
15151 > int
15152 > main ()
15153 > {
15154 >
15155 >  ;
15156 >  return 0;
15157 > }
15158 > _ACEOF
15159 > if ac_fn_c_try_compile "$LINENO"; then :
15160 >  eval "$as_CACHEVAR=yes"
15161 > else
15162 >  eval "$as_CACHEVAR=no"
15163 > fi
15164 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
15165 >  CFLAGS=$ax_check_save_flags
15166 > fi
15167 > eval ac_res=\$$as_CACHEVAR
15168 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
15169 > $as_echo "$ac_res" >&6; }
15170 > if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
15171 >  if ${CFLAGS+:} false; then :
15172 >  case " $CFLAGS " in
15173 >    *" $flag "*)
15174 >      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
15175 >  (: CFLAGS already contains $flag) 2>&5
15176 >  ac_status=$?
15177 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15178 >  test $ac_status = 0; }
15179 >      ;;
15180 >    *)
15181 >      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
15182 >  (: CFLAGS="$CFLAGS $flag") 2>&5
15183 >  ac_status=$?
15184 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15185 >  test $ac_status = 0; }
15186 >      CFLAGS="$CFLAGS $flag"
15187 >      ;;
15188 >   esac
15189 > else
15190 >  CFLAGS="$flag"
15191 > fi
15192 >
15193 > else
15194 >  :
15195 > fi
15196 >
15197 > done
15198 >
15199 >
15200 >
15201 > for flag in -Wcast-qual; do
15202 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
15203 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
15204 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
15205 > if eval \${$as_CACHEVAR+:} false; then :
15206 >  $as_echo_n "(cached) " >&6
15207 > else
15208 >
15209 >  ax_check_save_flags=$CFLAGS
15210 >  CFLAGS="$CFLAGS  $flag"
15211 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
15212 > /* end confdefs.h.  */
15213 >
15214 > int
15215 > main ()
15216 > {
15217 >
15218 >  ;
15219 >  return 0;
15220 > }
15221 > _ACEOF
15222 > if ac_fn_c_try_compile "$LINENO"; then :
15223 >  eval "$as_CACHEVAR=yes"
15224 > else
15225 >  eval "$as_CACHEVAR=no"
15226 > fi
15227 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
15228 >  CFLAGS=$ax_check_save_flags
15229 > fi
15230 > eval ac_res=\$$as_CACHEVAR
15231 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
15232 > $as_echo "$ac_res" >&6; }
15233 > if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
15234 >  if ${CFLAGS+:} false; then :
15235 >  case " $CFLAGS " in
15236 >    *" $flag "*)
15237 >      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
15238 >  (: CFLAGS already contains $flag) 2>&5
15239 >  ac_status=$?
15240 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15241 >  test $ac_status = 0; }
15242 >      ;;
15243 >    *)
15244 >      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
15245 >  (: CFLAGS="$CFLAGS $flag") 2>&5
15246 >  ac_status=$?
15247 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15248 >  test $ac_status = 0; }
15249 >      CFLAGS="$CFLAGS $flag"
15250 >      ;;
15251 >   esac
15252 > else
15253 >  CFLAGS="$flag"
15254 > fi
15255 >
15256 > else
15257 >  :
15258 > fi
15259 >
15260 > done
15261 >
15262 >
15263 >
15264 > for flag in -Wcast-align; do
15265 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
15266 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
15267 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
15268 > if eval \${$as_CACHEVAR+:} false; then :
15269 >  $as_echo_n "(cached) " >&6
15270 > else
15271 >
15272 >  ax_check_save_flags=$CFLAGS
15273 >  CFLAGS="$CFLAGS  $flag"
15274 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
15275 > /* end confdefs.h.  */
15276 >
15277 > int
15278 > main ()
15279 > {
15280 >
15281 >  ;
15282 >  return 0;
15283 > }
15284 > _ACEOF
15285 > if ac_fn_c_try_compile "$LINENO"; then :
15286 >  eval "$as_CACHEVAR=yes"
15287 > else
15288 >  eval "$as_CACHEVAR=no"
15289 > fi
15290 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
15291 >  CFLAGS=$ax_check_save_flags
15292 > fi
15293 > eval ac_res=\$$as_CACHEVAR
15294 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
15295 > $as_echo "$ac_res" >&6; }
15296 > if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
15297 >  if ${CFLAGS+:} false; then :
15298 >  case " $CFLAGS " in
15299 >    *" $flag "*)
15300 >      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
15301 >  (: CFLAGS already contains $flag) 2>&5
15302 >  ac_status=$?
15303 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15304 >  test $ac_status = 0; }
15305 >      ;;
15306 >    *)
15307 >      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
15308 >  (: CFLAGS="$CFLAGS $flag") 2>&5
15309 >  ac_status=$?
15310 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15311 >  test $ac_status = 0; }
15312 >      CFLAGS="$CFLAGS $flag"
15313 >      ;;
15314 >   esac
15315 > else
15316 >  CFLAGS="$flag"
15317 > fi
15318 >
15319 > else
15320 >  :
15321 > fi
15322 >
15323 > done
15324 >
15325 >
15326 >
15327 > for flag in -Wbad-function-cast; do
15328 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
15329 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
15330 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
15331 > if eval \${$as_CACHEVAR+:} false; then :
15332 >  $as_echo_n "(cached) " >&6
15333 > else
15334 >
15335 >  ax_check_save_flags=$CFLAGS
15336 >  CFLAGS="$CFLAGS  $flag"
15337 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
15338 > /* end confdefs.h.  */
15339 >
15340 > int
15341 > main ()
15342 > {
15343 >
15344 >  ;
15345 >  return 0;
15346 > }
15347 > _ACEOF
15348 > if ac_fn_c_try_compile "$LINENO"; then :
15349 >  eval "$as_CACHEVAR=yes"
15350 > else
15351 >  eval "$as_CACHEVAR=no"
15352 > fi
15353 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
15354 >  CFLAGS=$ax_check_save_flags
15355 > fi
15356 > eval ac_res=\$$as_CACHEVAR
15357 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
15358 > $as_echo "$ac_res" >&6; }
15359 > if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
15360 >  if ${CFLAGS+:} false; then :
15361 >  case " $CFLAGS " in
15362 >    *" $flag "*)
15363 >      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
15364 >  (: CFLAGS already contains $flag) 2>&5
15365 >  ac_status=$?
15366 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15367 >  test $ac_status = 0; }
15368 >      ;;
15369 >    *)
15370 >      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
15371 >  (: CFLAGS="$CFLAGS $flag") 2>&5
15372 >  ac_status=$?
15373 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15374 >  test $ac_status = 0; }
15375 >      CFLAGS="$CFLAGS $flag"
15376 >      ;;
15377 >   esac
15378 > else
15379 >  CFLAGS="$flag"
15380 > fi
15381 >
15382 > else
15383 >  :
15384 > fi
15385 >
15386 > done
15387 >
15388 >
15389 >
15390 > for flag in -Wmissing-declarations; do
15391 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
15392 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
15393 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
15394 > if eval \${$as_CACHEVAR+:} false; then :
15395 >  $as_echo_n "(cached) " >&6
15396 > else
15397 >
15398 >  ax_check_save_flags=$CFLAGS
15399 >  CFLAGS="$CFLAGS  $flag"
15400 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
15401 > /* end confdefs.h.  */
15402 >
15403 > int
15404 > main ()
15405 > {
15406 >
15407 >  ;
15408 >  return 0;
15409 > }
15410 > _ACEOF
15411 > if ac_fn_c_try_compile "$LINENO"; then :
15412 >  eval "$as_CACHEVAR=yes"
15413 > else
15414 >  eval "$as_CACHEVAR=no"
15415 > fi
15416 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
15417 >  CFLAGS=$ax_check_save_flags
15418 > fi
15419 > eval ac_res=\$$as_CACHEVAR
15420 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
15421 > $as_echo "$ac_res" >&6; }
15422 > if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
15423 >  if ${CFLAGS+:} false; then :
15424 >  case " $CFLAGS " in
15425 >    *" $flag "*)
15426 >      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
15427 >  (: CFLAGS already contains $flag) 2>&5
15428 >  ac_status=$?
15429 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15430 >  test $ac_status = 0; }
15431 >      ;;
15432 >    *)
15433 >      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
15434 >  (: CFLAGS="$CFLAGS $flag") 2>&5
15435 >  ac_status=$?
15436 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15437 >  test $ac_status = 0; }
15438 >      CFLAGS="$CFLAGS $flag"
15439 >      ;;
15440 >   esac
15441 > else
15442 >  CFLAGS="$flag"
15443 > fi
15444 >
15445 > else
15446 >  :
15447 > fi
15448 >
15449 > done
15450 >
15451 >
15452 >
15453 > for flag in -Wmissing-prototypes; do
15454 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
15455 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
15456 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
15457 > if eval \${$as_CACHEVAR+:} false; then :
15458 >  $as_echo_n "(cached) " >&6
15459 > else
15460 >
15461 >  ax_check_save_flags=$CFLAGS
15462 >  CFLAGS="$CFLAGS  $flag"
15463 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
15464 > /* end confdefs.h.  */
15465 >
15466 > int
15467 > main ()
15468 > {
15469 >
15470 >  ;
15471 >  return 0;
15472 > }
15473 > _ACEOF
15474 > if ac_fn_c_try_compile "$LINENO"; then :
15475 >  eval "$as_CACHEVAR=yes"
15476 > else
15477 >  eval "$as_CACHEVAR=no"
15478 > fi
15479 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
15480 >  CFLAGS=$ax_check_save_flags
15481 > fi
15482 > eval ac_res=\$$as_CACHEVAR
15483 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
15484 > $as_echo "$ac_res" >&6; }
15485 > if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
15486 >  if ${CFLAGS+:} false; then :
15487 >  case " $CFLAGS " in
15488 >    *" $flag "*)
15489 >      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
15490 >  (: CFLAGS already contains $flag) 2>&5
15491 >  ac_status=$?
15492 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15493 >  test $ac_status = 0; }
15494 >      ;;
15495 >    *)
15496 >      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
15497 >  (: CFLAGS="$CFLAGS $flag") 2>&5
15498 >  ac_status=$?
15499 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15500 >  test $ac_status = 0; }
15501 >      CFLAGS="$CFLAGS $flag"
15502 >      ;;
15503 >   esac
15504 > else
15505 >  CFLAGS="$flag"
15506 > fi
15507 >
15508 > else
15509 >  :
15510 > fi
15511 >
15512 > done
15513 >
15514 >
15515 >
15516 > for flag in -Wnested-externs; do
15517 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
15518 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
15519 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
15520 > if eval \${$as_CACHEVAR+:} false; then :
15521 >  $as_echo_n "(cached) " >&6
15522 > else
15523 >
15524 >  ax_check_save_flags=$CFLAGS
15525 >  CFLAGS="$CFLAGS  $flag"
15526 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
15527 > /* end confdefs.h.  */
15528 >
15529 > int
15530 > main ()
15531 > {
15532 >
15533 >  ;
15534 >  return 0;
15535 > }
15536 > _ACEOF
15537 > if ac_fn_c_try_compile "$LINENO"; then :
15538 >  eval "$as_CACHEVAR=yes"
15539 > else
15540 >  eval "$as_CACHEVAR=no"
15541 > fi
15542 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
15543 >  CFLAGS=$ax_check_save_flags
15544 > fi
15545 > eval ac_res=\$$as_CACHEVAR
15546 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
15547 > $as_echo "$ac_res" >&6; }
15548 > if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
15549 >  if ${CFLAGS+:} false; then :
15550 >  case " $CFLAGS " in
15551 >    *" $flag "*)
15552 >      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
15553 >  (: CFLAGS already contains $flag) 2>&5
15554 >  ac_status=$?
15555 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15556 >  test $ac_status = 0; }
15557 >      ;;
15558 >    *)
15559 >      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
15560 >  (: CFLAGS="$CFLAGS $flag") 2>&5
15561 >  ac_status=$?
15562 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15563 >  test $ac_status = 0; }
15564 >      CFLAGS="$CFLAGS $flag"
15565 >      ;;
15566 >   esac
15567 > else
15568 >  CFLAGS="$flag"
15569 > fi
15570 >
15571 > else
15572 >  :
15573 > fi
15574 >
15575 > done
15576 >
15577 >
15578 >
15579 > for flag in -Wredundant-decls; do
15580 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
15581 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
15582 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
15583 > if eval \${$as_CACHEVAR+:} false; then :
15584 >  $as_echo_n "(cached) " >&6
15585 > else
15586 >
15587 >  ax_check_save_flags=$CFLAGS
15588 >  CFLAGS="$CFLAGS  $flag"
15589 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
15590 > /* end confdefs.h.  */
15591 >
15592 > int
15593 > main ()
15594 > {
15595 >
15596 >  ;
15597 >  return 0;
15598 > }
15599 > _ACEOF
15600 > if ac_fn_c_try_compile "$LINENO"; then :
15601 >  eval "$as_CACHEVAR=yes"
15602 > else
15603 >  eval "$as_CACHEVAR=no"
15604 > fi
15605 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
15606 >  CFLAGS=$ax_check_save_flags
15607 > fi
15608 > eval ac_res=\$$as_CACHEVAR
15609 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
15610 > $as_echo "$ac_res" >&6; }
15611 > if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
15612 >  if ${CFLAGS+:} false; then :
15613 >  case " $CFLAGS " in
15614 >    *" $flag "*)
15615 >      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
15616 >  (: CFLAGS already contains $flag) 2>&5
15617 >  ac_status=$?
15618 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15619 >  test $ac_status = 0; }
15620 >      ;;
15621 >    *)
15622 >      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
15623 >  (: CFLAGS="$CFLAGS $flag") 2>&5
15624 >  ac_status=$?
15625 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15626 >  test $ac_status = 0; }
15627 >      CFLAGS="$CFLAGS $flag"
15628 >      ;;
15629 >   esac
15630 > else
15631 >  CFLAGS="$flag"
15632 > fi
15633 >
15634 > else
15635 >  :
15636 > fi
15637 >
15638 > done
15639 >
15640 >
15641 >
15642 > for flag in -Wshadow; do
15643 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
15644 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
15645 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
15646 > if eval \${$as_CACHEVAR+:} false; then :
15647 >  $as_echo_n "(cached) " >&6
15648 > else
15649 >
15650 >  ax_check_save_flags=$CFLAGS
15651 >  CFLAGS="$CFLAGS  $flag"
15652 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
15653 > /* end confdefs.h.  */
15654 >
15655 > int
15656 > main ()
15657 > {
15658 >
15659 >  ;
15660 >  return 0;
15661 > }
15662 > _ACEOF
15663 > if ac_fn_c_try_compile "$LINENO"; then :
15664 >  eval "$as_CACHEVAR=yes"
15665 > else
15666 >  eval "$as_CACHEVAR=no"
15667 > fi
15668 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
15669 >  CFLAGS=$ax_check_save_flags
15670 > fi
15671 > eval ac_res=\$$as_CACHEVAR
15672 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
15673 > $as_echo "$ac_res" >&6; }
15674 > if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
15675 >  if ${CFLAGS+:} false; then :
15676 >  case " $CFLAGS " in
15677 >    *" $flag "*)
15678 >      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
15679 >  (: CFLAGS already contains $flag) 2>&5
15680 >  ac_status=$?
15681 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15682 >  test $ac_status = 0; }
15683 >      ;;
15684 >    *)
15685 >      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
15686 >  (: CFLAGS="$CFLAGS $flag") 2>&5
15687 >  ac_status=$?
15688 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15689 >  test $ac_status = 0; }
15690 >      CFLAGS="$CFLAGS $flag"
15691 >      ;;
15692 >   esac
15693 > else
15694 >  CFLAGS="$flag"
15695 > fi
15696 >
15697 > else
15698 >  :
15699 > fi
15700 >
15701 > done
15702 >
15703 >
15704 >
15705 > for flag in -Wwrite-strings; do
15706 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
15707 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
15708 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
15709 > if eval \${$as_CACHEVAR+:} false; then :
15710 >  $as_echo_n "(cached) " >&6
15711 > else
15712 >
15713 >  ax_check_save_flags=$CFLAGS
15714 >  CFLAGS="$CFLAGS  $flag"
15715 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
15716 > /* end confdefs.h.  */
15717 >
15718 > int
15719 > main ()
15720 > {
15721 >
15722 >  ;
15723 >  return 0;
15724 > }
15725 > _ACEOF
15726 > if ac_fn_c_try_compile "$LINENO"; then :
15727 >  eval "$as_CACHEVAR=yes"
15728 > else
15729 >  eval "$as_CACHEVAR=no"
15730 > fi
15731 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
15732 >  CFLAGS=$ax_check_save_flags
15733 > fi
15734 > eval ac_res=\$$as_CACHEVAR
15735 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
15736 > $as_echo "$ac_res" >&6; }
15737 > if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
15738 >  if ${CFLAGS+:} false; then :
15739 >  case " $CFLAGS " in
15740 >    *" $flag "*)
15741 >      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
15742 >  (: CFLAGS already contains $flag) 2>&5
15743 >  ac_status=$?
15744 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15745 >  test $ac_status = 0; }
15746 >      ;;
15747 >    *)
15748 >      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
15749 >  (: CFLAGS="$CFLAGS $flag") 2>&5
15750 >  ac_status=$?
15751 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15752 >  test $ac_status = 0; }
15753 >      CFLAGS="$CFLAGS $flag"
15754 >      ;;
15755 >   esac
15756 > else
15757 >  CFLAGS="$flag"
15758 > fi
15759 >
15760 > else
15761 >  :
15762 > fi
15763 >
15764 > done
15765 >
15766 >
15767 >
15768 > for flag in -Wundef; do
15769 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
15770 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
15771 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
15772 > if eval \${$as_CACHEVAR+:} false; then :
15773 >  $as_echo_n "(cached) " >&6
15774 > else
15775 >
15776 >  ax_check_save_flags=$CFLAGS
15777 >  CFLAGS="$CFLAGS  $flag"
15778 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
15779 > /* end confdefs.h.  */
15780 >
15781 > int
15782 > main ()
15783 > {
15784 >
15785 >  ;
15786 >  return 0;
15787 > }
15788 > _ACEOF
15789 > if ac_fn_c_try_compile "$LINENO"; then :
15790 >  eval "$as_CACHEVAR=yes"
15791 > else
15792 >  eval "$as_CACHEVAR=no"
15793 > fi
15794 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
15795 >  CFLAGS=$ax_check_save_flags
15796 > fi
15797 > eval ac_res=\$$as_CACHEVAR
15798 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
15799 > $as_echo "$ac_res" >&6; }
15800 > if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
15801 >  if ${CFLAGS+:} false; then :
15802 >  case " $CFLAGS " in
15803 >    *" $flag "*)
15804 >      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
15805 >  (: CFLAGS already contains $flag) 2>&5
15806 >  ac_status=$?
15807 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15808 >  test $ac_status = 0; }
15809 >      ;;
15810 >    *)
15811 >      { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
15812 >  (: CFLAGS="$CFLAGS $flag") 2>&5
15813 >  ac_status=$?
15814 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15815 >  test $ac_status = 0; }
15816 >      CFLAGS="$CFLAGS $flag"
15817 >      ;;
15818 >   esac
15819 > else
15820 >  CFLAGS="$flag"
15821 > fi
15822 >
15823 > else
15824 >  :
15825 > fi
15826 >
15827 > done
15828 >
15829    fi
15830  
15831  

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines