]> git.ipfire.org Git - thirdparty/gcc.git/blame - libstdc++-v3/acinclude.m4
projects / thirdparty / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* gcc.dg/lower-subreg-1.c: Skip IA64 platform.
[thirdparty/gcc.git] / libstdc++-v3 / acinclude.m4
CommitLineData
ff66d28f 1
92eabea2
PE		 2dnl
3dnl GLIBCXX_CONDITIONAL (NAME, SHELL-TEST)
4dnl
5dnl Exactly like AM_CONDITIONAL, but delays evaluation of the test until the
6dnl end of configure. This lets tested variables be reassigned, and the
7dnl conditional will depend on the final state of the variable. For a simple
8dnl example of why this is needed, see GLIBCXX_ENABLE_HOSTED.
9dnl
10m4_define([_m4_divert(glibcxx_diversion)], 8000)dnl
f214923c 11AC_DEFUN([GLIBCXX_CONDITIONAL], [dnl
92eabea2
PE		 12 m4_divert_text([glibcxx_diversion],dnl
13 AM_CONDITIONAL([$1],[$2])
14 )dnl
15])dnl
f214923c 16AC_DEFUN([GLIBCXX_EVALUATE_CONDITIONALS], [m4_undivert([glibcxx_diversion])])dnl
92eabea2
PE		 17
18
ff66d28f
PE		 19dnl
20dnl Check to see what architecture and operating system we are compiling
21dnl for. Also, if architecture- or OS-specific flags are required for
22dnl compilation, pick them up here.
23dnl
f214923c 24AC_DEFUN([GLIBCXX_CHECK_HOST], [
ff66d28f 25 . $glibcxx_srcdir/configure.host
f214923c
BK		 26 AC_MSG_NOTICE([CPU config directory is $cpu_include_dir])
27 AC_MSG_NOTICE([OS config directory is $os_include_dir])
ff66d28f
PE		 28])
29
ff66d28f
PE		 30dnl
31dnl Initialize the rest of the library configury. At this point we have
32dnl variables like $host.
aebb8c22 33dnl
ff66d28f 34dnl Sets:
82ba99d5 35dnl SUBDIRS
ff66d28f
PE		 36dnl Substs:
37dnl glibcxx_builddir (absolute path)
38dnl glibcxx_srcdir (absolute path)
39dnl toplevel_srcdir (absolute path)
40dnl with_cross_host
41dnl with_newlib
42dnl with_target_subdir
43dnl plus
44dnl - the variables in GLIBCXX_CHECK_HOST / configure.host
45dnl - default settings for all AM_CONFITIONAL test variables
46dnl - lots of tools, like CC and CXX
aebb8c22 47dnl
f214923c 48AC_DEFUN([GLIBCXX_CONFIGURE], [
82ba99d5
PE		 49 # Keep these sync'd with the list in Makefile.am. The first provides an
50 # expandable list at autoconf time; the second provides an expandable list
51 # (i.e., shell variable) at configure time.
4312e020 52 m4_define([glibcxx_SUBDIRS],[include libmath libsupc++ src doc po testsuite])
82ba99d5
PE		 53 SUBDIRS='glibcxx_SUBDIRS'
54
d2caef2e
PE		 55 # These need to be absolute paths, yet at the same time need to
56 # canonicalize only relative paths, because then amd will not unmount
57 # drives. Thus the use of PWDCMD: set it to 'pawd' or 'amq -w' if using amd.
3d7c150e 58 glibcxx_builddir=`${PWDCMD-pwd}`
d2caef2e 59 case $srcdir in
ff66d28f
PE		 60 [\\/$]* | ?:[\\/]*) glibcxx_srcdir=${srcdir} ;;
61 *) glibcxx_srcdir=`cd "$srcdir" && ${PWDCMD-pwd} || echo "$srcdir"` ;;
d2caef2e 62 esac
ff66d28f 63 toplevel_srcdir=${glibcxx_srcdir}/..
3d7c150e
BK		 64 AC_SUBST(glibcxx_builddir)
65 AC_SUBST(glibcxx_srcdir)
ff66d28f 66 AC_SUBST(toplevel_srcdir)
d2caef2e 67
ff66d28f
PE		 68 # We use these options to decide which functions to include. They are
69 # set from the top level.
70 AC_ARG_WITH([target-subdir],
71 AC_HELP_STRING([--with-target-subdir=SUBDIR],
72 [configuring in a subdirectory]))
73
74 AC_ARG_WITH([cross-host],
75 AC_HELP_STRING([--with-cross-host=HOST],
76 [configuring with a cross compiler]))
77
78 AC_ARG_WITH([newlib],
79 AC_HELP_STRING([--with-newlib],
80 [assume newlib as a system C library]))
81
ff66d28f
PE		 82 # We're almost certainly being configured before anything else which uses
83 # C++, so all of our AC_PROG_* discoveries will be cached. It's vital that
84 # we not cache the value of CXX that we "discover" here, because it's set
85 # to something unique for us and libjava. Other target libraries need to
86 # find CXX for themselves. We yank the rug out from under the normal AC_*
87 # process by sneakily renaming the cache variable. This also lets us debug
88 # the value of "our" CXX in postmortems.
89 #
90 # We must also force CXX to /not/ be a precious variable, otherwise the
91 # wrong (non-multilib-adjusted) value will be used in multilibs. This
92 # little trick also affects CPPFLAGS, CXXFLAGS, and LDFLAGS. And as a side
93 # effect, CXXFLAGS is no longer automagically subst'd, so we have to do
f6dda651 94 # that ourselves. Un-preciousing AC_PROG_CC also affects CC and CFLAGS.
ff66d28f
PE		 95 #
96 # -fno-builtin must be present here so that a non-conflicting form of
97 # std::exit can be guessed by AC_PROG_CXX, and used in later tests.
fbe057bb 98
ff66d28f
PE		 99 m4_define([ac_cv_prog_CXX],[glibcxx_cv_prog_CXX])
100 m4_rename([_AC_ARG_VAR_PRECIOUS],[glibcxx_PRECIOUS])
101 m4_define([_AC_ARG_VAR_PRECIOUS],[])
102 save_CXXFLAGS="$CXXFLAGS"
103 CXXFLAGS="$CXXFLAGS -fno-builtin"
f6dda651 104 AC_PROG_CC
ff66d28f
PE		 105 AC_PROG_CXX
106 CXXFLAGS="$save_CXXFLAGS"
107 m4_rename([glibcxx_PRECIOUS],[_AC_ARG_VAR_PRECIOUS])
f6dda651 108 AC_SUBST(CFLAGS)
ff66d28f 109 AC_SUBST(CXXFLAGS)
b2dad0e3 110
ff66d28f
PE		 111 # Will set LN_S to either 'ln -s', 'ln', or 'cp -p' (if linking isn't
112 # available). Uncomment the next line to force a particular method.
113 AC_PROG_LN_S
114 #LN_S='cp -p'
115
5780a46b
BK		 116 AC_CHECK_TOOL(AS, as)
117 AC_CHECK_TOOL(AR, ar)
46840bcd 118 AC_CHECK_TOOL(RANLIB, ranlib, ranlib-not-found-in-path-error)
b2dad0e3 119
5780a46b 120 AM_MAINTAINER_MODE
b2dad0e3 121
92eabea2
PE		 122 # Set up safe default values for all subsequent AM_CONDITIONAL tests
123 # which are themselves conditionally expanded.
124 ## (Right now, this only matters for enable_wchar_t, but nothing prevents
125 ## other macros from doing the same. This should be automated.) -pme
16da539b 126 need_libmath=no
16da539b 127
464aea98
JM		 128 # Check for uClibc since Linux platforms use different configuration
129 # directories depending on the C library in use.
130 AC_EGREP_CPP([_using_uclibc], [
131 #include <stdio.h>
132 #if __UCLIBC__
133 _using_uclibc
134 #endif
135 ], uclibc=yes, uclibc=no)
136
ff66d28f
PE		 137 # Find platform-specific directories containing configuration info.
138 # Also possibly modify flags used elsewhere, as needed by the platform.
3d7c150e 139 GLIBCXX_CHECK_HOST
b2dad0e3
BK		 140])
141
142
c470c17d 143dnl
52b55e7d
PE		 144dnl Tests for newer compiler features, or features that are present in newer
145dnl compiler versions but not older compiler versions still in use, should
146dnl be placed here.
b2dad0e3 147dnl
ff66d28f
PE		 148dnl Defines:
149dnl WERROR='-Werror' if requested and possible; g++'s that lack the
150dnl new inlining code or the new system_header pragma will die on -Werror.
151dnl Leave it out by default and use maint-mode to use it.
152dnl SECTION_FLAGS='-ffunction-sections -fdata-sections' if
153dnl compiler supports it and the user has not requested debug mode.
c21b6f87 154dnl
f214923c 155AC_DEFUN([GLIBCXX_CHECK_COMPILER_FEATURES], [
a4e99046 156 # All these tests are for C++; save the language and the compiler flags.
52b55e7d 157 # The CXXFLAGS thing is suspicious, but based on similar bits previously
3d7c150e 158 # found in GLIBCXX_CONFIGURE.
a4e99046
PE		 159 AC_LANG_SAVE
160 AC_LANG_CPLUSPLUS
161 ac_test_CXXFLAGS="${CXXFLAGS+set}"
162 ac_save_CXXFLAGS="$CXXFLAGS"
a4e99046 163
7f586614
BK		 164 # Check for maintainer-mode bits.
165 if test x"$USE_MAINTAINER_MODE" = xno; then
166 WERROR=''
8bd636c5 167 else
7f586614 168 WERROR='-Werror'
8bd636c5
PE		 169 fi
170
c470c17d
BK		 171 # Check for -ffunction-sections -fdata-sections
172 AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections])
85ee35ca
BK		 173 CXXFLAGS='-g -Werror -ffunction-sections -fdata-sections'
174 AC_TRY_COMPILE([int foo; void bar() { };],, [ac_fdsections=yes], [ac_fdsections=no])
c470c17d
BK		 175 if test "$ac_test_CXXFLAGS" = set; then
176 CXXFLAGS="$ac_save_CXXFLAGS"
177 else
178 # this is the suspicious part
179 CXXFLAGS=''
180 fi
6aa43d99 181 if test x"$ac_fdsections" = x"yes"; then
c470c17d
BK		 182 SECTION_FLAGS='-ffunction-sections -fdata-sections'
183 fi
184 AC_MSG_RESULT($ac_fdsections)
185
a4e99046 186 AC_LANG_RESTORE
8bd636c5 187 AC_SUBST(WERROR)
c470c17d 188 AC_SUBST(SECTION_FLAGS)
b2dad0e3
BK		 189])
190
c470c17d
BK		 191
192dnl
421173e6
PE		 193dnl If GNU ld is in use, check to see if tricky linker opts can be used. If
194dnl the native linker is in use, all variables will be defined to something
195dnl safe (like an empty string).
196dnl
ff66d28f
PE		 197dnl Defines:
198dnl SECTION_LDFLAGS='-Wl,--gc-sections' if possible
a429affe 199dnl OPT_LDFLAGS='-Wl,-O1' and '-z,relro' if possible
ff66d28f
PE		 200dnl LD (as a side effect of testing)
201dnl Sets:
202dnl with_gnu_ld
d60a2d4d 203dnl glibcxx_ld_is_gold (set to "no" or "yes")
ff66d28f
PE		 204dnl glibcxx_gnu_ld_version (possibly)
205dnl
206dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will
207dnl set glibcxx_gnu_ld_version to 12345. Zeros cause problems.
c470c17d 208dnl
f214923c 209AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [
421173e6
PE		 210 # If we're not using GNU ld, then there's no point in even trying these
211 # tests. Check for that first. We should have already tested for gld
212 # by now (in libtool), but require it now just to be safe...
654421eb
DE		 213 test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS=''
214 test -z "$OPT_LDFLAGS" && OPT_LDFLAGS=''
421173e6 215 AC_REQUIRE([AC_PROG_LD])
ff66d28f 216 AC_REQUIRE([AC_PROG_AWK])
5bd17d39 217
c98b201b
PE		 218 # The name set by libtool depends on the version of libtool. Shame on us
219 # for depending on an impl detail, but c'est la vie. Older versions used
220 # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on
221 # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually
222 # makes sense). We'll test with_gnu_ld everywhere else, so if that isn't
223 # set (hence we're using an older libtool), then set it.
224 if test x${with_gnu_ld+set} != xset; then
225 if test x${ac_cv_prog_gnu_ld+set} != xset; then
226 # We got through "ac_require(ac_prog_ld)" and still not set? Huh?
227 with_gnu_ld=no
228 else
229 with_gnu_ld=$ac_cv_prog_gnu_ld
230 fi
231 fi
232
233 # Start by getting the version number. I think the libtool test already
234 # does some of this, but throws away the result.
d60a2d4d 235 glibcxx_ld_is_gold=no
e2c104d8
BK		 236 if test x"$with_gnu_ld" = x"yes"; then
237 AC_MSG_CHECKING([for ld version])
238 changequote(,)
d60a2d4d
ILT		 239 if $LD --version 2>/dev/null | grep 'GNU gold' >/dev/null 2>&1; then
240 glibcxx_ld_is_gold=yes
241 fi
e2c104d8 242 ldver=`$LD --version 2>/dev/null | head -1 | \
d60a2d4d 243 sed -e 's/GNU \(go\)\{0,1\}ld \(version \)\{0,1\}\(([^)]*) \)\{0,1\}\([0-9.][0-9.]*\).*/\4/'`
e2c104d8
BK		 244 changequote([,])
245 glibcxx_gnu_ld_version=`echo $ldver | \
246 $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`
247 AC_MSG_RESULT($glibcxx_gnu_ld_version)
248 fi
c98b201b 249
5bd17d39 250 # Set --gc-sections.
d60a2d4d
ILT		 251 glibcxx_have_gc_sections=no
252 if test "$glibcxx_ld_is_gold" = "yes"; then
253 if $LD --help 2>/dev/null | grep gc-sections >/dev/null 2>&1; then
254 glibcxx_have_gc_sections=yes
255 fi
256 else
257 glibcxx_gcsections_min_ld=21602
258 if test x"$with_gnu_ld" = x"yes" &&
ac2b2479 259 test $glibcxx_gnu_ld_version -gt $glibcxx_gcsections_min_ld ; then
d60a2d4d
ILT		 260 glibcxx_have_gc_sections=yes
261 fi
262 fi
263 if test "$glibcxx_have_gc_sections" = "yes"; then
ac2b2479
BK		 264 # Sufficiently young GNU ld it is! Joy and bunny rabbits!
265 # NB: This flag only works reliably after 2.16.1. Configure tests
266 # for this are difficult, so hard wire a value that should work.
421173e6 267
421173e6
PE		 268 ac_test_CFLAGS="${CFLAGS+set}"
269 ac_save_CFLAGS="$CFLAGS"
2a0ab51c 270 CFLAGS='-Wl,--gc-sections'
421173e6
PE		 271
272 # Check for -Wl,--gc-sections
273 AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
acb6e9be
BK		 274 AC_TRY_LINK([ int one(void) { return 1; }
275 int two(void) { return 2; }
276 ], [ two(); ] , [ac_gcsections=yes], [ac_gcsections=no])
360e8759
L		 277 if test "$ac_gcsections" = "yes"; then
278 rm -f conftest.c
279 touch conftest.c
280 if $CC -c conftest.c; then
281 if $LD --gc-sections -o conftest conftest.o 2>&1 | \
282 grep "Warning: gc-sections option ignored" > /dev/null; then
283 ac_gcsections=no
284 fi
285 fi
286 rm -f conftest.c conftest.o conftest
287 fi
acb6e9be
BK		 288 if test "$ac_gcsections" = "yes"; then
289 SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
290 fi
291 AC_MSG_RESULT($ac_gcsections)
292
421173e6
PE		 293 if test "$ac_test_CFLAGS" = set; then
294 CFLAGS="$ac_save_CFLAGS"
295 else
296 # this is the suspicious part
297 CFLAGS=''
298 fi
5bd17d39 299 fi
a9117427 300
a429affe 301 # Set -z,relro.
952c7b74 302 # Note this is only for shared objects.
a429affe
BK		 303 ac_ld_relro=no
304 if test x"$with_gnu_ld" = x"yes"; then
305 AC_MSG_CHECKING([for ld that supports -Wl,-z,relro])
306 cxx_z_relo=`$LD -v --help 2>/dev/null | grep "z relro"`
307 if test -n "$cxx_z_relo"; then
308 OPT_LDFLAGS="-Wl,-z,relro"
309 ac_ld_relro=yes
310 fi
311 AC_MSG_RESULT($ac_ld_relro)
312 fi
313
5bd17d39 314 # Set linker optimization flags.
6aa43d99 315 if test x"$with_gnu_ld" = x"yes"; then
654421eb 316 OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"
421173e6 317 fi
5bd17d39 318
c470c17d 319 AC_SUBST(SECTION_LDFLAGS)
421173e6 320 AC_SUBST(OPT_LDFLAGS)
c470c17d
BK		 321])
322
323
b2dad0e3 324dnl
ff66d28f
PE		 325dnl Check for headers for, and arguments to, the setrlimit() function.
326dnl Used only in testsuite_hooks.h. Called from GLIBCXX_CONFIGURE_TESTSUITE.
6aa43d99 327dnl
ff66d28f 328dnl Defines:
2ae6e982
PC		 329dnl _GLIBCXX_RES_LIMITS if we can set artificial resource limits
330dnl various HAVE_LIMIT_* for individual limit names
6aa43d99 331dnl
f214923c 332AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [
e0103440 333 AC_MSG_CHECKING([for RLIMIT_$1])
ff66d28f
PE		 334 AC_TRY_COMPILE(
335 [#include <unistd.h>
336 #include <sys/time.h>
337 #include <sys/resource.h>
338 ],
339 [ int f = RLIMIT_$1 ; ],
340 [glibcxx_mresult=1], [glibcxx_mresult=0])
2ae6e982 341 AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult,
ff66d28f 342 [Only used in build directory testsuite_hooks.h.])
e0103440
GK		 343 if test $glibcxx_mresult = 1 ; then res=yes ; else res=no ; fi
344 AC_MSG_RESULT($res)
ff66d28f
PE		 345])
346
f214923c 347AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [
ff66d28f
PE		 348 setrlimit_have_headers=yes
349 AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
350 [],
351 [setrlimit_have_headers=no])
352 # If don't have the headers, then we can't run the tests now, and we
353 # won't be seeing any of these during testsuite compilation.
354 if test $setrlimit_have_headers = yes; then
355 # Can't do these in a loop, else the resulting syntax is wrong.
356 GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA)
357 GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS)
358 GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM)
359 GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS)
2ae6e982 360 GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE)
ff66d28f
PE		 361
362 # Check for rlimit, setrlimit.
6d26724a 363 AC_CACHE_VAL(glibcxx_cv_setrlimit, [
ff66d28f
PE		 364 AC_TRY_COMPILE(
365 [#include <unistd.h>
366 #include <sys/time.h>
367 #include <sys/resource.h>
368 ],
369 [struct rlimit r;
370 setrlimit(0, &r);],
6d26724a 371 [glibcxx_cv_setrlimit=yes], [glibcxx_cv_setrlimit=no])
ff66d28f
PE		 372 ])
373 fi
374
2ae6e982 375 AC_MSG_CHECKING([for testsuite resource limits support])
6d26724a 376 if test $setrlimit_have_headers = yes && test $glibcxx_cv_setrlimit = yes; then
2ae6e982 377 ac_res_limits=yes
4651e622
KC		 378 AC_DEFINE(_GLIBCXX_RES_LIMITS, 1,
379 [Define if using setrlimit to set resource limits during
380 "make check"])
ff66d28f 381 else
2ae6e982 382 ac_res_limits=no
ff66d28f 383 fi
2ae6e982 384 AC_MSG_RESULT($ac_res_limits)
6aa43d99
BK		 385])
386
387
6aa43d99 388dnl
ff66d28f
PE		 389dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
390dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately.
6aa43d99 391dnl
f214923c 392AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [
e0103440 393 AC_MSG_CHECKING([for S_ISREG or S_IFREG])
ff66d28f
PE		 394 AC_CACHE_VAL(glibcxx_cv_S_ISREG, [
395 AC_TRY_LINK(
396 [#include <sys/stat.h>],
397 [struct stat buffer;
398 fstat(0, &buffer);
399 S_ISREG(buffer.st_mode);],
400 [glibcxx_cv_S_ISREG=yes],
401 [glibcxx_cv_S_ISREG=no])
402 ])
403 AC_CACHE_VAL(glibcxx_cv_S_IFREG, [
404 AC_TRY_LINK(
405 [#include <sys/stat.h>],
406 [struct stat buffer;
407 fstat(0, &buffer);
408 S_IFREG & buffer.st_mode;],
409 [glibcxx_cv_S_IFREG=yes],
410 [glibcxx_cv_S_IFREG=no])
411 ])
e0103440 412 res=no
ff66d28f 413 if test $glibcxx_cv_S_ISREG = yes; then
4651e622
KC		 414 AC_DEFINE(HAVE_S_ISREG, 1,
415 [Define if S_IFREG is available in <sys/stat.h>.])
e0103440 416 res=S_ISREG
ff66d28f 417 elif test $glibcxx_cv_S_IFREG = yes; then
4651e622
KC		 418 AC_DEFINE(HAVE_S_IFREG, 1,
419 [Define if S_IFREG is available in <sys/stat.h>.])
e0103440 420 res=S_IFREG
ff66d28f 421 fi
e0103440 422 AC_MSG_RESULT($res)
b2dad0e3
BK		 423])
424
425
dcfa0bc8 426dnl
ff66d28f 427dnl Check whether poll is available in <poll.h>, and define HAVE_POLL.
dcfa0bc8 428dnl
f214923c 429AC_DEFUN([GLIBCXX_CHECK_POLL], [
e0103440 430 AC_MSG_CHECKING([for poll])
ff66d28f 431 AC_CACHE_VAL(glibcxx_cv_POLL, [
3d05b345 432 AC_TRY_LINK(
ff66d28f
PE		 433 [#include <poll.h>],
434 [struct pollfd pfd[1];
435 pfd[0].events = POLLIN;
436 poll(pfd, 1, 0);],
437 [glibcxx_cv_POLL=yes],
438 [glibcxx_cv_POLL=no])
439 ])
440 if test $glibcxx_cv_POLL = yes; then
4651e622 441 AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.])
ff66d28f 442 fi
e0103440 443 AC_MSG_RESULT($glibcxx_cv_POLL)
ff66d28f
PE		 444])
445
446
447dnl
448dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV.
449dnl
f214923c 450AC_DEFUN([GLIBCXX_CHECK_WRITEV], [
e0103440 451 AC_MSG_CHECKING([for writev])
ff66d28f 452 AC_CACHE_VAL(glibcxx_cv_WRITEV, [
3d05b345 453 AC_TRY_LINK(
ff66d28f
PE		 454 [#include <sys/uio.h>],
455 [struct iovec iov[2];
456 writev(0, iov, 0);],
457 [glibcxx_cv_WRITEV=yes],
458 [glibcxx_cv_WRITEV=no])
459 ])
460 if test $glibcxx_cv_WRITEV = yes; then
4651e622 461 AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.])
ff66d28f 462 fi
e0103440 463 AC_MSG_RESULT($glibcxx_cv_WRITEV)
ff66d28f
PE		 464])
465
466
3d05b345
PC		 467dnl
468dnl Check whether int64_t is available in <stdint.h>, and define HAVE_INT64_T.
469dnl
f214923c 470AC_DEFUN([GLIBCXX_CHECK_INT64_T], [
e0103440 471 AC_MSG_CHECKING([for int64_t])
3d05b345
PC		 472 AC_CACHE_VAL(glibcxx_cv_INT64_T, [
473 AC_TRY_COMPILE(
474 [#include <stdint.h>],
475 [int64_t var;],
476 [glibcxx_cv_INT64_T=yes],
477 [glibcxx_cv_INT64_T=no])
478 ])
479 if test $glibcxx_cv_INT64_T = yes; then
4651e622 480 AC_DEFINE(HAVE_INT64_T, 1, [Define if int64_t is available in <stdint.h>.])
3d05b345 481 fi
e0103440 482 AC_MSG_RESULT($glibcxx_cv_INT64_T)
3d05b345
PC		 483])
484
485
486dnl
487dnl Check whether LFS support is available.
488dnl
f214923c 489AC_DEFUN([GLIBCXX_CHECK_LFS], [
0c6b814a 490 AC_LANG_SAVE
9d47bc51
PC		 491 AC_LANG_CPLUSPLUS
492 ac_save_CXXFLAGS="$CXXFLAGS"
493 CXXFLAGS="$CXXFLAGS -fno-exceptions"
e0103440 494 AC_MSG_CHECKING([for LFS support])
3d05b345
PC		 495 AC_CACHE_VAL(glibcxx_cv_LFS, [
496 AC_TRY_LINK(
0c6b814a
PC		 497 [#include <unistd.h>
498 #include <stdio.h>
dd5d134b 499 #include <sys/stat.h>
0c6b814a 500 ],
5c89246d
PC		 501 [FILE* fp;
502 fopen64("t", "w");
503 fseeko64(fp, 0, SEEK_CUR);
504 ftello64(fp);
dd5d134b
PC		 505 lseek64(1, 0, SEEK_CUR);
506 struct stat64 buf;
507 fstat64(1, &buf);],
3d05b345
PC		 508 [glibcxx_cv_LFS=yes],
509 [glibcxx_cv_LFS=no])
510 ])
511 if test $glibcxx_cv_LFS = yes; then
4651e622 512 AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.])
3d05b345 513 fi
e0103440 514 AC_MSG_RESULT($glibcxx_cv_LFS)
9d47bc51
PC		 515 CXXFLAGS="$ac_save_CXXFLAGS"
516 AC_LANG_RESTORE
3d05b345
PC		 517])
518
519
1165dc50
PC		 520dnl
521dnl Check for whether a fully dynamic basic_string implementation should
522dnl be turned on, that does not put empty objects in per-process static
523dnl memory (mostly useful together with shared memory allocators, see PR
524dnl libstdc++/16612 for details).
525dnl
526dnl --enable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING
527dnl --disable-fully-dynamic-string leaves _GLIBCXX_FULLY_DYNAMIC_STRING undefined
528dnl + Usage: GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING[(DEFAULT)]
529dnl Where DEFAULT is either `yes' or `no'.
530dnl
531AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [
532 GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory])
533 if test $enable_fully_dynamic_string = yes; then
4651e622
KC		 534 AC_DEFINE(_GLIBCXX_FULLY_DYNAMIC_STRING, 1,
535 [Define if a fully dynamic basic_string is wanted.])
1165dc50
PC		 536 fi
537])
538
539
ff66d28f
PE		 540dnl
541dnl Does any necessary configuration of the testsuite directory. Generates
542dnl the testsuite_hooks.h header.
543dnl
544dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.
545dnl
546dnl Sets:
84946e72 547dnl enable_abi_check
e3f78d9b
BK		 548dnl GLIBCXX_TEST_WCHAR_T
549dnl GLIBCXX_TEST_THREAD
ff66d28f
PE		 550dnl Substs:
551dnl baseline_dir
552dnl
f214923c 553AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [
0646b059 554 if $GLIBCXX_IS_NATIVE ; then
2ae6e982 555 # Do checks for resource limit functions.
ff66d28f
PE		 556 GLIBCXX_CHECK_SETRLIMIT
557
558 # Look for setenv, so that extended locale tests can be performed.
559 GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
0646b059 560 fi
dbc66058 561
0646b059
GK		 562 if $GLIBCXX_IS_NATIVE && test $is_hosted = yes &&
563 test $enable_symvers != no; then
564 case "$host" in
565 *-*-cygwin*)
566 enable_abi_check=no ;;
567 *)
568 enable_abi_check=yes ;;
569 esac
dbc66058
DJ		 570 else
571 # Only build this as native, since automake does not understand
572 # CXX_FOR_BUILD.
573 enable_abi_check=no
ff66d28f 574 fi
84946e72 575
ff66d28f 576 # Export file names for ABI checking.
fb5c309d 577 baseline_dir="$glibcxx_srcdir/config/abi/post/${abi_baseline_pair}\$(MULTISUBDIR)"
ff66d28f 578 AC_SUBST(baseline_dir)
ff66d28f
PE		 579])
580
581
582dnl
583dnl Set up *_INCLUDES variables for all sundry Makefile.am's.
584dnl
585dnl Substs:
586dnl GLIBCXX_INCLUDES
587dnl TOPLEVEL_INCLUDES
ff66d28f 588dnl
f214923c 589AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [
0df3f383
PE		 590 # Used for every C++ compile we perform.
591 GLIBCXX_INCLUDES="\
592-I$glibcxx_builddir/include/$host_alias \
593-I$glibcxx_builddir/include \
594-I$glibcxx_srcdir/libsupc++"
ff66d28f 595
0df3f383 596 # For Canadian crosses, pick this up too.
ff66d28f 597 if test $CANADIAN = yes; then
37e0ff11 598 GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}"
ff66d28f
PE		 599 fi
600
0df3f383
PE		 601 # Stuff in the actual top level. Currently only used by libsupc++ to
602 # get unwind* headers from the gcc dir.
603 #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/gcc -I$(toplevel_srcdir)/include'
604 TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/gcc'
ff66d28f
PE		 605
606 # Now, export this to all the little Makefiles....
607 AC_SUBST(GLIBCXX_INCLUDES)
608 AC_SUBST(TOPLEVEL_INCLUDES)
ff66d28f
PE		 609])
610
611
612dnl
613dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
614dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.)
615dnl
616dnl Substs:
617dnl OPTIMIZE_CXXFLAGS
618dnl WARN_FLAGS
619dnl
f214923c 620AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [
ff66d28f
PE		 621 # Optimization flags that are probably a good idea for thrill-seekers. Just
622 # uncomment the lines below and make, everything else is ready to go...
62801a96 623 # Alternatively OPTIMIZE_CXXFLAGS can be set in configure.host.
ff66d28f 624 # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
ff66d28f
PE		 625 AC_SUBST(OPTIMIZE_CXXFLAGS)
626
dc7c62ae 627 WARN_FLAGS='-Wall -Wextra -Wwrite-strings -Wcast-qual'
ff66d28f
PE		 628 AC_SUBST(WARN_FLAGS)
629])
630
631
632dnl
633dnl All installation directory information is determined here.
634dnl
635dnl Substs:
636dnl gxx_install_dir
637dnl glibcxx_prefixdir
638dnl glibcxx_toolexecdir
639dnl glibcxx_toolexeclibdir
640dnl
641dnl Assumes cross_compiling bits already done, and with_cross_host in
642dnl particular.
643dnl
0f57bf40 644dnl This logic must match gcc/configure.ac's setting of gcc_gxx_include_dir.
505692b0 645dnl config/gxx-include-dir.m4 must be kept consistant with this as well.
f214923c 646AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
ff66d28f
PE		 647 glibcxx_toolexecdir=no
648 glibcxx_toolexeclibdir=no
649 glibcxx_prefixdir=$prefix
650
651 AC_MSG_CHECKING([for gxx-include-dir])
652 AC_ARG_WITH([gxx-include-dir],
653 AC_HELP_STRING([--with-gxx-include-dir=DIR],
654 [installation directory for include files]),
655 [case "$withval" in
656 yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;;
657 no) gxx_include_dir=no ;;
658 *) gxx_include_dir=$withval ;;
659 esac],
660 [gxx_include_dir=no])
661 AC_MSG_RESULT($gxx_include_dir)
662
663 AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
664 AC_ARG_ENABLE([version-specific-runtime-libs],
665 AC_HELP_STRING([--enable-version-specific-runtime-libs],
666 [Specify that runtime libraries should be installed in a compiler-specific directory]),
667 [case "$enableval" in
668 yes) version_specific_libs=yes ;;
669 no) version_specific_libs=no ;;
670 *) AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
671 esac],
672 [version_specific_libs=no])
673 AC_MSG_RESULT($version_specific_libs)
674
675 # Default case for install directory for include files.
676 if test $version_specific_libs = no && test $gxx_include_dir = no; then
0f57bf40
MM		 677 gxx_include_dir='include/c++/${gcc_version}'
678 if test -n "$with_cross_host" &&
679 test x"$with_cross_host" != x"no"; then
680 gxx_include_dir='${prefix}/${target_alias}/'"$gxx_include_dir"
681 else
682 gxx_include_dir='${prefix}/'"$gxx_include_dir"
683 fi
ff66d28f
PE		 684 fi
685
686 # Version-specific runtime libs processing.
687 if test $version_specific_libs = yes; then
688 # Need the gcc compiler version to know where to install libraries
689 # and header files if --enable-version-specific-runtime-libs option
0314451d
GK		 690 # is selected. FIXME: these variables are misnamed, there are
691 # no executables installed in _toolexecdir or _toolexeclibdir.
ff66d28f 692 if test x"$gxx_include_dir" = x"no"; then
47194af4 693 gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
ff66d28f 694 fi
0314451d 695 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
47194af4 696 glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
ff66d28f
PE		 697 fi
698
699 # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
700 # Install a library built with a cross compiler in tooldir, not libdir.
701 if test x"$glibcxx_toolexecdir" = x"no"; then
702 if test -n "$with_cross_host" &&
703 test x"$with_cross_host" != x"no"; then
fbe057bb
PE		 704 glibcxx_toolexecdir='${exec_prefix}/${host_alias}'
705 glibcxx_toolexeclibdir='${toolexecdir}/lib'
ff66d28f 706 else
0314451d 707 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
fbe057bb 708 glibcxx_toolexeclibdir='${libdir}'
ff66d28f 709 fi
fbe057bb 710 multi_os_directory=`$CXX -print-multi-os-directory`
ff66d28f
PE		 711 case $multi_os_directory in
712 .) ;; # Avoid trailing /.
713 *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;
714 esac
715 fi
716
717 AC_MSG_CHECKING([for install location])
718 AC_MSG_RESULT($gxx_include_dir)
719
720 AC_SUBST(glibcxx_prefixdir)
721 AC_SUBST(gxx_include_dir)
722 AC_SUBST(glibcxx_toolexecdir)
723 AC_SUBST(glibcxx_toolexeclibdir)
724])
725
726
727dnl
728dnl GLIBCXX_ENABLE
729dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
730dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
731dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
732dnl
733dnl See docs/html/17_intro/configury.html#enable for documentation.
734dnl
735m4_define([GLIBCXX_ENABLE],[dnl
736m4_define([_g_switch],[--enable-$1])dnl
737m4_define([_g_help],[AC_HELP_STRING(_g_switch$3,[$4 @<:@default=$2@:>@])])dnl
738 AC_ARG_ENABLE($1,_g_help,
739 m4_bmatch([$5],
740 [^permit ],
741 [[
742 case "$enableval" in
743 m4_bpatsubst([$5],[permit ])) ;;
744 *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
745 dnl Idea for future: generate a URL pointing to
746 dnl "onlinedocs/configopts.html#whatever"
747 esac
748 ]],
749 [^$],
750 [[
751 case "$enableval" in
752 yes|no) ;;
753 *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
754 esac
755 ]],
756 [[$5]]),
757 [enable_]m4_bpatsubst([$1],-,_)[=][$2])
758m4_undefine([_g_switch])dnl
759m4_undefine([_g_help])dnl
760])
761
762
763dnl
764dnl Check for ISO/IEC 9899:1999 "C99" support.
765dnl
766dnl --enable-c99 defines _GLIBCXX_USE_C99
767dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined
768dnl + Usage: GLIBCXX_ENABLE_C99[(DEFAULT)]
769dnl Where DEFAULT is either `yes' or `no'.
770dnl + If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
771dnl
f214923c 772AC_DEFUN([GLIBCXX_ENABLE_C99], [
ff66d28f
PE		 773 GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
774
347669a0
BK		 775 if test x"$enable_c99" = x"yes"; then
776
ff66d28f
PE		 777 AC_LANG_SAVE
778 AC_LANG_CPLUSPLUS
779
18f310b7
PC		 780 # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
781 # undefined and fake C99 facilities - like pre-standard snprintf - may be
782 # spuriously enabled.
783 # Long term, -std=c++0x could be even better, could manage to explicitely
784 # request C99 facilities to the underlying C headers.
b6f914f6 785 ac_save_CXXFLAGS="$CXXFLAGS"
18f310b7 786 CXXFLAGS="$CXXFLAGS -std=c++98"
b6f914f6
RS		 787 ac_save_LIBS="$LIBS"
788 ac_save_gcc_no_link="$gcc_no_link"
789
790 if test x$gcc_no_link != xyes; then
791 # Use -fno-exceptions to that the C driver can link these tests without
792 # hitting undefined references to personality routines.
793 CXXFLAGS="$CXXFLAGS -fno-exceptions"
794 AC_CHECK_LIB(m, sin, [
795 LIBS="$LIBS -lm"
796 ], [
797 # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
798 gcc_no_link=yes
799 ])
800 fi
801
ff66d28f 802 # Check for the existence of <math.h> functions used if C99 is enabled.
ff66d28f 803 AC_MSG_CHECKING([for ISO C99 support in <math.h>])
6d26724a 804 AC_CACHE_VAL(glibcxx_cv_c99_math, [
b6f914f6
RS		 805 GCC_TRY_COMPILE_OR_LINK(
806 [#include <math.h>
807 volatile double d1, d2;
808 volatile int i;],
809 [i = fpclassify(d1);
810 i = isfinite(d1);
811 i = isinf(d1);
812 i = isnan(d1);
813 i = isnormal(d1);
814 i = signbit(d1);
815 i = isgreater(d1, d2);
816 i = isgreaterequal(d1, d2);
817 i = isless(d1, d2);
818 i = islessequal(d1, d2);
819 i = islessgreater(d1, d2);
820 i = islessgreater(d1, d2);
821 i = isunordered(d1, d2);
6d26724a 822 ],[glibcxx_cv_c99_math=yes], [glibcxx_cv_c99_math=no])
347669a0 823 ])
6d26724a
RW		 824 AC_MSG_RESULT($glibcxx_cv_c99_math)
825 if test x"$glibcxx_cv_c99_math" = x"yes"; then
4651e622
KC		 826 AC_DEFINE(_GLIBCXX_USE_C99_MATH, 1,
827 [Define if C99 functions or macros in <math.h> should be imported
828 in <cmath> in namespace std.])
517da0ce
MM		 829 fi
830
225962a0 831 # Check for the existence of <complex.h> complex math functions.
52e6723c
BK		 832 # This is necessary even though libstdc++ uses the builtin versions
833 # of these functions, because if the builtin cannot be used, a reference
834 # to the library function is emitted.
5ad2f32d 835 AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
52e6723c 836 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
6d26724a 837 glibcxx_cv_c99_complex=no;
52e6723c 838 if test x"$ac_has_complex_h" = x"yes"; then
52e6723c 839 AC_MSG_CHECKING([for ISO C99 support in <complex.h>])
b6f914f6
RS		 840 GCC_TRY_COMPILE_OR_LINK(
841 [#include <complex.h>
842 typedef __complex__ float float_type;
843 typedef __complex__ double double_type;
844 typedef __complex__ long double ld_type;
845 volatile float_type tmpf;
846 volatile double_type tmpd;
847 volatile ld_type tmpld;
848 volatile float f;
849 volatile double d;
850 volatile long double ld;],
851 [f = cabsf(tmpf);
852 f = cargf(tmpf);
853 tmpf = ccosf(tmpf);
854 tmpf = ccoshf(tmpf);
855 tmpf = cexpf(tmpf);
856 tmpf = clogf(tmpf);
857 tmpf = csinf(tmpf);
858 tmpf = csinhf(tmpf);
859 tmpf = csqrtf(tmpf);
860 tmpf = ctanf(tmpf);
861 tmpf = ctanhf(tmpf);
862 tmpf = cpowf(tmpf, tmpf);
863 d = cabs(tmpd);
864 d = carg(tmpd);
865 tmpd = ccos(tmpd);
866 tmpd = ccosh(tmpd);
867 tmpd = cexp(tmpd);
868 tmpd = clog(tmpd);
869 tmpd = csin(tmpd);
870 tmpd = csinh(tmpd);
871 tmpd = csqrt(tmpd);
872 tmpd = ctan(tmpd);
873 tmpd = ctanh(tmpd);
874 tmpd = cpow(tmpd, tmpd);
875 ld = cabsl(tmpld);
876 ld = cargl(tmpld);
877 tmpld = ccosl(tmpld);
878 tmpld = ccoshl(tmpld);
879 tmpld = cexpl(tmpld);
880 tmpld = clogl(tmpld);
881 tmpld = csinl(tmpld);
882 tmpld = csinhl(tmpld);
883 tmpld = csqrtl(tmpld);
884 tmpld = ctanl(tmpld);
885 tmpld = ctanhl(tmpld);
886 tmpld = cpowl(tmpld, tmpld);
6d26724a 887 ],[glibcxx_cv_c99_complex=yes], [glibcxx_cv_c99_complex=no])
52e6723c 888 fi
6d26724a
RW		 889 AC_MSG_RESULT($glibcxx_cv_c99_complex)
890 if test x"$glibcxx_cv_c99_complex" = x"yes"; then
4651e622
KC		 891 AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1,
892 [Define if C99 functions in <complex.h> should be used in
893 <complex>. Using compiler builtins for these functions requires
894 corresponding C99 library functions to be present.])
52e6723c
BK		 895 fi
896
ff66d28f 897 # Check for the existence in <stdio.h> of vscanf, et. al.
ff66d28f 898 AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
6d26724a 899 AC_CACHE_VAL(glibcxx_cv_c99_stdio, [
b6f914f6
RS		 900 GCC_TRY_COMPILE_OR_LINK(
901 [#include <stdio.h>
902 #include <stdarg.h>
903 void foo(char* fmt, ...)
904 {
905 va_list args; va_start(args, fmt);
906 vfscanf(stderr, "%i", args);
907 vscanf("%i", args);
908 vsnprintf(fmt, 0, "%i", args);
909 vsscanf(fmt, "%i", args);
910 }],
911 [snprintf("12", 0, "%i");],
6d26724a 912 [glibcxx_cv_c99_stdio=yes], [glibcxx_cv_c99_stdio=no])
347669a0 913 ])
6d26724a 914 AC_MSG_RESULT($glibcxx_cv_c99_stdio)
ff66d28f
PE		 915
916 # Check for the existence in <stdlib.h> of lldiv_t, et. al.
ff66d28f 917 AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
6d26724a 918 AC_CACHE_VAL(glibcxx_cv_c99_stdlib, [
b6f914f6
RS		 919 GCC_TRY_COMPILE_OR_LINK(
920 [#include <stdlib.h>
921 volatile float f;
922 volatile long double ld;
923 volatile unsigned long long ll;
924 lldiv_t mydivt;],
925 [char* tmp;
926 f = strtof("gnu", &tmp);
927 ld = strtold("gnu", &tmp);
928 ll = strtoll("gnu", &tmp, 10);
929 ll = strtoull("gnu", &tmp, 10);
930 ll = llabs(10);
931 mydivt = lldiv(10,1);
932 ll = mydivt.quot;
933 ll = mydivt.rem;
934 ll = atoll("10");
935 _Exit(0);
6d26724a 936 ],[glibcxx_cv_c99_stdlib=yes], [glibcxx_cv_c99_stdlib=no])
347669a0 937 ])
6d26724a 938 AC_MSG_RESULT($glibcxx_cv_c99_stdlib)
ff66d28f 939
8a9b2875 940 # Check for the existence in <wchar.h> of wcstold, etc.
6d26724a 941 glibcxx_cv_c99_wchar=no;
347669a0
BK		 942 if test x"$ac_has_wchar_h" = xyes &&
943 test x"$ac_has_wctype_h" = xyes; then
8a9b2875 944 AC_MSG_CHECKING([for ISO C99 support in <wchar.h>])
347669a0 945 AC_TRY_COMPILE([#include <wchar.h>
347669a0
BK		 946 namespace test
947 {
347669a0
BK		 948 using ::wcstold;
949 using ::wcstoll;
347669a0 950 using ::wcstoull;
347669a0 951 }
6d26724a 952 ],[],[glibcxx_cv_c99_wchar=yes], [glibcxx_cv_c99_wchar=no])
347669a0
BK		 953
954 # Checks for wide character functions that may not be present.
955 # Injection of these is wrapped with guard macros.
956 # NB: only put functions here, instead of immediately above, if
957 # absolutely necessary.
958 AC_TRY_COMPILE([#include <wchar.h>
959 namespace test { using ::vfwscanf; } ], [],
960 [AC_DEFINE(HAVE_VFWSCANF,1,
961 [Defined if vfwscanf exists.])],[])
962
963 AC_TRY_COMPILE([#include <wchar.h>
964 namespace test { using ::vswscanf; } ], [],
965 [AC_DEFINE(HAVE_VSWSCANF,1,
966 [Defined if vswscanf exists.])],[])
967
968 AC_TRY_COMPILE([#include <wchar.h>
969 namespace test { using ::vwscanf; } ], [],
970 [AC_DEFINE(HAVE_VWSCANF,1,[Defined if vwscanf exists.])],[])
971
972 AC_TRY_COMPILE([#include <wchar.h>
973 namespace test { using ::wcstof; } ], [],
974 [AC_DEFINE(HAVE_WCSTOF,1,[Defined if wcstof exists.])],[])
975
976 AC_TRY_COMPILE([#include <wctype.h>],
977 [ wint_t t; int i = iswblank(t);],
978 [AC_DEFINE(HAVE_ISWBLANK,1,
979 [Defined if iswblank exists.])],[])
980
6d26724a 981 AC_MSG_RESULT($glibcxx_cv_c99_wchar)
347669a0 982 fi
ff66d28f 983
347669a0 984 # Option parsed, now set things appropriately.
6d26724a
RW		 985 if test x"$glibcxx_cv_c99_math" = x"no" ||
986 test x"$glibcxx_cv_c99_complex" = x"no" ||
987 test x"$glibcxx_cv_c99_stdio" = x"no" ||
988 test x"$glibcxx_cv_c99_stdlib" = x"no" ||
989 test x"$glibcxx_cv_c99_wchar" = x"no"; then
ff66d28f 990 enable_c99=no;
347669a0 991 else
4651e622
KC		 992 AC_DEFINE(_GLIBCXX_USE_C99, 1,
993 [Define if C99 functions or macros from <wchar.h>, <math.h>,
994 <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
ff66d28f
PE		 995 fi
996
b6f914f6
RS		 997 gcc_no_link="$ac_save_gcc_no_link"
998 LIBS="$ac_save_LIBS"
999 CXXFLAGS="$ac_save_CXXFLAGS"
ff66d28f 1000 AC_LANG_RESTORE
347669a0
BK		 1001 fi
1002
1003 AC_MSG_CHECKING([for fully enabled ISO C99 support])
1004 AC_MSG_RESULT($enable_c99)
dcfa0bc8
PE		 1005])
1006
1007
bd2bb1ea
PC		 1008dnl
1009dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
1010dnl facilities in Chapter 8, "C compatibility".
1011dnl
1012AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
1013
1014 AC_LANG_SAVE
1015 AC_LANG_CPLUSPLUS
1016
18f310b7
PC		 1017 # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
1018 # undefined and fake C99 facilities may be spuriously enabled.
1019 ac_save_CXXFLAGS="$CXXFLAGS"
1020 CXXFLAGS="$CXXFLAGS -std=c++98"
1021
bd2bb1ea
PC		 1022 # Check for the existence of <complex.h> complex math functions used
1023 # by tr1/complex.
1024 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1025 ac_c99_complex_tr1=no;
1026 if test x"$ac_has_complex_h" = x"yes"; then
1027 AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
1028 AC_TRY_COMPILE([#include <complex.h>],
1029 [typedef __complex__ float float_type; float_type tmpf;
1030 cacosf(tmpf);
1031 casinf(tmpf);
1032 catanf(tmpf);
1033 cacoshf(tmpf);
1034 casinhf(tmpf);
1035 catanhf(tmpf);
1036 typedef __complex__ double double_type; double_type tmpd;
1037 cacos(tmpd);
1038 casin(tmpd);
1039 catan(tmpd);
1040 cacosh(tmpd);
1041 casinh(tmpd);
1042 catanh(tmpd);
1043 typedef __complex__ long double ld_type; ld_type tmpld;
1044 cacosl(tmpld);
1045 casinl(tmpld);
1046 catanl(tmpld);
1047 cacoshl(tmpld);
1048 casinhl(tmpld);
1049 catanhl(tmpld);
1050 ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
1051 fi
1052 AC_MSG_RESULT($ac_c99_complex_tr1)
1053 if test x"$ac_c99_complex_tr1" = x"yes"; then
1054 AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
1055 [Define if C99 functions in <complex.h> should be used in
1056 <tr1/complex>. Using compiler builtins for these functions
1057 requires corresponding C99 library functions to be present.])
1058 fi
1059
1060 # Check for the existence of <ctype.h> functions.
1061 AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>])
6d26724a 1062 AC_CACHE_VAL(glibcxx_cv_c99_ctype_tr1, [
bd2bb1ea 1063 AC_TRY_COMPILE([#include <ctype.h>],
20921e53 1064 [int ch;
98fb1d29
PC		 1065 int ret;
1066 ret = isblank(ch);
6d26724a 1067 ],[glibcxx_cv_c99_ctype_tr1=yes], [glibcxx_cv_c99_ctype_tr1=no])
bd2bb1ea 1068 ])
6d26724a
RW		 1069 AC_MSG_RESULT($glibcxx_cv_c99_ctype_tr1)
1070 if test x"$glibcxx_cv_c99_ctype_tr1" = x"yes"; then
bd2bb1ea
PC		 1071 AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
1072 [Define if C99 functions in <ctype.h> should be imported in
1073 <tr1/cctype> in namespace std::tr1.])
1074 fi
1075
20921e53
PC		 1076 # Check for the existence of <fenv.h> functions.
1077 AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1078 ac_c99_fenv_tr1=no;
1079 if test x"$ac_has_fenv_h" = x"yes"; then
1080 AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
1081 AC_TRY_COMPILE([#include <fenv.h>],
1082 [int except, mode;
1083 fexcept_t* pflag;
1084 fenv_t* penv;
98fb1d29
PC		 1085 int ret;
1086 ret = feclearexcept(except);
1087 ret = fegetexceptflag(pflag, except);
1088 ret = feraiseexcept(except);
1089 ret = fesetexceptflag(pflag, except);
1090 ret = fetestexcept(except);
1091 ret = fegetround();
1092 ret = fesetround(mode);
1093 ret = fegetenv(penv);
1094 ret = feholdexcept(penv);
1095 ret = fesetenv(penv);
1096 ret = feupdateenv(penv);
20921e53
PC		 1097 ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
1098 fi
1099 AC_MSG_RESULT($ac_c99_fenv_tr1)
1100 if test x"$ac_c99_fenv_tr1" = x"yes"; then
1101 AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
1102 [Define if C99 functions in <fenv.h> should be imported in
1103 <tr1/cfenv> in namespace std::tr1.])
1104 fi
1105
2a1d6346
PC		 1106 # Check for the existence of <stdint.h> types.
1107 AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>])
6d26724a 1108 AC_CACHE_VAL(glibcxx_cv_c99_stdint_tr1, [
2a1d6346
PC		 1109 AC_TRY_COMPILE([#include <stdint.h>],
1110 [typedef int8_t my_int8_t;
1111 typedef int16_t my_int16_t;
1112 typedef int32_t my_int32_t;
1113 typedef int64_t my_int64_t;
1114 typedef int_fast8_t my_int_fast8_t;
1115 typedef int_fast16_t my_int_fast16_t;
1116 typedef int_fast32_t my_int_fast32_t;
1117 typedef int_fast64_t my_int_fast64_t;
1118 typedef int_least8_t my_int_least8_t;
1119 typedef int_least16_t my_int_least16_t;
1120 typedef int_least32_t my_int_least32_t;
1121 typedef int_least64_t my_int_least64_t;
1122 typedef intmax_t my_intmax_t;
1123 typedef intptr_t my_intptr_t;
1124 typedef uint8_t my_uint8_t;
1125 typedef uint16_t my_uint16_t;
1126 typedef uint32_t my_uint32_t;
1127 typedef uint64_t my_uint64_t;
1128 typedef uint_fast8_t my_uint_fast8_t;
1129 typedef uint_fast16_t my_uint_fast16_t;
1130 typedef uint_fast32_t my_uint_fast32_t;
1131 typedef uint_fast64_t my_uint_fast64_t;
1132 typedef uint_least8_t my_uint_least8_t;
1133 typedef uint_least16_t my_uint_least16_t;
1134 typedef uint_least32_t my_uint_least32_t;
1135 typedef uint_least64_t my_uint_least64_t;
1136 typedef uintmax_t my_uintmax_t;
1137 typedef uintptr_t my_uintptr_t;
6d26724a 1138 ],[glibcxx_cv_c99_stdint_tr1=yes], [glibcxx_cv_c99_stdint_tr1=no])
2a1d6346 1139 ])
6d26724a
RW		 1140 AC_MSG_RESULT($glibcxx_cv_c99_stdint_tr1)
1141 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
2a1d6346
PC		 1142 AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
1143 [Define if C99 types in <stdint.h> should be imported in
1144 <tr1/cstdint> in namespace std::tr1.])
1145 fi
1146
4f0de5dd
PC		 1147 # Check for the existence of <math.h> functions.
1148 AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>])
6d26724a 1149 AC_CACHE_VAL(glibcxx_cv_c99_math_tr1, [
4f0de5dd 1150 AC_TRY_COMPILE([#include <math.h>],
9a7ab578
PC		 1151 [typedef double_t my_double_t;
1152 typedef float_t my_float_t;
1153 acosh(0.0);
4f0de5dd
PC		 1154 acoshf(0.0f);
1155 acoshl(0.0l);
1156 asinh(0.0);
1157 asinhf(0.0f);
1158 asinhl(0.0l);
1159 atanh(0.0);
1160 atanhf(0.0f);
1161 atanhl(0.0l);
1162 cbrt(0.0);
1163 cbrtf(0.0f);
1164 cbrtl(0.0l);
1165 copysign(0.0, 0.0);
1166 copysignf(0.0f, 0.0f);
1167 copysignl(0.0l, 0.0l);
1168 erf(0.0);
1169 erff(0.0f);
1170 erfl(0.0l);
1171 erfc(0.0);
1172 erfcf(0.0f);
1173 erfcl(0.0l);
1174 exp2(0.0);
1175 exp2f(0.0f);
1176 exp2l(0.0l);
1177 expm1(0.0);
1178 expm1f(0.0f);
1179 expm1l(0.0l);
1180 fdim(0.0, 0.0);
1181 fdimf(0.0f, 0.0f);
1182 fdiml(0.0l, 0.0l);
1183 fma(0.0, 0.0, 0.0);
1184 fmaf(0.0f, 0.0f, 0.0f);
1185 fmal(0.0l, 0.0l, 0.0l);
1186 fmax(0.0, 0.0);
1187 fmaxf(0.0f, 0.0f);
1188 fmaxl(0.0l, 0.0l);
1189 fmin(0.0, 0.0);
1190 fminf(0.0f, 0.0f);
1191 fminl(0.0l, 0.0l);
1192 hypot(0.0, 0.0);
1193 hypotf(0.0f, 0.0f);
1194 hypotl(0.0l, 0.0l);
1195 ilogb(0.0);
1196 ilogbf(0.0f);
1197 ilogbl(0.0l);
1198 lgamma(0.0);
1199 lgammaf(0.0f);
1200 lgammal(0.0l);
1201 llrint(0.0);
1202 llrintf(0.0f);
1203 llrintl(0.0l);
1204 llround(0.0);
1205 llroundf(0.0f);
1206 llroundl(0.0l);
1207 log1p(0.0);
1208 log1pf(0.0f);
1209 log1pl(0.0l);
1210 log2(0.0);
1211 log2f(0.0f);
1212 log2l(0.0l);
1213 logb(0.0);
1214 logbf(0.0f);
1215 logbl(0.0l);
1216 lrint(0.0);
1217 lrintf(0.0f);
1218 lrintl(0.0l);
1219 lround(0.0);
1220 lroundf(0.0f);
1221 lroundl(0.0l);
1222 nan(0);
1223 nanf(0);
1224 nanl(0);
1225 nearbyint(0.0);
1226 nearbyintf(0.0f);
1227 nearbyintl(0.0l);
1228 nextafter(0.0, 0.0);
1229 nextafterf(0.0f, 0.0f);
1230 nextafterl(0.0l, 0.0l);
1231 nexttoward(0.0, 0.0);
1232 nexttowardf(0.0f, 0.0f);
1233 nexttowardl(0.0l, 0.0l);
1234 remainder(0.0, 0.0);
1235 remainderf(0.0f, 0.0f);
1236 remainderl(0.0l, 0.0l);
1237 remquo(0.0, 0.0, 0);
1238 remquo(0.0f, 0.0f, 0);
1239 remquo(0.0l, 0.0l, 0);
1240 rint(0.0);
1241 rintf(0.0f);
1242 rintl(0.0l);
1243 round(0.0);
1244 roundf(0.0f);
1245 roundl(0.0l);
1246 scalbln(0.0, 0l);
1247 scalblnf(0.0f, 0l);
1248 scalblnl(0.0l, 0l);
1249 scalbn(0.0, 0);
1250 scalbnf(0.0f, 0);
1251 scalbnl(0.0l, 0);
1252 tgamma(0.0);
1253 tgammaf(0.0f);
1254 tgammal(0.0l);
1255 trunc(0.0);
1256 truncf(0.0f);
1257 truncl(0.0l);
6d26724a 1258 ],[glibcxx_cv_c99_math_tr1=yes], [glibcxx_cv_c99_math_tr1=no])
4f0de5dd 1259 ])
6d26724a
RW		 1260 AC_MSG_RESULT($glibcxx_cv_c99_math_tr1)
1261 if test x"$glibcxx_cv_c99_math_tr1" = x"yes"; then
4f0de5dd
PC		 1262 AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
1263 [Define if C99 functions or macros in <math.h> should be imported
1264 in <tr1/cmath> in namespace std::tr1.])
1265 fi
1266
03bf3bc1
PC		 1267 # Check for the existence of <inttypes.h> functions (NB: doesn't make
1268 # sense if the previous check fails, per C99, 7.8/1).
1269 ac_c99_inttypes_tr1=no;
6d26724a 1270 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
03bf3bc1
PC		 1271 AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
1272 AC_TRY_COMPILE([#include <inttypes.h>],
1273 [intmax_t i, numer, denom, base;
1274 const char* s;
1275 char** endptr;
af66a43e
PC		 1276 intmax_t ret = imaxabs(i);
1277 imaxdiv_t dret = imaxdiv(numer, denom);
03bf3bc1 1278 ret = strtoimax(s, endptr, base);
af66a43e 1279 uintmax_t uret = strtoumax(s, endptr, base);
03bf3bc1
PC		 1280 ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
1281 fi
52a64bd3
PC		 1282 AC_MSG_RESULT($ac_c99_inttypes_tr1)
1283 if test x"$ac_c99_inttypes_tr1" = x"yes"; then
1284 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
1285 [Define if C99 functions in <inttypes.h> should be imported in
03bf3bc1 1286 <tr1/cinttypes> in namespace std::tr1.])
52a64bd3
PC		 1287 fi
1288
1e41a98c
PC		 1289 # Check for the existence of the <stdbool.h> header.
1290 AC_CHECK_HEADERS(stdbool.h)
1291
18f310b7 1292 CXXFLAGS="$ac_save_CXXFLAGS"
bd2bb1ea
PC		 1293 AC_LANG_RESTORE
1294])
1295
d8bc9819
PC		 1296dnl
1297dnl Check whether "dev/random" and "dev/urandom" are available for the
1298dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
1299dnl
1300AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [
1301
1302 AC_MSG_CHECKING([for "dev/random" and "dev/urandom" for TR1 random_device])
6d26724a 1303 AC_CACHE_VAL(glibcxx_cv_random_tr1, [
d8bc9819
PC		 1304 AC_TRY_RUN([#include <stdio.h>
1305 int main()
1306 {
1307 return !(fopen("/dev/random", "r")
1308 && fopen("/dev/urandom", "r"));
1309 }
1310 ],
6d26724a
RW		 1311 [glibcxx_cv_random_tr1=yes], [glibcxx_cv_random_tr1=no],
1312 [glibcxx_cv_random_tr1=no])
d8bc9819 1313 ])
6d26724a
RW		 1314 AC_MSG_RESULT($glibcxx_cv_random_tr1)
1315 if test x"$glibcxx_cv_random_tr1" = x"yes"; then
d8bc9819
PC		 1316 AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
1317 [Define if dev/random and dev/urandom are available for
1318 the random_device of TR1 (Chapter 5.1).])
1319 fi
1320
1321])
bd2bb1ea 1322
0646d8a3
BK		 1323dnl
1324dnl Check whether macros, etc are present for <system_error>
1325dnl
1326AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [
1327
6d26724a
RW		 1328m4_pushdef([n_syserr], [1])dnl
1329m4_foreach([syserr], [EOWNERDEAD, ENOTRECOVERABLE, ENOLINK, EPROTO, ENODATA,
1330 ENOSR, ENOSTR, ETIME, sys_nerr, EBADMSG, ECANCELED,
1331 EOVERFLOW, ENOTSUP, EIDRM, ETXTBSY],
1332[m4_pushdef([SYSERR], m4_toupper(syserr))dnl
1333AC_MSG_CHECKING([for syserr])
1334AC_CACHE_VAL([glibcxx_cv_system_error[]n_syserr], [
1335AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <errno.h>]],
1336 [int i = syserr;])],
1337 [glibcxx_cv_system_error[]n_syserr=yes],
1338 [glibcxx_cv_system_error[]n_syserr=no])
1339])
1340AC_MSG_RESULT([$glibcxx_cv_system_error[]n_syserr])
1341if test x"$glibcxx_cv_system_error[]n_syserr" = x"yes"; then
1342 AC_DEFINE([HAVE_]SYSERR, 1, [Define if ]syserr[ exists.])
1343fi
1344m4_define([n_syserr], m4_incr(n_syserr))dnl
1345m4_popdef([SYSERR])dnl
1346])
1347m4_popdef([n_syserr])dnl
0646d8a3
BK		 1348])
1349
d466a7e2
BK		 1350dnl
1351dnl Check whether C++200x's standard layout types are supported.
1352dnl
1353AC_DEFUN([GLIBCXX_CHECK_STANDARD_LAYOUT], [
1354
1355 AC_MSG_CHECKING([for ISO C++200x standard layout type support])
1356 AC_CACHE_VAL(ac_standard_layout, [
1357 AC_LANG_SAVE
1358 AC_LANG_CPLUSPLUS
1359 ac_test_CXXFLAGS="${CXXFLAGS+set}"
1360 ac_save_CXXFLAGS="$CXXFLAGS"
1361 CXXFLAGS='-std=gnu++0x'
1362
1363 AC_TRY_COMPILE([struct b
1364 {
1365 bool t;
1366
1367 // Need standard layout relaxation from POD
1368 private:
1369 b& operator=(const b&);
1370 b(const b&);
1371 };
1372
1373 int main()
1374 {
1375 b tst1 = { false };
1376 return 0;
1377 }],,
1378 [ac_standard_layout=yes], [ac_standard_layout=no])
1379
1380 CXXFLAGS="$ac_save_CXXFLAGS"
1381 AC_LANG_RESTORE
1382 ])
1383 AC_MSG_RESULT($ac_standard_layout)
1384 if test x"$ac_standard_layout" = x"yes"; then
1385 AC_DEFINE(_GLIBCXX_USE_STANDARD_LAYOUT, 1,
1386 [Define if standard layout types are supported in C++200x.])
1387 fi
1388])
1389
0214010c 1390dnl
ff66d28f
PE		 1391dnl Check for what type of C headers to use.
1392dnl
1393dnl --enable-cheaders= [does stuff].
1394dnl --disable-cheaders [does not do anything, really].
1395dnl + Usage: GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
af13a7a6 1396dnl Where DEFAULT is either 'c' or 'c_std' or 'c_global'.
ff66d28f 1397dnl
f214923c 1398AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
ff66d28f 1399 GLIBCXX_ENABLE(cheaders,$1,[=KIND],
af13a7a6 1400 [construct "C" headers for g++], [permit c|c_std|c_global])
ff66d28f
PE		 1401 AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1402
1403 C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1404
af13a7a6
BK		 1405 # Allow overrides to configure.host here.
1406 if test $enable_cheaders = c_global; then
1407 c_compatibility=yes
1408 fi
1409
1410 if test $enable_cheaders = c_global || test $enable_cheaders = c_std; then
1411 c_extra=yes
1412 fi
1413
ff66d28f 1414 AC_SUBST(C_INCLUDE_DIR)
92eabea2
PE		 1415 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1416 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
af13a7a6 1417 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
92eabea2 1418 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
af13a7a6 1419 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_EXTRA, test $c_extra = yes)
ff66d28f
PE		 1420])
1421
1422
0214010c 1423dnl
ff66d28f
PE		 1424dnl Check for which locale library to use. The choice is mapped to
1425dnl a subdirectory of config/locale.
37bc6ca2 1426dnl
ff66d28f 1427dnl Default is generic.
0214010c 1428dnl
f214923c 1429AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
ff66d28f
PE		 1430 GLIBCXX_ENABLE(clocale,auto,[@<:@=MODEL@:>@],
1431 [use MODEL for target locale package],
1432 [permit generic|gnu|ieee_1003.1-2001|yes|no|auto])
0258dc3a
BK		 1433
1434 # Deal with gettext issues. Default to not using it (=no) until we detect
1435 # support for it later. Let the user turn it off via --e/d, but let that
1436 # default to on for easier handling.
1437 USE_NLS=no
1438 AC_ARG_ENABLE(nls,
1439 AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1440 [],
1441 [enable_nls=yes])
ff66d28f 1442
0258dc3a 1443 # Either a known packaage, or "auto"
ff66d28f
PE		 1444 if test $enable_clocale = no || test $enable_clocale = yes; then
1445 enable_clocale=auto
1446 fi
0214010c
BK		 1447 enable_clocale_flag=$enable_clocale
1448
0258dc3a 1449 # Probe for locale model to use if none specified.
ff66d28f
PE		 1450 # Default to "generic".
1451 if test $enable_clocale_flag = auto; then
7d3998a4
PE		 1452 case ${target_os} in
1453 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
0258dc3a 1454 enable_clocale_flag=gnu
56deb74c 1455 ;;
a7f7b334 1456 darwin* | freebsd*)
f9686024
GK		 1457 enable_clocale_flag=darwin
1458 ;;
56deb74c 1459 *)
ff66d28f
PE		 1460 enable_clocale_flag=generic
1461 ;;
56deb74c
BK		 1462 esac
1463 fi
1464
0258dc3a
BK		 1465 # Sanity check model, and test for special functionality.
1466 if test $enable_clocale_flag = gnu; then
1467 AC_EGREP_CPP([_GLIBCXX_ok], [
1468 #include <features.h>
1469 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1470 _GLIBCXX_ok
1471 #endif
1472 ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1473
1ba74130
PC		 1474 if test $enable_clocale = auto; then
1475 # Test for bugs early in glibc-2.2.x series
1476 AC_TRY_RUN([
1477 #define _GNU_SOURCE 1
1478 #include <locale.h>
1479 #include <string.h>
1480 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
1481 extern __typeof(newlocale) __newlocale;
1482 extern __typeof(duplocale) __duplocale;
1483 extern __typeof(strcoll_l) __strcoll_l;
1484 #endif
1485 int main()
1486 {
1487