Google

Back to the Main Page.

ac_cflags_check

Download the M4 Source.

Synopsis

Version

    guidod @ ac-archive-0.5.39

Author

Description

The AC_CFLAGS_WANT_NO_ macros do all have two arguments. The first flags the importance-level and the second an alternative shellvar and both can be omitted where the first will usually default to 0 or 1 or 2 and the second to the advertised CFLAGS variable where it gets appended.

All the importance-levels may be pushed as numeric or under a commmon name. "0" = "no" means disable (including warnings), "1" = "warn" means let the compiler warn at the construct if the compiler can be told to do so, "2" = "yes" means let the compiler run in that mode if a modeswitch option is available, and "3" = "strict" means to error-out if the compiler does not support the given feature.

The default for the second argument is CFLAGS (or CXXFLAGS for its cousin routines named AC_CXXFLAGS_WANT_) where the compiler-options are appended to but that can be overridden. Still, it will _append_ to that shell var.

All WANT-names follow the long-options from gcc. Therefore, if you look into `gcc --help -v` then you will largely be able to guess the name of the macro as some -fvolatile-global option would map to a macro name of AC_CFLAGS_WANT_VOLATILE_GLOBAL. A lot of function however map to a name of _WANT_NO_ where the default would be to have the feature enabled, e.g. AC_CFLAGS_WANT_NO_LONG_LONG (for -fno-long-long), and in some of these case the disable-word is turned into a simple _NO_, so you will -fomit-framepointer as AC_CFLAGS_WANT_NO_FRAMEPOINTER.

Note that a lot of macros can in fact never be feature-enabled as they are just plain warning-levels. Where we have a bunch of AC_CFLAGS_WANT_ and AC_CFLAGS_WANT_NO_ function, these do often have a cousin just named AC_CFLAGS_WARN_AT_ and AC_CFLAGS_NO_WARN_ respectivly.

Even though the names are gcc-oriented you will find that quite some of the macros contain code parts that enable the option to be enabled or disabled for other compilers - especially the native compilers of some operating systems like hpux, irix, aix, solaris. That's what makes these macros so powerful - you do not have to tes $GCC = yes, and you do not have to handle the different versions of GCC (the gcc3 has moved a lot of backend options -malign to be general options -falign). On the downside there are vast number of options in this file since gcc has so many and most are still only gcc. That's largely just convenience style.

(C) 2002 Guido Draheim, free license as of GNU autoconf.

M4 Source Code

dnl AC_CFLAGS_CHECK(levelignore, shellvar, optionname)
AC_DEFUN([AC_CFLAGS_CHECK],
[AC_CACHE_CHECK(whether ${CC-cc} accepts [$3], [$2],
[echo 'void f(){}' > conftest.c
if test -z "`${CC-cc} -c $3 conftest.c 2>&1`"; then
  m4_if($2,,CFLAGS,$2)="[$]m4_if($2,,CFLAGS,$2) $3"
fi
rm -f conftest*
])])

AC_DEFUN([AC_CXXFLAGS_CHECK],
[AC_CACHE_CHECK(whether ${CXX-c++} accepts [$3], [$2],
[echo 'void f(){}' > conftest.c
if test -z "`${CXX-c++} -c $3 conftest.c 2>&1`"; then
  m4_if($2,,CXXFLAGS,$2)="[$]m4_if($2,,CXXFLAGS,$2) $3"
fi
rm -f conftest*
])])

dnl do nothing when level=no, default-level=yes
dnl AC_CFLAGS_DO_WANT(level, shellvar, optionname, option-no-name, default)
AC_DEFUN([AC_CFLAGS_DO_WANT],
[case "m4_if([$1],,[yes],[$1])" in
  m4_if([$5],,[0|no],[$5])) ;; # skip - assumed the default
  0|no) AC_CFLAGS_CHECK($1,$2,$4) ;;
  *) AC_CFLAGS_CHECK($1,$2,$3) ;;
esac])

