| blob | c27d914864d932ab53e004b6b4581932b958e13c |
1 # -*- Autoconf -*-
2 # This file is part of the aMule Project.
3 #
4 # Copyright (c) 2003-2011 aMule Team ( admin@amule.org / http://www.amule.org )
5 #
6 # Any parts of this program derived from the xMule, lMule or eMule project,
7 # or contributed by third-party developers are copyrighted by their
8 # respective authors.
9 #
10 # This program is free software; you can redistribute it and/or modify
11 # it under the terms of the GNU General Public License as published by
12 # the Free Software Foundation; either version 2 of the License, or
13 # (at your option) any later version.
14 #
15 # This program is distributed in the hope that it will be useful,
16 # but WITHOUT ANY WARRANTY; without even the implied warranty of
17 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 # GNU General Public License for more details.
19 #
20 # You should have received a copy of the GNU General Public License
21 # along with this program; if not, write to the Free Software
22 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 #
25 m4_pattern_forbid(MULE_)dnl Check for unexpanded *MULE_* macros
26 m4_pattern_allow(AMULE_)dnl Allow the *AMULE_* names
27 m4_pattern_forbid(__mule_)dnl Check for unexpanded internal macros
30 # -------------------- #
31 # Common useful macros #
32 # -------------------- #
34 dnl MULE_APPEND(VARNAME, VALUE)
35 AC_DEFUN([MULE_APPEND], [m4_if([$2],, [m4_warn([syntax], [Appending nothing to $1 is a do-nothing!])], [$1="$$1 $2"])])
37 dnl MULE_PREPEND(VARNAME, VALUE)
38 AC_DEFUN([MULE_PREPEND], [m4_if([$2],, [m4_warn([syntax], [Prepending nothing to $1 is a do-nothing!])], [$1="$2 $$1"])])
40 dnl MULE_ADDFLAG(FLAGTYPE, VALUE)
41 AC_DEFUN([MULE_ADDFLAG], [MULE_APPEND([MULE[]$1[]FLAGS], [$2])])
43 dnl MULE_ADDCCXXFLAG(VALUE)
44 AC_DEFUN([MULE_ADDCCXXFLAG],
45 [
46 MULE_ADDFLAG([C], [$1])
47 MULE_ADDFLAG([CXX], [$1])
48 ])
50 dnl MULE_BACKUP(VAR)
51 AC_DEFUN([MULE_BACKUP], [mule_backup_$1="$$1"])
53 dnl MULE_RESTORE(VAR)
54 AC_DEFUN([MULE_RESTORE], [$1="$mule_backup_$1"])
57 # ------------------- #
58 # Issuing diagnostics #
59 # ------------------- #
61 # -----------------------------------------------------------------------------
62 # __mule_print_final_warning(section, condition, message)
63 # -----------------------------------------------------------------------------
64 m4_define([__mule_print_final_warning],
65 [m4_divert_push($1)dnl
66 if test [$2]; then
67 cat <<_MULEEOT
69 m4_pushdef([__mule_Prefix1], [* ])dnl
70 m4_pushdef([__mule_Prefix], [ ])dnl
71 m4_foreach([__mule_Line], m4_quote(m4_split([$3], [
72 ])), [m4_text_wrap(m4_defn([__mule_Line]), __mule_Prefix, __mule_Prefix1)
73 m4_define([__mule_Prefix1], __mule_Prefix)dnl
74 ])[]dnl
75 m4_popdef([__mule_Prefix])dnl
76 m4_popdef([__mule_Prefix1])dnl
77 _MULEEOT
78 fi
79 m4_divert_pop()])
81 dnl ---------------------------------------------------------------------------
82 dnl MULE_WARNING(MESSAGE)
83 dnl
84 dnl Works like AC_MSG_WARN(), but the warning will be reproduced at the end of
85 dnl the configure run. An empty line is prepended at the final output and a
86 dnl newline is appended for free.
87 dnl ---------------------------------------------------------------------------
88 m4_ifndef([_MULE_WARNINGS],[
89 m4_define([_m4_divert(_MULE_WARNINGS)], m4_incr(_m4_divert([BODY])))])
90 m4_define([_MULE_WARNCOUNT], [0])
92 m4_divert_push(_MULE_WARNINGS)dnl
93 if test ${_mule_has_warnings:-no} = yes; then
94 echo ""
95 echo ""
96 echo " *** Warnings during configuration ***"
97 fi
98 m4_divert_pop()dnl
100 m4_define([MULE_WARNING],
101 [AC_MSG_WARN(
102 m4_pushdef([__mule_Prefix], [ ])dnl
103 m4_foreach([__mule_Line], m4_quote(m4_split([$1], [
104 ])), [
105 m4_text_wrap(m4_defn([__mule_Line]), __mule_Prefix)])[]dnl
106 m4_popdef([__mule_Prefix])dnl
107 )
108 _mule_warning_[]_MULE_WARNCOUNT[]=yes
109 _mule_has_warnings=yes
110 __mule_print_final_warning([_MULE_WARNINGS], [${_mule_warning_]_MULE_WARNCOUNT[:-no} = yes], [$1])dnl
111 m4_define([_MULE_WARNCOUNT], incr(_MULE_WARNCOUNT))])
113 dnl ---------------------------------------------------------------------------
114 dnl MULE_DEPRECATED(OLDFLAG [, NEWFLAG])
115 dnl
116 dnl Marks OLDFLAG as deprecated and produces an appropriate warning. If NEWFLAG
117 dnl is specified and is unset the value of OLDFLAG is assigned to NEWFLAG (i.e.
118 dnl if the user specified both OLDFLAG and NEWFLAG, NEWFLAG takes precedence;
119 dnl if only OLDFLAG is specified it will be redirected to NEWFLAG).
120 dnl
121 dnl There should be no AC_ARG_* for the deprecated flag, and if the old flag is
122 dnl deprecated in favour of a new one, MULE_DEPRECATED *MUST* precede the
123 dnl AC_ARG_* definition of the new flag (otherwise redirection may not work).
124 dnl ---------------------------------------------------------------------------
125 m4_define([_MULE_DEPRECATIONWARNINGS], [incr(_MULE_WARNINGS)])
126 m4_define([__mule_display_option_name], [m4_if(m4_substr([$1], 0, 1), [-],, [--])m4_bpatsubst([$1], [_], [-])])
127 m4_define([__mule_ac_option_name], [m4_bpatsubst(m4_bpatsubst(m4_bpatsubst(m4_bpatsubst([$1], [^-+], []), [-], [_]), [^disable], [enable]), [^without], [with])])
129 m4_define([MULE_DEPRECATED],
130 [if test "${__mule_ac_option_name([$1])+set}" = "set"; then
131 _mule_has_warnings=yes
132 m4_ifvaln([$2], [ if test "${__mule_ac_option_name([$2]):-unset}" = "unset"; then
133 __mule_ac_option_name([$2])=$__mule_ac_option_name([$1])
134 fi])fi
135 __mule_print_final_warning([_MULE_DEPRECATIONWARNINGS], ["${]__mule_ac_option_name([$1])[+set}" = set], __mule_display_option_name([$1])[ is now deprecated and ]m4_ifval([$2], [might be removed in the future without further notice. Please use ]__mule_display_option_name([$2])[ instead.], [not supported anymore.]))])
138 # ----------------- #
139 # Argument handling #
140 # ----------------- #
141 m4_define([__mule_arg_default], [__mule_arg_[]m4_translit([$1], [-], [_])[]_default])
142 m4_define([__mule_arg_value], [${enable_[]m4_translit([$1], [-], [_])[]:-[]__mule_arg_default([$1])[]}])
144 dnl ---------------------------------------------------------------------------
145 dnl MULE_ARG_ENABLE(FEATURE, DEFAULT-VALUE, HELP-STRING [, AUTOMAKE-CONDITIONAL])
146 dnl
147 dnl Wrapper around AC_ARG_ENABLE() that supports automatically setting up a
148 dnl conditional variable for automake, remembering default value for
149 dnl conditionals and supplying the help string based on the default value (i.e.
150 dnl it produce "--enable-FEATURE HELP-STRING" if the default is no, and
151 dnl "--disable-FEATURE HELP-STRING" if the default is yes. The default value
152 dnl *MUST* be either `yes' or `no'.
153 dnl ---------------------------------------------------------------------------
154 m4_define([MULE_ARG_ENABLE],
155 [m4_if([$2], [yes],, [m4_if([$2], [no],, [m4_fatal([Default value must be either `yes' or `no'!])])])dnl
156 m4_define(__mule_arg_default([$1]), [$2])dnl
157 AC_ARG_ENABLE([$1], [AS_HELP_STRING(m4_if([$2], [yes], [--disable-$1], [--enable-$1]), [$3])])
158 m4_ifvaln([$4], [AM_CONDITIONAL([$4], [test ]__mule_arg_value([$1])[ = yes])])])
160 dnl ---------------------------------------------------------------------------
161 dnl MULE_IS_ENABLED(FEATURE)
162 dnl
163 dnl Used in shell conditionals, tests whether the named feature is enabled or
164 dnl not, considering also the default value. FEATURE *must* have been set up
165 dnl using MULE_ARG_ENABLE().
166 dnl ---------------------------------------------------------------------------
167 m4_define([MULE_IS_ENABLED],
168 [m4_ifdef(__mule_arg_default([$1]), __mule_arg_value([$1])[ = yes], [m4_fatal([Unknown feature `$1'!])])])
170 m4_define([MULE_IS_ENABLED_ANY], [__mule_if_multi([$1], [-o])])
171 m4_define([MULE_IS_ENABLED_ALL], [__mule_if_multi([$1], [-a])])
173 dnl ---------------------------------------------------------------------------
174 dnl MULE_ENABLEVAR(FEATURE)
175 dnl
176 dnl Expands to the name of the shell variable holding the enabled/disabled
177 dnl status of FEATURE. FEATRUE *must* have been set up using MULE_ARG_ENABLE().
178 dnl ---------------------------------------------------------------------------
179 m4_define([MULE_ENABLEVAR],
180 [m4_ifdef(__mule_arg_default([$1]), [enable_[]m4_translit([$1], [-], [_])], [m4_fatal([Unknown feature `$1'!])])])
182 dnl ---------------------------------------------------------------------------
183 dnl MULE_STATUSOF(FEATURE)
184 dnl
185 dnl Expands to the value of the shell variable holding the status of FEATURE,
186 dnl considering default values. FEATURE *must* have been set up using
187 dnl MULE_ARG_ENABLE().
188 dnl ---------------------------------------------------------------------------
189 m4_define([MULE_STATUSOF],
190 [m4_ifdef(__mule_arg_default([$1]), __mule_arg_value([$1]), [m4_fatal([Unknown feature `$1'!])])])
193 # ---------------------- #
194 # Conditional processing #
195 # ---------------------- #
196 m4_define([__mule_if_multi],
197 [m4_define([__mule_if_logic], [])dnl
198 m4_foreach([__mule_condition], [$1], [__mule_if_logic MULE_IS_ENABLED(__mule_condition) ][m4_define([__mule_if_logic], [$2])])dnl
199 m4_undefine([__mule_if_logic])])
201 dnl ---------------------------------------------------------------------------
202 dnl MULE_IF_ENABLED(FEATURE, [ACTION-IF-ENABLED], [ACTION-IF-DISABLED])
203 dnl
204 dnl Basically a wrapper around AS_IF(), the test being if FEATURE is enabled.
205 dnl FEATURE must have been set up by MULE_ARG_ENABLE().
206 dnl ---------------------------------------------------------------------------
207 m4_define([MULE_IF_ENABLED],
208 [AS_IF([test MULE_IS_ENABLED([$1])], [$2], [$3])])
210 m4_define([MULE_IF_ENABLED_ALL],
211 [AS_IF([test]__mule_if_multi([$1], [-a]), [$2], [$3])])
213 m4_define([MULE_IF_ENABLED_ANY],
214 [AS_IF([test]__mule_if_multi([$1], [-o]), [$2], [$3])])
216 dnl ---------------------------------------------------------------------------
217 dnl MULE_IF(CONDITION, [IF-TRUE] [, ELIF-CONDITION, [IF-TRUE]]... [, ELSE-BRANCH])
218 dnl
219 dnl Works like AS_IF(), but allows elif-branches too.
220 dnl ---------------------------------------------------------------------------
221 m4_define([__mule_if_helper],
222 [m4_if( [$#], 0,,
223 [$#], 1, [m4_ifvaln([$1], [m4_n([else]) $1])],
224 [m4_n([elif $1; then]) m4_ifvaln([$2], [$2], :)])dnl
225 m4_if(m4_eval([$# > 2]), 1, [$0(m4_shiftn(2, $@))])])
227 m4_define([MULE_IF],
228 [m4_if( [$#], 0,,
229 [$#], 1,,
230 [m4_n([if $1; then]) m4_ifval([$2],[$2], :)
231 m4_if(m4_eval([$# > 2]), 1, [__mule_if_helper(m4_shiftn(2, $@))])m4_n([fi])])])
234 # ------------------------ #
235 # High level helper macros #
236 # ------------------------ #
238 dnl ---------------------------------------------------------------------------
239 dnl MULE_COMBINATE(ARGS, ...)
240 dnl
241 dnl Creates all possible combinations of ARGS, enclosed in double quotes. Order
242 dnl of arguments is preserved during expansion, and shorter sequences always
243 dnl come before longer ones.
244 dnl
245 dnl Example:
246 dnl MULE_COMBINATE([a], [b], [c])
247 dnl expands to
248 dnl "" "a" "b" "c" "a b" "a c" "b c" "a b c"
249 dnl ---------------------------------------------------------------------------
250 m4_define([__mule_combinate_append],
251 [m4_if( [$#], [0],,
252 [$#], [1], [$1],
253 [m4_ifblank([$1], [$0(m4_shift($@))], [$1 $0(m4_shift($@))])])])
255 m4_define([__mule_combinate_print], ["__mule_combinate_append($@)" ])
256 m4_define([__mule_combinate_helper],
257 [m4_if( [$1], [0], [__mule_combinate_print([$2])],
258 [$1], m4_eval([$# - 2]), [__mule_combinate_print(m4_shift($@))],
259 [$0(m4_decr([$1]), __mule_combinate_append([$2], [$3]), m4_shiftn([3], $@))$0([$1], [$2], m4_shiftn([3], $@))])])
261 m4_define([__mule_combinate_for],
262 [m4_if([$1], [$2],, [__mule_combinate_helper([$1], [], m4_shiftn([2], $@))$0(m4_incr([$1]), m4_shift($@))])])
264 m4_define([MULE_COMBINATE],
265 [__mule_combinate_for([0], m4_incr([$#]), $@)])
268 # ------------------- #
269 # Feature test macros #
270 # ------------------- #
272 dnl ---------------------------------------------------------------------------
273 dnl MULE_CHECK_SYSTEM
274 dnl
275 dnl Checks host system type, and sets system-specific flags accordingly.
276 dnl Sets $SYS to the name of the host os.
277 dnl ---------------------------------------------------------------------------
278 AC_DEFUN([MULE_CHECK_SYSTEM],
279 [AC_REQUIRE([AC_CANONICAL_HOST])dnl
281 case "${host_os}" in
282 darwin*)
283 SYS=darwin
284 MULECPPFLAGS="-no-cpp-precomp -D_INTL_REDIRECT_MACROS -DNOPCH";
285 MULELDFLAGS="-bind_at_load"
286 touch src/Scanner.cpp
287 ;;
288 openbsd*)
289 SYS=openbsd
290 LIBS="$LIBS -L/usr/local/lib"
291 MULECPPFLAGS="-D__OPENBSD__"
292 ;;
293 *cygwin* | *mingw32*)
294 SYS=win32
295 MULECPPFLAGS="-DNOMINMAX"
296 ;;
297 solaris*)
298 SYS=solaris
299 RESOLV_LIB="-lresolv -lnsl"
300 LIBS="$LIBS -lrt"
301 ;;
302 *netbsd*)
303 SYS=netbsd
304 # Now this is against autoconf recommendation that configure should not modify CPPFLAGS and LDFLAGS
305 # However, these values in NetBSD are required even to run the tests, and this is the easiest way to do it.
306 # Still, we prepend them, instead of adding, so the user may override them.
307 MULE_PREPEND([CPPFLAGS], [-I/usr/pkg/include])
308 MULE_PREPEND([LDFLAGS], [-R/usr/pkg/lib -L/usr/pkg/lib])
309 ;;
310 *irix*)
311 SYS=irix
312 MULECPPFLAGS="-D__IRIX__"
313 ;;
314 *)
315 SYS=unknown
316 ;;
317 esac
319 # -lpthread is needed by Debian but FreeBSD < 5 doesn't support it
320 AS_IF([test ${SYS:-unknown} != win32],
321 [
322 AC_MSG_CHECKING([if this is a FreeBSD 4 or earlier system])
323 AS_IF([test x"`uname -s`" = xFreeBSD && test 0`uname -r | cut -c 1` -lt 5],
324 [
325 MULE_ADDFLAG([LD], [-pthread])
326 AC_MSG_RESULT(yes)
327 ], [
328 MULE_ADDFLAG([LD], [-lpthread])
329 AC_MSG_RESULT(no)
330 ])
331 ])
333 AC_SUBST([RESOLV_LIB])dnl
334 AC_SUBST([MULECPPFLAGS])dnl
335 AC_SUBST([MULECFLAGS])dnl
336 AC_SUBST([MULECXXFLAGS])dnl
337 AC_SUBST([MULELDFLAGS])dnl
338 AC_SUBST([MULERCFLAGS])dnl
339 ])
341 dnl ---------------------------------------------------------------------------
342 dnl MULE_COMPILATION_FLAGS
343 dnl
344 dnl Checks type of compilation requested by user, and sets various flags
345 dnl accordingly.
346 dnl ---------------------------------------------------------------------------
347 AC_DEFUN([MULE_COMPILATION_FLAGS],
348 [dnl AC_REQUIRE([MULE_CHECK_GLIBCXX])dnl
350 MULE_ARG_ENABLE([debug], [yes], [disable additional debugging output])
351 MULE_ARG_ENABLE([profile], [no], [enable code profiling])
352 MULE_ARG_ENABLE([optimize], [no], [enable code optimization])
354 MULE_IF_ENABLED([debug],
355 [
356 MULE_ADDFLAG([CPP], [-D__DEBUG__])
357 MULE_ADDCCXXFLAG([-g])
358 AS_IF([test ${GCC:-no} = yes], [MULE_ADDCCXXFLAG([-W -Wall -Wshadow -Wundef -ggdb -fno-inline -fmessage-length=0])])
359 AS_IF([test ${SYS:-unknown} = win32], [MULE_ADDFLAG([RC], [-D__DEBUG__])])
360 ], [
361 AS_IF([test ${GCC:-no} = yes], [MULE_ADDCCXXFLAG([-W -Wall -Wshadow -Wundef])])
362 ])
364 MULE_IF_ENABLED([profile],
365 [
366 MULE_ADDCCXXFLAG([-pg])
367 MULE_ADDFLAG([LD], [-pg])
368 ])
370 MULE_IF_ENABLED([optimize], [MULE_ADDCCXXFLAG([-O2])])
372 MULE_ADDFLAG([CPP], [-DUSE_WX_EXTENSIONS])
373 ])
375 dnl ---------------------------------------------------------------------------
376 dnl MULE_CHECK_GLIBCXX
377 dnl
378 dnl Checks whether we use the GNU C++ Library.
379 dnl ---------------------------------------------------------------------------
380 AC_DEFUN([MULE_CHECK_GLIBCXX],
381 [dnl
382 AC_REQUIRE([AC_PROG_EGREP])dnl
383 AC_REQUIRE([AC_PROG_CXXCPP])dnl
384 AC_LANG_ASSERT([C++])dnl
386 AC_MSG_CHECKING([if we're using the GNU C++ library])
387 AC_PREPROC_IFELSE([
388 AC_LANG_SOURCE([[
389 #include <string>
390 #ifndef __GLIBCXX__
391 #error Non-GNU C++ library found.
392 #endif
393 ]])
394 ], [GLIBCXX=yes], [GLIBCXX=no])
395 AC_MSG_RESULT([$GLIBCXX])
396 ])
398 dnl ---------------------------------------------------------------------------
399 dnl MULE_CHECK_STRICT_ALIASING
400 dnl
401 dnl Checks whether the C++ compiler uses strict aliasing.
402 dnl This check could use the C compiler, but the source is C++ and the two
403 dnl compilers are not necessarily the same, or they might use different
404 dnl compiler flags...
405 dnl ---------------------------------------------------------------------------
406 AC_DEFUN([MULE_CHECK_STRICT_ALIASING],
407 [AC_LANG_ASSERT([C++])dnl
409 AH_TEMPLATE([GCC_USES_STRICT_ALIASING], [Define to 1 if the C++ compiler is the GNU C++ compiler and it is using strict aliasing.])
411 AS_IF([test ${GCC:-no} = yes],
412 [
413 dnl Backup current flags and turn warnings into errors
414 MULE_BACKUP([CXXFLAGS])
415 MULE_APPEND([CXXFLAGS], [$MULECPPFLAGS $MULECFLAGS $MULECXXFLAGS -Werror])
417 AC_MSG_CHECKING([whether the C++ compiler ($CXX) uses strict aliasing])
418 AC_COMPILE_IFELSE([
419 AC_LANG_PROGRAM([], [[
420 int a;
421 short *b = (short*)&a;
422 short c = *b;
424 return c;
425 ]])
426 ], [
427 AC_MSG_RESULT([no])
428 ], [
429 AC_MSG_RESULT([yes])
430 AC_DEFINE([GCC_USES_STRICT_ALIASING])
431 ])
433 dnl Restore flags
434 MULE_RESTORE([CXXFLAGS])
435 ])
436 ])
438 dnl ---------------------------------------------------------------------------
439 dnl MULE_CHECK_WX_SUPPORTS_LARGEFILE
440 dnl
441 dnl Test that wxWidgets is built with support for large-files. If not
442 dnl configure is terminated.
443 dnl ---------------------------------------------------------------------------
444 AC_DEFUN([MULE_CHECK_WX_SUPPORTS_LARGEFILE],
445 [AC_LANG_ASSERT([C++])dnl
447 dnl Backup current flags and setup flags for testing
448 MULE_BACKUP([CPPFLAGS])
449 MULE_APPEND([CPPFLAGS], [$WX_CPPFLAGS])
451 AC_MSG_CHECKING([that wxWidgets has support for large files])
452 AC_PREPROC_IFELSE([
453 AC_LANG_SOURCE([[
454 #include <wx/wx.h>
455 #include <wx/filefn.h>
456 #ifndef wxHAS_LARGE_FILES
457 #error No LargeFile support!
458 #endif
459 ]])
460 ], [
461 AC_MSG_RESULT([yes])
462 ], [
463 AC_MSG_RESULT([no])
464 AC_MSG_ERROR([
465 Support for large files in wxWidgets is required by aMule.
466 To continue you must recompile wxWidgets with support for
467 large files enabled.])
468 ])
470 dnl Restore backup'd flags
471 MULE_RESTORE([CPPFLAGS])
472 ])
475 dnl --------------------------------------------------------------------------
476 dnl MULE_CHECK_CCACHE
477 dnl
478 dnl Checks if ccache is requested and available, and makes use of it
479 dnl --------------------------------------------------------------------------
480 AC_DEFUN([MULE_CHECK_CCACHE],
481 [
482 MULE_ARG_ENABLE([ccache], [no], [enable ccache support for fast recompilation])
484 AC_ARG_WITH([ccache-prefix],
485 [AS_HELP_STRING([--with-ccache-prefix=PREFIX], [prefix where ccache is installed])])
487 AC_MSG_CHECKING([whether ccache support should be added])
488 AC_MSG_RESULT([MULE_STATUSOF([ccache])])
490 MULE_IF_ENABLED([ccache], [
491 AC_MSG_CHECKING([for ccache presence])
492 AS_IF([test -z "$with_ccache_prefix"], [
493 ccache_full=`which ccache`
494 with_ccache_prefix=`dirname ${ccache_full}`
495 ])
496 AS_IF([$with_ccache_prefix/ccache -V >/dev/null 2>&1], [
497 CC="$with_ccache_prefix/ccache $CC"
498 CXX="$with_ccache_prefix/ccache $CXX"
499 BUILD_CC="$with_ccache_prefix/ccache $BUILD_CC"
500 ], [MULE_ENABLEVAR([ccache])=no])
501 AC_MSG_RESULT([MULE_STATUSOF([ccache])])
502 ])
503 ])
506 dnl ----------------------------------------------------
507 dnl MULE_CHECK_EXCEPTIONS
508 dnl Checks for broken exception-handling. This is needed
509 dnl because exception handling is broken for some archs/
510 dnl compilers.
511 dnl ----------------------------------------------------
512 AC_DEFUN([MULE_CHECK_EXCEPTIONS],
513 [AC_LANG_ASSERT([C++])dnl
515 AC_MSG_CHECKING([for exception-handling])
516 AC_RUN_IFELSE([
517 AC_LANG_PROGRAM(, [[
518 try {
519 throw 1;
520 } catch (int) {
521 return 0;
522 }
523 return 1;
524 ]])
525 ], [
526 AC_MSG_RESULT([yes])
527 ], [
528 AC_MSG_RESULT([no])
529 AC_MSG_ERROR([Exception handling does not work. Broken compiler?])
530 ], [
531 AC_MSG_RESULT([undeterminable])
532 MULE_WARNING(
533 [Cross-compilation detected, so exception handling cannot be tested.
534 Note that broken exception handling in your compiler may lead to unexpected crashes.])
535 ])
536 ])
539 dnl ---------------------------------------------------------------------------
540 dnl MULE_CHECK_CXXABI
541 dnl
542 dnl This function will test the header <cxxabi.h> and abi::__cxa_demangle()
543 dnl ---------------------------------------------------------------------------
544 AC_DEFUN([MULE_CHECK_CXXABI],
545 [AC_LANG_ASSERT([C++])dnl
547 AC_CHECK_HEADERS([typeinfo])
548 AC_MSG_CHECKING([for <cxxabi.h> and __cxa_demangle()])
549 AC_LINK_IFELSE([
550 AC_LANG_PROGRAM([[
551 #ifdef HAVE_TYPEINFO
552 # include <typeinfo>
553 #endif
554 #include <cxxabi.h>
555 ]], [[
556 int status;
557 char * demangled = abi::__cxa_demangle("", 0, 0, &status);
558 std::type_info *ti = abi::__cxa_current_exception_type();
559 ]])
560 ], [
561 AH_TEMPLATE([HAVE_CXXABI], [Define to 1 if you have the <cxxabi.h> header which declares abi::__cxa_demangle()])
562 AC_DEFINE([HAVE_CXXABI])
563 AC_MSG_RESULT([yes])
564 ], [
565 AC_MSG_RESULT([no])
566 ])
567 ])
570 dnl ---------------------------------------------------------------------------
571 dnl MULE_CHECK_EXECINFO
572 dnl
573 dnl This function will test the header <execinfo.h> and backtrace()
574 dnl ---------------------------------------------------------------------------
575 AC_DEFUN([MULE_CHECK_EXECINFO],
576 [
577 AC_MSG_CHECKING([for <execinfo.h> and backtrace()])
578 AC_LINK_IFELSE([
579 AC_LANG_PROGRAM([[
580 #include <execinfo.h>
581 ]], [[
582 void *bt[1];
583 int n = backtrace((void **)&bt, 1);
584 char **bt_syms = backtrace_symbols(bt, n);
585 ]])
586 ], [
587 AH_TEMPLATE([HAVE_EXECINFO], [Define to 1 if you have the <execinfo.h> header which declares backtrace()])
588 AC_DEFINE([HAVE_EXECINFO])
589 AC_MSG_RESULT([yes])
590 ], [
591 AC_MSG_RESULT([no])
592 ])
593 ])
596 dnl ---------------------------------------------------------------------------
597 dnl MULE_DENOISER
598 dnl
599 dnl Test for denoising level and add denoiser commands to config.status
600 dnl ---------------------------------------------------------------------------
601 AC_DEFUN([MULE_DENOISER],
602 [
603 AC_ARG_WITH([denoise-level],
604 [AS_HELP_STRING([--with-denoise-level=<level>], [Specifies denoising level (0-4):])
605 AS_HELP_STRING([], [0 - Do nothing])
606 AS_HELP_STRING([], [4 - Suppress all normal output])
607 AS_HELP_STRING([], [(for more information see src/utils/scripts/denoiser.rules)])
608 ])
610 AC_MSG_CHECKING([denoising level])
611 AS_IF([test ${with_denoise_level:-5} = yes], [with_denoise_level=5])
612 AS_IF([test ${with_denoise_level:-5} = no], [with_denoise_level=0])
613 AS_IF([test ${with_denoise_level:-5} -gt 4],
614 [AS_IF([test "${svndate:+set}" = "set"], [with_denoise_level=1], [with_denoise_level=4])])
615 AC_MSG_RESULT([$with_denoise_level])
617 AC_CONFIG_COMMANDS([denoiser], [[if test $denoiserlevel -gt 0; then
618 if test ! -d src/utils/scripts; then mkdir -p src/utils/scripts; fi
619 sed -e "1{x;s/.*/1/;x;};/^[ ]*\$/d;/^#if /{/level.*$denoiserlevel/{x;s/^/1/;x;b0;};x;s/^/0/;x;:0;d;};/^#else/{x;/^1/{s/1/0/;b1;};s/0/1/;:1;x;d;};/^#endif/{x;s/.//;x;d;};/^[ ]*#/d;x;/^1/{x;b;};x;d" \
620 $srcdir/src/utils/scripts/denoiser.rules > src/utils/scripts/denoiser.sed
621 for i in `find . -name 'Makefile' -print`; do
622 if test -n "`head -n 1 $i | grep '^#'`"; then
623 sed -f src/utils/scripts/denoiser.sed $i > $i.tmp && mv $i.tmp $i
624 fi
625 done
626 fi]], [denoiserlevel=$with_denoise_level])
627 ])