[thirdparty/gcc.git] / libstdc++-v3 / linkage.m4

dnl
dnl This file contains macros for testing linkage.
dnl

dnl
dnl Check to see if the (math function) argument passed is
dnl declared when using the c++ compiler
dnl ASSUMES argument is a math function with ONE parameter
dnl
dnl GLIBCXX_CHECK_MATH_DECL_1
AC_DEFUN([GLIBCXX_CHECK_MATH_DECL_1], [
  AC_MSG_CHECKING([for $1 declaration])
  if test x${glibcxx_cv_func_$1_use+set} != xset; then
    AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
      AC_LANG_SAVE
      AC_LANG_CPLUSPLUS
      AC_TRY_COMPILE([#include <math.h>
		      #ifdef HAVE_IEEEFP_H
		      #include <ieeefp.h>
		      #endif
		     ],
                     [ $1(0);],
                      [glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
      AC_LANG_RESTORE
    ])
  fi
  AC_MSG_RESULT($glibcxx_cv_func_$1_use)
])


dnl 
dnl Define autoheader template for using the underscore functions
dnl For each parameter, create a macro where if func doesn't exist,
dnl but _func does, then it will "#define func _func".
dnl
dnl GLIBCXX_MAYBE_UNDERSCORED_FUNCS
AC_DEFUN([GLIBCXX_MAYBE_UNDERSCORED_FUNCS], 
[AC_FOREACH([glibcxx_ufunc], [$1],
  [AH_VERBATIM(_[]glibcxx_ufunc,
[#if defined (]AS_TR_CPP(HAVE__[]glibcxx_ufunc)[) && ! defined (]AS_TR_CPP(HAVE_[]glibcxx_ufunc)[)
# define ]AS_TR_CPP(HAVE_[]glibcxx_ufunc)[ 1
# define ]glibcxx_ufunc[ _]glibcxx_ufunc[
#endif])])
])


dnl
dnl Check to see if the (math function) argument passed is
dnl 1) declared when using the c++ compiler
dnl 2) has "C" linkage
dnl 3) if not, see if 1) and 2) for argument prepended with '_'
dnl
dnl Define HAVE_CARGF etc if "cargf" is declared and links
dnl
dnl argument 1 is name of function to check
dnl
dnl ASSUMES argument is a math function with ONE parameter
dnl
dnl GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1
AC_DEFUN([GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1], [
  GLIBCXX_CHECK_MATH_DECL_1($1)
  if test x$glibcxx_cv_func_$1_use = x"yes"; then
    AC_CHECK_FUNCS($1)
  else
    GLIBCXX_CHECK_MATH_DECL_1(_$1)
    if test x$glibcxx_cv_func__$1_use = x"yes"; then
      AC_CHECK_FUNCS(_$1)
    fi
  fi
  GLIBCXX_MAYBE_UNDERSCORED_FUNCS($1)
])