dnl do nothing when level=yes, default-level=no
dnl AC_CFLAGS_WANT_NO(level, shellvar, default, optionname, option-no-name)
AC_DEFUN([AC_CFLAGS_WANT_NO],
[case "m4_if([$1],,[no],[$1])" in
  m4_if($5,,1|2|3|warn|yes|strict,$5)) ;; # skip - assumed the default
  0|no) AC_CFLAGS_CHECK($1,$2,$4) ;;
  *) AC_CFLAGS_CHECK($1,$2,$3) ;;
esac])


dnl do nothing when level=no, default-level=yes
dnl AC_CXXFLAGS_DO_WANT(level, shellvar, optionname, option-no-name, default)
AC_DEFUN([AC_CXXFLAGS_DO_WANT],
[case "m4_if([$1],,[yes],[$1])" in
  m4_if([$5],,[0|no],[$5])) ;; # skip - assumed the default
  0|no) AC_CXXFLAGS_CHECK($1,$2,$4) ;;
  *) AC_CXXFLAGS_CHECK($1,$2,$3) ;;
esac])

dnl do nothing when level=yes, default-level=no
dnl AC_CXXFLAGS_WANT_NO(level, shellvar, default, optionname, option-no-name)
AC_DEFUN([AC_CXXFLAGS_WANT_NO],
[case "m4_if([$1],,[no],[$1])" in
  m4_if($5,,1|2|3|warn|yes|strict,$5)) ;; # skip - assumed the default
  0|no) AC_CXXFLAGS_CHECK($1,$2,$4) ;;
  *) AC_CXXFLAGS_CHECK($1,$2,$3) ;;
esac])



dnl warn if trigraphs are encounted
AC_DEFUN([AC_CFLAGS_WARN_AT_TRIGRAPHS],
[AC_CFLAGS_DO_WANT([$1],[$2],[-Wtrigraphs],[-Wno-trigraphs])])

AC_DEFUN([AC_CFLAGS_NO_WARN_TRIGRAPHS],
[AC_CFLAGS_WANT_NO([$1],[$2],[-Wtrigraphs],[-Wno-trigraphs])])

dnl warn if one comment starts inside another
AC_DEFUN([AC_CFLAGS_WARN_AT_COMMENTS],
[AC_CFLAGS_DO_WANT([$1],[$2],[-Wcomments],[-Wno-comments])])

AC_DEFUN([AC_CFLAGS_NO_WARN_COMMENTS],
[AC_CFLAGS_WANT_NO([$1],[$2],[-Wcomments],[-Wno-comments])])

AC_DEFUN([AC_CXXFLAGS_WARN_AT_COMMENTS],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-Wcomments],[-Wno-comments])])

AC_DEFUN([AC_CXXFLAGS_NO_WARN_COMMENTS],
[AC_CXXFLAGS_WANT_NO([$1],[$2],[-Wcomments],[-Wno-comments])])

dnl warn bout features not present in traditional C
AC_DEFUN([AC_CFLAGS_WARN_AT_TRADITIONAL],
[AC_CFLAGS_DO_WANT([$1],[$2],[-Wtraditional],[-Wno-traditional])])

AC_DEFUN([AC_CFLAGS_NO_WARN_TRADITIONAL],
[AC_CFLAGS_WANT_NO([$1],[$2],[-Wtraditional],[-Wno-traditional])])

dnl warn if an undefined macro is used by %:if
AC_DEFUN([AC_CFLAGS_WARN_AT_UNDEF],
[AC_CFLAGS_DO_WANT([$1],[$2],[-Wundef],[-Wno-undef])])

AC_DEFUN([AC_CFLAGS_NO_WARN_UNDEF],
[AC_CFLAGS_WANT_NO([$1],[$2],[-Wundef],[-Wno-undef])])

AC_DEFUN([AC_CXXFLAGS_WARN_AT_UNDEF],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-Wundef],[-Wno-undef])])

AC_DEFUN([AC_CXXFLAGS_NO_WARN_UNDEF],
[AC_CXXFLAGS_WANT_NO([$1],[$2],[-Wundef],[-Wno-undef])])

