eclass/autotools.eclass

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