dnl
dnl Like GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1, but does a bunch of
dnl of functions at once.  It's an all-or-nothing check -- either
dnl HAVE_XYZ is defined for each of the functions, or for none of them.
dnl Doing it this way saves significant configure time.
AC_DEFUN([GLIBCXX_CHECK_MATH_DECLS_AND_LINKAGES_1], [
  define([funclist],patsubst($3,\(\w+\)\(\W*\),\1 ))dnl
  AC_MSG_CHECKING([for $1 functions])
  AC_CACHE_VAL(glibcxx_cv_func_$2_use, [
    AC_LANG_SAVE
    AC_LANG_CPLUSPLUS
    AC_TRY_COMPILE([#include <math.h>],
                   patsubst(funclist,[\w+],[\& (0);]),
                   [glibcxx_cv_func_$2_use=yes],
                   [glibcxx_cv_func_$2_use=no])
    AC_LANG_RESTORE])
  AC_MSG_RESULT($glibcxx_cv_func_$2_use)
  if test x$glibcxx_cv_func_$2_use = x"yes"; then
    AC_CHECK_FUNCS(funclist)
  else
    AC_MSG_CHECKING([for _$1 functions])
    AC_CACHE_VAL(glibcxx_cv_func__$2_use, [
      AC_LANG_SAVE
      AC_LANG_CPLUSPLUS
      AC_TRY_COMPILE([#include <math.h>],
                     patsubst(funclist,[\w+],[_\& (0);]),
                     [glibcxx_cv_func__$2_use=yes],
                     [glibcxx_cv_func__$2_use=no])
      AC_LANG_RESTORE])
    AC_MSG_RESULT($glibcxx_cv_func__$2_use)
    if test x$glibcxx_cv_func__$2_use = x"yes"; then
      AC_CHECK_FUNCS(patsubst(funclist,[\w+],[_\&]))
    fi
  fi
  GLIBCXX_MAYBE_UNDERSCORED_FUNCS(funclist)
  undefine([funclist])
])

dnl
dnl Check to see if the (math function) argument passed is
dnl declared when using the c++ compiler
dnl ASSUMES argument is a math function with TWO parameters
dnl
dnl GLIBCXX_CHECK_MATH_DECL_2
AC_DEFUN([GLIBCXX_CHECK_MATH_DECL_2], [
  AC_MSG_CHECKING([for $1 declaration])
  if test x${glibcxx_cv_func_$1_use+set} != xset; then
    AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
      AC_LANG_SAVE
      AC_LANG_CPLUSPLUS
      AC_TRY_COMPILE([#include <math.h>],
                     [ $1(0, 0);],
                     [glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
      AC_LANG_RESTORE
    ])
  fi
  AC_MSG_RESULT($glibcxx_cv_func_$1_use)
])

dnl
dnl Check to see if the (math function) argument passed is
dnl 1) declared when using the c++ compiler
dnl 2) has "C" linkage
dnl
dnl Define HAVE_CARGF etc if "cargf" is declared and links
dnl
dnl argument 1 is name of function to check
dnl
dnl ASSUMES argument is a math function with TWO parameters
dnl
dnl GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2
AC_DEFUN([GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2], [
  GLIBCXX_CHECK_MATH_DECL_2($1)
  if test x$glibcxx_cv_func_$1_use = x"yes"; then
    AC_CHECK_FUNCS($1)
  else
    GLIBCXX_CHECK_MATH_DECL_2(_$1)
    if test x$glibcxx_cv_func__$1_use = x"yes"; then
      AC_CHECK_FUNCS(_$1)
    fi
  fi
  GLIBCXX_MAYBE_UNDERSCORED_FUNCS($1)
])


dnl
dnl Check to see if the (math function) argument passed is
dnl declared when using the c++ compiler
dnl ASSUMES argument is a math function with THREE parameters
dnl
dnl GLIBCXX_CHECK_MATH_DECL_3
AC_DEFUN([GLIBCXX_CHECK_MATH_DECL_3], [
  AC_MSG_CHECKING([for $1 declaration])
  if test x${glibcxx_cv_func_$1_use+set} != xset; then
    AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
      AC_LANG_SAVE
      AC_LANG_CPLUSPLUS
      AC_TRY_COMPILE([#include <math.h>],
                     [ $1(0, 0, 0);],
                     [glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
      AC_LANG_RESTORE
    ])
  fi
  AC_MSG_RESULT($glibcxx_cv_func_$1_use)
])

dnl
dnl Check to see if the (math function) argument passed is
dnl 1) declared when using the c++ compiler
dnl 2) has "C" linkage
dnl
dnl Define HAVE_CARGF etc if "cargf" is declared and links
dnl
dnl argument 1 is name of function to check
dnl
dnl ASSUMES argument is a math function with THREE parameters
dnl
dnl GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_3
AC_DEFUN([GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_3], [
  GLIBCXX_CHECK_MATH_DECL_3($1)
  if test x$glibcxx_cv_func_$1_use = x"yes"; then
    AC_CHECK_FUNCS($1)
  else
    GLIBCXX_CHECK_MATH_DECL_3(_$1)
    if test x$glibcxx_cv_func__$1_use = x"yes"; then
      AC_CHECK_FUNCS(_$1)
    fi
  fi
  GLIBCXX_MAYBE_UNDERSCORED_FUNCS($1)
])