dnl suppress warnings from system headers
AC_DEFUN([AC_CFLAGS_NO_WARN_SYSTEM_HEADERS],
[AC_CFLAGS_WANT_NO([$1],[$2],[-Wsystem-headers],[-Wno-system-headers])])

AC_DEFUN([AC_CFLAGS_WARN_AT_SYSTEM_HEADERS],
[AC_CFLAGS_DO_WANT([$1],[$2],[-Wsystem-headers],[-Wno-system-headers])])

AC_DEFUN([AC_CXXFLAGS_NO_WARN_SYSTEM_HEADERS],
[AC_CFLAGS_WANT_NO([$1],[$2],[-Wsystem-headers],[-Wno-system-headers])])

AC_DEFUN([AC_CXXFLAGS_WARN_AT_SYSTEM_HEADERS],
[AC_CFLAGS_DO_WANT([$1],[$2],[-Wsystem-headers],[-Wno-system-headers])])

dnl combined warnings
AC_DEFUN([AC_CFLAGS_WARN_ALL],
[AC_CFLAGS_DO_WANT([$1],[$2],[-Wall])])

AC_DEFUN([AC_CFLAGS_WARN_EXTRA],
[AC_CFLAGS_DO_WANT([$1],[$2],[-W])])

AC_DEFUN([AC_CXXFLAGS_WARN_ALL],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-Wall])])

AC_DEFUN([AC_CXXFLAGS_WARN_EXTRA],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-W])])

dnl report on permanent memory allocation at end of run
AC_DEFUN([AC_CFLAGS_WANT_MEM_REPORT],
[AC_CFLAGS_DO_WANT([$1],[$2],[-fmem-report])])

AC_DEFUN([AC_CXXFLAGS_WANT_MEM_REPORT],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-fmem-report])])

dnl report time taken by each compiler pass at end of run
AC_DEFUN([AC_CFLAGS_WANT_TIME_REPORT],
[AC_CFLAGS_DO_WANT([$1],[$2],[-ftime-report])])

AC_DEFUN([AC_CXXFLAGS_WANT_TIME_REPORT],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-ftime-report])])

dnl convert floting point constant to single precision constant
AC_DEFUN([AC_CFLAGS_WANT_SINGLE_PRECISION_CONSTANT],
[AC_CFLAGS_DO_WANT([$1],[$2],[-fsingle-precision-constant])])

AC_DEFUN([AC_CXXFLAGS_WANT_SINGLE_PRECISION_CONSTANT],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-fsingle-precision-constant])])

dnl generate code to check bounds before dereferencing pointers and arrays
AC_DEFUN([AC_CFLAGS_WANT_BOUNDS_CHECK],
[AC_CFLAGS_DO_WANT([$1],[$2],[-fbounds-check])])

AC_DEFUN([AC_CXXFLAGS_WANT_BOUNDS_CHECK],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-fbounds-check])])

dnl compile pointers as triples: value, base and end
AC_DEFUN([AC_CFLAGS_WANT_BOUNDED_POINTERS],
[AC_CFLAGS_DO_WANT([$1],[$2],[-fbounded-pointers])])

AC_DEFUN([AC_CXXFLAGS_WANT_BOUNDED_POINTERS],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-fbounded-pointers])])

dnl allow math optimizations that may violate IEEE or ANSI standards
AC_DEFUN([AC_CFLAGS_WANT_UNSAFE_MATH_OPTIMIZATIONS],
[AC_CFLAGS_DO_WANT([$1],[$2],[-funsafe-math-optimizations])])

AC_DEFUN([AC_CXXFLAGS_WANT_UNSAFE_MATH_OPTIMIZATIONS],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-funsafe-math-optimizations])])

dnl floating-point operations can trap
AC_DEFUN([AC_CFLAGS_WANT_TRAPPING_MATH],
[AC_CFLAGS_DO_WANT([$1],[$2],[-ftrapping-math])])

