eclass/autotools.eclass

   1 # Copyright 1999-2015 Gentoo Foundation
   2 # Distributed under the terms of the GNU General Public License v2
   3 # $Id$
   4
   5 # @ECLASS: autotools.eclass
   6 # @MAINTAINER:
   7 # base-system@gentoo.org
   8 # @BLURB: Regenerates auto* build scripts
   9 # @DESCRIPTION:
  10 # This eclass is for safely handling autotooled software packages that need to
  11 # regenerate their build scripts.  All functions will abort in case of errors.
  12
  13 # Note: We require GNU m4, as does autoconf.  So feel free to use any features
  14 # from the GNU version of m4 without worrying about other variants (i.e. BSD).
  15
  16 if [[ ${__AUTOTOOLS_AUTO_DEPEND+set} == "set" ]] ; then
  17         # See if we were included already, but someone changed the value
  18         # of AUTOTOOLS_AUTO_DEPEND on us.  We could reload the entire
  19         # eclass at that point, but that adds overhead, and it's trivial
  20         # to re-order inherit in eclasses/ebuilds instead.  #409611
  21         if [[ ${__AUTOTOOLS_AUTO_DEPEND} != ${AUTOTOOLS_AUTO_DEPEND} ]] ; then
  22                 die "AUTOTOOLS_AUTO_DEPEND changed value between inherits; please inherit autotools.eclass first! ${__AUTOTOOLS_AUTO_DEPEND} -> ${AUTOTOOLS_AUTO_DEPEND}"
  23         fi
  24 fi
  25
  26 if [[ -z ${_AUTOTOOLS_ECLASS} ]]; then
  27 _AUTOTOOLS_ECLASS=1
  28
  29 inherit libtool
  30
  31 # @ECLASS-VARIABLE: WANT_AUTOCONF
  32 # @DESCRIPTION:
  33 # The major version of autoconf your package needs
  34 : ${WANT_AUTOCONF:=latest}
  35
  36 # @ECLASS-VARIABLE: WANT_AUTOMAKE
  37 # @DESCRIPTION:
  38 # The major version of automake your package needs
  39 : ${WANT_AUTOMAKE:=latest}
  40
  41 # @ECLASS-VARIABLE: WANT_LIBTOOL
  42 # @DESCRIPTION:
  43 # Do you want libtool?  Valid values here are "latest" and "none".
  44 : ${WANT_LIBTOOL:=latest}
  45
  46 # @ECLASS-VARIABLE: _LATEST_AUTOMAKE
  47 # @INTERNAL
  48 # @DESCRIPTION:
  49 # CONSTANT!
  50 # The latest major version/slot of automake available on each arch.  #312315
  51 # We should list both the latest stable, and the latest unstable.  #465732
  52 # This way the stable builds will still work, but the unstable are allowed
  53 # to build & test things for us ahead of time (if they have it installed).
  54 # If a newer slot is stable on any arch, and is NOT reflected in this list,
  55 # then circular dependencies may arise during emerge @system bootstraps.
  56 # Do NOT change this variable in your ebuilds!
  57 # If you want to force a newer minor version, you can specify the correct
  58 # WANT value by using a colon:  <PV>:<WANT_AUTOMAKE>
  59 _LATEST_AUTOMAKE=( 1.15:1.15 )
  60
  61 _automake_atom="sys-devel/automake"
  62 _autoconf_atom="sys-devel/autoconf"
  63 if [[ -n ${WANT_AUTOMAKE} ]]; then
  64         case ${WANT_AUTOMAKE} in
  65                 # Even if the package doesn't use automake, we still need to depend
  66                 # on it because we run aclocal to process m4 macros.  This matches
  67                 # the autoreconf tool, so this requirement is correct.  #401605
  68                 none) ;;
  69                 latest)
  70                         # Use SLOT deps if we can.  For EAPI=0, we get pretty close.
  71                         if [[ ${EAPI:-0} != 0 ]] ; then
  72                                 _automake_atom="|| ( `printf '>=sys-devel/automake-%s:%s ' ${_LATEST_AUTOMAKE[@]/:/ }` )"
  73                         else
  74                                 _automake_atom="|| ( `printf '>=sys-devel/automake-%s ' ${_LATEST_AUTOMAKE[@]/%:*}` )"
  75                         fi
  76                         ;;
  77                 *)      _automake_atom="=sys-devel/automake-${WANT_AUTOMAKE}*" ;;
  78         esac
  79         export WANT_AUTOMAKE
  80 fi
  81
  82 if [[ -n ${WANT_AUTOCONF} ]] ; then
  83         case ${WANT_AUTOCONF} in
  84                 none)       _autoconf_atom="" ;; # some packages don't require autoconf at all
  85                 2.1)        _autoconf_atom="~sys-devel/autoconf-2.13" ;;
  86                 # if you change the "latest" version here, change also autotools_env_setup
  87                 latest|2.5) _autoconf_atom=">=sys-devel/autoconf-2.69" ;;
  88                 *)          die "Invalid WANT_AUTOCONF value '${WANT_AUTOCONF}'" ;;
  89         esac
  90         export WANT_AUTOCONF
  91 fi
  92
  93 _libtool_atom=">=sys-devel/libtool-2.4"
  94 if [[ -n ${WANT_LIBTOOL} ]] ; then
  95         case ${WANT_LIBTOOL} in
  96                 none)   _libtool_atom="" ;;
  97                 latest) ;;
  98                 *)      die "Invalid WANT_LIBTOOL value '${WANT_LIBTOOL}'" ;;
  99         esac
 100         export WANT_LIBTOOL
 101 fi
 102
 103 # Force people (nicely) to upgrade to a newer version of gettext as
 104 # older ones are known to be crappy.  #496454
 105 AUTOTOOLS_DEPEND="!<sys-devel/gettext-0.18.1.1-r3
 106         ${_automake_atom}
 107         ${_autoconf_atom}
 108         ${_libtool_atom}"
 109 RDEPEND=""
 110
 111 # @ECLASS-VARIABLE: AUTOTOOLS_AUTO_DEPEND
 112 # @DESCRIPTION:
 113 # Set to 'no' to disable automatically adding to DEPEND.  This lets
 114 # ebuilds former conditional depends by using ${AUTOTOOLS_DEPEND} in
 115 # their own DEPEND string.
 116 : ${AUTOTOOLS_AUTO_DEPEND:=yes}
 117 if [[ ${AUTOTOOLS_AUTO_DEPEND} != "no" ]] ; then
 118         DEPEND=${AUTOTOOLS_DEPEND}
 119 fi
 120 __AUTOTOOLS_AUTO_DEPEND=${AUTOTOOLS_AUTO_DEPEND} # See top of eclass
 121
 122 unset _automake_atom _autoconf_atom
 123
 124 # @ECLASS-VARIABLE: AM_OPTS
 125 # @DEFAULT_UNSET
 126 # @DESCRIPTION:
 127 # Additional options to pass to automake during
 128 # eautoreconf call.
 129
 130 # @ECLASS-VARIABLE: AT_NOEAUTOMAKE
 131 # @DEFAULT_UNSET
 132 # @DESCRIPTION:
 133 # Don't run eautomake command if set to 'yes'; only used to workaround
 134 # broken packages.  Generally you should, instead, fix the package to
 135 # not call AM_INIT_AUTOMAKE if it doesn't actually use automake.
 136
 137 # @ECLASS-VARIABLE: AT_NOELIBTOOLIZE
 138 # @DEFAULT_UNSET
 139 # @DESCRIPTION:
 140 # Don't run elibtoolize command if set to 'yes',
 141 # useful when elibtoolize needs to be ran with
 142 # particular options
 143
 144 # @ECLASS-VARIABLE: AT_M4DIR
 145 # @DESCRIPTION:
 146 # Additional director(y|ies) aclocal should search
 147 : ${AT_M4DIR:=}
 148
 149 # @ECLASS-VARIABLE: AT_SYS_M4DIR
 150 # @INTERNAL
 151 # @DESCRIPTION:
 152 # For system integrators, a list of additional aclocal search paths.
 153 # This variable gets eval-ed, so you can use variables in the definition
 154 # that may not be valid until eautoreconf & friends are run.
 155 : ${AT_SYS_M4DIR:=}
 156
 157 # @FUNCTION: eautoreconf
 158 # @DESCRIPTION:
 159 # This function mimes the behavior of autoreconf, but uses the different
 160 # eauto* functions to run the tools. It doesn't accept parameters, but
 161 # the directory with include files can be specified with AT_M4DIR variable.
 162 #
 163 # Should do a full autoreconf - normally what most people will be interested in.
 164 # Also should handle additional directories specified by AC_CONFIG_SUBDIRS.
 165 eautoreconf() {
 166         local x g
 167
 168         # Subdirs often share a common build dir #529404.  If so, we can't safely
 169         # run in parallel because many tools clobber the content in there.  Libtool
 170         # and automake both `rm && cp` while aclocal reads the output.  We might be
 171         # able to handle this if we split the steps and grab locks on the dirs the
 172         # tools actually write to.  Then we'd run all the common tools that use
 173         # those inputs.  Doing this in bash does not scale easily.
 174         # If we do re-enable parallel support, make sure #426512 is handled.
 175         if [[ -z ${AT_NO_RECURSIVE} ]] ; then
 176                 # Take care of subdirs
 177                 for x in $(autotools_check_macro_val AC_CONFIG_SUBDIRS) ; do
 178                         if [[ -d ${x} ]] ; then
 179                                 pushd "${x}" >/dev/null
 180                                 # Avoid unsafe nested multijob_finish_one for bug #426512.
 181                                 AT_NOELIBTOOLIZE="yes" eautoreconf || die
 182                                 popd >/dev/null
 183                         fi
 184                 done
 185         fi
 186
 187         einfo "Running eautoreconf in '${PWD}' ..."
 188
 189         local m4dirs=$(autotools_check_macro_val AC_CONFIG_{AUX,MACRO}_DIR)
 190         [[ -n ${m4dirs} ]] && mkdir -p ${m4dirs}
 191
 192         # Run all the tools before aclocal so we can gather the .m4 files.
 193         local i tools=(
 194                 # <tool> <was run> <command>
 195                 glibgettext false "autotools_run_tool glib-gettextize --copy --force"
 196                 gettext     false "autotools_run_tool --at-missing autopoint --force"
 197                 # intltool must come after autopoint.
 198                 intltool    false "autotools_run_tool intltoolize --automake --copy --force"
 199                 gtkdoc      false "autotools_run_tool --at-missing gtkdocize --copy"
 200                 gnomedoc    false "autotools_run_tool --at-missing gnome-doc-prepare --copy --force"
 201                 libtool     false "_elibtoolize --auto-ltdl --install --copy --force"
 202         )
 203         for (( i = 0; i < ${#tools[@]}; i += 3 )) ; do
 204                 if _at_uses_${tools[i]} ; then
 205                         tools[i+1]=true
 206                         ${tools[i+2]}
 207                 fi
 208         done
 209
 210         # Generate aclocal.m4 with our up-to-date m4 files.
 211         local rerun_aclocal=false
 212         eaclocal
 213
 214         # Check to see if we had macros expanded by other macros or in other
 215         # m4 files that we couldn't detect early.  This is uncommon, but some
 216         # packages do this, so we have to handle it correctly.
 217         for (( i = 0; i < ${#tools[@]}; i += 3 )) ; do
 218                 if ! ${tools[i+1]} && _at_uses_${tools[i]} ; then
 219                         ${tools[i+2]}
 220                         rerun_aclocal=true
 221                 fi
 222         done
 223         ${rerun_aclocal} && eaclocal
 224
 225         if [[ ${WANT_AUTOCONF} = 2.1 ]] ; then
 226                 eautoconf
 227         else
 228                 eautoconf --force
 229         fi
 230         eautoheader
 231         [[ ${AT_NOEAUTOMAKE} != "yes" ]] && FROM_EAUTORECONF="yes" eautomake ${AM_OPTS}
 232
 233         if [[ ${AT_NOELIBTOOLIZE} != "yes" ]] ; then
 234                 # Call it here to prevent failures due to elibtoolize called _before_
 235                 # eautoreconf.
 236                 elibtoolize --force "${PWD}"
 237         fi
 238
 239         return 0
 240 }
 241
 242 # @FUNCTION: _at_uses_pkg
 243 # @USAGE: <macros>
 244 # @INTERNAL
 245 # See if the specified macros are enabled.
 246 _at_uses_pkg() {
 247         if [[ -n $(autotools_check_macro "$@") ]] ; then
 248                 return 0
 249         else
 250                 # If the trace didn't find it (perhaps because aclocal.m4 hasn't
 251                 # been generated yet), cheat, but be conservative.
 252                 local macro args=()
 253                 for macro ; do
 254                         args+=( -e "^[[:space:]]*${macro}\>" )
 255                 done
 256                 egrep -q "${args[@]}" configure.??
 257         fi
 258 }
 259 _at_uses_autoheader()  { _at_uses_pkg A{C,M}_CONFIG_HEADER{S,}; }
 260 _at_uses_automake()    { _at_uses_pkg AM_INIT_AUTOMAKE; }
 261 _at_uses_gettext()     { _at_uses_pkg AM_GNU_GETTEXT_{,REQUIRE_}VERSION; }
 262 _at_uses_glibgettext() { _at_uses_pkg AM_GLIB_GNU_GETTEXT; }
 263 _at_uses_intltool()    { _at_uses_pkg {AC,IT}_PROG_INTLTOOL; }
 264 _at_uses_gtkdoc()      { _at_uses_pkg GTK_DOC_CHECK; }
 265 _at_uses_gnomedoc()    { _at_uses_pkg GNOME_DOC_INIT; }
 266 _at_uses_libtool()     { _at_uses_pkg A{C,M}_PROG_LIBTOOL LT_INIT; }
 267 _at_uses_libltdl()     { _at_uses_pkg LT_CONFIG_LTDL_DIR; }
 268
 269 # @FUNCTION: eaclocal_amflags
 270 # @DESCRIPTION:
 271 # Extract the ACLOCAL_AMFLAGS value from the Makefile.am and try to handle
 272 # (most) of the crazy crap that people throw at us.
 273 eaclocal_amflags() {
 274         local aclocal_opts amflags_file
 275
 276         for amflags_file in GNUmakefile.am Makefile.am GNUmakefile.in Makefile.in ; do
 277                 [[ -e ${amflags_file} ]] || continue
 278                 # setup the env in case the pkg does something crazy
 279                 # in their ACLOCAL_AMFLAGS.  like run a shell script
 280                 # which turns around and runs autotools. #365401
 281                 # or split across multiple lines. #383525
 282                 autotools_env_setup
 283                 aclocal_opts=$(sed -n \
 284                         "/^ACLOCAL_AMFLAGS[[:space:]]*=/{ \
 285                           # match the first line
 286                           s:[^=]*=::p; \
 287                           # then gobble up all escaped lines
 288                           : nextline /\\\\$/{ n; p; b nextline; } \
 289                         }" ${amflags_file})
 290                 eval aclocal_opts=\""${aclocal_opts}"\"
 291                 break
 292         done
 293
 294         echo ${aclocal_opts}
 295 }
 296
 297 # @FUNCTION: eaclocal
 298 # @DESCRIPTION:
 299 # These functions runs the autotools using autotools_run_tool with the
 300 # specified parametes. The name of the tool run is the same of the function
 301 # without e prefix.
 302 # They also force installing the support files for safety.
 303 # Respects AT_M4DIR for additional directories to search for macro's.
 304 eaclocal() {
 305         [[ ! -f aclocal.m4 || -n $(grep -e 'generated.*by aclocal' aclocal.m4) ]] && \
 306                 autotools_run_tool --at-m4flags aclocal "$@" $(eaclocal_amflags)
 307 }
 308
 309 # @FUNCTION: _elibtoolize
 310 # @DESCRIPTION:
 311 # Runs libtoolize.
 312 #
 313 # Note the '_' prefix: avoid collision with elibtoolize() from libtool.eclass.
 314 _elibtoolize() {
 315         local LIBTOOLIZE=${LIBTOOLIZE:-$(type -P glibtoolize > /dev/null && echo glibtoolize || echo libtoolize)}
 316
 317         if [[ $1 == "--auto-ltdl" ]] ; then
 318                 shift
 319                 _at_uses_libltdl && set -- "$@" --ltdl
 320         fi
 321
 322         [[ -f GNUmakefile.am || -f Makefile.am ]] && set -- "$@" --automake
 323
 324         autotools_run_tool ${LIBTOOLIZE} "$@"
 325 }
 326
 327 # @FUNCTION: eautoheader
 328 # @DESCRIPTION:
 329 # Runs autoheader.
 330 eautoheader() {
 331         _at_uses_autoheader || return 0
 332         autotools_run_tool --at-no-fail --at-m4flags autoheader "$@"
 333 }
 334
 335 # @FUNCTION: eautoconf
 336 # @DESCRIPTION:
 337 # Runs autoconf.
 338 eautoconf() {
 339         if [[ ! -f configure.ac && ! -f configure.in ]] ; then
 340                 echo
 341                 eerror "No configure.{ac,in} present in '${PWD}'!"
 342                 echo
 343                 die "No configure.{ac,in} present!"
 344         fi
 345         if [[ ${WANT_AUTOCONF} != "2.1" && -e configure.in ]] ; then
 346                 eqawarn "This package has a configure.in file which has long been deprecated.  Please"
 347                 eqawarn "update it to use configure.ac instead as newer versions of autotools will die"
 348                 eqawarn "when it finds this file.  See https://bugs.gentoo.org/426262 for details."
 349         fi
 350
 351         autotools_run_tool --at-m4flags autoconf "$@"
 352 }
 353
 354 # @FUNCTION: eautomake
 355 # @DESCRIPTION:
 356 # Runs automake.
 357 eautomake() {
 358         local extra_opts=()
 359         local makefile_name
 360
 361         # Run automake if:
 362         #  - a Makefile.am type file exists
 363         #  - the configure script is using the AM_INIT_AUTOMAKE directive
 364         for makefile_name in {GNUmakefile,{M,m}akefile}.am "" ; do
 365                 [[ -f ${makefile_name} ]] && break
 366         done
 367
 368         _automake_version() {
 369                 autotools_run_tool --at-output automake --version 2>/dev/null |
 370                         sed -n -e '1{s:.*(GNU automake) ::p;q}'
 371         }
 372
 373         if [[ -z ${makefile_name} ]] ; then
 374                 _at_uses_automake || return 0
 375
 376         elif [[ -z ${FROM_EAUTORECONF} && -f ${makefile_name%.am}.in ]]; then
 377                 local used_automake
 378                 local installed_automake
 379
 380                 installed_automake=$(WANT_AUTOMAKE= _automake_version)
 381                 used_automake=$(head -n 1 < ${makefile_name%.am}.in | \
 382                         sed -e 's:.*by automake \(.*\) from .*:\1:')
 383
 384                 if [[ ${installed_automake} != ${used_automake} ]]; then
 385                         ewarn "Automake used for the package (${used_automake}) differs from" \
 386                                 "the installed version (${installed_automake})."
 387                         ewarn "Forcing a full rebuild of the autotools to workaround."
 388                         eautoreconf
 389                         return 0
 390                 fi
 391         fi
 392
 393         [[ -f INSTALL && -f AUTHORS && -f ChangeLog && -f NEWS && -f README ]] \
 394                 || extra_opts+=( --foreign )
 395
 396         # Older versions of automake do not support --force-missing.  But we want
 397         # to use this whenever possible to update random bundled files #133489.
 398         case $(_automake_version) in
 399         1.4|1.4[.-]*) ;;
 400         *) extra_opts+=( --force-missing ) ;;
 401         esac
 402
 403         autotools_run_tool automake --add-missing --copy "${extra_opts[@]}" "$@"
 404 }
 405
 406 # @FUNCTION: eautopoint
 407 # @DESCRIPTION:
 408 # Runs autopoint (from the gettext package).
 409 eautopoint() {
 410         autotools_run_tool autopoint "$@"
 411 }
 412
 413 # @FUNCTION: config_rpath_update
 414 # @USAGE: [destination]
 415 # @DESCRIPTION:
 416 # Some packages utilize the config.rpath helper script, but don't
 417 # use gettext directly.  So we have to copy it in manually since
 418 # we can't let `autopoint` do it for us.
 419 config_rpath_update() {
 420         local dst src=$(type -P gettext | sed 's:bin/gettext:share/gettext/config.rpath:')
 421
 422         [[ $# -eq 0 ]] && set -- $(find -name config.rpath)
 423         [[ $# -eq 0 ]] && return 0
 424
 425         einfo "Updating all config.rpath files"
 426         for dst in "$@" ; do
 427                 einfo "   ${dst}"
 428                 cp "${src}" "${dst}" || die
 429         done
 430 }
 431
 432 # @FUNCTION: autotools_env_setup
 433 # @INTERNAL
 434 # @DESCRIPTION:
 435 # Process the WANT_AUTO{CONF,MAKE} flags.
 436 autotools_env_setup() {
 437         # We do the "latest" → version switch here because it solves
 438         # possible order problems, see bug #270010 as an example.
 439         if [[ ${WANT_AUTOMAKE} == "latest" ]]; then
 440                 local pv
 441                 for pv in ${_LATEST_AUTOMAKE[@]/#*:} ; do
 442                         # has_version respects ROOT, but in this case, we don't want it to,
 443                         # thus "ROOT=/" prefix:
 444                         ROOT=/ has_version "=sys-devel/automake-${pv}*" && export WANT_AUTOMAKE="${pv}"
 445                 done
 446                 [[ ${WANT_AUTOMAKE} == "latest" ]] && \
 447                         die "Cannot find the latest automake! Tried ${_LATEST_AUTOMAKE[*]}"
 448         fi
 449         [[ ${WANT_AUTOCONF} == "latest" ]] && export WANT_AUTOCONF=2.5
 450 }
 451
 452 # @FUNCTION: autotools_run_tool
 453 # @USAGE: [--at-no-fail] [--at-m4flags] [--at-missing] [--at-output] <autotool> [tool-specific flags]
 454 # @INTERNAL
 455 # @DESCRIPTION:
 456 # Run the specified autotool helper, but do logging and error checking
 457 # around it in the process.
 458 autotools_run_tool() {
 459         # Process our own internal flags first
 460         local autofail=true m4flags=false missing_ok=false return_output=false
 461         while [[ -n $1 ]] ; do
 462                 case $1 in
 463                 --at-no-fail) autofail=false;;
 464                 --at-m4flags) m4flags=true;;
 465                 --at-missing) missing_ok=true;;
 466                 --at-output)  return_output=true;;
 467                 # whatever is left goes to the actual tool
 468                 *) break;;
 469                 esac
 470                 shift
 471         done
 472
 473         if [[ ${EBUILD_PHASE} != "unpack" && ${EBUILD_PHASE} != "prepare" ]]; then
 474                 ewarn "QA Warning: running $1 in ${EBUILD_PHASE} phase"
 475         fi
 476
 477         if ${missing_ok} && ! type -P ${1} >/dev/null ; then
 478                 einfo "Skipping '$*' due $1 not installed"
 479                 return 0
 480         fi
 481
 482         autotools_env_setup
 483
 484         # Allow people to pass in full paths. #549268
 485         local STDERR_TARGET="${T}/${1##*/}.out"
 486         # most of the time, there will only be one run, but if there are
 487         # more, make sure we get unique log filenames
 488         if [[ -e ${STDERR_TARGET} ]] ; then
 489                 local i=1
 490                 while :; do
 491                         STDERR_TARGET="${T}/${1##*/}-${i}.out"
 492                         [[ -e ${STDERR_TARGET} ]] || break
 493                         : $(( i++ ))
 494                 done
 495         fi
 496
 497         if ${m4flags} ; then
 498                 set -- "${1}" $(autotools_m4dir_include) "${@:2}" $(autotools_m4sysdir_include)
 499         fi
 500
 501         # If the caller wants to probe something, then let them do it directly.
 502         if ${return_output} ; then
 503                 "$@"
 504                 return
 505         fi
 506
 507         printf "***** $1 *****\n***** PWD: ${PWD}\n***** $*\n\n" > "${STDERR_TARGET}"
 508
 509         ebegin "Running $@"
 510         "$@" >> "${STDERR_TARGET}" 2>&1
 511         if ! eend $? && ${autofail} ; then
 512                 echo
 513                 eerror "Failed Running $1 !"
 514                 eerror
 515                 eerror "Include in your bugreport the contents of:"
 516                 eerror
 517                 eerror "  ${STDERR_TARGET}"
 518                 echo
 519                 die "Failed Running $1 !"
 520         fi
 521 }
 522
 523 # Internal function to check for support
 524
 525 # Keep a list of all the macros we might use so that we only
 526 # have to run the trace code once.  Order doesn't matter.
 527 ALL_AUTOTOOLS_MACROS=(
 528         A{C,M}_PROG_LIBTOOL LT_INIT LT_CONFIG_LTDL_DIR
 529         A{C,M}_CONFIG_HEADER{S,}
 530         AC_CONFIG_SUBDIRS
 531         AC_CONFIG_AUX_DIR AC_CONFIG_MACRO_DIR
 532         AM_INIT_AUTOMAKE
 533         AM_GLIB_GNU_GETTEXT
 534         AM_GNU_GETTEXT_{,REQUIRE_}VERSION
 535         {AC,IT}_PROG_INTLTOOL
 536         GTK_DOC_CHECK
 537         GNOME_DOC_INIT
 538 )
 539 autotools_check_macro() {
 540         [[ -f configure.ac || -f configure.in ]] || return 0
 541
 542         # We can run in multiple dirs, so we have to cache the trace
 543         # data in $PWD rather than an env var.
 544         local trace_file=".__autoconf_trace_data"
 545         if [[ ! -e ${trace_file} ]] || [[ ! aclocal.m4 -ot ${trace_file} ]] ; then
 546                 WANT_AUTOCONF="2.5" autoconf \
 547                         $(autotools_m4dir_include) \
 548                         ${ALL_AUTOTOOLS_MACROS[@]/#/--trace=} > ${trace_file} 2>/dev/null
 549         fi
 550
 551         local macro args=()
 552         for macro ; do
 553                 has ${macro} ${ALL_AUTOTOOLS_MACROS[@]} || die "internal error: add ${macro} to ALL_AUTOTOOLS_MACROS"
 554                 args+=( -e ":${macro}:" )
 555         done
 556         grep "${args[@]}" ${trace_file}
 557 }
 558
 559 # @FUNCTION: autotools_check_macro_val
 560 # @USAGE: <macro> [macros]
 561 # @INTERNAL
 562 # @DESCRIPTION:
 563 # Look for a macro and extract its value.
 564 autotools_check_macro_val() {
 565         local macro scan_out
 566
 567         for macro ; do
 568                 autotools_check_macro "${macro}" | \
 569                         gawk -v macro="${macro}" \
 570                                 '($0 !~ /^[[:space:]]*(#|dnl)/) {
 571                                         if (match($0, macro ":(.*)$", res))
 572                                                 print res[1]
 573                                 }' | uniq
 574         done
 575
 576         return 0
 577 }
 578
 579 _autotools_m4dir_include() {
 580         local x include_opts flag
 581
 582         # Use the right flag to autoconf based on the version #448986
 583         [[ ${WANT_AUTOCONF} == "2.1" ]] \
 584                 && flag="l" \
 585                 || flag="I"
 586
 587         for x in "$@" ; do
 588                 case ${x} in
 589                         # We handle it below
 590                         -${flag}) ;;
 591                         *)
 592                                 [[ ! -d ${x} ]] && ewarn "autotools.eclass: '${x}' does not exist"
 593                                 include_opts+=" -${flag} ${x}"
 594                                 ;;
 595                 esac
 596         done
 597
 598         echo ${include_opts}
 599 }
 600 autotools_m4dir_include()    { _autotools_m4dir_include ${AT_M4DIR} ; }
 601 autotools_m4sysdir_include() {
 602         # First try to use the paths the system integrator has set up.
 603         local paths=( $(eval echo ${AT_SYS_M4DIR}) )
 604
 605         if [[ ${#paths[@]} -eq 0 && -n ${SYSROOT} ]] ; then
 606                 # If they didn't give us anything, then default to the SYSROOT.
 607                 # This helps when cross-compiling.
 608                 local path="${SYSROOT}/usr/share/aclocal"
 609                 [[ -d ${path} ]] && paths+=( "${path}" )
 610         fi
 611         _autotools_m4dir_include "${paths[@]}"
 612 }
 613
 614 fi