dnl
dnl Check to see if the (stdlib function) argument passed is
dnl 1) declared when using the c++ compiler
dnl 2) has "C" linkage
dnl
dnl argument 1 is name of function to check
dnl
dnl ASSUMES argument is a stdlib function without parameters
dnl
dnl GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_0
AC_DEFUN([GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_0], [
  AC_MSG_CHECKING([for $1 declaration])
  if test x${glibcxx_cv_func_$1_use+set} != xset; then
    AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
      AC_LANG_SAVE
      AC_LANG_CPLUSPLUS
      AC_TRY_COMPILE([#include <stdlib.h>],
                     [ $1();],
                     [glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
      AC_LANG_RESTORE
    ])
  fi
  AC_MSG_RESULT($glibcxx_cv_func_$1_use)
  if test x$glibcxx_cv_func_$1_use = x"yes"; then
    AC_CHECK_FUNCS($1)
  fi
])


dnl
dnl Check to see if the (stdlib function) argument passed is
dnl 1) declared when using the c++ compiler
dnl 2) has "C" linkage
dnl
dnl argument 1 is name of function to check
dnl
dnl ASSUMES argument is a stdlib function with ONE parameter
dnl
dnl GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_1
AC_DEFUN([GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_1], [
  AC_MSG_CHECKING([for $1 declaration])
  if test x${glibcxx_cv_func_$1_use+set} != xset; then
    AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
      AC_LANG_SAVE
      AC_LANG_CPLUSPLUS
      AC_TRY_COMPILE([#include <stdlib.h>],
                     [ $1(0);],
                     [glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
      AC_LANG_RESTORE
    ])
  fi
  AC_MSG_RESULT($glibcxx_cv_func_$1_use)
  if test x$glibcxx_cv_func_$1_use = x"yes"; then
    AC_CHECK_FUNCS($1)
  fi
])


dnl
dnl Check to see if the (stdlib function) argument passed is
dnl 1) declared when using the c++ compiler
dnl 2) has "C" linkage
dnl
dnl argument 1 is name of function to check
dnl
dnl ASSUMES argument is a stdlib function with TWO parameters
dnl
dnl GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_2
AC_DEFUN([GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_2], [
  AC_MSG_CHECKING([for $1 declaration])
  if test x${glibcxx_cv_func_$1_use+set} != xset; then
    AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
      AC_LANG_SAVE
      AC_LANG_CPLUSPLUS
      AC_TRY_COMPILE([#include <stdlib.h>],
                     [ $1(0, 0);],
                     [glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
      AC_LANG_RESTORE
    ])
  fi
  AC_MSG_RESULT($glibcxx_cv_func_$1_use)
  if test x$glibcxx_cv_func_$1_use = x"yes"; then
    AC_CHECK_FUNCS($1)
  fi
  GLIBCXX_MAYBE_UNDERSCORED_FUNCS($1)
])


dnl
dnl Check to see if the (stdlib function) argument passed is
dnl 1) declared when using the c++ compiler
dnl 2) has "C" linkage
dnl
dnl argument 1 is name of function to check
dnl
dnl ASSUMES argument is a stdlib function with THREE parameters
dnl
dnl GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3
AC_DEFUN([GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3], [
  AC_MSG_CHECKING([for $1 declaration])
  if test x${glibcxx_cv_func_$1_use+set} != xset; then
    AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
      AC_LANG_SAVE
      AC_LANG_CPLUSPLUS
      AC_TRY_COMPILE([#include <stdlib.h>],
                     [ $1(0, 0, 0);],
                     [glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
      AC_LANG_RESTORE
    ])
  fi
  AC_MSG_RESULT($glibcxx_cv_func_$1_use)
  if test x$glibcxx_cv_func_$1_use = x"yes"; then
    AC_CHECK_FUNCS($1)
  fi
])

dnl
dnl Check to see what the underlying c library is like
dnl These checks need to do two things:
dnl 1) make sure the name is declared when using the c++ compiler
dnl 2) make sure the name has "C" linkage
dnl This might seem like overkill but experience has shown that it's not...
dnl
dnl Define HAVE_STRTOLD if "strtold" is declared and links
dnl Define HAVE_STRTOF if "strtof" is declared and links
dnl
dnl GLIBCXX_CHECK_STDLIB_SUPPORT
AC_DEFUN([GLIBCXX_CHECK_STDLIB_SUPPORT], [
  ac_test_CXXFLAGS="${CXXFLAGS+set}"
  ac_save_CXXFLAGS="$CXXFLAGS"
  CXXFLAGS='-fno-builtin -D_GNU_SOURCE'

  GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_1(at_quick_exit)
  GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_1(quick_exit)
  GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_2(strtold)
  GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_2(strtof)

  CXXFLAGS="$ac_save_CXXFLAGS"
])