AC_DEFUN([AC_CXXFLAGS_WANT_TRAPPING_MATH],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-ftrapping-math])])

dnl set errno after built-in math functions
AC_DEFUN([AC_CFLAGS_WANT_MATH_ERRNO],
[AC_CFLAGS_DO_WANT([$1],[$2],[-fmath-errno])])

AC_DEFUN([AC_CXXFLAGS_WANT_MATH_ERRNO],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-fmath-errno])])

dnl enables guessing of branch probabilities
AC_DEFUN([AC_CFLAGS_WANT_GUESS_BRANCH_PROBABILITY],
[AC_CFLAGS_DO_WANT([$1],[$2],[-fguess-branch-probability])])

AC_DEFUN([AC_CXXFLAGS_WANT_GUESS_BRANCH_PROBABILITY],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-fguess-branch-probability])])

dnl external symbols have a leading underscore
AC_DEFUN([AC_CFLAGS_WANT_LEADING_UNDERSCORE],
[AC_CFLAGS_DO_WANT([$1],[$2],
	[-fleading-underscore],[-fno-leading-underscore])])

AC_DEFUN([AC_CFLAGS_WANT_NO_LEADING_UNDERSCORE],
[AC_CFLAGS_WANT_NO([$1],[$2],
	[-fleading-underscore],[-fno-leading-underscore])])

AC_DEFUN([AC_CXXFLAGS_WANT_LEADING_UNDERSCORE],
[AC_CXXFLAGS_DO_WANT([$1],[$2],
	[-fleading-underscore],[-fno-leading-underscore])])

AC_DEFUN([AC_CXXFLAGS_WANT_NO_LEADING_UNDERSCORE],
[AC_CXXFLAGS_WANT_NO([$1],[$2],
	[-fleading-underscore],[-fno-leading-underscore])])

dnl insert stack checking code into the program
AC_DEFUN([AC_CFLAGS_WANT_STACK_CHECK],
[AC_CFLAGS_DO_WANT([$1],[$2],[-fstack-check])])

AC_DEFUN([AC_CXXFLAGS_WANT_STACK_CHECK],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-fstack-check])])

dnl do not put uninitialized globals into the common section
AC_DEFUN([AC_CFLAGS_WANT_NO_COMMON],
[AC_CFLAGS_WANT_NO([$1],[$2],[-fcommon],[-fno-common])])

AC_DEFUN([AC_CXXFLAGS_WANT_NO_COMMON],
[AC_CXXFLAGS_WANT_NO([$1],[$2],[-fcommon],[-fno-common])])

dnl enable exception handling
AC_DEFUN([AC_CXXFLAGS_WANT_EXCEPTIONS],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-fexceptions],[-fno-exceptions])])

AC_DEFUN([AC_CXXFLAGS_WANT_NO_EXCEPTIONS],
[AC_CXXFLAGS_WANT_NO([$1],[$2],[-fexceptions],[-fno-exceptions])])

dnl do not perform the global common subexpression elimination
AC_DEFUN([AC_CFLAGS_WANT_NO_GCSE],
[AC_CFLAGS_WANT_NO([$1],[$2],[-fgsce],[-fno-gsce])])

AC_DEFUN([AC_CXXFLAGS_WANT_NO_GCSE],
[AC_CXXFLAGS_WANT_NO([$1],[$2],[-fgsce],[-fno-gsce])])

dnl do not respect the "inline" keyword
AC_DEFUN([AC_CFLAGS_WANT_NO_INLINE],
[AC_CFLAGS_WANT_NO([$1],[$2],[-finline],[-fno-inline])])

AC_DEFUN([AC_CXXFLAGS_WANT_NO_INLINE],
[AC_CXXFLAGS_WANT_NO([$1],[$2],[-finline],[-fno-inline])])

dnl integrate simple functions into their callers
AC_DEFUN([AC_CFLAGS_WANT_INLINE_FUNCTIONS],
[AC_CFLAGS_DO_WANT([$1],[$2],[-finline-functions],[-fno-inline-functions])])

