acinclude.m4

   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 #
  24
  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
  28
  29
  30 # -------------------- #
  31 # Common useful macros #
  32 # -------------------- #
  33
  34 dnl MULE_APPEND(VARNAME, VALUE)
  35 AC_DEFUN([MULE_APPEND], [$1="$$1 $2"])
  36
  37 dnl MULE_PREPEND(VARNAME, VALUE)
  38 AC_DEFUN([MULE_PREPEND], [$1="$2 $$1"])
  39
  40 dnl MULE_ADDFLAG(FLAGTYPE, VALUE)
  41 AC_DEFUN([MULE_ADDFLAG], [MULE_APPEND([MULE[]$1[]FLAGS], [$2])])
  42
  43 dnl MULE_ADDCCXXFLAG(VALUE)
  44 AC_DEFUN([MULE_ADDCCXXFLAG],
  45 [
  46         MULE_ADDFLAG([C], [$1])
  47         MULE_ADDFLAG([CXX], [$1])
  48 ])
  49
  50 dnl MULE_BACKUP(VAR)
  51 AC_DEFUN([MULE_BACKUP], [mule_backup_$1="$$1"])
  52
  53 dnl MULE_RESTORE(VAR)
  54 AC_DEFUN([MULE_RESTORE], [$1="$mule_backup_$1"])
  55
  56
  57 # ------------------- #
  58 # Issuing diagnostics #
  59 # ------------------- #
  60
  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
  68
  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()])
  80
  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])
  91
  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
  99
 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))])
 112
 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])])
 128
 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.]))])
 136
 137
 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])[]}])
 143
 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])])])
 159
 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'!])])])
 169
 170 m4_define([MULE_IS_ENABLED_ANY], [__mule_if_multi([$1], [-o])])
 171 m4_define([MULE_IS_ENABLED_ALL], [__mule_if_multi([$1], [-a])])
 172
 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'!])])])
 181
 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'!])])])
 191
 192
 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])])
 200
 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])])
 209
 210 m4_define([MULE_IF_ENABLED_ALL],
 211 [AS_IF([test]__mule_if_multi([$1], [-a]), [$2], [$3])])
 212
 213 m4_define([MULE_IF_ENABLED_ANY],
 214 [AS_IF([test]__mule_if_multi([$1], [-o]), [$2], [$3])])
 215
 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, $@))])])
 226
 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])])])
 232
 233
 234 # ------------------------ #
 235 # High level helper macros #
 236 # ------------------------ #
 237
 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($@))])])])
 254
 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], $@))])])
 260
 261 m4_define([__mule_combinate_for],
 262         [m4_if([$1], [$2],, [__mule_combinate_helper([$1], [], m4_shiftn([2], $@))$0(m4_incr([$1]), m4_shift($@))])])
 263
 264 m4_define([MULE_COMBINATE],
 265         [__mule_combinate_for([0], m4_incr([$#]), $@)])
 266
 267
 268 # ------------------- #
 269 # Feature test macros #
 270 # ------------------- #
 271
 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
 280
 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
 318
 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         ])
 332
 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 ])
 340
 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
 349
 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])
 353
 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         ])
 363
 364         MULE_IF_ENABLED([profile],
 365         [
 366                 MULE_ADDCCXXFLAG([-pg])
 367                 MULE_ADDFLAG([LD], [-pg])
 368         ])
 369
 370         MULE_IF_ENABLED([optimize],     [MULE_ADDCCXXFLAG([-O2])])
 371
 372         MULE_ADDFLAG([CPP], [-DUSE_WX_EXTENSIONS])
 373 ])
 374
 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
 385
 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 ])
 397
 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
 408
 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.])
 410
 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])
 416
 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;
 423
 424                                 return c;
 425                         ]])
 426                 ], [
 427                         AC_MSG_RESULT([no])
 428                 ], [
 429                         AC_MSG_RESULT([yes])
 430                         AC_DEFINE([GCC_USES_STRICT_ALIASING])
 431                 ])
 432
 433                 dnl Restore flags
 434                 MULE_RESTORE([CXXFLAGS])
 435         ])
 436 ])
 437
 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
 446
 447         dnl Backup current flags and setup flags for testing
 448         MULE_BACKUP([CPPFLAGS])
 449         MULE_APPEND([CPPFLAGS], [$WX_CPPFLAGS])
 450
 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         ])
 469
 470         dnl Restore backup'd flags
 471         MULE_RESTORE([CPPFLAGS])
 472 ])
 473
 474
 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])
 483
 484         AC_ARG_WITH([ccache-prefix],
 485                 [AS_HELP_STRING([--with-ccache-prefix=PREFIX], [prefix where ccache is installed])])
 486
 487         AC_MSG_CHECKING([whether ccache support should be added])
 488         AC_MSG_RESULT([MULE_STATUSOF([ccache])])
 489
 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 ])
 504
 505
 506 dnl ----------------------------------------------------
 507 dnl MULE_CHECK_FLEX_EXTENDED
 508 dnl check if flex can produce header files
 509 dnl ----------------------------------------------------
 510 AC_DEFUN([MULE_CHECK_FLEX_EXTENDED],
 511 [
 512         AC_MSG_CHECKING([for extended flex capabilities])
 513
 514         extended_flex=`flex --help | grep header-file`
 515         AS_IF([test -n "$extended_flex"], [HAVE_FLEX_EXTENDED=yes], [HAVE_FLEX_EXTENDED=no])
 516         AC_MSG_RESULT($HAVE_FLEX_EXTENDED)
 517
 518         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])])
 519 ])
 520
 521
 522 dnl ----------------------------------------------------
 523 dnl MULE_CHECK_EXCEPTIONS
 524 dnl Checks for broken exception-handling. This is needed
 525 dnl because exception handling is broken for some archs/
 526 dnl compilers.
 527 dnl ----------------------------------------------------
 528 AC_DEFUN([MULE_CHECK_EXCEPTIONS],
 529 [AC_LANG_ASSERT([C++])dnl
 530
 531         AC_MSG_CHECKING([for exception-handling])
 532         AC_RUN_IFELSE([
 533                 AC_LANG_PROGRAM(, [[
 534                         try {
 535                                 throw 1;
 536                         } catch (int) {
 537                                 return 0;
 538                         }
 539                         return 1;
 540                 ]])
 541         ], [
 542                 AC_MSG_RESULT([yes])
 543         ], [
 544                 AC_MSG_RESULT([no])
 545                 AC_MSG_ERROR([Exception handling does not work. Broken compiler?])
 546         ], [
 547                 AC_MSG_RESULT([undeterminable])
 548                 MULE_WARNING(
 549                         [Cross-compilation detected, so exception handling cannot be tested.
 550                         Note that broken exception handling in your compiler may lead to unexpected crashes.])
 551         ])
 552 ])
 553
 554
 555 dnl ---------------------------------------------------------------------------
 556 dnl MULE_CHECK_CXXABI
 557 dnl
 558 dnl This function will test the header <cxxabi.h> and abi::__cxa_demangle()
 559 dnl ---------------------------------------------------------------------------
 560 AC_DEFUN([MULE_CHECK_CXXABI],
 561 [AC_LANG_ASSERT([C++])dnl
 562
 563         AC_CHECK_HEADERS([typeinfo])
 564         AC_MSG_CHECKING([for <cxxabi.h> and __cxa_demangle()])
 565         AC_LINK_IFELSE([
 566                 AC_LANG_PROGRAM([[
 567                         #ifdef HAVE_TYPEINFO
 568                         #       include <typeinfo>
 569                         #endif
 570                         #include <cxxabi.h>
 571                 ]], [[
 572                         int status;
 573                         char * demangled = abi::__cxa_demangle("", 0, 0, &status);
 574                         std::type_info *ti = abi::__cxa_current_exception_type();
 575                 ]])
 576         ], [
 577                 AH_TEMPLATE([HAVE_CXXABI], [Define to 1 if you have the <cxxabi.h> header which declares abi::__cxa_demangle()])
 578                 AC_DEFINE([HAVE_CXXABI])
 579                 AC_MSG_RESULT([yes])
 580         ], [
 581                 AC_MSG_RESULT([no])
 582         ])
 583 ])
 584
 585
 586 dnl ---------------------------------------------------------------------------
 587 dnl MULE_CHECK_EXECINFO
 588 dnl
 589 dnl This function will test the header <execinfo.h> and backtrace()
 590 dnl ---------------------------------------------------------------------------
 591 AC_DEFUN([MULE_CHECK_EXECINFO],
 592 [
 593         AC_MSG_CHECKING([for <execinfo.h> and backtrace()])
 594         AC_LINK_IFELSE([
 595                 AC_LANG_PROGRAM([[
 596                         #include <execinfo.h>
 597                 ]], [[
 598                         void *bt[1];
 599                         int n = backtrace((void **)&bt, 1);
 600                         char **bt_syms = backtrace_symbols(bt, n);
 601                 ]])
 602         ], [
 603                 AH_TEMPLATE([HAVE_EXECINFO], [Define to 1 if you have the <execinfo.h> header which declares backtrace()])
 604                 AC_DEFINE([HAVE_EXECINFO])
 605                 AC_MSG_RESULT([yes])
 606         ], [
 607                 AC_MSG_RESULT([no])
 608         ])
 609 ])
 610
 611
 612 dnl ---------------------------------------------------------------------------
 613 dnl MULE_DENOISER
 614 dnl
 615 dnl Test for denoising level and add denoiser commands to config.status
 616 dnl ---------------------------------------------------------------------------
 617 AC_DEFUN([MULE_DENOISER],
 618 [
 619         AC_ARG_WITH([denoise-level],
 620                 [AS_HELP_STRING([--with-denoise-level=<level>], [Specifies denoising level (0-4):])
 621                 AS_HELP_STRING([], [0 - Do nothing])
 622                 AS_HELP_STRING([], [4 - Suppress all normal output])
 623                 AS_HELP_STRING([], [(for more information see src/utils/scripts/denoiser.rules)])
 624         ])
 625
 626         AC_MSG_CHECKING([denoising level])
 627         AS_IF([test ${with_denoise_level:-5} = yes], [with_denoise_level=5])
 628         AS_IF([test ${with_denoise_level:-5} = no], [with_denoise_level=0])
 629         AS_IF([test ${with_denoise_level:-5} -gt 4],
 630                 [AS_IF([test "${svndate:+set}" = "set"], [with_denoise_level=0], [with_denoise_level=4])])
 631         AC_MSG_RESULT([$with_denoise_level])
 632
 633         AC_CONFIG_COMMANDS([denoiser], [[if test $denoiserlevel -gt 0; then
 634                 if test ! -d src/utils/scripts; then mkdir -p src/utils/scripts; fi
 635                 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" \
 636                         $srcdir/src/utils/scripts/denoiser.rules > src/utils/scripts/denoiser.sed
 637                 for i in `find . -name 'Makefile' -print`; do
 638                         if test -n "`head -n 1 $i | grep '^#'`"; then
 639                                 sed -f src/utils/scripts/denoiser.sed $i > $i.tmp && mv $i.tmp $i
 640                         fi
 641                 done
 642         fi]], [denoiserlevel=$with_denoise_level])
 643 ])