dnl
dnl Check to see what the underlying c library or math library is like.
dnl These checks need to do two things:
dnl 1) make sure the name is declared when using the c++ compiler
dnl 2) make sure the name has "C" linkage
dnl This might seem like overkill but experience has shown that it's not...
dnl
dnl Define HAVE_CARGF etc if "cargf" is found.
dnl
dnl GLIBCXX_CHECK_MATH_SUPPORT
AC_DEFUN([GLIBCXX_CHECK_MATH_SUPPORT], [
  ac_test_CXXFLAGS="${CXXFLAGS+set}"
  ac_save_CXXFLAGS="$CXXFLAGS"
  CXXFLAGS='-fno-builtin -D_GNU_SOURCE'

  dnl Check libm
  AC_CHECK_LIB(m, sin, libm="-lm")
  ac_save_LIBS="$LIBS"
  LIBS="$LIBS $libm"

  dnl Check to see if certain C math functions exist.
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(isinf)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(isnan)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(finite)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_3(sincos)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(fpclass)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(qfpclass)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(hypot)

  dnl Check to see if basic C math functions have float versions.
  GLIBCXX_CHECK_MATH_DECLS_AND_LINKAGES_1(float trig,
                                          float_trig,
                                          acosf asinf atanf \
                                          cosf sinf tanf \
                                          coshf sinhf tanhf)
  GLIBCXX_CHECK_MATH_DECLS_AND_LINKAGES_1(float round,
                                          float_round,
                                          ceilf floorf)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(expf)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(isnanf)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(isinff)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(atan2f)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(fabsf)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(fmodf)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(frexpf)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(hypotf)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(ldexpf)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(logf)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(log10f)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(modff)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(modf)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(powf)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(sqrtf)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_3(sincosf)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(finitef)

  dnl Check to see if basic C math functions have long double versions.
  GLIBCXX_CHECK_MATH_DECLS_AND_LINKAGES_1(long double trig,
                                          long_double_trig,
                                          acosl asinl atanl \
                                          cosl sinl tanl \
                                          coshl sinhl tanhl)
  GLIBCXX_CHECK_MATH_DECLS_AND_LINKAGES_1(long double round,
                                          long_double_round,
                                          ceill floorl)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(isnanl)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(isinfl)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(atan2l)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(expl)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(fabsl)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(fmodl)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(frexpl)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(hypotl)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(ldexpl)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(logl)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(log10l)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(modfl)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(powl)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(sqrtl)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_3(sincosl)
  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(finitel)

  LIBS="$ac_save_LIBS"
  CXXFLAGS="$ac_save_CXXFLAGS"
])
Commit	Line	Data
ff66d28f	1	dnl
92efec6e	2	dnl This file contains macros for testing linkage.
ff66d28f PE	3	dnl
	4
	5	dnl
	6	dnl Check to see if the (math function) argument passed is
	7	dnl declared when using the c++ compiler
	8	dnl ASSUMES argument is a math function with ONE parameter
	9	dnl
	10	dnl GLIBCXX_CHECK_MATH_DECL_1
f214923c	11	AC_DEFUN([GLIBCXX_CHECK_MATH_DECL_1], [
ff66d28f PE	12	AC_MSG_CHECKING([for $1 declaration])
	13	if test x${glibcxx_cv_func_$1_use+set} != xset; then
	14	AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
	15	AC_LANG_SAVE
	16	AC_LANG_CPLUSPLUS
	17	AC_TRY_COMPILE([#include <math.h>
	18	#ifdef HAVE_IEEEFP_H
	19	#include <ieeefp.h>
	20	#endif
	21	],
	22	[ $1(0);],
92efec6e	23	[glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
ff66d28f PE	24	AC_LANG_RESTORE
	25	])
	26	fi
	27	AC_MSG_RESULT($glibcxx_cv_func_$1_use)
	28	])
	29