AC_DEFUN([AC_CFLAGS_WANT_NO_INLINE_FUNCTIONS],
[AC_CFLAGS_WANT_NO([$1],[$2],[-finline-functions],[-fno-inline-functions])])

AC_DEFUN([AC_CXXFLAGS_WANT_INLINE_FUNCTIONS],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-finline-functions],[-fno-inline-functions])])

AC_DEFUN([AC_CXXFLAGS_WANT_NO_INLINE_FUNCTIONS],
[AC_CXXFLAGS_WANT_NO([$1],[$2],[-finline-functions],[-fno-inline-functions])])

dnl integrate simple functions into their callers
AC_DEFUN([AC_CFLAGS_WANT_KEEP_INLINE_FUNCTIONS],
[AC_CFLAGS_DO_WANT([$1],[$2],
  [-fkeep-inline-functions],[-fno-keep-inline-functions])])

AC_DEFUN([AC_CFLAGS_WANT_NO_KEEP_INLINE_FUNCTIONS],
[AC_CFLAGS_WANT_NO([$1],[$2],
  [-fkeep-inline-functions],[-fno-keep-inline-functions])])

AC_DEFUN([AC_CXXFLAGS_WANT_KEEP_INLINE_FUNCTIONS],
[AC_CXXFLAGS_DO_WANT([$1],[$2],
  [-fkeep-inline-functions],[-fno-keep-inline-functions])])

AC_DEFUN([AC_CXXFLAGS_WANT_NO_KEEP_INLINE_FUNCTIONS],
[AC_CXXFLAGS_WANT_NO([$1],[$2],
  [-fkeep-inline-functions],[-fno-keep-inline-functions])])

dnl ac_cflags_want_no_writable_strings -> ac_prog_cc_no_writable_strings

dnl when possible do not generate stack frames
AC_DEFUN([AC_CFLAGS_WANT_NO_FRAME_POINTER],
[AC_CFLAGS_WANT_NO([$1],[$2],
  [-fno-omit-frame-pointer],[-fomit-frame-pointer])])

AC_DEFUN([AC_CXXFLAGS_WANT_NO_FRAME_POINTER],
[AC_CXXFLAGS_WANT_NO([$1],[$2],
  [-fno-omit-frame-pointer],[-fomit-frame-pointer])])

dnl defer popping functions args from stack until later
AC_DEFUN([AC_CFLAGS_WANT_DEFER_POP],
[AC_CFLAGS_DO_WANT([$1],[$2], [-fdefer-pop],[-fno-defer-pop])])

AC_DEFUN([AC_CXXFLAGS_WANT_DEFER_POP],
[AC_CXXFLAGS_DO_WANT([$1],[$2], [-fdefer-pop],[-fno-defer-pop])])

dnl consider all mem refs to static data to be volatile
AC_DEFUN([AC_CFLAGS_WANT_VOLATILE_STATIC],
[AC_CFLAGS_DO_WANT([$1],[$2], [-fvolatile-static],[-fno-volatile-static])])

AC_DEFUN([AC_CFLAGS_WANT_NO_VOLATILE_STATIC],
[AC_CFLAGS_WANT_NO([$1],[$2], [-fvolatile-static],[-fno-volatile-static])])

AC_DEFUN([AC_CXXFLAGS_WANT_VOLATILE_STATIC],
[AC_CXXFLAGS_DO_WANT([$1],[$2], [-fvolatile-static],[-fno-volatile-static])])

AC_DEFUN([AC_CXXFLAGS_WANT_NO_VOLATILE_STATIC],
[AC_CXXFLAGS_WANT_NO([$1],[$2], [-fvolatile-static],[-fno-volatile-static])])

dnl consider all mem refs to global data to be volatile
AC_DEFUN([AC_CFLAGS_WANT_VOLATILE_GLOBAL],
[AC_CFLAGS_DO_WANT([$1],[$2], [-fvolatile-global],[-fno-volatile-global])])

