Upstream tarball 10013
[amule.git] / acinclude.m4
blob8fa6d9bb29c8cd2fcd6c9dd660416bbf7814eae5
1 #                                                       -*- Autoconf -*-
2 # This file is part of the aMule Project.
4 # Copyright (c) 2003-2008 aMule Team ( admin@amule.org / http://www.amule.org )
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.
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.
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.
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
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], [$1="$$1 $2"])
37 dnl MULE_PREPEND(VARNAME, VALUE)
38 AC_DEFUN([MULE_PREPEND], [$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],
46         MULE_ADDFLAG([C], [$1])
47         MULE_ADDFLAG([CXX], [$1])
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
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_define([_MULE_WARNINGS],
89         [m4_ifdef([_m4_divert(BODY)], incr(_m4_divert(BODY)), [5000])])
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 ***"
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
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])
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).
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])
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)
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 dnl ---------------------------------------------------------------------------
171 dnl MULE_ENABLEVAR(FEATURE)
173 dnl Expands to the name of the shell variable holding the enabled/disabled
174 dnl status of FEATURE. FEATRUE *must* have been set up using MULE_ARG_ENABLE().
175 dnl ---------------------------------------------------------------------------
176 m4_define([MULE_ENABLEVAR],
177 [m4_ifdef(__mule_arg_default([$1]), [enable_[]m4_translit([$1], [-], [_])], [m4_fatal([Unknown feature `$1'!])])])
179 dnl ---------------------------------------------------------------------------
180 dnl MULE_STATUSOF(FEATURE)
182 dnl Expands to the value of the shell variable holding the status of FEATURE,
183 dnl considering default values. FEATURE *must* have been set up using
184 dnl MULE_ARG_ENABLE().
185 dnl ---------------------------------------------------------------------------
186 m4_define([MULE_STATUSOF],
187 [m4_ifdef(__mule_arg_default([$1]), __mule_arg_value([$1]), [m4_fatal([Unknown feature `$1'!])])])
190 # ---------------------- #
191 # Conditional processing #
192 # ---------------------- #
193 m4_define([__mule_if_multi],
194 [m4_define([__mule_if_logic], [])dnl
195 m4_foreach([__mule_condition], [$1], [__mule_if_logic MULE_IS_ENABLED(__mule_condition) ][m4_define([__mule_if_logic], [$2])])dnl
196 m4_undefine([__mule_if_logic])])
198 dnl ---------------------------------------------------------------------------
199 dnl MULE_IF_ENABLED(FEATURE, [ACTION-IF-ENABLED], [ACTION-IF-DISABLED])
201 dnl Basically a wrapper around AS_IF(), the test being if FEATURE is enabled.
202 dnl FEATURE must have been set up by MULE_ARG_ENABLE().
203 dnl ---------------------------------------------------------------------------
204 m4_define([MULE_IF_ENABLED],
205 [AS_IF([test MULE_IS_ENABLED([$1])], [$2], [$3])])
207 m4_define([MULE_IF_ENABLED_ALL],
208 [AS_IF([test]__mule_if_multi([$1], [-a]), [$2], [$3])])
210 m4_define([MULE_IF_ENABLED_ANY],
211 [AS_IF([test]__mule_if_multi([$1], [-o]), [$2], [$3])])
213 dnl ---------------------------------------------------------------------------
214 dnl MULE_IF(CONDITION, [IF-TRUE] [, ELIF-CONDITION, [IF-TRUE]]... [, ELSE-BRANCH])
216 dnl Works like AS_IF(), but allows elif-branches too.
217 dnl ---------------------------------------------------------------------------
218 m4_define([__mule_if_helper],
219 [m4_if( [$#], 0,,
220         [$#], 1, [m4_ifvaln([$1], [m4_n([else])  $1])],
221         [m4_n([elif $1; then])  m4_ifvaln([$2], [$2], :)])dnl
222 m4_if(m4_eval([$# > 2]), 1, [$0(m4_shiftn(2, $@))])])
224 m4_define([MULE_IF],
225 [m4_if( [$#], 0,,
226         [$#], 1,,
227         [m4_n([if $1; then])  m4_ifval([$2],[$2], :)
228 m4_if(m4_eval([$# > 2]), 1, [__mule_if_helper(m4_shiftn(2, $@))])m4_n([fi])])])
231 # ----------------------- #
232 # Other high-level macros #
233 # ----------------------- #
235 dnl ---------------------------------------------------------------------------
236 dnl MULE_CHECK_SYSTEM
238 dnl Checks host system type, and sets system-specific flags accordingly.
239 dnl Sets $SYS to the name of the host os.
240 dnl ---------------------------------------------------------------------------
241 AC_DEFUN([MULE_CHECK_SYSTEM],
242 [AC_REQUIRE([AC_CANONICAL_HOST])dnl
244         case "${host_os}" in
245         darwin*)
246                 SYS=darwin
247                 MULECPPFLAGS="-no-cpp-precomp -D_INTL_REDIRECT_MACROS -DNOPCH";
248                 MULELDFLAGS="-bind_at_load"
249                 touch src/Scanner.cpp
250                 ;;
251         openbsd*) 
252                 SYS=openbsd
253                 LIBS="$LIBS -L/usr/local/lib"
254                 MULECPPFLAGS="-D__OPENBSD__"
255                 ;;
256         *cygwin* | *mingw32*)
257                 SYS=win32
258                 MULECPPFLAGS="-DNOMINMAX"
259                 ;;
260         solaris*)
261                 SYS=solaris
262                 RESOLV_LIB="-lresolv -lnsl"
263                 LIBS="$LIBS -lrt"
264                 ;;
265         *netbsd*)
266                 SYS=netbsd
267                 # Now this is against autoconf recommendation that configure should not modify CPPFLAGS and LDFLAGS
268                 # However, these values in NetBSD are required even to run the tests, and this is the easiest way to do it.
269                 # Still, we prepend them, instead of adding, so the user may override them.
270                 MULE_PREPEND([CPPFLAGS], [-I/usr/pkg/include])
271                 MULE_PREPEND([LDFLAGS], [-R/usr/pkg/lib -L/usr/pkg/lib])
272                 ;;
273         *irix*)
274                 SYS=irix
275                 MULECPPFLAGS="-D__IRIX__"
276                 ;;
277         *)
278                 SYS=unknown
279                 ;;
280         esac
282         # -lpthread is needed by Debian but FreeBSD < 5 doesn't support it
283         AS_IF([test ${SYS:-unknown} != win32],
284         [
285                 AC_MSG_CHECKING([if this is a FreeBSD 4 or earlier system])
286                 AS_IF([test x"`uname -s`" = xFreeBSD && test 0`uname -r | cut -c 1` -lt 5],
287                 [
288                         MULE_ADDFLAG([LD], [-pthread])
289                         AC_MSG_RESULT(yes)
290                 ], [
291                         MULE_ADDFLAG([LD], [-lpthread])
292                         AC_MSG_RESULT(no)
293                 ])
294         ])
296 AC_SUBST([RESOLV_LIB])dnl
297 AC_SUBST([MULECPPFLAGS])dnl
298 AC_SUBST([MULECFLAGS])dnl
299 AC_SUBST([MULECXXFLAGS])dnl
300 AC_SUBST([MULELDFLAGS])dnl
301 AC_SUBST([MULERCFLAGS])dnl
304 dnl ---------------------------------------------------------------------------
305 dnl MULE_COMPILATION_FLAGS
307 dnl Checks type of compilation requested by user, and sets various flags
308 dnl accordingly.
309 dnl ---------------------------------------------------------------------------
310 AC_DEFUN([MULE_COMPILATION_FLAGS],
311 [AC_REQUIRE([MULE_CHECK_GLIBCXX])dnl
313         MULE_ARG_ENABLE([debug],        [yes],  [disable additional debugging output])
314         MULE_ARG_ENABLE([profile],      [no],   [enable code profiling])
315         MULE_ARG_ENABLE([optimize],     [no],   [enable code optimization])
317         MULE_IF_ENABLED([debug],
318         [
319                 MULE_ADDFLAG([CPP], [-D__DEBUG__])
320                 MULE_ADDCCXXFLAG([-g])
321                 AS_IF([test ${GLIBCXX:-no} = yes],      [MULE_ADDFLAG([CPP], [-D_GLIBCXX_DEBUG -D_GLIBCXX_DEBUG_PEDANTIC])])
322                 AS_IF([test ${GCC:-no} = yes],          [MULE_ADDCCXXFLAG([-W -Wall -Wshadow -Wundef -ggdb -fno-inline -fmessage-length=0])])
323                 AS_IF([test ${SYS:-unknown} = win32],   [MULE_ADDFLAG([RC], [-D__DEBUG__])])
324         ], [
325                 AS_IF([test ${GCC:-no} = yes], [MULE_ADDCCXXFLAG([-W -Wall -Wshadow -Wundef])])
326         ])
328         MULE_IF_ENABLED([profile],
329         [
330                 MULE_ADDCCXXFLAG([-pg])
331                 MULE_ADDFLAG([LD], [-pg])
332         ])
334         MULE_IF_ENABLED([optimize],     [MULE_ADDCCXXFLAG([-O2])])
336         MULE_ADDFLAG([CPP], [-DUSE_WX_EXTENSIONS])
339 dnl ---------------------------------------------------------------------------
340 dnl MULE_CHECK_GLIBCXX
342 dnl Checks whether we use the GNU C++ Library.
343 dnl ---------------------------------------------------------------------------
344 AC_DEFUN([MULE_CHECK_GLIBCXX],
345 [dnl
346 AC_REQUIRE([AC_PROG_EGREP])dnl
347 AC_REQUIRE([AC_PROG_CXXCPP])dnl
348 AC_LANG_ASSERT([C++])dnl
350         AC_MSG_CHECKING([if we're using the GNU C++ library])
351         AC_PREPROC_IFELSE([
352                 AC_LANG_SOURCE([[
353                         #include <string>
354                         #ifndef __GLIBCXX__
355                         #error Non-GNU C++ library found.
356                         #endif
357                 ]])
358         ], [GLIBCXX=yes], [GLIBCXX=no])
359         AC_MSG_RESULT([$GLIBCXX])
362 dnl ---------------------------------------------------------------------------
363 dnl MULE_CHECK_WX_SUPPORTS_LARGEFILE
365 dnl Test that wxWidgets is built with support for large-files. If not
366 dnl configure is terminated.
367 dnl ---------------------------------------------------------------------------
368 AC_DEFUN([MULE_CHECK_WX_SUPPORTS_LARGEFILE],
369 [AC_LANG_ASSERT([C++])dnl
371         dnl Backup current flags and setup flags for testing
372         MULE_BACKUP([CPPFLAGS])
373         MULE_APPEND([CPPFLAGS], [$WX_CPPFLAGS])
375         AC_MSG_CHECKING([that wxWidgets has support for large files])
376         AC_PREPROC_IFELSE([
377                 AC_LANG_SOURCE([[
378                         #include <wx/wx.h>
379                         #include <wx/filefn.h>
380                         #ifndef wxHAS_LARGE_FILES
381                                 #error No LargeFile support!
382                         #endif
383                 ]])
384         ], [
385                 AC_MSG_RESULT([yes])
386         ], [
387                 AC_MSG_RESULT([no])
388                 AC_MSG_ERROR([
389         Support for large files in wxWidgets is required by aMule.
390         To continue you must recompile wxWidgets with support for 
391         large files enabled.])
392         ])
394         dnl Restore backup'd flags
395         MULE_RESTORE([CPPFLAGS])
399 dnl --------------------------------------------------------------------------
400 dnl MULE_CHECK_CCACHE
402 dnl Checks if ccache is requested and available, and makes use of it
403 dnl --------------------------------------------------------------------------
404 AC_DEFUN([MULE_CHECK_CCACHE],
406         MULE_ARG_ENABLE([ccache], [no], [enable ccache support for fast recompilation])
408         AC_ARG_WITH([ccache-prefix],
409                 [AS_HELP_STRING([--with-ccache-prefix=PREFIX], [prefix where ccache is installed])])
411         AC_MSG_CHECKING([whether ccache support should be added])
412         AC_MSG_RESULT([MULE_STATUSOF([ccache])])
414         MULE_IF_ENABLED([ccache], [
415                 AC_MSG_CHECKING([for ccache presence])
416                 AS_IF([test -z "$with_ccache_prefix"], [
417                         ccache_full=`which ccache`
418                         with_ccache_prefix=`dirname ${ccache_full}`
419                 ])
420                 AS_IF([$with_ccache_prefix/ccache -V >/dev/null 2>&1], [
421                         CC="$with_ccache_prefix/ccache $CC"
422                         CXX="$with_ccache_prefix/ccache $CXX"
423                         BUILD_CC="$with_ccache_prefix/ccache $BUILD_CC"
424                 ], [MULE_ENABLEVAR([ccache])=no])
425                 AC_MSG_RESULT([MULE_STATUSOF([ccache])])
426         ])
430 dnl ----------------------------------------------------
431 dnl MULE_CHECK_BFD
432 dnl check if bfd.h is on the system and usable
433 dnl ----------------------------------------------------
434 AC_DEFUN([MULE_CHECK_BFD],
435 [AC_REQUIRE([MULE_CHECK_NLS])dnl
437         AC_MSG_CHECKING([for bfd])
438         result=no
439         for bfd_ldadd in "" "${LIBINTL}"; do
440                 MULE_BACKUP([LIBS])
441                 MULE_BACKUP([LDFLAGS])
442                 MULE_PREPEND([LIBS], [-lbfd -liberty ${bfd_ldadd} ${ZLIB_LIBS}])
443                 MULE_APPEND([LDFLAGS], [${ZLIB_LDFLAGS}])
444                 AC_LINK_IFELSE([
445                         AC_LANG_PROGRAM([[
446                                 #include <ansidecl.h>
447                                 #include <bfd.h>
448                         ]], [[
449                                 char *dummy = bfd_errmsg(bfd_get_error());
450                         ]])
451                 ], [
452                         result=yes
453                         BFD_CPPFLAGS="-DHAVE_BFD"
454                         BFD_LIBS="-lbfd -liberty ${bfd_ldadd}"
455                         MULE_RESTORE([LIBS])
456                         MULE_RESTORE([LDFLAGS])
457                         break
458                 ])
459                 MULE_RESTORE([LIBS])
460                 MULE_RESTORE([LDFLAGS])
461         done
463         AC_MSG_RESULT([$result])
465         AS_IF([test $result = no],
466                 [MULE_WARNING([bfd.h not found or unusable, please install binutils development package if you are a developer or want to help testing aMule])])
468 AC_SUBST([BFD_CPPFLAGS])dnl
469 AC_SUBST([BFD_LIBS])dnl
473 dnl ----------------------------------------------------
474 dnl MULE_CHECK_FLEX_EXTENDED
475 dnl check if flex can produce header files
476 dnl ----------------------------------------------------
477 AC_DEFUN([MULE_CHECK_FLEX_EXTENDED],
479         AC_MSG_CHECKING([for extended flex capabilities])
481         extended_flex=`flex --help | grep header-file`
482         AS_IF([test -n "$extended_flex"], [HAVE_FLEX_EXTENDED=yes], [HAVE_FLEX_EXTENDED=no])
483         AC_MSG_RESULT($HAVE_FLEX_EXTENDED)
485         AS_IF([test $HAVE_FLEX_EXTENDED = no], [AC_MSG_NOTICE([Your flex version doesn't support --header-file flag. This is not critical, but an upgrade is recommended])])
489 dnl ----------------------------------------------------
490 dnl MULE_CHECK_EXCEPTIONS
491 dnl Checks for broken exception-handling. This is needed
492 dnl because exception handling is broken for some archs/
493 dnl compilers.
494 dnl ----------------------------------------------------
495 AC_DEFUN([MULE_CHECK_EXCEPTIONS],
496 [AC_LANG_ASSERT([C++])dnl
498         AC_MSG_CHECKING([for exception-handling])
499         AC_RUN_IFELSE([
500                 AC_LANG_PROGRAM(, [[
501                         try {
502                                 throw 1;
503                         } catch (int) {
504                                 return 0;
505                         }
506                         return 1;
507                 ]])
508         ], [
509                 AC_MSG_RESULT([yes])
510         ], [
511                 AC_MSG_RESULT([no])
512                 AC_MSG_ERROR([Exception handling does not work. Broken compiler?])
513         ], [
514                 AC_MSG_RESULT([undeterminable])
515                 MULE_WARNING(
516                         [Cross-compilation detected, so exception handling cannot be tested.
517                         Note that broken exception handling in your compiler may lead to unexpected crashes.])
518         ])
522 dnl ---------------------------------------------------------------------------
523 dnl MULE_CHECK_CXXABI
525 dnl This function will test the header <cxxabi.h> and abi::__cxa_demangle()
526 dnl ---------------------------------------------------------------------------
527 AC_DEFUN([MULE_CHECK_CXXABI],
528 [AC_LANG_ASSERT([C++])dnl
530         AC_MSG_CHECKING([for <cxxabi.h> and __cxa_demangle()])
531         AC_LINK_IFELSE([
532                 AC_LANG_PROGRAM([[
533                         #include <cxxabi.h>
534                 ]], [[
535                         int status;
536                         char * demangled = abi::__cxa_demangle("", 0, 0, &status);
537                         std::type_info *ti = abi::__cxa_current_exception_type();
538                 ]])
539         ], [
540                 AH_TEMPLATE([HAVE_CXXABI], [Define to 1 if you have the <cxxabi.h> header which declares abi::__cxa_demangle()])
541                 AC_DEFINE([HAVE_CXXABI])
542                 AC_MSG_RESULT([yes])
543         ], [
544                 AC_MSG_RESULT([no])
545         ])
549 dnl ---------------------------------------------------------------------------
550 dnl MULE_CHECK_EXECINFO
552 dnl This function will test the header <execinfo.h> and backtrace()
553 dnl ---------------------------------------------------------------------------
554 AC_DEFUN([MULE_CHECK_EXECINFO],
556         AC_MSG_CHECKING([for <execinfo.h> and backtrace()])
557         AC_LINK_IFELSE([
558                 AC_LANG_PROGRAM([[
559                         #include <execinfo.h>
560                 ]], [[
561                         void *bt[1];
562                         int n = backtrace(&bt, 1);
563                         const char **bt_syms = backtrace_symbols(bt, n);
564                 ]])
565         ], [
566                 AH_TEMPLATE([HAVE_EXECINFO], [Define to 1 if you have the <execinfo.h> header which declares backtrace()])
567                 AC_DEFINE([HAVE_EXECINFO])
568                 AC_MSG_RESULT([yes])
569         ], [
570                 AC_MSG_RESULT([no])
571         ])
574 dnl ---------------------------------------------------------------------------
575 dnl MULE_CHECK_MMAP
577 dnl Checks for mmap() and makes use of it when found.
578 dnl ---------------------------------------------------------------------------
579 AC_DEFUN([MULE_CHECK_MMAP],
581         MULE_ARG_ENABLE([mmap], [no], [enable using mapped memory if supported])
583         MULE_IF_ENABLED([mmap], [
584                 AC_CHECK_HEADERS([sys/mman.h])
585                 AC_FUNC_MMAP
586                 AC_CHECK_FUNCS([munmap sysconf])
587                 AS_IF([test $ac_cv_func_sysconf = yes], [
588                         AC_MSG_CHECKING([for pagesize constant for sysconf])
589                         AC_LINK_IFELSE([
590                                 AC_LANG_PROGRAM([[
591                                         #include <unistd.h>
592                                 ]], [[
593                                         return sysconf(_SC_PAGESIZE);
594                                 ]])
595                         ], [
596                                 AC_MSG_RESULT([_SC_PAGESIZE])
597                                 AC_DEFINE([HAVE__SC_PAGESIZE], [1], [Define to 1 if you have the _SC_PAGESIZE constant in <unistd.h>])
598                         ], [
599                                 AC_LINK_IFELSE([
600                                         AC_LANG_PROGRAM([[
601                                                 #include <unistd.h>
602                                         ]], [[
603                                                 return sysconf(_SC_PAGE_SIZE);
604                                         ]])
605                                 ], [
606                                         AC_MSG_RESULT([_SC_PAGE_SIZE])
607                                         AC_DEFINE([HAVE__SC_PAGE_SIZE], [1], [Define to 1 if you have the _SC_PAGE_SIZE constant in <unistd.h>, but not _SC_PAGESIZE])
608                                 ], [
609                                         AC_MSG_RESULT([none])
610                                 ])
611                         ])
612                 ])
613         ], [
614                 # fake the result of the test for munmap() for the gettext macros
615                 ac_cv_func_munmap=no
616         ])
620 dnl ---------------------------------------------------------------------------
621 dnl MULE_DENOISER
623 dnl Test for denoising level and add denoiser commands to config.status
624 dnl ---------------------------------------------------------------------------
625 AC_DEFUN([MULE_DENOISER],
627         AC_ARG_WITH([denoise-level],
628                 [AS_HELP_STRING([--with-denoise-level=<level>], [Specifies denoising level (0-4):])
629                 AS_HELP_STRING([], [0 - Do nothing])
630                 AS_HELP_STRING([], [4 - Suppress all normal output])
631                 AS_HELP_STRING([], [(for more information see src/utils/scripts/denoiser.rules)])
632         ])
634         AC_MSG_CHECKING([denoising level])
635         AS_IF([test ${with_denoise_level:-5} = yes], [with_denoise_level=5])
636         AS_IF([test ${with_denoise_level:-5} = no], [with_denoise_level=0])
637         AS_IF([test ${with_denoise_level:-5} -gt 4],
638                 [AS_IF([test "${svndate:+set}" = "set"], [with_denoise_level=0], [with_denoise_level=4])])
639         AC_MSG_RESULT([$with_denoise_level])
641         AC_CONFIG_COMMANDS([denoiser], [[if test $denoiserlevel -gt 0; then
642                 if test ! -d src/utils/scripts; then mkdir -p src/utils/scripts; fi
643                 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" \
644                         $srcdir/src/utils/scripts/denoiser.rules > src/utils/scripts/denoiser.sed
645                 for i in `find . -name 'Makefile' -print`; do
646                         if test -n "`head -n 1 $i | grep '^#'`"; then
647                                 sed -f src/utils/scripts/denoiser.sed $i > $i.tmp && mv $i.tmp $i
648                         fi
649                 done
650         fi]], [denoiserlevel=$with_denoise_level])