3df45831	30
42dedaee KC	31	dnl
	32	dnl Define autoheader template for using the underscore functions
	33	dnl For each parameter, create a macro where if func doesn't exist,
	34	dnl but _func does, then it will "#define func _func".
	35	dnl
	36	dnl GLIBCXX_MAYBE_UNDERSCORED_FUNCS
	37	AC_DEFUN([GLIBCXX_MAYBE_UNDERSCORED_FUNCS],
	38	[AC_FOREACH([glibcxx_ufunc], [$1],
	39	[AH_VERBATIM(_[]glibcxx_ufunc,
	40	[#if defined (]AS_TR_CPP(HAVE__[]glibcxx_ufunc)[) && ! defined (]AS_TR_CPP(HAVE_[]glibcxx_ufunc)[)
	41	# define ]AS_TR_CPP(HAVE_[]glibcxx_ufunc)[ 1
	42	# define ]glibcxx_ufunc[ _]glibcxx_ufunc[
	43	#endif])])
	44	])
	45
	46
ff66d28f PE	47	dnl
	48	dnl Check to see if the (math function) argument passed is
	49	dnl 1) declared when using the c++ compiler
	50	dnl 2) has "C" linkage
	51	dnl 3) if not, see if 1) and 2) for argument prepended with '_'
	52	dnl
	53	dnl Define HAVE_CARGF etc if "cargf" is declared and links
	54	dnl
	55	dnl argument 1 is name of function to check
	56	dnl
	57	dnl ASSUMES argument is a math function with ONE parameter
	58	dnl
	59	dnl GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1
f214923c	60	AC_DEFUN([GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1], [
ff66d28f PE	61	GLIBCXX_CHECK_MATH_DECL_1($1)
	62	if test x$glibcxx_cv_func_$1_use = x"yes"; then
	63	AC_CHECK_FUNCS($1)
	64	else
	65	GLIBCXX_CHECK_MATH_DECL_1(_$1)
	66	if test x$glibcxx_cv_func__$1_use = x"yes"; then
	67	AC_CHECK_FUNCS(_$1)
	68	fi
	69	fi
42dedaee	70	GLIBCXX_MAYBE_UNDERSCORED_FUNCS($1)
ff66d28f PE	71	])
	72
	73
	74	dnl
	75	dnl Like GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1, but does a bunch of
	76	dnl of functions at once. It's an all-or-nothing check -- either
	77	dnl HAVE_XYZ is defined for each of the functions, or for none of them.
	78	dnl Doing it this way saves significant configure time.