AC_DEFUN([AC_CFLAGS_WANT_NO_VOLATILE_GLOBAL],
[AC_CFLAGS_WANT_NO([$1],[$2], [-fvolatile-global],[-fno-volatile-global])])

AC_DEFUN([AC_CXXFLAGS_WANT_VOLATILE_GLOBAL],
[AC_CXXFLAGS_DO_WANT([$1],[$2], [-fvolatile-global],[-fno-volatile-global])])

AC_DEFUN([AC_CXXFLAGS_WANT_NO_VOLATILE_GLOBAL],
[AC_CXXFLAGS_WANT_NO([$1],[$2], [-fvolatile-global],[-fno-volatile-global])])

dnl consider all mem refs through pointers as volatile
AC_DEFUN([AC_CFLAGS_WANT_VOLATILE],
[AC_CFLAGS_DO_WANT([$1],[$2], [-fvolatile],[-fno-volatile])])

AC_DEFUN([AC_CFLAGS_WANT_NO_VOLATILE],
[AC_CFLAGS_WANT_NO([$1],[$2], [-fvolatile],[-fno-volatile])])

AC_DEFUN([AC_CXXFLAGS_WANT_VOLATILE],
[AC_CXXFLAGS_DO_WANT([$1],[$2], [-fvolatile],[-fno-volatile])])

AC_DEFUN([AC_CXXFLAGS_WANT_NO_VOLATILE],
[AC_CXXFLAGS_WANT_NO([$1],[$2], [-fvolatile],[-fno-volatile])])

dnl warn about functions which might be candidates for attribute noreturn
AC_DEFUN([AC_CFLAGS_WARN_AT_MISSING_NORETURN],
[AC_CFLAGS_DO_WANT([$1],[$2],[-Wmissing-noreturn],[-Wno-missing-noreturn])])

AC_DEFUN([AC_CFLAGS_NO_WARN_MISSING_NORETURN],
[AC_CFLAGS_WANT_NO([$1],[$2],[-Wmissing-noreturn],[-Wno-missing-noreturn])])

AC_DEFUN([AC_CXXFLAGS_WARN_AT_MISSING_NORETURN],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-Wmissing-noreturn],[-Wno-missing-noreturn])])

AC_DEFUN([AC_CXXFLAGS_NO_WARN_MISSING_NORETURN],
[AC_CXXFLAGS_WANT_NO([$1],[$2],[-Wmissing-noreturn],[-Wno-missing-noreturn])])

dnl warn when padding is required to align struct members
AC_DEFUN([AC_CFLAGS_WARN_AT_PADDED],
[AC_CFLAGS_DO_WANT([$1],[$2],[-Wpadded],[-Wno-padded])])

AC_DEFUN([AC_CFLAGS_NO_WARN_PADDED],
[AC_CFLAGS_WANT_NO([$1],[$2],[-Wpadded],[-Wno-padded])])

AC_DEFUN([AC_CXXFLAGS_WARN_AT_PADDED],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-Wpadded],[-Wno-padded])])

AC_DEFUN([AC_CXXFLAGS_NO_WARN_PADDED],
[AC_CXXFLAGS_WANT_NO([$1],[$2],[-Wpadded],[-Wno-padded])])

dnl warn when the packed attribute has no effect on struct layout
AC_DEFUN([AC_CFLAGS_WARN_AT_PACKED],
[AC_CFLAGS_DO_WANT([$1],[$2],[-Wpacked],[-Wno-packed])])

AC_DEFUN([AC_CFLAGS_NO_WARN_PACKED],
[AC_CFLAGS_WANT_NO([$1],[$2],[-Wpacked],[-Wno-packed])])

AC_DEFUN([AC_CXXFLAGS_WARN_AT_PACKED],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-Wpacked],[-Wno-packed])])

AC_DEFUN([AC_CXXFLAGS_NO_WARN_PACKED],
[AC_CXXFLAGS_WANT_NO([$1],[$2],[-Wpacked],[-Wno-packed])])

