OSDN Git Service

libstdc++/3243
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / acinclude.m4
1 dnl
2 dnl Initialize configure bits.
3 dnl
4 dnl GLIBCPP_CONFIGURE
5 AC_DEFUN(GLIBCPP_CONFIGURE, [
6   dnl Default to --enable-multilib
7   AC_ARG_ENABLE(multilib,
8   [  --enable-multilib       build hella library versions (default)],
9   [case "${enableval}" in
10     yes) multilib=yes ;;
11     no)  multilib=no ;;
12     *)   AC_MSG_ERROR(bad value ${enableval} for multilib option) ;;
13    esac], [multilib=yes])dnl
14
15   glibcpp_basedir=$srcdir/$toprel/$1/libstdc++-v3
16   AC_SUBST(glibcpp_basedir)
17
18   AM_INIT_AUTOMAKE(libstdc++, 3.0.0)
19
20   # Never versions of autoconf add an underscore to these functions.
21   # Prevent future problems ...
22   ifdef([AC_PROG_CC_G],[],[define([AC_PROG_CC_G],defn([_AC_PROG_CC_G]))])
23   ifdef([AC_PROG_CC_GNU],[],[define([AC_PROG_CC_GNU],defn([_AC_PROG_CC_GNU]))])
24   ifdef([AC_PROG_CXX_G],[],[define([AC_PROG_CXX_G],defn([_AC_PROG_CXX_G]))])
25   ifdef([AC_PROG_CXX_GNU],[],[define([AC_PROG_CXX_GNU],defn([_AC_PROG_CXX_GNU]))])
26
27 #  AC_PROG_CC
28
29 # FIXME: We temporarily define our own version of AC_PROG_CC.  This is
30 # copied from autoconf 2.12, but does not call AC_PROG_CC_WORKS.  We
31 # are probably using a cross compiler, which will not be able to fully
32 # link an executable.  This should really be fixed in autoconf
33 # itself.
34
35 AC_DEFUN(LIB_AC_PROG_CC,
36 [AC_BEFORE([$0], [AC_PROG_CPP])dnl
37 dnl Fool anybody using AC_PROG_CC.
38 AC_PROVIDE([AC_PROG_CC])
39 AC_CHECK_PROG(CC, gcc, gcc)
40 if test -z "$CC"; then
41   AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc)
42   test -z "$CC" && AC_MSG_ERROR([no acceptable cc found in \$PATH])
43 fi
44
45 AC_PROG_CC_GNU
46
47 if test $ac_cv_prog_gcc = yes; then
48   GCC=yes
49 dnl Check whether -g works, even if CFLAGS is set, in case the package
50 dnl plays around with CFLAGS (such as to build both debugging and
51 dnl normal versions of a library), tasteless as that idea is.
52   ac_test_CFLAGS="${CFLAGS+set}"
53   ac_save_CFLAGS="$CFLAGS"
54   CFLAGS=
55   AC_PROG_CC_G
56   if test "$ac_test_CFLAGS" = set; then
57     CFLAGS="$ac_save_CFLAGS"
58   elif test $ac_cv_prog_cc_g = yes; then
59     CFLAGS="-g -O2"
60   else
61     CFLAGS="-O2"
62   fi
63 else
64   GCC=
65   test "${CFLAGS+set}" = set || CFLAGS="-g"
66 fi
67 ])
68
69 LIB_AC_PROG_CC
70
71 # Can't just call these here as g++ requires libstc++ to be built....
72 #  AC_PROG_CXX
73
74 # Likewise for AC_PROG_CXX.
75 AC_DEFUN(LIB_AC_PROG_CXX,
76 [AC_BEFORE([$0], [AC_PROG_CXXCPP])dnl
77 dnl Fool anybody using AC_PROG_CXX.
78 AC_PROVIDE([AC_PROG_CXX])
79 # Use glibcpp_CXX so that we do not cause CXX to be cached with the
80 # flags that come in CXX while configuring libstdc++.  They're different
81 # from those used for all other target libraries.  If CXX is set in
82 # the environment, respect that here.
83 glibcpp_CXX=$CXX
84 AC_CHECK_PROGS(glibcpp_CXX, $CCC c++ g++ gcc CC cxx cc++, gcc)
85 AC_SUBST(glibcpp_CXX)
86 CXX=$glibcpp_CXX
87 test -z "$glibcpp_CXX" && AC_MSG_ERROR([no acceptable c++ found in \$PATH])
88
89 AC_PROG_CXX_GNU
90
91 if test $ac_cv_prog_gxx = yes; then
92   GXX=yes
93 dnl Check whether -g works, even if CXXFLAGS is set, in case the package
94 dnl plays around with CXXFLAGS (such as to build both debugging and
95 dnl normal versions of a library), tasteless as that idea is.
96   ac_test_CXXFLAGS="${CXXFLAGS+set}"
97   ac_save_CXXFLAGS="$CXXFLAGS"
98   CXXFLAGS=
99   AC_PROG_CXX_G
100   if test "$ac_test_CXXFLAGS" = set; then
101     CXXFLAGS="$ac_save_CXXFLAGS"
102   elif test $ac_cv_prog_cxx_g = yes; then
103     CXXFLAGS="-g -O2"
104   else
105     CXXFLAGS="-O2"
106   fi
107 else
108   GXX=
109   test "${CXXFLAGS+set}" = set || CXXFLAGS="-g"
110 fi
111 ])
112
113 LIB_AC_PROG_CXX
114
115   AC_CHECK_TOOL(AS, as)
116   AC_CHECK_TOOL(AR, ar)
117   AC_CHECK_TOOL(RANLIB, ranlib, ranlib-not-found-in-path-error)
118   AC_PROG_INSTALL
119
120   AM_MAINTAINER_MODE
121
122   # We need AC_EXEEXT to keep automake happy in cygnus mode.  However,
123   # at least currently, we never actually build a program, so we never
124   # need to use $(EXEEXT).  Moreover, the test for EXEEXT normally
125   # fails, because we are probably configuring with a cross compiler
126   # which cant create executables.  So we include AC_EXEEXT to keep
127   # automake happy, but we dont execute it, since we dont care about
128   # the result.
129   if false; then
130     # autoconf 2.50 runs AC_EXEEXT by default, and the macro expands
131     # to nothing, so nothing would remain between `then' and `fi' if it
132     # were not for the `:' below.
133     :
134     AC_EXEEXT
135   fi
136
137   . [$]{glibcpp_basedir}/configure.host
138
139   case [$]{glibcpp_basedir} in
140     /* | [A-Za-z]:[\\/]*) libgcj_flagbasedir=[$]{glibcpp_basedir} ;;
141     *) glibcpp_flagbasedir='[$](top_builddir)/'[$]{glibcpp_basedir} ;;
142   esac
143
144   # This does for the target what configure.host does for the host.  In
145   # addition to possibly modifying the same flags, it also sets up symlinks.
146   GLIBCPP_CHECK_TARGET
147 ])
148
149
150 dnl
151 dnl Check to see if g++ can compile this library, and if so, if any version-
152 dnl specific precautions need to be taken. 
153 dnl 
154 dnl GLIBCPP_CHECK_COMPILER_VERSION
155 AC_DEFUN(GLIBCPP_CHECK_COMPILER_VERSION, [
156 if test ! -f stamp-sanity-compiler; then
157   AC_MSG_CHECKING([for g++ that will successfully compile libstdc++-v3])
158   AC_LANG_SAVE
159   AC_LANG_CPLUSPLUS
160   AC_TRY_COMPILE(, [
161   #if __GNUC__ < 3
162     not_ok
163   #endif
164   ], gpp_satisfactory=yes, AC_MSG_ERROR([please upgrade to GCC 3.0 or above]))
165   AC_LANG_RESTORE
166   AC_MSG_RESULT($gpp_satisfactory)
167   touch stamp-sanity-compiler
168 fi
169 ])
170
171
172 dnl
173 dnl Tests for newer compiler features, or features that are present in newer
174 dnl compiler versions but not older compiler versions still in use, should
175 dnl be placed here.
176 dnl
177 dnl Define WERROR='-Werror' if requested and possible; g++'s that lack the
178 dnl new inlining code or the new system_header pragma will die on -Werror.
179 dnl Leave it out by default and use maint-mode to use it.
180 dnl
181 dnl Define SECTION_FLAGS='-ffunction-sections -fdata-sections' if
182 dnl compiler supports it and the user has not requested debug mode.
183 dnl
184 dnl GLIBCPP_CHECK_COMPILER_FEATURES
185 AC_DEFUN(GLIBCPP_CHECK_COMPILER_FEATURES, [
186   # All these tests are for C++; save the language and the compiler flags.
187   # The CXXFLAGS thing is suspicious, but based on similar bits previously
188   # found in GLIBCPP_CONFIGURE.
189   AC_LANG_SAVE
190   AC_LANG_CPLUSPLUS
191   ac_test_CXXFLAGS="${CXXFLAGS+set}"
192   ac_save_CXXFLAGS="$CXXFLAGS"
193
194   # Check for maintainer-mode bits.
195   if test x"$USE_MAINTAINER_MODE" = xno; then
196     WERROR=''
197   else
198     WERROR='-Werror'
199   fi
200
201   # Check for -ffunction-sections -fdata-sections
202   AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections])
203   CXXFLAGS='-Werror -ffunction-sections -fdata-sections'
204   AC_TRY_COMPILE(, [int foo;
205   ], [ac_fdsections=yes], [ac_fdsections=no])
206   if test "$ac_test_CXXFLAGS" = set; then
207     CXXFLAGS="$ac_save_CXXFLAGS"
208   else
209     # this is the suspicious part
210     CXXFLAGS=''
211   fi
212   if test x"$ac_fdsections" = x"yes" &&
213      test x"$enable_debug" = x"no"; then
214     SECTION_FLAGS='-ffunction-sections -fdata-sections'
215   fi
216   AC_MSG_RESULT($ac_fdsections)
217
218   AC_LANG_RESTORE
219   AC_SUBST(WERROR)
220   AC_SUBST(SECTION_FLAGS)
221 ])
222
223
224 dnl
225 dnl If GNU ld is in use, check to see if tricky linker opts can be used.  If
226 dnl the native linker is in use, all variables will be defined to something
227 dnl safe (like an empty string).
228 dnl
229 dnl Define SECTION_LDFLAGS='-Wl,--gc-sections' if possible.
230 dnl Define OPT_LDFLAGS='-Wl,-O1' if possible.
231 dnl
232 dnl GLIBCPP_CHECK_LINKER_FEATURES
233 AC_DEFUN(GLIBCPP_CHECK_LINKER_FEATURES, [
234   # If we're not using GNU ld, then there's no point in even trying these
235   # tests.  Check for that first.  We should have already tested for gld
236   # by now (in libtool), but require it now just to be safe...
237   SECTION_LDFLAGS=''
238   OPT_LDFLAGS=''
239   AC_REQUIRE([AC_PROG_LD])
240
241   # Set --gc-sections.
242   if test "$ac_cv_prog_gnu_ld" = "notbroken"; then
243     # GNU ld it is!  Joy and bunny rabbits!
244
245     # All these tests are for C++; save the language and the compiler flags.
246     # Need to do this so that g++ won't try to link in libstdc++
247     ac_test_CFLAGS="${CFLAGS+set}"
248     ac_save_CFLAGS="$CFLAGS"
249     CFLAGS='-x c++  -Wl,--gc-sections'
250
251     # Check for -Wl,--gc-sections
252     # XXX This test is broken at the moment, as symbols required for
253     # linking are now in libsupc++ (not built yet.....). In addition, 
254     # this test has cored on solaris in the past. In addition,
255     # --gc-sections doesn't really work at the moment (keeps on discarding
256     # used sections, first .eh_frame and now some of the glibc sections for
257     # iconv). Bzzzzt. Thanks for playing, maybe next time.
258     AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
259     AC_TRY_RUN([
260      int main(void) 
261      {
262        try { throw 1; }
263        catch (...) { };
264        return 0;
265      }
266     ], [ac_sectionLDflags=yes],[ac_sectionLFflags=no], [ac_sectionLDflags=yes])
267     if test "$ac_test_CFLAGS" = set; then
268       CFLAGS="$ac_save_CFLAGS"
269     else
270       # this is the suspicious part
271       CFLAGS=''
272     fi
273     if test "$ac_sectionLDflags" = "yes"; then
274       SECTION_LDFLAGS='-Wl,--gc-sections'
275     fi
276     AC_MSG_RESULT($ac_sectionLDflags)
277   fi
278
279   # Set linker optimization flags.
280   if test x"$ac_cv_prog_gnu_ld" = x"yes" &&
281      test x"$enable_debug" = x"no"; then
282     OPT_LDFLAGS='-Wl,-O1'
283   fi
284
285   AC_SUBST(SECTION_LDFLAGS)
286   AC_SUBST(OPT_LDFLAGS)
287 ])
288
289
290 dnl
291 dnl Check to see if the (math function) argument passed is
292 dnl declared when using the c++ compiler
293 dnl ASSUMES argument is a math function with ONE parameter
294 dnl
295 dnl GLIBCPP_CHECK_MATH_DECL_1
296 AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_1, [
297   AC_MSG_CHECKING([for $1 declaration])
298   if test x${glibcpp_cv_func_$1_use+set} != xset; then
299     AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
300       AC_LANG_SAVE
301       AC_LANG_CPLUSPLUS
302       AC_TRY_COMPILE([#include <math.h>
303                       #ifdef HAVE_IEEEFP_H
304                       #include <ieeefp.h>
305                       #endif
306                      ], 
307                      [ $1(0);], 
308                      [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
309       AC_LANG_RESTORE
310     ])
311   fi
312   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
313 ])
314
315 dnl
316 dnl Check to see if the (math function) argument passed is
317 dnl 1) declared when using the c++ compiler
318 dnl 2) has "C" linkage
319 dnl 3) if not, see if 1) and 2) for argument prepended with '_'
320 dnl
321 dnl Define HAVE_CARGF etc if "cargf" is declared and links
322 dnl
323 dnl argument 1 is name of function to check
324 dnl
325 dnl ASSUMES argument is a math function with ONE parameter
326 dnl
327 dnl GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1
328 AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1, [
329   GLIBCPP_CHECK_MATH_DECL_1($1)
330   if test x$glibcpp_cv_func_$1_use = x"yes"; then
331     AC_CHECK_FUNCS($1)    
332   else
333     GLIBCPP_CHECK_MATH_DECL_1(_$1)
334     if test x$glibcpp_cv_func__$1_use = x"yes"; then
335       AC_CHECK_FUNCS(_$1)    
336     fi
337   fi
338 ])
339
340
341 dnl
342 dnl Like GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1, but does a bunch of
343 dnl of functions at once.  It's an all-or-nothing check -- either 
344 dnl HAVE_XYZ is defined for each of the functions, or for none of them.
345 dnl Doing it this way saves significant configure time.
346 AC_DEFUN(GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1, [
347   AC_MSG_CHECKING([for $1 functions])
348   AC_CACHE_VAL(glibcpp_cv_func_$2_use, [
349     AC_LANG_SAVE
350     AC_LANG_CPLUSPLUS
351     AC_TRY_COMPILE([#include <math.h>],
352                    [ `for x in $3; do echo "$x (0);"; done` ],
353                    [glibcpp_cv_func_$2_use=yes],
354                    [glibcpp_cv_func_$2_use=no])
355     AC_LANG_RESTORE])
356   AC_MSG_RESULT($glibcpp_cv_func_$2_use)
357   if test x$glibcpp_cv_func_$2_use = x"yes"; then
358     AC_CHECK_FUNCS($3)
359   fi
360 ])
361
362 dnl
363 dnl Check to see if the (math function) argument passed is
364 dnl declared when using the c++ compiler
365 dnl ASSUMES argument is a math function with TWO parameters
366 dnl
367 dnl GLIBCPP_CHECK_MATH_DECL_2
368 AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_2, [
369   AC_MSG_CHECKING([for $1 declaration])
370   if test x${glibcpp_cv_func_$1_use+set} != xset; then
371     AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
372       AC_LANG_SAVE
373       AC_LANG_CPLUSPLUS
374       AC_TRY_COMPILE([#include <math.h>], 
375                      [ $1(0, 0);], 
376                      [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
377       AC_LANG_RESTORE
378     ])
379   fi
380   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
381 ])
382
383 dnl
384 dnl Check to see if the (math function) argument passed is
385 dnl 1) declared when using the c++ compiler
386 dnl 2) has "C" linkage
387 dnl
388 dnl Define HAVE_CARGF etc if "cargf" is declared and links
389 dnl
390 dnl argument 1 is name of function to check
391 dnl
392 dnl ASSUMES argument is a math function with TWO parameters
393 dnl
394 dnl GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2
395 AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2, [
396   GLIBCPP_CHECK_MATH_DECL_2($1)
397   if test x$glibcpp_cv_func_$1_use = x"yes"; then
398     AC_CHECK_FUNCS($1)    
399   else
400     GLIBCPP_CHECK_MATH_DECL_2(_$1)
401     if test x$glibcpp_cv_func__$1_use = x"yes"; then
402       AC_CHECK_FUNCS(_$1)    
403     fi
404   fi
405 ])
406
407
408 dnl
409 dnl Check to see if the (math function) argument passed is
410 dnl declared when using the c++ compiler
411 dnl ASSUMES argument is a math function with THREE parameters
412 dnl
413 dnl GLIBCPP_CHECK_MATH_DECL_3
414 AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_3, [
415   AC_MSG_CHECKING([for $1 declaration])
416   if test x${glibcpp_cv_func_$1_use+set} != xset; then
417     AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
418       AC_LANG_SAVE
419       AC_LANG_CPLUSPLUS
420       AC_TRY_COMPILE([#include <math.h>], 
421                      [ $1(0, 0, 0);], 
422                      [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
423       AC_LANG_RESTORE
424     ])
425   fi
426   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
427 ])
428
429 dnl
430 dnl Check to see if the (math function) argument passed is
431 dnl 1) declared when using the c++ compiler
432 dnl 2) has "C" linkage
433 dnl
434 dnl Define HAVE_CARGF etc if "cargf" is declared and links
435 dnl
436 dnl argument 1 is name of function to check
437 dnl
438 dnl ASSUMES argument is a math function with THREE parameters
439 dnl
440 dnl GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3
441 AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3, [
442   GLIBCPP_CHECK_MATH_DECL_3($1)
443   if test x$glibcpp_cv_func_$1_use = x"yes"; then
444     AC_CHECK_FUNCS($1)    
445   else
446     GLIBCPP_CHECK_MATH_DECL_3(_$1)
447     if test x$glibcpp_cv_func__$1_use = x"yes"; then
448       AC_CHECK_FUNCS(_$1)    
449     fi
450   fi
451 ])
452
453
454 dnl
455 dnl Check to see if the (stdlib function) argument passed is
456 dnl 1) declared when using the c++ compiler
457 dnl 2) has "C" linkage
458 dnl
459 dnl argument 1 is name of function to check
460 dnl
461 dnl ASSUMES argument is a math function with TWO parameters
462 dnl
463 dnl GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2
464 AC_DEFUN(GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2, [
465   AC_MSG_CHECKING([for $1 declaration])
466   if test x${glibcpp_cv_func_$1_use+set} != xset; then
467     AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
468       AC_LANG_SAVE
469       AC_LANG_CPLUSPLUS
470       AC_TRY_COMPILE([#include <stdlib.h>], 
471                      [ $1(0, 0);], 
472                      [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
473       AC_LANG_RESTORE
474     ])
475   fi
476   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
477   if test x$glibcpp_cv_func_$1_use = x"yes"; then
478     AC_CHECK_FUNCS($1)    
479   fi
480 ])
481
482
483 dnl
484 dnl Because the builtins are picky picky picky about the arguments they take, 
485 dnl do an explict linkage tests here.
486 dnl Check to see if the (math function) argument passed is
487 dnl 1) declared when using the c++ compiler
488 dnl 2) has "C" linkage
489 dnl
490 dnl Define HAVE_CARGF etc if "cargf" is declared and links
491 dnl
492 dnl argument 1 is name of function to check
493 dnl
494 dnl ASSUMES argument is a math function with ONE parameter
495 dnl
496 dnl GLIBCPP_CHECK_BUILTIN_MATH_DECL_LINKAGE_1
497 AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1, [
498   AC_MSG_CHECKING([for $1 declaration])
499   if test x${glibcpp_cv_func_$1_use+set} != xset; then
500     AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
501       AC_LANG_SAVE
502       AC_LANG_CPLUSPLUS
503       AC_TRY_COMPILE([#include <math.h>], 
504                      [ $1(0);], 
505                      [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
506       AC_LANG_RESTORE
507     ])
508   fi
509   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
510   if test x$glibcpp_cv_func_$1_use = x"yes"; then
511     AC_MSG_CHECKING([for $1 linkage])
512     if test x${glibcpp_cv_func_$1_link+set} != xset; then
513       AC_CACHE_VAL(glibcpp_cv_func_$1_link, [
514         AC_TRY_LINK([#include <math.h>], 
515                     [ $1(0);], 
516                     [glibcpp_cv_func_$1_link=yes], [glibcpp_cv_func_$1_link=no])
517       ])
518     fi
519     AC_MSG_RESULT($glibcpp_cv_func_$1_link)
520     if test x$glibcpp_cv_func_$1_link = x"yes"; then
521       ac_tr_func=HAVE_`echo $1 | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
522       AC_DEFINE_UNQUOTED(${ac_tr_func})
523     fi
524   fi
525 ])
526
527
528 dnl
529 dnl Check to see what builtin math functions are supported
530 dnl
531 dnl check for __builtin_abs
532 dnl check for __builtin_fabsf
533 dnl check for __builtin_fabs
534 dnl check for __builtin_fabl
535 dnl check for __builtin_labs
536 dnl check for __builtin_sqrtf
537 dnl check for __builtin_sqrtl
538 dnl check for __builtin_fsqrt
539 dnl check for __builtin_sinf
540 dnl check for __builtin_sin
541 dnl check for __builtin_sinl
542 dnl check for __builtin_cosf
543 dnl check for __builtin_cos
544 dnl check for __builtin_cosl
545 dnl
546 dnl GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT
547 AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT, [
548   dnl Test for builtin math functions.
549   dnl These are made in gcc/c-common.c 
550   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_abs)
551   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabsf)
552   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabs)
553   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabsl)
554   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_labs)
555
556   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrtf)
557   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fsqrt)
558   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrtl)
559
560   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sinf)
561   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sin)
562   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sinl)
563
564   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cosf)
565   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cos)
566   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cosl)
567
568   dnl There is, without a doubt, a more elegant way to have these
569   dnl names exported so that they won't be stripped out of acconfig.h by
570   dnl autoheader. I leave this as an exercise to somebody less frustrated
571   dnl than I.... please email the libstdc++ list if you can figure out a
572   dnl more elegant approach (see autoconf/acgen.m4 and specifically
573   dnl AC_CHECK_FUNC for things to steal.)
574   dummyvar=no
575   if test x$dummyvar = x"yes"; then
576     AC_DEFINE(HAVE___BUILTIN_ABS)
577     AC_DEFINE(HAVE___BUILTIN_LABS)
578     AC_DEFINE(HAVE___BUILTIN_COS)
579     AC_DEFINE(HAVE___BUILTIN_COSF)
580     AC_DEFINE(HAVE___BUILTIN_COSL)
581     AC_DEFINE(HAVE___BUILTIN_FABS)
582     AC_DEFINE(HAVE___BUILTIN_FABSF)
583     AC_DEFINE(HAVE___BUILTIN_FABSL)
584     AC_DEFINE(HAVE___BUILTIN_SIN)
585     AC_DEFINE(HAVE___BUILTIN_SINF)
586     AC_DEFINE(HAVE___BUILTIN_SINL)
587     AC_DEFINE(HAVE___BUILTIN_FSQRT)
588     AC_DEFINE(HAVE___BUILTIN_SQRTF)
589     AC_DEFINE(HAVE___BUILTIN_SQRTL)
590   fi
591 ])
592
593
594 dnl
595 dnl Check to see what the underlying c library 
596 dnl These checks need to do two things: 
597 dnl 1) make sure the name is declared when using the c++ compiler
598 dnl 2) make sure the name has "C" linkage
599 dnl This might seem like overkill but experience has shown that it's not...
600 dnl
601 dnl Define HAVE_STRTOLD if "strtold" is declared and links
602 dnl Define HAVE_STRTOF if "strtof" is declared and links
603 dnl Define HAVE_DRAND48 if "drand48" is declared and links
604 dnl
605 dnl GLIBCPP_CHECK_STDLIB_SUPPORT
606 AC_DEFUN(GLIBCPP_CHECK_STDLIB_SUPPORT, [
607   ac_test_CXXFLAGS="${CXXFLAGS+set}"
608   ac_save_CXXFLAGS="$CXXFLAGS"
609   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
610
611   GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2(strtold)
612   AC_CHECK_FUNCS(drand48)
613
614   CXXFLAGS="$ac_save_CXXFLAGS"
615 ])
616
617
618 dnl
619 dnl Check to see what the underlying c library or math library is like.
620 dnl These checks need to do two things: 
621 dnl 1) make sure the name is declared when using the c++ compiler
622 dnl 2) make sure the name has "C" linkage
623 dnl This might seem like overkill but experience has shown that it's not...
624 dnl
625 dnl Define HAVE_CARGF etc if "cargf" is found.
626 dnl
627 dnl GLIBCPP_CHECK_MATH_SUPPORT
628 AC_DEFUN(GLIBCPP_CHECK_MATH_SUPPORT, [
629   ac_test_CXXFLAGS="${CXXFLAGS+set}"
630   ac_save_CXXFLAGS="$CXXFLAGS"
631   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
632
633   dnl Check libm
634   AC_CHECK_LIB(m, sin, libm="-lm")
635   ac_save_LIBS="$LIBS"
636   LIBS="$LIBS $libm"
637
638   dnl Check to see if certain C math functions exist.
639   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isinf)
640   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isnan)
641   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(finite)
642   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(copysign)
643   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(sincos)
644   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(fpclass)
645   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(qfpclass)
646
647   dnl Check to see if basic C math functions have float versions.
648   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(float trig,
649                                           float_trig,
650                                           acosf asinf atanf \
651                                           cosf sinf tanf \
652                                           coshf sinhf tanhf)
653   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(float round,
654                                           float_round,
655                                           ceilf floorf)
656   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isnanf)
657   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isinff)
658   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(fabsf)
659   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(fmodf)
660   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(frexpf)
661   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(ldexpf)
662   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(logf)
663   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(log10f)
664   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(modff)
665   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(powf)
666   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(sqrtf)
667   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(sincosf)
668   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(finitef)
669
670   dnl Check to see if basic C math functions have long double versions.
671   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(long double trig,
672                                           long_double_trig,
673                                           acosl asinl atanl \
674                                           cosl sinl tanl \
675                                           coshl sinhl tanhl)
676   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(long double round,
677                                           long_double_round,
678                                           ceill floorl)
679   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isnanl)
680   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isinfl)
681   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(copysignl)
682   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(atan2l)
683   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(expl)
684   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(fabsl)
685   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(fmodl)
686   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(frexpl)
687   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(ldexpl)
688   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(logl)
689   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(log10l)
690   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(modfl)
691   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(powl)
692   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(sqrtl)
693   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(sincosl)
694   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(finitel)
695
696   dnl Some runtimes have these functions with a preceding underscore. Please
697   dnl keep this sync'd with the one above. And if you add any new symbol,
698   dnl please add the corresponding block in the @BOTTOM@ section of acconfig.h.
699   dnl Check to see if certain C math functions exist.
700
701   dnl Check to see if basic C math functions have float versions.
702   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_float trig,
703                                           _float_trig,
704                                           _acosf _asinf _atanf \
705                                           _cosf _sinf _tanf \
706                                           _coshf _sinhf _tanhf)
707   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_float round,
708                                           _float_round,
709                                           _ceilf _floorf)
710
711   dnl Check to see if basic C math functions have long double versions.
712   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_long double trig,
713                                           _long_double_trig,
714                                           _acosl _asinl _atanl \
715                                           _cosl _sinl _tanl \
716                                           _coshl _sinhl _tanhl)
717   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_long double round,
718                                           _long_double_round,
719                                           _ceill _floorl)
720
721   LIBS="$ac_save_LIBS"
722   CXXFLAGS="$ac_save_CXXFLAGS"
723 ])
724
725
726 dnl
727 dnl Check to see if there is native support for complex 
728 dnl
729 dnl Don't compile bits in math/* if native support exits.
730 dnl
731 dnl Define USE_COMPLEX_LONG_DOUBLE etc if "atan2l/copysignl" is found.
732 dnl
733 dnl GLIBCPP_CHECK_COMPLEX_MATH_SUPPORT
734 AC_DEFUN(GLIBCPP_CHECK_COMPLEX_MATH_SUPPORT, [
735   dnl Check for complex versions of math functions of platform.
736   AC_CHECK_LIB(m, main)
737   AC_REPLACE_MATHFUNCS(nan hypot hypotf atan2f expf copysignf)
738
739   dnl Compile the long double complex functions only if the function 
740   dnl provides the non-complex long double functions that are needed.
741   dnl Currently this includes copysignl and atan2l, which should be
742   dnl cached from the GLIBCPP_CHECK_MATH_SUPPORT macro, above.
743   USE_COMPLEX_LONG_DOUBLE=no
744   if test x$ac_cv_func_atan2l = x"yes" &&
745      test x$ac_cv_func_copysignl = x"yes"; then
746     USE_COMPLEX_LONG_DOUBLE=yes
747     AC_REPLACE_MATHFUNCS(hypotl signbitl)
748   fi
749
750   AC_SUBST(USE_COMPLEX_LONG_DOUBLE)
751 ])
752
753
754 dnl Check to see what architecture and operating system we are compiling
755 dnl for.  Also, if architecture- or OS-specific flags are required for
756 dnl compilation, pick them up here.
757 dnl 
758 dnl GLIBCPP_CHECK_TARGET
759 AC_DEFUN(GLIBCPP_CHECK_TARGET, [
760     . [$]{glibcpp_basedir}/configure.target
761     AC_MSG_RESULT(CPU config directory is $cpu_include_dir)
762     AC_MSG_RESULT(OS config directory is $os_include_dir)
763     AC_LINK_FILES($os_include_dir/bits/os_defines.h, include/bits/os_defines.h)
764 ])
765
766
767 dnl
768 dnl Check to see if this target can enable the wchar_t parts of libstdc++.
769 dnl If --disable-c-mbchar was given, no wchar_t stuff is enabled.  (This
770 dnl must have been previously checked.)
771 dnl
772 dnl Define _GLIBCPP_USE_WCHAR_T if all the bits are found 
773 dnl Define HAVE_MBSTATE_T if mbstate_t is not in wchar.h
774 dnl
775 dnl GLIBCPP_CHECK_WCHAR_T_SUPPORT
776 AC_DEFUN(GLIBCPP_CHECK_WCHAR_T_SUPPORT, [
777
778   dnl Test wchar.h for mbstate_t, which is needed for char_traits and
779   dnl others even if wchar_t support is not on.
780   AC_MSG_CHECKING([for mbstate_t])
781   AC_TRY_COMPILE([#include <wchar.h>],
782   [mbstate_t teststate;], 
783   have_mbstate_t=yes, have_mbstate_t=no)
784   AC_MSG_RESULT($have_mbstate_t)
785   if test x"$have_mbstate_t" = xyes; then
786     AC_DEFINE(HAVE_MBSTATE_T)
787   fi
788
789   dnl Sanity check for existence of ISO C99 headers for extended encoding.
790   AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
791   AC_CHECK_HEADER(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
792   
793   dnl Only continue checking if the ISO C99 headers exist and support is on.
794   if test x"$ac_has_wchar_h" = xyes &&
795      test x"$ac_has_wctype_h" = xyes &&
796      test x"$enable_c_mbchar" != xno; then
797       
798     dnl Test wchar.h for WCHAR_MIN, WCHAR_MAX, which is needed before
799     dnl numeric_limits can instantiate type_traits<wchar_t>
800     AC_MSG_CHECKING([for WCHAR_MIN and WCHAR_MAX])
801     AC_TRY_COMPILE([#include <wchar.h>],
802     [int i = WCHAR_MIN; int j = WCHAR_MAX;], 
803     has_wchar_minmax=yes, has_wchar_minmax=no)
804     AC_MSG_RESULT($has_wchar_minmax)
805     
806     dnl Test wchar.h for WEOF, which is what we use to determine whether
807     dnl to specialize for char_traits<wchar_t> or not.
808     AC_MSG_CHECKING([for WEOF])
809     AC_TRY_COMPILE([
810       #include <wchar.h>
811       #include <stddef.h>],
812     [wint_t i = WEOF;],
813     has_weof=yes, has_weof=no)
814     AC_MSG_RESULT($has_weof)
815   
816     dnl Tests for wide character functions used in char_traits<wchar_t>.
817     ac_wfuncs=yes
818     AC_CHECK_FUNCS(wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset,, \
819     ac_wfuncs=no)
820   
821     dnl Checks for names injected into std:: by the c_std headers.
822     AC_CHECK_FUNCS(btowc wctob fgetwc fgetwc fgetws fputwc fputws fwide \
823     fwprintf fwscanf swprintf swscanf vfwprintf vfwscanf vswprintf vswscanf \
824     vwprintf vwscanf wprintf wscanf getwc getwchar mbsinit mbrlen mbrtowc \
825     mbsrtowcs wcsrtombs putwc putwchar ungetwc wcrtomb wcstod wcstof wcstol \
826     wcstoul wcscpy wcsncpy wcscat wcsncat wcscmp wcscoll wcsncmp wcsxfrm \
827     wcscspn wcsspn wcstok wcsftime wcschr wcspbrk wcsrchr wcsstr,, \
828     ac_wfuncs=no)
829
830     AC_MSG_CHECKING([for ISO C99 wchar_t support])
831     if test x"$has_weof" = xyes &&
832        test x"$has_wchar_minmax" = xyes &&
833        test x"$ac_wfuncs" = xyes; then
834       ac_isoC99_wchar_t=yes
835     else
836       ac_isoC99_wchar_t=no
837     fi
838     AC_MSG_RESULT($ac_isoC99_wchar_t)
839   
840     dnl Use iconv for wchar_t to char conversions. As such, check for 
841     dnl X/Open Portability Guide, version 2 features (XPG2).
842     AC_CHECK_HEADER(iconv.h, ac_has_iconv_h=yes, ac_has_iconv_h=no)
843     AC_CHECK_HEADER(langinfo.h, ac_has_langinfo_h=yes, ac_has_langinfo_h=no)
844
845     dnl Check for existence of libiconv.a providing XPG2 wchar_t support.
846     AC_CHECK_LIB(iconv, iconv, libiconv="-liconv")
847     ac_save_LIBS="$LIBS"
848     LIBS="$LIBS $libiconv"
849
850     AC_CHECK_FUNCS(iconv_open iconv_close iconv nl_langinfo, \
851     ac_XPG2funcs=yes, ac_XPG2funcs=no)
852   
853     LIBS="$ac_save_LIBS"
854
855     AC_MSG_CHECKING([for XPG2 wchar_t support])
856     if test x"$ac_has_iconv_h" = xyes &&
857        test x"$ac_has_langinfo_h" = xyes &&
858        test x"$ac_XPG2funcs" = xyes; then
859       ac_XPG2_wchar_t=yes
860     else
861       ac_XPG2_wchar_t=no
862     fi
863     AC_MSG_RESULT($ac_XPG2_wchar_t)
864   
865     dnl At the moment, only enable wchar_t specializations if all the
866     dnl above support is present.
867     AC_MSG_CHECKING([for enabled wchar_t specializations])
868     if test x"$ac_isoC99_wchar_t" = xyes &&
869        test x"$ac_XPG2_wchar_t" = xyes; then
870       AC_DEFINE(_GLIBCPP_USE_WCHAR_T)
871       AC_MSG_RESULT("yes")
872     else
873       AC_MSG_RESULT("no")
874     fi
875   else
876     dnl Wide characters disabled by the user. 
877     AC_MSG_WARN([wchar_t support disabled.])
878   fi
879 ])
880
881
882 dnl
883 dnl Check for special debugging mode; not for production use.
884 dnl
885 dnl GLIBCPP_ENABLE_DEBUG
886 dnl --enable-debug sets '-ggdb3 -O0'.
887 dnl --disable-debug sets '-g' and whatever optimization options the
888 dnl     compiler can handle.
889 dnl  +  --enable-maintainer-mode automatically defaults this to on.
890 dnl  +  Perhaps -D/-U of NDEBUG, DEBUG, DEBUG_ASSERT, ...?
891 dnl  +  Usage:  GLIBCPP_ENABLE_DEBUG[(DEFAULT)]
892 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
893 dnl       defaults to `no'.
894 AC_DEFUN(GLIBCPP_ENABLE_DEBUG, [dnl
895 define([GLIBCPP_ENABLE_DEBUG_DEFAULT], ifelse($1, yes, yes, no))dnl
896 AC_ARG_ENABLE(debug,
897 changequote(<<, >>)dnl
898 <<  --enable-debug          extra debugging, turn off optimization [default=>>GLIBCPP_ENABLE_DEBUG_DEFAULT],
899 changequote([, ])dnl
900 [case "${enableval}" in
901  yes) enable_debug=yes ;;
902  no)  enable_debug=no ;;
903  *)   AC_MSG_ERROR([Unknown argument to enable/disable extra debugging]) ;;
904  esac],
905 enable_debug=GLIBCPP_ENABLE_DEBUG_DEFAULT)dnl
906
907 dnl Option parsed, now set things appropriately
908 case "${enable_debug}" in
909     yes) 
910         DEBUG_FLAGS='-O0 -ggdb3'                        
911         ;; 
912     no)   
913         DEBUG_FLAGS='-g'
914         ;;
915 esac
916 AC_SUBST(DEBUG_FLAGS)
917 ])
918
919
920 dnl
921 dnl Check for "unusual" flags to pass to the compiler while building.
922 dnl
923 dnl GLIBCPP_ENABLE_CXX_FLAGS
924 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
925 dnl     experimental flags such as -fhonor-std, -fsquangle, -Dfloat=char, etc.
926 dnl     Somehow this same set of flags must be passed when [re]building
927 dnl     libgcc.
928 dnl --disable-cxx-flags passes nothing.
929 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
930 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
931 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
932 dnl  +  Usage:  GLIBCPP_ENABLE_CXX_FLAGS(default flags)
933 dnl       If "default flags" is an empty string (or "none"), the effect is
934 dnl       the same as --disable or --enable=no.
935 AC_DEFUN(GLIBCPP_ENABLE_CXX_FLAGS, [dnl
936 define([GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT], ifelse($1,,, $1))dnl
937 AC_ARG_ENABLE(cxx-flags,
938 changequote(<<, >>)dnl
939 <<  --enable-cxx-flags=FLAGS      pass compiler FLAGS when building library;
940                                 [default=>>GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT],
941 changequote([, ])dnl
942 [case "x$enableval" in
943  xyes)   
944         AC_MSG_ERROR([--enable-cxx-flags needs compiler flags as arguments]) ;;
945  xno|x)  
946         enable_cxx_flags='' ;;
947  *)      
948         enable_cxx_flags="$enableval" ;;
949  esac],
950 enable_cxx_flags='GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT')
951
952 dnl Thinko on my part during design.  This kludge is the workaround.
953 if test "$enable_cxx_flags" = "none"; then 
954   enable_cxx_flags=''; 
955 fi
956
957 dnl Run through flags (either default or command-line) and set anything
958 dnl extra (e.g., #defines) that must accompany particular g++ options.
959 if test -n "$enable_cxx_flags"; then
960     for f in $enable_cxx_flags; do
961         case "$f" in
962             -fhonor-std)  ;;
963             -*)  ;;
964             *)   # and we're trying to pass /what/ exactly?
965                  AC_MSG_ERROR([compiler flags start with a -]) ;;
966         esac
967     done
968 fi
969 EXTRA_CXX_FLAGS="$enable_cxx_flags"
970 AC_SUBST(EXTRA_CXX_FLAGS)
971 ])
972
973
974 dnl
975 dnl Check for which locale library to use:  gnu or generic.
976 dnl
977 dnl GLIBCPP_ENABLE_CLOCALE
978 dnl --enable-clocale=gnu sets config/c_locale_gnu.cc and friends
979 dnl --enable-clocale=generic sets config/c_locale_generic.cc and friends
980 dnl 
981 dnl default is generic
982 dnl
983 AC_DEFUN(GLIBCPP_ENABLE_CLOCALE, [
984   AC_MSG_CHECKING([for clocale to use])
985   AC_ARG_ENABLE(clocale,
986   [  --enable-clocale        enable model for target locale package. 
987   --enable-clocale=MODEL  use MODEL target-speific locale package. [default=generic]
988   ], 
989   if test x$enable_clocale = xno; then
990      enable_clocale=generic
991   fi,
992      enable_clocale=generic)
993
994   enable_clocale_flag=$enable_clocale
995
996   dnl Check if a valid locale package
997   case x${enable_clocale_flag} in
998     xgnu)
999       CLOCALE_H=config/c_locale_gnu.h
1000       CLOCALE_CC=config/c_locale_gnu.cc
1001       AC_MSG_RESULT(gnu)
1002       ;;
1003     xgeneric)
1004       CLOCALE_H=config/c_locale_generic.h
1005       CLOCALE_CC=config/c_locale_generic.cc
1006       AC_MSG_RESULT(generic)
1007       ;;
1008     *)
1009       echo "$enable_clocale is an unknown locale package" 1>&2
1010       exit 1
1011       ;;
1012   esac
1013
1014   AC_LINK_FILES($CLOCALE_H, include/bits/c++locale.h)
1015   AC_LINK_FILES($CLOCALE_CC, src/c++locale.cc)
1016 ])
1017
1018
1019 dnl
1020 dnl Check for which I/O library to use:  libio, or something specific.
1021 dnl
1022 dnl GLIBCPP_ENABLE_CSTDIO
1023 dnl --enable-cstdio=libio sets config/c_io_libio.h and friends
1024 dnl 
1025 dnl default is stdio
1026 dnl
1027 AC_DEFUN(GLIBCPP_ENABLE_CSTDIO, [
1028   AC_MSG_CHECKING([for cstdio to use])
1029   AC_ARG_ENABLE(cstdio,
1030   [  --enable-cstdio         enable stdio for target io package. 
1031   --enable-cstdio=LIB     use LIB target-speific io package. [default=stdio]
1032   ], 
1033   if test x$enable_cstdio = xno; then
1034      enable_cstdio=stdio
1035   fi,
1036      enable_cstdio=stdio)
1037
1038   enable_cstdio_flag=$enable_cstdio
1039
1040   dnl Check if a valid I/O package
1041   case x${enable_cstdio_flag} in
1042     xlibio)
1043       CSTDIO_H=config/c_io_libio.h
1044       BASIC_FILE_H=config/basic_file_libio.h
1045       BASIC_FILE_CC=config/basic_file_libio.cc
1046       AC_MSG_RESULT(libio)
1047
1048       # see if we are on a system with libio native (ie, linux)
1049       AC_CHECK_HEADER(libio.h,  has_libio=yes, has_libio=no)
1050
1051       # Need to check and see what version of glibc is being used. If
1052       # it's not glibc-2.2 or higher, then we'll need to go ahead and 
1053       # compile most of libio for linux systems.
1054       if test x$has_libio = x"yes"; then
1055         case "$target" in
1056           *-*-linux*)
1057               AC_MSG_CHECKING([for glibc version >= 2.2])
1058               AC_EGREP_CPP([ok], [
1059             #include <features.h>
1060               #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2) 
1061                     ok
1062               #endif
1063               ], glibc_satisfactory=yes, glibc_satisfactory=no)
1064               AC_MSG_RESULT($glibc_satisfactory)
1065             ;;
1066         esac
1067
1068         # XXX at the moment, admit defeat and force the recompilation
1069         # XXX of glibc even on glibc-2.2 systems, because libio is not synched.
1070         glibc_satisfactory=no        
1071
1072         if test x$glibc_satisfactory = x"yes"; then
1073            need_libio=no
1074            need_wlibio=no        
1075         else
1076            need_libio=yes
1077            # bkoz XXX need to add checks to enable this
1078            # pme XXX here's a first pass at such a check
1079            if test x$enable_c_mbchar != xno; then
1080               need_wlibio=yes
1081            else
1082               need_wlibio=no
1083            fi
1084         fi
1085
1086       else
1087          # Using libio, but <libio.h> doesn't exist on the target system. . .
1088          need_libio=yes
1089          # bkoz XXX need to add checks to enable this
1090          # pme XXX here's a first pass at such a check
1091          if test x$enable_c_mbchar != xno; then
1092              need_wlibio=yes
1093          else
1094              need_wlibio=no
1095          fi
1096       fi
1097       ;;
1098     xstdio | x | xno | xnone | xyes)
1099       # default
1100       CSTDIO_H=config/c_io_stdio.h
1101       BASIC_FILE_H=config/basic_file_stdio.h
1102       BASIC_FILE_CC=config/basic_file_stdio.cc
1103       AC_MSG_RESULT(stdio)
1104
1105       # We're not using stdio.
1106       need_libio=no
1107       need_wlibio=no
1108       ;;
1109     *)
1110       echo "$enable_cstdio is an unknown io package" 1>&2
1111       exit 1
1112       ;;
1113   esac
1114   AC_LINK_FILES($CSTDIO_H, include/bits/c++io.h)
1115   AC_LINK_FILES($BASIC_FILE_H, include/bits/basic_file_model.h)
1116   AC_LINK_FILES($BASIC_FILE_CC, src/basic_file.cc)
1117
1118   # 2000-08-04 bkoz hack
1119   CCODECVT_C=config/c_io_libio_codecvt.c
1120   AC_LINK_FILES($CCODECVT_C, libio/c_codecvt.c)
1121   # 2000-08-04 bkoz hack
1122
1123   AM_CONDITIONAL(GLIBCPP_BUILD_LIBIO,
1124                  test "$need_libio" = yes || test "$need_wlibio" = yes)
1125   AM_CONDITIONAL(GLIBCPP_NEED_LIBIO, test "$need_libio" = yes)
1126   AM_CONDITIONAL(GLIBCPP_NEED_WLIBIO, test "$need_wlibio" = yes)
1127   if test "$need_libio" = yes || test "$need_wlibio" = yes; then
1128     libio_la=../libio/libio.la
1129   else
1130     libio_la=
1131   fi
1132   AC_SUBST(libio_la)
1133 ])
1134
1135
1136 dnl
1137 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
1138 dnl We must stage the required headers so that they will be installed
1139 dnl with the library (unlike libgcc, the STL implementation is provided
1140 dnl solely within headers).  Since we must not inject random user-space
1141 dnl macro names into user-provided C++ code, we first stage into <file>-in
1142 dnl and process to <file> with an output command.  The reason for a two-
1143 dnl stage process here is to correctly handle $srcdir!=$objdir without
1144 dnl having to write complex code (the sed commands to clean the macro
1145 dnl namespace are complex and fragile enough as it is).  We must also
1146 dnl add a relative path so that -I- is supported properly.
1147 dnl
1148 AC_DEFUN(GLIBCPP_ENABLE_THREADS, [
1149   AC_MSG_CHECKING([for thread model used by GCC])
1150   target_thread_file=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'`
1151   AC_MSG_RESULT([$target_thread_file])
1152
1153   AC_LINK_FILES($toprel/gcc/gthr.h, include/bits/gthr.h-in)
1154   AC_LINK_FILES($toprel/gcc/gthr-single.h,
1155                 include/bits/gthr-single.h-in)
1156   AC_LINK_FILES($toprel/gcc/gthr-$target_thread_file.h,
1157                 include/bits/gthr-default.h-in)
1158   if test $target_thread_file != single; then
1159     AC_DEFINE(HAVE_GTHR_DEFAULT)
1160     AC_DEFINE(_GLIBCPP_SUPPORTS_WEAK, __GXX_WEAK__)
1161   fi
1162   AC_OUTPUT_COMMANDS([d=include/bits
1163     rm -f $d/gthr.h $d/gthr-single.h $d/gthr-default.h
1164     sed '/^#/s/\([A-Z_][A-Z_]*\)/_GLIBCPP_\1/g' <$d/gthr.h-in \
1165       | sed 's,"gthr-,"bits/gthr-,' >$d/gthr.h
1166     sed 's/\(UNUSED\)/_GLIBCPP_\1/g' <$d/gthr-single.h-in \
1167       | sed 's/\(GCC[A-Z_]*_H\)/_GLIBCPP_\1/g' >$d/gthr-single.h
1168     sed 's/\(UNUSED\)/_GLIBCPP_\1/g' <$d/gthr-default.h-in \
1169       | sed 's/\(GCC[A-Z_]*_H\)/_GLIBCPP_\1/g' \
1170       | sed 's/\([A-Z_]*WEAK\)/_GLIBCPP_\1/g' >$d/gthr-default.h])
1171 ])
1172
1173
1174 dnl
1175 dnl Check for exception handling support.  If an explicit enable/disable
1176 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
1177 dnl target may or may not support call frame exceptions.
1178 dnl
1179 dnl GLIBCPP_ENABLE_SJLJ_EXCEPTIONS
1180 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
1181 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
1182 dnl
1183 dnl Define _GLIBCPP_SJLJ_EXCEPTIONS if the compiler is configured for it.
1184 dnl
1185 AC_DEFUN(GLIBCPP_ENABLE_SJLJ_EXCEPTIONS, [
1186   AC_MSG_CHECKING([for exception model to use])
1187   AC_LANG_SAVE
1188   AC_LANG_CPLUSPLUS
1189   AC_ARG_ENABLE(sjlj-exceptions,
1190   [  --enable-sjlj-exceptions  force use of builtin_setjmp for exceptions],
1191   [:],
1192   [dnl Botheration.  Now we've got to detect the exception model.
1193    dnl Link tests against libgcc.a are problematic since -- at least
1194    dnl as of this writing -- we've not been given proper -L bits for
1195    dnl single-tree newlib and libgloss.
1196    dnl
1197    dnl This is what AC_TRY_COMPILE would do if it didn't delete the
1198    dnl conftest files before we got a change to grep them first.
1199    cat > conftest.$ac_ext << EOF
1200 [#]line __oline__ "configure"
1201 struct S { ~S(); };
1202 void bar();
1203 void foo()
1204 {
1205   S s;
1206   bar();
1207 }
1208 EOF
1209    old_CXXFLAGS="$CXXFLAGS"  
1210    CXXFLAGS=-S
1211    if AC_TRY_EVAL(ac_compile); then
1212      if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
1213        enable_sjlj_exceptions=yes
1214      elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
1215        enable_sjlj_exceptions=no
1216      fi
1217    fi
1218    CXXFLAGS="$old_CXXFLAGS"
1219    rm -f conftest*])
1220    if test x$enable_sjlj_exceptions = xyes; then
1221      AC_DEFINE(_GLIBCPP_SJLJ_EXCEPTIONS, 1,
1222         [Define if the compiler is configured for setjmp/longjmp exceptions.])
1223      ac_exception_model_name=sjlj
1224    elif test x$enable_sjlj_exceptions = xno; then
1225      ac_exception_model_name="call frame"
1226    else
1227      AC_MSG_ERROR([unable to detect exception model])
1228    fi
1229    AC_LANG_RESTORE
1230    AC_MSG_RESULT($ac_exception_model_name)
1231 ])
1232
1233
1234 dnl
1235 dnl Check for ISO/IEC 9899:1999 "C99" support.
1236 dnl
1237 dnl GLIBCPP_ENABLE_C99
1238 dnl --enable-c99 defines _GLIBCPP_USE_C99
1239 dnl --disable-c99 leaves _GLIBCPP_USE_C99 undefined
1240 dnl  +  Usage:  GLIBCPP_ENABLE_C99[(DEFAULT)]
1241 dnl       Where DEFAULT is either `yes' or `no'.  If omitted, it
1242 dnl       defaults to `no'.
1243 dnl  +  If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
1244 dnl
1245 dnl GLIBCPP_ENABLE_C99
1246 AC_DEFUN(GLIBCPP_ENABLE_C99, [dnl
1247   define([GLIBCPP_ENABLE_C99_DEFAULT], ifelse($1, yes, yes, no))dnl
1248
1249   AC_ARG_ENABLE(c99,
1250   changequote(<<, >>)dnl
1251   <<--enable-c99      turns on 'ISO/IEC 9899:1999 support' [default=>>GLIBCPP_ENABLE_C99_DEFAULT],
1252   changequote([, ])dnl
1253   [case "$enableval" in
1254    yes) enable_c99=yes ;;
1255    no)  enable_c99=no ;;
1256    *)   AC_MSG_ERROR([Unknown argument to enable/disable C99]) ;;
1257    esac],
1258   enable_c99=GLIBCPP_ENABLE_C99_DEFAULT)dnl
1259  
1260   AC_LANG_SAVE
1261   AC_LANG_CPLUSPLUS
1262
1263   # Check for the existence of <math.h> functions used if C99 is enabled.
1264   ac_c99_math=yes;
1265   AC_MSG_CHECKING([for ISO C99 support in <math.h>])
1266   AC_TRY_COMPILE([#include <math.h>],[fpclassify(0.0);],, [ac_c99_math=no])
1267   AC_TRY_COMPILE([#include <math.h>],[isfinite(0.0);],, [ac_c99_math=no])
1268   AC_TRY_COMPILE([#include <math.h>],[isinf(0.0);],, [ac_c99_math=no])
1269   AC_TRY_COMPILE([#include <math.h>],[isnan(0.0);],, [ac_c99_math=no])
1270   AC_TRY_COMPILE([#include <math.h>],[isnormal(0.0);],, [ac_c99_math=no])
1271   AC_TRY_COMPILE([#include <math.h>],[signbit(0.0);],, [ac_c99_math=no])
1272   AC_TRY_COMPILE([#include <math.h>],[isgreater(0.0,0.0);],, [ac_c99_math=no])
1273   AC_TRY_COMPILE([#include <math.h>],
1274                  [isgreaterequal(0.0,0.0);],, [ac_c99_math=no])
1275   AC_TRY_COMPILE([#include <math.h>],[isless(0.0,0.0);],, [ac_c99_math=no])
1276   AC_TRY_COMPILE([#include <math.h>],[islessequal(0.0,0.0);],,[ac_c99_math=no])
1277   AC_TRY_COMPILE([#include <math.h>],
1278                  [islessgreater(0.0,0.0);],, [ac_c99_math=no])
1279   AC_TRY_COMPILE([#include <math.h>],
1280                  [isunordered(0.0,0.0);],, [ac_c99_math=no])
1281   AC_MSG_RESULT($ac_c99_math)
1282
1283   # Check for the existence in <stdio.h> of vscanf, et. al.
1284   ac_c99_stdio=yes;
1285   AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
1286   AC_TRY_COMPILE([#include <stdio.h>],
1287                  [snprintf("12", 0, "%i");],, [ac_c99_stdio=no])
1288   AC_TRY_COMPILE([#include <stdio.h>
1289                   #include <stdarg.h>
1290                   void foo(char* fmt, ...)
1291                   {va_list args; va_start(args, fmt);
1292                   vfscanf(stderr, "%i", args);}],
1293                   [],, [ac_c99_stdio=no])
1294   AC_TRY_COMPILE([#include <stdio.h>
1295                   #include <stdarg.h>
1296                   void foo(char* fmt, ...)
1297                   {va_list args; va_start(args, fmt);
1298                   vscanf("%i", args);}],
1299                   [],, [ac_c99_stdio=no])
1300   AC_TRY_COMPILE([#include <stdio.h>
1301                   #include <stdarg.h>
1302                   void foo(char* fmt, ...)
1303                   {va_list args; va_start(args, fmt);
1304                   vsnprintf(fmt, 0, "%i", args);}],
1305                   [],, [ac_c99_stdio=no])
1306   AC_TRY_COMPILE([#include <stdio.h>
1307                   #include <stdarg.h>
1308                   void foo(char* fmt, ...)
1309                   {va_list args; va_start(args, fmt);
1310                   vsscanf(fmt, "%i", args);}],
1311                   [],, [ac_c99_stdio=no])
1312   AC_MSG_RESULT($ac_c99_stdio)
1313
1314   # Check for the existence in <stdlib.h> of lldiv_t, et. al.
1315   ac_c99_stdlib=yes;
1316   AC_MSG_CHECKING([for lldiv_t declaration])
1317   AC_CACHE_VAL(ac_c99_lldiv_t, [
1318   AC_TRY_COMPILE([#include <stdlib.h>], 
1319                    [ lldiv_t mydivt;], 
1320                    [ac_c99_lldiv_t=yes], [ac_c99_lldiv_t=no])
1321   ])
1322   AC_MSG_RESULT($ac_c99_lldiv_t)
1323
1324   AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
1325   AC_TRY_COMPILE([#include <stdlib.h>],
1326                  [char* tmp; strtof("gnu", &tmp);],, [ac_c99_stdlib=no])
1327   AC_TRY_COMPILE([#include <stdlib.h>],
1328                  [char* tmp; strtold("gnu", &tmp);],, [ac_c99_stdlib=no])
1329   AC_TRY_COMPILE([#include <stdlib.h>],
1330                  [char* tmp; strtoll("gnu", &tmp, 10);],, [ac_c99_stdlib=no])
1331   AC_TRY_COMPILE([#include <stdlib.h>],
1332                  [char* tmp; strtoull("gnu", &tmp, 10);],, [ac_c99_stdlib=no])
1333   AC_TRY_COMPILE([#include <stdlib.h>], [llabs(10);],, [ac_c99_stdlib=no])
1334   AC_TRY_COMPILE([#include <stdlib.h>], [lldiv(10,1);],, [ac_c99_stdlib=no])
1335   AC_TRY_COMPILE([#include <stdlib.h>], [atoll("10");],, [ac_c99_stdlib=no])
1336   AC_TRY_COMPILE([#include <stdlib.h>], [_Exit(0);],, [ac_c99_stdlib=no])
1337   if test x"$ac_c99_lldiv_t" = x"no"; then
1338     ac_c99_stdlib=no; 
1339   fi; 
1340   AC_MSG_RESULT($ac_c99_stdlib)
1341
1342   # Check for the existence of <wchar.h> functions used if C99 is enabled.
1343   # XXX the wchar.h checks should be rolled into the general C99 bits.
1344   ac_c99_wchar=yes;
1345   AC_MSG_CHECKING([for additional ISO C99 support in <wchar.h>])
1346   AC_TRY_COMPILE([#include <wchar.h>], 
1347                  [wcstold(L"10.0", NULL);],, [ac_c99_wchar=no])
1348   AC_TRY_COMPILE([#include <wchar.h>], 
1349                  [wcstoll(L"10", NULL, 10);],, [ac_c99_wchar=no])
1350   AC_TRY_COMPILE([#include <wchar.h>], 
1351                  [wcstoull(L"10", NULL, 10);],, [ac_c99_wchar=no])
1352   AC_MSG_RESULT($ac_c99_wchar)
1353
1354   AC_MSG_CHECKING([for enabled ISO C99 support])
1355   if test x"$ac_c99_math" = x"no" ||
1356      test x"$ac_c99_stdio" = x"no" ||
1357      test x"$ac_c99_stdlib" = x"no" ||
1358      test x"$ac_c99_wchar" = x"no"; then
1359     enable_c99=no; 
1360   fi; 
1361   AC_MSG_RESULT($enable_c99)
1362
1363   # Option parsed, now set things appropriately
1364   if test x"$enable_c99" = x"yes"; then
1365     AC_DEFINE(_GLIBCPP_USE_C99)
1366   fi
1367
1368   AC_LANG_RESTORE
1369 ])
1370
1371
1372 dnl
1373 dnl Check for template specializations for the 'long long' type extension.
1374 dnl NB: Must check for C99 support before calling _GLIBCPP_ENABLE_LONG_LONG
1375 dnl
1376 dnl GLIBCPP_ENABLE_LONG_LONG
1377 dnl --enable-long-long defines _GLIBCPP_USE_LONG_LONG
1378 dnl --disable-long-long leaves _GLIBCPP_USE_LONG_LONG undefined
1379 dnl  +  Usage:  GLIBCPP_ENABLE_LONG_LONG[(DEFAULT)]
1380 dnl       Where DEFAULT is either `yes' or `no'.  If omitted, it
1381 dnl       defaults to `no'.
1382 dnl  +  If 'long long' stuff is not available, ignores DEFAULT and sets `no'.
1383 dnl
1384 dnl GLIBCPP_ENABLE_LONG_LONG
1385 AC_DEFUN(GLIBCPP_ENABLE_LONG_LONG, [dnl
1386   define([GLIBCPP_ENABLE_LONG_LONG_DEFAULT], ifelse($1, yes, yes, no))dnl
1387
1388   AC_ARG_ENABLE(long-long,
1389   changequote(<<, >>)dnl
1390   <<--enable-long-long      turns on 'long long' [default=>>GLIBCPP_ENABLE_LONG_LONG_DEFAULT],
1391   changequote([, ])dnl
1392   [case "$enableval" in
1393    yes) enable_long_long=yes ;;
1394    no)  enable_long_long=no ;;
1395    *)   AC_MSG_ERROR([Unknown argument to enable/disable long long]) ;;
1396    esac],
1397   enable_long_long=GLIBCPP_ENABLE_LONG_LONG_DEFAULT)dnl
1398
1399   # iostreams require strtoll, strtoull to compile. If the
1400   # GLIBCPP_ENABLE_C99 tests found these, and if C99 support is enabled,
1401   # go ahead and allow long long to be used.
1402   if test x"$enable_c99" = x"no"; then
1403     enable_long_long=no; 
1404   fi
1405
1406   # Option parsed, now set things appropriately
1407   AC_MSG_CHECKING([for enabled long long support])
1408   if test x"$enable_long_long" = xyes; then
1409     AC_DEFINE(_GLIBCPP_USE_LONG_LONG)
1410   fi
1411   AC_MSG_RESULT($enable_long_long)
1412 ])
1413
1414
1415 dnl
1416 dnl Check for what kind of C headers to use.
1417 dnl
1418 dnl GLIBCPP_ENABLE_CHEADERS
1419 dnl --enable-cheaders= [does stuff].
1420 dnl --disable-cheaders [does not do anything, really].
1421 dnl  +  This will eventually need to be 'c_shadow' by default.
1422 dnl  +  Usage:  GLIBCPP_ENABLE_CHEADERS[(DEFAULT)]
1423 dnl       Where DEFAULT is either `c' or `c_std' or 'c_shadow'.  
1424 dnl       If ommitted, it defaults to `c_std'.
1425 AC_DEFUN(GLIBCPP_ENABLE_CHEADERS, [dnl
1426 define([GLIBCPP_ENABLE_CHEADERS_DEFAULT], ifelse($1, c_std, c_std, c_std))dnl
1427 AC_MSG_CHECKING([for c header strategy to use])
1428 AC_ARG_ENABLE(cheaders,
1429 changequote(<<, >>)dnl
1430 <<  --enable-cheaders       construct "C" header files for g++ [default=>>GLIBCPP_ENABLE_CHEADERS_DEFAULT],
1431 changequote([, ])
1432   [case "$enableval" in
1433    c) 
1434         enable_cheaders=c 
1435         ;;
1436    c_std)  
1437         enable_cheaders=c_std 
1438         ;;
1439    c_shadow)  
1440         enable_cheaders=c_shadow 
1441         ;;
1442    *)   AC_MSG_ERROR([Unknown argument to enable/disable "C" headers]) 
1443         ;;
1444   esac],
1445   enable_cheaders=GLIBCPP_ENABLE_CHEADERS_DEFAULT)
1446   AC_MSG_RESULT($enable_cheaders)
1447
1448   dnl Option parsed, now set things appropriately
1449   case "$enable_cheaders" in
1450     c_shadow) 
1451         CSHADOW_FLAGS="-fno-builtin"
1452         C_INCLUDE_DIR='${top_srcdir}/include/c_shadow'
1453         AC_DEFINE(_GLIBCPP_USE_SHADOW_HEADERS)
1454         ;;
1455     c_std)   
1456         CSHADOW_FLAGS=""
1457         C_INCLUDE_DIR='${top_srcdir}/include/c_std'
1458         ;;
1459     c)   
1460         CSHADOW_FLAGS=""
1461         C_INCLUDE_DIR='${top_srcdir}/include/c'
1462         ;;
1463   esac
1464
1465   AC_SUBST(CSHADOW_FLAGS)
1466   AC_SUBST(C_INCLUDE_DIR)
1467   AM_CONDITIONAL(GLIBCPP_USE_CSHADOW, test "$enable_cheaders" = c_shadow)
1468 ])
1469
1470
1471 dnl
1472 dnl Check for wide character support.  Has the same effect as the option
1473 dnl in gcc's configure, but in a form that autoconf can mess with.
1474 dnl
1475 dnl GLIBCPP_ENABLE_C_MBCHAR
1476 dnl --enable-c-mbchar requests all the wchar_t stuff.
1477 dnl --disable-c-mbchar doesn't.
1478 dnl  +  Usage:  GLIBCPP_ENABLE_C_MBCHAR[(DEFAULT)]
1479 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
1480 dnl       defaults to `no'.
1481 AC_DEFUN(GLIBCPP_ENABLE_C_MBCHAR, [dnl
1482 define([GLIBCPP_ENABLE_C_MBCHAR_DEFAULT], ifelse($1, yes, yes, no))dnl
1483 AC_ARG_ENABLE(c-mbchar,
1484 changequote(<<, >>)dnl
1485 <<  --enable-c-mbchar       enable multibyte (wide) characters [default=>>GLIBCPP_ENABLE_C_MBCHAR_DEFAULT],
1486 changequote([, ])dnl
1487 [case "$enableval" in
1488  yes) enable_c_mbchar=yes ;;
1489  no)  enable_c_mbchar=no ;;
1490  *)   AC_MSG_ERROR([Unknown argument to enable/disable c-mbchar]) ;;
1491  esac],
1492 enable_c_mbchar=GLIBCPP_ENABLE_C_MBCHAR_DEFAULT)dnl
1493 dnl Option parsed, now other scripts can test enable_c_mbchar for yes/no.
1494 ])
1495
1496
1497 dnl
1498 dnl Set up *_INCLUDES and *_INCLUDE_DIR variables for all sundry Makefile.am's.
1499 dnl
1500 dnl GLIBCPP_INCLUDE_DIR
1501 dnl C_INCLUDE_DIR
1502 dnl TOPLEVEL_INCLUDES
1503 dnl LIBMATH_INCLUDES
1504 dnl LIBSUPCXX_INCLUDES
1505 dnl LIBIO_INCLUDES
1506 dnl CSHADOW_INCLUDES
1507 dnl
1508 dnl GLIBCPP_EXPORT_INCLUDE
1509 AC_DEFUN(GLIBCPP_EXPORT_INCLUDES, [
1510   # Root level of the include sources.
1511   GLIBCPP_INCLUDE_DIR='$(top_srcdir)/include'
1512
1513   # Can either use include/c or include/c_std to grab "C" headers. This
1514   # variable is set to the include directory currently in use.
1515   # set with C_INCLUDE_DIR in GLIBCPP_ENABLE_CHEADERS
1516    
1517   # Passed down for canadian crosses.
1518   if  test x"$CANADIAN" = xyes; then
1519     TOPLEVEL_INCLUDES='-I$(includedir)'
1520   fi
1521
1522   LIBMATH_INCLUDES='-I$(top_srcdir)/libmath'
1523
1524   LIBSUPCXX_INCLUDES='-I$(top_srcdir)/libsupc++'
1525
1526   #if GLIBCPP_NEED_LIBIO
1527   LIBIO_INCLUDES='-I$(top_builddir)/libio -I$(top_srcdir)/libio'
1528   #else
1529   #LIBIO_INCLUDES='-I$(top_srcdir)/libio'
1530   #endif
1531
1532   #if GLIBCPP_USE_CSHADOW
1533   #  CSHADOW_INCLUDES='-I$(GLIBCPP_INCLUDE_DIR)/std -I$(C_INCLUDE_DIR) \
1534   #                   -I$(top_blddir)/cshadow'
1535   #else
1536   CSTD_INCLUDES='-I$(GLIBCPP_INCLUDE_DIR)/std -I$(C_INCLUDE_DIR)'
1537   #endif
1538
1539   # Now, export this to all the little Makefiles....
1540   AC_SUBST(GLIBCPP_INCLUDE_DIR)
1541   AC_SUBST(TOPLEVEL_INCLUDES)
1542   AC_SUBST(LIBMATH_INCLUDES)
1543   AC_SUBST(LIBSUPCXX_INCLUDES)
1544   AC_SUBST(LIBIO_INCLUDES)
1545   AC_SUBST(CSTD_INCLUDES)
1546 ])
1547
1548
1549 dnl
1550 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
1551 dnl
1552 AC_DEFUN(GLIBCPP_EXPORT_FLAGS, [
1553   # Optimization flags that are probably a good idea for thrill-seekers. Just
1554   # uncomment the lines below and make, everything else is ready to go... 
1555   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc 
1556   OPTIMIZE_CXXFLAGS=
1557   AC_SUBST(OPTIMIZE_CXXFLAGS)
1558
1559   WARN_FLAGS='-Wall -Wno-format -W -Wwrite-strings -Winline'
1560   AC_SUBST(WARN_FLAGS)
1561 ])
1562
1563 dnl
1564 dnl  GLIBCPP_EXPORT_INSTALL_INFO
1565 dnl  calculates gxx_install_dir
1566 dnl  exports glibcpp_toolexecdir
1567 dnl  exports glibcpp_toolexeclibdir
1568 dnl  exports glibcpp_builddir
1569 dnl  exports glibcpp_srcdir
1570 dnl  exports glibcpp_prefixdir
1571 dnl
1572 dnl Assumes cross_compiling bits already done, and with_cross_host in
1573 dnl particular
1574 dnl
1575 dnl GLIBCPP_EXPORT_INSTALL_INFO
1576 AC_DEFUN(GLIBCPP_EXPORT_INSTALL_INFO, [
1577
1578 glibcpp_toolexecdir=no
1579 glibcpp_toolexeclibdir=no
1580
1581 # Export build and source directories.
1582 # These need to be absolute paths, yet at the same time need to
1583 # canonicalize only relative paths, because then amd will not unmount
1584 # drives. Thus the use of PWDCMD: set it to 'pawd' or 'amq -w' if using amd.
1585 glibcpp_builddir=`pwd`
1586 case $srcdir in
1587 [\\/$]* | ?:[\\/]*) glibcpp_srcdir=${srcdir} ;;
1588 *) glibcpp_srcdir=`cd "$srcdir" && ${PWDCMD-pwd} || echo "$srcdir"` ;;
1589 esac
1590 glibcpp_prefixdir=${prefix}
1591
1592 AC_MSG_CHECKING([for interface version number])
1593 libstdcxx_interface=$INTERFACE
1594 AC_MSG_RESULT($libstdcxx_interface)
1595
1596 # Process the option --with-gxx-include-dir=<path to include-files directory>
1597 AC_MSG_CHECKING([for --with-gxx-include-dir])
1598 AC_ARG_WITH(gxx-include-dir,
1599 [  --with-gxx-include-dir  the installation directory for include files],
1600 [case "${withval}" in
1601   yes)
1602     AC_MSG_ERROR(Missing directory for --with-gxx-include-dir)
1603     gxx_include_dir=no
1604     ;;
1605   no)
1606     gxx_include_dir=no
1607     ;;
1608   *)
1609     gxx_include_dir=${withval}
1610     ;;
1611 esac], [gxx_include_dir=no])
1612 AC_MSG_RESULT($gxx_include_dir)
1613
1614 # Process the option "--enable-version-specific-runtime-libs"
1615 AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
1616 AC_ARG_ENABLE(version-specific-runtime-libs,
1617 [  --enable-version-specific-runtime-libs    Specify that runtime libraries should be installed in a compiler-specific directory ],
1618 [  version_specific_libs=yes
1619 # Need the gcc compiler version to know where to install libraries
1620 # and header files if --enable-version-specific-runtime-libs option
1621 # is selected.
1622 changequote(,)dnl
1623 gcc_version_trigger=${srcdir}/../gcc/version.c
1624 gcc_version_full=`grep version_string ${gcc_version_trigger} | sed -e 's/.*\"\([^\"]*\)\".*/\1/'`
1625 gcc_version=`echo ${gcc_version_full} | sed -e 's/\([^ ]*\) .*/\1/'`
1626 gxx_include_dir='$(libdir)/gcc-lib/$(target_alias)/'${gcc_version}/include/g++
1627 glibcpp_toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
1628 glibcpp_toolexeclibdir='$(toolexecdir)/'${gcc_version}'$(MULTISUBDIR)'
1629 changequote([,])dnl
1630 ],version_specific_libs=no)
1631 AC_MSG_RESULT($version_specific_libs)
1632
1633 # Default case for install directory for include files.
1634 if test x"$version_specific_libs" = x"no" \
1635    && test x"$gxx_include_dir" = x"no"; then
1636   gxx_include_dir='$(prefix)'/include/g++-${libstdcxx_interface}
1637 fi
1638
1639 # Calculate glibcpp_toolexecdir, glibcpp_toolexeclibdir
1640 # Install a library built with a cross compiler in tooldir, not libdir.
1641 if test x"$glibcpp_toolexecdir" = x"no"; then 
1642   if test -n "$with_cross_host" &&
1643      test x"$with_cross_host" != x"no"; then
1644     glibcpp_toolexecdir='$(exec_prefix)/$(target_alias)'
1645     glibcpp_toolexeclibdir='$(toolexecdir)/lib$(MULTISUBDIR)'
1646   else
1647     glibcpp_toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
1648     glibcpp_toolexeclibdir='$(libdir)$(MULTISUBDIR)'
1649   fi
1650 fi
1651
1652 AC_MSG_CHECKING([for install location])
1653 AC_MSG_RESULT($gxx_include_dir)
1654
1655 AC_SUBST(glibcpp_builddir)
1656 AC_SUBST(glibcpp_srcdir)
1657 AC_SUBST(glibcpp_prefixdir)
1658 AC_SUBST(gxx_include_dir)
1659 AC_SUBST(glibcpp_toolexecdir)
1660 AC_SUBST(glibcpp_toolexeclibdir)
1661 ])
1662
1663
1664 # Check whether LC_MESSAGES is available in <locale.h>.
1665 # Ulrich Drepper <drepper@cygnus.com>, 1995.
1666 #
1667 # This file file be copied and used freely without restrictions.  It can
1668 # be used in projects which are not available under the GNU Public License
1669 # but which still want to provide support for the GNU gettext functionality.
1670 # Please note that the actual code is *not* freely available.
1671
1672 # serial 1
1673
1674 AC_DEFUN(AC_LC_MESSAGES, [
1675   AC_CHECK_HEADER(locale.h, [
1676     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
1677       [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
1678        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
1679     if test $ac_cv_val_LC_MESSAGES = yes; then
1680       AC_DEFINE(HAVE_LC_MESSAGES)
1681     fi
1682   ])
1683 ])
1684
1685
1686 # Check for functions in math library.
1687 # Ulrich Drepper <drepper@cygnus.com>, 1998.
1688 #
1689 # This file can be copied and used freely without restrictions.  It can
1690 # be used in projects which are not available under the GNU Public License
1691 # but which still want to provide support for the GNU gettext functionality.
1692 # Please note that the actual code is *not* freely available.
1693
1694 # serial 1
1695
1696 dnl AC_REPLACE_MATHFUNCS(FUNCTION...)
1697 AC_DEFUN(AC_REPLACE_MATHFUNCS,
1698 [AC_CHECK_FUNCS([$1], , [LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"])
1699 AC_SUBST(LIBMATHOBJS)dnl
1700 ])
1701
1702
1703 # Check for string functions.
1704 # Ulrich Drepper <drepper@cygnus.com>, 1998.
1705 #
1706 # This file can be copied and used freely without restrictions.  It can
1707 # be used in projects which are not available under the GNU Public License
1708 # but which still want to provide support for the GNU gettext functionality.
1709 # Please note that the actual code is *not* freely available.
1710
1711 # serial 1
1712
1713 dnl AC_REPLACE_STRINGFUNCS(FUNCTION...)
1714 AC_DEFUN(AC_REPLACE_STRINGFUNCS,
1715 [AC_CHECK_FUNCS([$1], , [LIBSTRINGOBJS="$LIBSTRINGOBJS ${ac_func}.lo"])
1716 AC_SUBST(LIBSTRINGOBJS)dnl
1717 ])
1718
1719
1720 dnl This macro searches for a GNU version of make.  If a match is found, the
1721 dnl makefile variable `ifGNUmake' is set to the empty string, otherwise it is
1722 dnl set to "#". This is useful for  including a special features in a Makefile,
1723 dnl which cannot be handled by other versions of make.  The variable
1724 dnl _cv_gnu_make_command is set to the command to invoke GNU make if it exists,
1725 dnl the empty string otherwise.
1726 dnl
1727 dnl Here is an example of its use:
1728 dnl
1729 dnl Makefile.in might contain:
1730 dnl
1731 dnl     # A failsafe way of putting a dependency rule into a makefile
1732 dnl     $(DEPEND):
1733 dnl             $(CC) -MM $(srcdir)/*.c > $(DEPEND)
1734 dnl
1735 dnl     @ifGNUmake@ ifeq ($(DEPEND),$(wildcard $(DEPEND)))
1736 dnl     @ifGNUmake@ include $(DEPEND)
1737 dnl     @ifGNUmake@ endif
1738 dnl
1739 dnl Then configure.in would normally contain:
1740 dnl
1741 dnl     CHECK_GNU_MAKE()
1742 dnl     AC_OUTPUT(Makefile)
1743 dnl
1744 dnl Then perhaps to cause gnu make to override any other make, we could do
1745 dnl something like this (note that GNU make always looks for GNUmakefile first):
1746 dnl
1747 dnl     if  ! test x$_cv_gnu_make_command = x ; then
1748 dnl             mv Makefile GNUmakefile
1749 dnl             echo .DEFAULT: > Makefile ;
1750 dnl             echo \  $_cv_gnu_make_command \$@ >> Makefile;
1751 dnl     fi
1752 dnl
1753 dnl Then, if any (well almost any) other make is called, and GNU make also
1754 dnl exists, then the other make wraps the GNU make.
1755 dnl
1756 dnl @author John Darrington <j.darrington@elvis.murdoch.edu.au>
1757 dnl @version 1.1 #### replaced Id string now that Id is for lib-v3; pme
1758 dnl
1759 dnl #### Changes for libstdc++-v3:  reformatting and linewrapping; prepending
1760 dnl #### GLIBCPP_ to the macro name; adding the :-make fallback in the
1761 dnl #### conditional's subshell (" --version" is not a command), using a
1762 dnl #### different option to grep(1).
1763 dnl #### -pme
1764 dnl #### Fixed Bourne shell portability bug (use ${MAKE-make}, not
1765 dnl #### ${MAKE:-make}).
1766 dnl #### -msokolov
1767 AC_DEFUN(
1768   GLIBCPP_CHECK_GNU_MAKE, [AC_CACHE_CHECK( for GNU make,_cv_gnu_make_command,
1769           _cv_gnu_make_command='' ;
1770 dnl Search all the common names for GNU make
1771           for a in "${MAKE-make}" make gmake gnumake ; do
1772                   if ( $a --version 2> /dev/null | grep -c GNU > /dev/null )
1773                   then
1774                           _cv_gnu_make_command=$a ;
1775                           break;
1776                   fi
1777           done ;
1778   ) ;
1779 dnl If there was a GNU version, then set @ifGNUmake@ to the empty
1780 dnl string, '#' otherwise
1781   if test  "x$_cv_gnu_make_command" != "x"  ; then
1782           ifGNUmake='' ;
1783   else
1784           ifGNUmake='#' ;
1785   fi
1786   AC_SUBST(ifGNUmake)
1787 ])
1788
1789 sinclude(../libtool.m4)
1790 dnl The lines below arrange for aclocal not to bring an installed
1791 dnl libtool.m4 into aclocal.m4, while still arranging for automake to
1792 dnl add a definition of LIBTOOL to Makefile.in.
1793 ifelse(,,,[AC_SUBST(LIBTOOL)
1794 AC_DEFUN([AM_PROG_LIBTOOL])
1795 AC_DEFUN([AC_LIBTOOL_DLOPEN])
1796 AC_DEFUN([AC_PROG_LD])
1797 ])
1798
1799