f214923c	79	AC_DEFUN([GLIBCXX_CHECK_MATH_DECLS_AND_LINKAGES_1], [
3df45831	80	define([funclist],patsubst($3,\(\w+\)\(\W*\),\1 ))dnl
ff66d28f PE	81	AC_MSG_CHECKING([for $1 functions])
	82	AC_CACHE_VAL(glibcxx_cv_func_$2_use, [
	83	AC_LANG_SAVE
	84	AC_LANG_CPLUSPLUS
	85	AC_TRY_COMPILE([#include <math.h>],
3df45831	86	patsubst(funclist,[\w+],[\& (0);]),
ff66d28f PE	87	[glibcxx_cv_func_$2_use=yes],
	88	[glibcxx_cv_func_$2_use=no])
	89	AC_LANG_RESTORE])
	90	AC_MSG_RESULT($glibcxx_cv_func_$2_use)
	91	if test x$glibcxx_cv_func_$2_use = x"yes"; then
3df45831 KC	92	AC_CHECK_FUNCS(funclist)
	93	else
	94	AC_MSG_CHECKING([for _$1 functions])
	95	AC_CACHE_VAL(glibcxx_cv_func__$2_use, [
	96	AC_LANG_SAVE
	97	AC_LANG_CPLUSPLUS
	98	AC_TRY_COMPILE([#include <math.h>],
	99	patsubst(funclist,[\w+],[_\& (0);]),
	100	[glibcxx_cv_func__$2_use=yes],
	101	[glibcxx_cv_func__$2_use=no])
	102	AC_LANG_RESTORE])
	103	AC_MSG_RESULT($glibcxx_cv_func__$2_use)
	104	if test x$glibcxx_cv_func__$2_use = x"yes"; then
	105	AC_CHECK_FUNCS(patsubst(funclist,[\w+],[_\&]))
	106	fi
ff66d28f	107	fi
42dedaee	108	GLIBCXX_MAYBE_UNDERSCORED_FUNCS(funclist)
3df45831	109	undefine([funclist])
ff66d28f PE	110	])
	111
	112	dnl
	113	dnl Check to see if the (math function) argument passed is
	114	dnl declared when using the c++ compiler
	115	dnl ASSUMES argument is a math function with TWO parameters
	116	dnl
	117	dnl GLIBCXX_CHECK_MATH_DECL_2
f214923c	118	AC_DEFUN([GLIBCXX_CHECK_MATH_DECL_2], [
ff66d28f PE	119	AC_MSG_CHECKING([for $1 declaration])
	120	if test x${glibcxx_cv_func_$1_use+set} != xset; then
	121	AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
	122	AC_LANG_SAVE
	123	AC_LANG_CPLUSPLUS
	124	AC_TRY_COMPILE([#include <math.h>],
	125	[ $1(0, 0);],
	126	[glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
	127	AC_LANG_RESTORE
	128	])
	129	fi
	130	AC_MSG_RESULT($glibcxx_cv_func_$1_use)
	131	])
	132
	133	dnl
	134	dnl Check to see if the (math function) argument passed is
	135	dnl 1) declared when using the c++ compiler
	136	dnl 2) has "C" linkage
	137	dnl
	138	dnl Define HAVE_CARGF etc if "cargf" is declared and links
	139	dnl
	140	dnl argument 1 is name of function to check
	141	dnl
	142	dnl ASSUMES argument is a math function with TWO parameters
	143	dnl
	144	dnl GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2
f214923c	145	AC_DEFUN([GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2], [
ff66d28f PE	146	GLIBCXX_CHECK_MATH_DECL_2($1)
	147	if test x$glibcxx_cv_func_$1_use = x"yes"; then
	148	AC_CHECK_FUNCS($1)
	149	else
	150	GLIBCXX_CHECK_MATH_DECL_2(_$1)
	151	if test x$glibcxx_cv_func__$1_use = x"yes"; then
	152	AC_CHECK_FUNCS(_$1)
	153	fi
	154	fi
42dedaee	155	GLIBCXX_MAYBE_UNDERSCORED_FUNCS($1)
ff66d28f PE	156	])
	157
	158
	159	dnl
	160	dnl Check to see if the (math function) argument passed is
	161	dnl declared when using the c++ compiler
	162	dnl ASSUMES argument is a math function with THREE parameters
	163	dnl
	164	dnl GLIBCXX_CHECK_MATH_DECL_3
f214923c	165	AC_DEFUN([GLIBCXX_CHECK_MATH_DECL_3], [
ff66d28f PE	166	AC_MSG_CHECKING([for $1 declaration])
	167	if test x${glibcxx_cv_func_$1_use+set} != xset; then
	168	AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
	169	AC_LANG_SAVE
	170	AC_LANG_CPLUSPLUS
	171	AC_TRY_COMPILE([#include <math.h>],
	172	[ $1(0, 0, 0);],
	173	[glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
	174	AC_LANG_RESTORE
	175	])
	176	fi
	177	AC_MSG_RESULT($glibcxx_cv_func_$1_use)
	178	])
	179
	180	dnl
	181	dnl Check to see if the (math function) argument passed is
	182	dnl 1) declared when using the c++ compiler
	183	dnl 2) has "C" linkage
	184	dnl
	185	dnl Define HAVE_CARGF etc if "cargf" is declared and links
	186	dnl
	187	dnl argument 1 is name of function to check
	188	dnl
	189	dnl ASSUMES argument is a math function with THREE parameters
	190	dnl
	191	dnl GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_3
f214923c	192	AC_DEFUN([GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_3], [
ff66d28f PE	193	GLIBCXX_CHECK_MATH_DECL_3($1)
	194	if test x$glibcxx_cv_func_$1_use = x"yes"; then
	195	AC_CHECK_FUNCS($1)
	196	else
	197	GLIBCXX_CHECK_MATH_DECL_3(_$1)
	198	if test x$glibcxx_cv_func__$1_use = x"yes"; then
	199	AC_CHECK_FUNCS(_$1)
	200	fi
	201	fi
42dedaee	202	GLIBCXX_MAYBE_UNDERSCORED_FUNCS($1)
ff66d28f PE	203	])
	204
	205
222a5b1d RO	206	dnl
	207	dnl Check to see if the (stdlib function) argument passed is
	208	dnl 1) declared when using the c++ compiler
	209	dnl 2) has "C" linkage
	210	dnl
	211	dnl argument 1 is name of function to check
	212	dnl
	213	dnl ASSUMES argument is a stdlib function without parameters
	214	dnl
	215	dnl GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_0