dnl warn when an inlined function cannot be inlined
AC_DEFUN([AC_CFLAGS_WARN_AT_INLINE],
[AC_CFLAGS_DO_WANT([$1],[$2],[-Winline],[-Wno-inline])])

AC_DEFUN([AC_CFLAGS_NO_WARN_INLINE],
[AC_CFLAGS_WANT_NO([$1],[$2],[-Winline],[-Wno-inline])])

AC_DEFUN([AC_CXXFLAGS_WARN_AT_INLINE],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-Winline],[-Wno-inline])])

AC_DEFUN([AC_CXXFLAGS_NO_WARN_INLINE],
[AC_CXXFLAGS_WANT_NO([$1],[$2],[-Winline],[-Wno-inline])])

dnl warn about uninitialized automatic variables
AC_DEFUN([AC_CFLAGS_WARN_AT_UNINITIALIZED],
[AC_CFLAGS_DO_WANT([$1],[$2],[-Wuninitialized],[-Wno-uninitialized])])

AC_DEFUN([AC_CFLAGS_NO_WARN_UNINITIALIZED],
[AC_CFLAGS_WANT_NO([$1],[$2],[-Wuninitialized],[-Wno-uninitialized])])

dnl warn about code that will never be executed
AC_DEFUN([AC_CFLAGS_WARN_AT_UNREACHABLE_CODE],
[AC_CFLAGS_DO_WANT([$1],[$2],[-Wunreachable-code],[-Wno-unreachable-code])])

AC_DEFUN([AC_CFLAGS_NO_WARN_UNREACHABLE_CODE],
[AC_CFLAGS_WANT_NO([$1],[$2],[-Wunreachable-code],[-Wno-unreachable-code])])

AC_DEFUN([AC_CXXFLAGS_WARN_AT_UNREACHABLE_CODE],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-Wunreachable-code],[-Wno-unreachable-code])])

AC_DEFUN([AC_CXXFLAGS_NO_WARN_UNREACHABLE_CODE],
[AC_CXXFLAGS_WANT_NO([$1],[$2],[-Wunreachable-code],[-Wno-unreachable-code])])

dnl ac_cflags_want_unsigned_char -> ..................

dnl do not recognize any built in functions
AC_DEFUN([AC_CFLAGS_WANT_NO_BUILTINS],
[AC_CFLAGS_WANT_NO([$1],[$2],[-fno-builtin],[-fbuiltin])])

dnl assume that libc (and main) do not exist
AC_DEFUN([AC_CFLAGS_WANT_FREESTANDING],
[AC_CFLAGS_DO_WANT([$1],[$2],[-ffreestanding],[-fno-freestanding])])

dnl allow the use of dollar-sign inside identifiers
AC_DEFUN([AC_CFLAGS_WANT_DOLLARS_IN_IDENTIFIERS],
[AC_CFLAGS_DO_WANT([$1],[$2],[-fdollars-in-identifiers])])

dnl ................................ C++ ..............................

dnl check the return value of new
AC_DEFUN([AC_CXXFLAGS_WANT_CHECK_NEW],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-fcheck-new],[-fno-check-new])])

AC_DEFUN([AC_CXXFLAGS_WANT_NO_CHECK_NEW],
[AC_CXXFLAGS_WANT_NO([$1],[$2],[-fcheck-new],[-fno-check-new])])

dnl do not inline member functions by default
AC_DEFUN([AC_CXXFLAGS_WANT_NO_DEFAULT_INLINE],
[AC_CXXFLAGS_WANT_NO([$1],[$2],[-fdefault-inline],[-fno-default-inline])])

AC_DEFUN([AC_CXXFLAGS_WANT_DEFAULT_INLINE],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-fdefault-inline],[-fno-default-inline])])

dnl do not generate run time type descriptor information
AC_DEFUN([AC_CXXFLAGS_WANT_NO_RTTI],
[AC_CXXFLAGS_WANT_NO([$1],[$2],[-frtti],[-fno-rtti])])

AC_DEFUN([AC_CXXFLAGS_WANT_RTTI],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-frtti],[-fno-rtti])])

dnl do not generate code to check exception specifications
AC_DEFUN([AC_CXXFLAGS_WANT_NO_ENFORCE_EH_SPECS],
[AC_CXXFLAGS_WANT_NO([$1],[$2],[-fenforce-eh-specs],[-fno-enforce-eh-specs])])

AC_DEFUN([AC_CXXFLAGS_WANT_ENFORCE_EH_SPECS],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-fenforce-eh-specs],[-fno-enforce-eh-specs])])

dnl export functions even if they can be inlined
AC_DEFUN([AC_CXXFLAGS_WANT_NO_IMPLEMENT_INLINES],
[AC_CXXFLAGS_WANT_NO([$1],[$2],[-fimplement-inlines],-fno-implement-inlines)])

AC_DEFUN([AC_CXXFLAGS_WANT_IMPLEMENT_INLINES],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-fimplement-inlines],-fno-implement-inlines)])

dnl only emit expclit template instantiations
AC_DEFUN([AC_CXXFLAGS_WANT_NO_IMPLICIT_TEMPLATES],
[AC_CXXFLAGS_WANT_NO([$1],[$2],
	[-fimplicit-templates],[-fno-implicit-templates])])

AC_DEFUN([AC_CXXFLAGS_WANT_IMPLICIT_TEMPLATES],
[AC_CXXFLAGS_DO_WANT([$1],[$2],
	[-fimplicit-templates],[-fno-implicit-templates])])

dnl only emit expclit template instantiations of inline templates
AC_DEFUN([AC_CXXFLAGS_WANT_NO_IMPLICIT-INLINE_TEMPLATES],
[AC_CXXFLAGS_WANT_NO([$1],[$2],
	[-fimplicit-inline-templates],[-fno-implicit-inline-templates])])

AC_DEFUN([AC_CXXFLAGS_WANT_IMPLICIT-INLINE_TEMPLATES],
[AC_CXXFLAGS_DO_WANT([$1],[$2],
	[-fimplicit-inline-templates],[-fno-implicit-inline-templates])])

dnl warn about inconsistent return types
AC_DEFUN([AC_CXXFLAGS_WARN_AT_RETURN_TYPE],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-Wreturn-type],[-Wno-return-type])])

AC_DEFUN([AC_CXXFLAGS_NO_WARN_RETURN_TYPE],
[AC_CXXFLAGS_WANT_NO([$1],[$2],[-Wreturn-type],[-Wno-return-type])])

dnl warn about overloaded virtual function names
AC_DEFUN([AC_CXXFLAGS_WARN_AT_OVERLOADED_VIRTUAL],
[AC_CXXFLAGS_DO_WANT([$1],[$2],
	[-Woverloaded-virtual],[-Wno-overloaded-virtual])])

AC_DEFUN([AC_CXXFLAGS_NO_WARN_OVERLOADED_VIRTUAL],
[AC_CXXFLAGS_WANT_NO([$1],[$2],
	[-Woverloaded-virtual],[-Wno-overloaded-virtual])])

dnl warn about non virtual destructors
AC_DEFUN([AC_CXXFLAGS_WARN_AT_NON_VIRTUAL_DTOR],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-Wnon-virtual-dtor],[-Wno-non-virtual-dtor])])

AC_DEFUN([AC_CXXFLAGS_NO_WARN_NON_VIRTUAL_DTOR],
[AC_CXXFLAGS_WANT_NO([$1],[$2],[-Wnon-virtual-dtor],[-Wno-non-virtual-dtor])])

dnl warn when the compiler reorders code (e.g. constructor list)
AC_DEFUN([AC_CXXFLAGS_WARN_AT_REORDER],
[AC_CXXFLAGS_DO_WANT([$1],[$2],[-Wreorder],[-Wno-reorder])])

AC_DEFUN([AC_CXXFLAGS_NO_WARN_REORDER],
[AC_CXXFLAGS_WANT_NO([$1],[$2],[-Wreorder],[-Wno-reorder])])