f214923c	216	AC_DEFUN([GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_0], [
222a5b1d RO	217	AC_MSG_CHECKING([for $1 declaration])
	218	if test x${glibcxx_cv_func_$1_use+set} != xset; then
	219	AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
	220	AC_LANG_SAVE
	221	AC_LANG_CPLUSPLUS
	222	AC_TRY_COMPILE([#include <stdlib.h>],
	223	[ $1();],
	224	[glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
	225	AC_LANG_RESTORE
	226	])
	227	fi
	228	AC_MSG_RESULT($glibcxx_cv_func_$1_use)
	229	if test x$glibcxx_cv_func_$1_use = x"yes"; then
	230	AC_CHECK_FUNCS($1)
	231	fi
	232	])
	233
	234
cc999d03 JM	235	dnl
	236	dnl Check to see if the (stdlib function) argument passed is
	237	dnl 1) declared when using the c++ compiler
	238	dnl 2) has "C" linkage
	239	dnl
	240	dnl argument 1 is name of function to check
	241	dnl
	242	dnl ASSUMES argument is a stdlib function with ONE parameter
	243	dnl
	244	dnl GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_1
	245	AC_DEFUN([GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_1], [
	246	AC_MSG_CHECKING([for $1 declaration])
	247	if test x${glibcxx_cv_func_$1_use+set} != xset; then
	248	AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
	249	AC_LANG_SAVE
	250	AC_LANG_CPLUSPLUS
	251	AC_TRY_COMPILE([#include <stdlib.h>],
	252	[ $1(0);],
	253	[glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
	254	AC_LANG_RESTORE
	255	])
	256	fi
	257	AC_MSG_RESULT($glibcxx_cv_func_$1_use)
	258	if test x$glibcxx_cv_func_$1_use = x"yes"; then
	259	AC_CHECK_FUNCS($1)
	260	fi
	261	])
	262
	263
ff66d28f PE	264	dnl
	265	dnl Check to see if the (stdlib function) argument passed is
	266	dnl 1) declared when using the c++ compiler
	267	dnl 2) has "C" linkage
	268	dnl
	269	dnl argument 1 is name of function to check
	270	dnl
747d0b96	271	dnl ASSUMES argument is a stdlib function with TWO parameters
ff66d28f PE	272	dnl
ff66d28f PE	273	dnl GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_2
f214923c	274	AC_DEFUN([GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_2], [
ff66d28f PE	275	AC_MSG_CHECKING([for $1 declaration])
	276	if test x${glibcxx_cv_func_$1_use+set} != xset; then
	277	AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
	278	AC_LANG_SAVE
	279	AC_LANG_CPLUSPLUS
	280	AC_TRY_COMPILE([#include <stdlib.h>],
	281	[ $1(0, 0);],
	282	[glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
	283	AC_LANG_RESTORE
	284	])
	285	fi
	286	AC_MSG_RESULT($glibcxx_cv_func_$1_use)
	287	if test x$glibcxx_cv_func_$1_use = x"yes"; then
	288	AC_CHECK_FUNCS($1)
	289	fi
42dedaee	290	GLIBCXX_MAYBE_UNDERSCORED_FUNCS($1)
ff66d28f PE	291	])
	292
	293
	294	dnl
	295	dnl Check to see if the (stdlib function) argument passed is
	296	dnl 1) declared when using the c++ compiler
	297	dnl 2) has "C" linkage
	298	dnl
	299	dnl argument 1 is name of function to check
	300	dnl
747d0b96	301	dnl ASSUMES argument is a stdlib function with THREE parameters
ff66d28f PE	302	dnl
ff66d28f PE	303	dnl GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3
f214923c	304	AC_DEFUN([GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3], [
ff66d28f PE	305	AC_MSG_CHECKING([for $1 declaration])
	306	if test x${glibcxx_cv_func_$1_use+set} != xset; then
	307	AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
	308	AC_LANG_SAVE
	309	AC_LANG_CPLUSPLUS
	310	AC_TRY_COMPILE([#include <stdlib.h>],
	311	[ $1(0, 0, 0);],
	312	[glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
	313	AC_LANG_RESTORE
	314	])
	315	fi
	316	AC_MSG_RESULT($glibcxx_cv_func_$1_use)
	317	if test x$glibcxx_cv_func_$1_use = x"yes"; then
	318	AC_CHECK_FUNCS($1)
	319	fi
	320	])
	321
ff66d28f PE	322	dnl
	323	dnl Check to see what the underlying c library is like
	324	dnl These checks need to do two things:
	325	dnl 1) make sure the name is declared when using the c++ compiler
	326	dnl 2) make sure the name has "C" linkage
	327	dnl This might seem like overkill but experience has shown that it's not...
	328	dnl
	329	dnl Define HAVE_STRTOLD if "strtold" is declared and links
	330	dnl Define HAVE_STRTOF if "strtof" is declared and links
ff66d28f PE	331	dnl
ff66d28f PE	332	dnl GLIBCXX_CHECK_STDLIB_SUPPORT
f214923c	333	AC_DEFUN([GLIBCXX_CHECK_STDLIB_SUPPORT], [
ff66d28f PE	334	ac_test_CXXFLAGS="${CXXFLAGS+set}"
	335	ac_save_CXXFLAGS="$CXXFLAGS"
	336	CXXFLAGS='-fno-builtin -D_GNU_SOURCE'
	337
cc999d03 JM	338	GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_1(at_quick_exit)
cc999d03 JM	339	GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_1(quick_exit)
ff66d28f PE	340	GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_2(strtold)
ff66d28f PE	341	GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_2(strtof)
ff66d28f PE	342
	343	CXXFLAGS="$ac_save_CXXFLAGS"
	344	])
	345
	346	dnl
	347	dnl Check to see what the underlying c library or math library is like.
	348	dnl These checks need to do two things:
	349	dnl 1) make sure the name is declared when using the c++ compiler
	350	dnl 2) make sure the name has "C" linkage
	351	dnl This might seem like overkill but experience has shown that it's not...
	352	dnl
	353	dnl Define HAVE_CARGF etc if "cargf" is found.
	354	dnl
	355	dnl GLIBCXX_CHECK_MATH_SUPPORT
f214923c	356	AC_DEFUN([GLIBCXX_CHECK_MATH_SUPPORT], [
ff66d28f PE	357	ac_test_CXXFLAGS="${CXXFLAGS+set}"
	358	ac_save_CXXFLAGS="$CXXFLAGS"
	359	CXXFLAGS='-fno-builtin -D_GNU_SOURCE'
	360
	361	dnl Check libm
	362	AC_CHECK_LIB(m, sin, libm="-lm")
	363	ac_save_LIBS="$LIBS"
	364	LIBS="$LIBS $libm"
	365
	366	dnl Check to see if certain C math functions exist.
	367	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(isinf)
	368	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(isnan)
	369	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(finite)
ff66d28f PE	370	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_3(sincos)
	371	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(fpclass)
	372	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(qfpclass)
	373	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(hypot)
	374
	375	dnl Check to see if basic C math functions have float versions.
	376	GLIBCXX_CHECK_MATH_DECLS_AND_LINKAGES_1(float trig,
	377	float_trig,
	378	acosf asinf atanf \
	379	cosf sinf tanf \
	380	coshf sinhf tanhf)
	381	GLIBCXX_CHECK_MATH_DECLS_AND_LINKAGES_1(float round,
	382	float_round,
	383	ceilf floorf)
	384	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(expf)
	385	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(isnanf)
	386	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(isinff)
	387	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(atan2f)
	388	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(fabsf)
	389	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(fmodf)
	390	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(frexpf)
	391	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(hypotf)
	392	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(ldexpf)
	393	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(logf)
	394	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(log10f)
	395	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(modff)
3a642d50	396	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(modf)
ff66d28f PE	397	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(powf)
	398	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(sqrtf)
	399	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_3(sincosf)
	400	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(finitef)
	401
	402	dnl Check to see if basic C math functions have long double versions.
	403	GLIBCXX_CHECK_MATH_DECLS_AND_LINKAGES_1(long double trig,
	404	long_double_trig,
	405	acosl asinl atanl \
	406	cosl sinl tanl \
	407	coshl sinhl tanhl)
	408	GLIBCXX_CHECK_MATH_DECLS_AND_LINKAGES_1(long double round,
	409	long_double_round,
	410	ceill floorl)
	411	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(isnanl)
	412	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(isinfl)
ff66d28f PE	413	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(atan2l)
	414	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(expl)
	415	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(fabsl)
	416	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(fmodl)
	417	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(frexpl)
	418	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(hypotl)
	419	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(ldexpl)
	420	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(logl)
	421	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(log10l)
	422	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(modfl)
	423	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(powl)
	424	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(sqrtl)
	425	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_3(sincosl)
	426	GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(finitel)
	427
ff66d28f PE	428	LIBS="$ac_save_LIBS"
	429	CXXFLAGS="$ac_save_CXXFLAGS"
	430	])