/[gentoo-x86]/eclass/autotools.eclass
Gentoo

Diff of /eclass/autotools.eclass

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

Revision 1.1.1.1 Revision 1.177
1# Copyright 1999-2005 Gentoo Foundation 1# Copyright 1999-2015 Gentoo Foundation
2# Distributed under the terms of the GNU General Public License v2 2# Distributed under the terms of the GNU General Public License v2
3# $Header: /var/cvsroot/gentoo-x86/eclass/autotools.eclass,v 1.1.1.1 2005/11/30 09:59:24 chriswhite Exp $ 3# $Header: /var/cvsroot/gentoo-x86/eclass/autotools.eclass,v 1.177 2015/07/17 09:36:24 vapier Exp $
4# 4
5# Author: Diego Pettenò <flameeyes@gentoo.org> 5# @ECLASS: autotools.eclass
6# Enhancements: Martin Schlemmer <azarah@gentoo.org> 6# @MAINTAINER:
7# 7# base-system@gentoo.org
8# @BLURB: Regenerates auto* build scripts
9# @DESCRIPTION:
8# This eclass is for handling autotooled software packages that 10# This eclass is for safely handling autotooled software packages that need to
9# needs to regenerate their build scripts. 11# regenerate their build scripts. All functions will abort in case of errors.
10#
11# NB: If you add anything, please comment it!
12 12
13inherit eutils gnuconfig 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).
14 15
15#DEPEND="sys-devel/automake 16if [[ ${__AUTOTOOLS_AUTO_DEPEND+set} == "set" ]] ; then
16# sys-devel/autoconf 17 # See if we were included already, but someone changed the value
17# sys-devel/libtool" 18 # of AUTOTOOLS_AUTO_DEPEND on us. We could reload the entire
18# 19 # eclass at that point, but that adds overhead, and it's trivial
19# Ebuilds should rather depend on the proper version of the tool. 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
24fi
20 25
21# Variables: 26if [[ -z ${_AUTOTOOLS_ECLASS} ]]; then
22# 27_AUTOTOOLS_ECLASS=1
28
29inherit 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"
63if [[ -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
80fi
81
82if [[ -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-${WANT_AUTOCONF}*" ;;
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
91fi
92
93_libtool_atom=">=sys-devel/libtool-2.4"
94if [[ -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
101fi
102
103# Force people (nicely) to upgrade to a newer version of gettext as
104# older ones are known to be crappy. #496454
105AUTOTOOLS_DEPEND="!<sys-devel/gettext-0.18.1.1-r3
106 ${_automake_atom}
107 ${_autoconf_atom}
108 ${_libtool_atom}"
109RDEPEND=""
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}
117if [[ ${AUTOTOOLS_AUTO_DEPEND} != "no" ]] ; then
118 DEPEND=${AUTOTOOLS_DEPEND}
119fi
120__AUTOTOOLS_AUTO_DEPEND=${AUTOTOOLS_AUTO_DEPEND} # See top of eclass
121
122unset _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:
23# AT_M4DIR - Additional director(y|ies) aclocal should search 146# Additional director(y|ies) aclocal should search
24# AT_GNUCONF_UPDATE - Should gnuconfig_update() be run (normally handled by 147: ${AT_M4DIR:=}
25# econf()) [yes|no]
26# AM_OPTS - Additional options to pass to automake during
27# eautoreconf call.
28 148
29# Functions: 149# @ECLASS-VARIABLE: AT_SYS_M4DIR
30# 150# @INTERNAL
31# eautoreconf() - Should do a full autoreconf - normally what most people 151# @DESCRIPTION:
32# will be interested in. Also should handle additional 152# For system integrators, a list of additional aclocal search paths.
33# directories specified by AC_CONFIG_SUBDIRS. 153# This variable gets eval-ed, so you can use variables in the definition
34# eaclocal() - Runs aclocal. Respects AT_M4DIR for additional directories 154# that may not be valid until eautoreconf & friends are run.
35# to search for macro's. 155: ${AT_SYS_M4DIR:=}
36# _elibtoolize() - Runs libtoolize. Note the '_' prefix .. to not collide
37# with elibtoolize() from libtool.eclass
38# eautoconf - Runs autoconf.
39# eautoheader - Runs autoheader.
40# eautomake - Runs automake
41#
42 156
43# XXX: M4DIR should be depreciated 157# @FUNCTION: eautoreconf
44AT_M4DIR=${AT_M4DIR:-${M4DIR}} 158# @DESCRIPTION:
45AT_GNUCONF_UPDATE="no"
46
47
48# This function mimes the behavior of autoreconf, but uses the different 159# This function mimes the behavior of autoreconf, but uses the different
49# eauto* functions to run the tools. It doesn't accept parameters, but 160# eauto* functions to run the tools. It doesn't accept parameters, but
50# the directory with include files can be specified with AT_M4DIR variable. 161# the directory with include files can be specified with AT_M4DIR variable.
51# 162#
52# Note: doesn't run autopoint right now, but runs gnuconfig_update. 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.
53eautoreconf() { 165eautoreconf() {
54 local pwd=$(pwd) x 166 local x g
55 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
56 # Take care of subdirs 176 # Take care of subdirs
57 for x in $(autotools_get_subdirs); do 177 for x in $(autotools_check_macro_val AC_CONFIG_SUBDIRS) ; do
58 if [[ -d ${x} ]] ; then 178 if [[ -d ${x} ]] ; then
59 cd "${x}" 179 pushd "${x}" >/dev/null
60 eautoreconf 180 # Avoid unsafe nested multijob_finish_one for bug #426512.
61 cd "${pwd}" 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 --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]}
62 fi 207 fi
63 done 208 done
64 209
210 # Generate aclocal.m4 with our up-to-date m4 files.
211 local rerun_aclocal=false
65 eaclocal 212 eaclocal
66 _elibtoolize --copy --force 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
67 eautoconf 226 eautoconf
227 else
228 eautoconf --force
229 fi
68 eautoheader 230 eautoheader
69 eautomake ${AM_OPTS} 231 [[ ${AT_NOEAUTOMAKE} != "yes" ]] && FROM_EAUTORECONF="yes" eautomake ${AM_OPTS}
70 232
71 # Normally run by econf() 233 if [[ ${AT_NOELIBTOOLIZE} != "yes" ]] ; then
72 [[ ${AT_GNUCONF_UPDATE} == "yes" ]] && gnuconfig_update 234 # Call it here to prevent failures due to elibtoolize called _before_
235 # eautoreconf.
236 elibtoolize --force "${PWD}"
237 fi
73 238
74 return 0 239 return 0
75} 240}
76 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_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
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.
272eaclocal_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:
77# These functions runs the autotools using autotools_run_tool with the 298# These functions runs the autotools using autotools_run_tool with the
78# specified parametes. The name of the tool run is the same of the function 299# specified parametes. The name of the tool run is the same of the function
79# without e prefix. 300# without e prefix.
80# They also force installing the support files for safety. 301# They also force installing the support files for safety.
302# Respects AT_M4DIR for additional directories to search for macro's.
81eaclocal() { 303eaclocal() {
82 local aclocal_opts
83
84 # XXX: M4DIR should be depreciated
85 AT_M4DIR=${AT_M4DIR:-${M4DIR}}
86
87 if [[ -n ${AT_M4DIR} ]] ; then
88 for x in ${AT_M4DIR} ; do
89 case "${x}" in
90 "-I")
91 # We handle it below
92 ;;
93 "-I"*)
94 # Invalid syntax, but maybe we should help out ...
95 ewarn "eaclocal: Proper syntax is (note the space after '-I'): aclocal -I <dir>"
96 aclocal_opts="${aclocal_opts} -I ${x}"
97 ;;
98 *)
99 [[ ! -d ${x} ]] && ewarn "eaclocal: '${x}' does not exist"
100 aclocal_opts="${aclocal_opts} -I ${x}"
101 ;;
102 esac
103 done
104 fi
105
106 [[ ! -f aclocal.m4 || -n $(grep -e 'generated.*by aclocal' aclocal.m4) ]] && \ 304 [[ ! -f aclocal.m4 || -n $(grep -e 'generated.*by aclocal' aclocal.m4) ]] && \
107 autotools_run_tool aclocal "$@" ${aclocal_opts} 305 autotools_run_tool --at-m4flags aclocal "$@" $(eaclocal_amflags)
108} 306}
109 307
308# @FUNCTION: _elibtoolize
309# @DESCRIPTION:
310# Runs libtoolize.
311#
312# Note the '_' prefix: avoid collision with elibtoolize() from libtool.eclass.
110_elibtoolize() { 313_elibtoolize() {
111 local opts 314 local LIBTOOLIZE=${LIBTOOLIZE:-$(type -P glibtoolize > /dev/null && echo glibtoolize || echo libtoolize)}
112 315
113 # Check if we should run libtoolize 316 [[ -f GNUmakefile.am || -f Makefile.am ]] && set -- "$@" --automake
114 [[ -n $(autotools_check_macro "AC_PROG_LIBTOOL") ]] || return 0
115 317
116 [[ -f Makefile.am ]] && opts="--automake"
117
118 [[ "${USERLAND}" == "Darwin" ]] && LIBTOOLIZE="glibtoolize"
119 autotools_run_tool ${LIBTOOLIZE:-libtoolize} "$@" ${opts} 318 autotools_run_tool ${LIBTOOLIZE} "$@"
120
121 # Need to rerun aclocal
122 eaclocal
123} 319}
124 320
321# @FUNCTION: eautoheader
322# @DESCRIPTION:
323# Runs autoheader.
125eautoheader() { 324eautoheader() {
126 # Check if we should run autoheader 325 _at_uses_autoheader || return 0
127 [[ -n $(autotools_check_macro "AC_CONFIG_HEADERS") ]] || return 0 326 autotools_run_tool --at-no-fail --at-m4flags autoheader "$@"
128 autotools_run_tool autoheader "$@"
129} 327}
130 328
329# @FUNCTION: eautoconf
330# @DESCRIPTION:
331# Runs autoconf.
131eautoconf() { 332eautoconf() {
132 if [[ ! -f configure.ac && ! -f configure.in ]] ; then 333 if [[ ! -f configure.ac && ! -f configure.in ]] ; then
133 echo 334 echo
134 eerror "No configure.{ac,in} present in '$(pwd | sed -e 's:.*/::')'!" 335 eerror "No configure.{ac,in} present in '${PWD}'!"
135 echo 336 echo
136 die "No configure.{ac,in} present!" 337 die "No configure.{ac,in} present!"
137 fi 338 fi
339 if [[ ${WANT_AUTOCONF} != "2.1" && -e configure.in ]] ; then
340 eqawarn "This package has a configure.in file which has long been deprecated. Please"
341 eqawarn "update it to use configure.ac instead as newer versions of autotools will die"
342 eqawarn "when it finds this file. See https://bugs.gentoo.org/426262 for details."
343 fi
138 344
139 autotools_run_tool autoconf "$@" 345 autotools_run_tool --at-m4flags autoconf "$@"
140} 346}
141 347
348# @FUNCTION: eautomake
349# @DESCRIPTION:
350# Runs automake.
142eautomake() { 351eautomake() {
143 local extra_opts 352 local extra_opts=()
353 local makefile_name
144 354
145 [[ -f Makefile.am ]] || return 0 355 # Run automake if:
356 # - a Makefile.am type file exists
357 # - the configure script is using the AM_INIT_AUTOMAKE directive
358 for makefile_name in {GNUmakefile,{M,m}akefile}.am "" ; do
359 [[ -f ${makefile_name} ]] && break
360 done
146 361
362 _automake_version() {
363 autotools_run_tool --at-output automake --version 2>/dev/null |
364 sed -n -e '1{s:.*(GNU automake) ::p;q}'
365 }
366
367 if [[ -z ${makefile_name} ]] ; then
368 _at_uses_automake || return 0
369
370 elif [[ -z ${FROM_EAUTORECONF} && -f ${makefile_name%.am}.in ]]; then
371 local used_automake
372 local installed_automake
373
374 installed_automake=$(WANT_AUTOMAKE= _automake_version)
375 used_automake=$(head -n 1 < ${makefile_name%.am}.in | \
376 sed -e 's:.*by automake \(.*\) from .*:\1:')
377
378 if [[ ${installed_automake} != ${used_automake} ]]; then
379 ewarn "Automake used for the package (${used_automake}) differs from" \
380 "the installed version (${installed_automake})."
381 ewarn "Forcing a full rebuild of the autotools to workaround."
382 eautoreconf
383 return 0
384 fi
385 fi
386
147 [[ -f INSTALL && -f AUTHORS && -f ChangeLog ]] \ 387 [[ -f INSTALL && -f AUTHORS && -f ChangeLog && -f NEWS && -f README ]] \
148 || extra_opts="${extra_opts} --foreign" 388 || extra_opts+=( --foreign )
149 389
150 # --force-missing seems not to be recognized by some flavours of automake 390 # Older versions of automake do not support --force-missing. But we want
391 # to use this whenever possible to update random bundled files #133489.
392 case $(_automake_version) in
393 1.4|1.4[.-]*) ;;
394 *) extra_opts+=( --force-missing ) ;;
395 esac
396
151 autotools_run_tool automake --add-missing --copy ${extra_opts} "$@" 397 autotools_run_tool automake --add-missing --copy "${extra_opts[@]}" "$@"
152} 398}
153 399
400# @FUNCTION: eautopoint
401# @DESCRIPTION:
402# Runs autopoint (from the gettext package).
403eautopoint() {
404 autotools_run_tool autopoint "$@"
405}
154 406
407# @FUNCTION: config_rpath_update
408# @USAGE: [destination]
409# @DESCRIPTION:
410# Some packages utilize the config.rpath helper script, but don't
411# use gettext directly. So we have to copy it in manually since
412# we can't let `autopoint` do it for us.
413config_rpath_update() {
414 local dst src=$(type -P gettext | sed 's:bin/gettext:share/gettext/config.rpath:')
155 415
156# Internal function to run an autotools' tool 416 [[ $# -eq 0 ]] && set -- $(find -name config.rpath)
417 [[ $# -eq 0 ]] && return 0
418
419 einfo "Updating all config.rpath files"
420 for dst in "$@" ; do
421 einfo " ${dst}"
422 cp "${src}" "${dst}" || die
423 done
424}
425
426# @FUNCTION: autotools_env_setup
427# @INTERNAL
428# @DESCRIPTION:
429# Process the WANT_AUTO{CONF,MAKE} flags.
430autotools_env_setup() {
431 # We do the "latest" → version switch here because it solves
432 # possible order problems, see bug #270010 as an example.
433 if [[ ${WANT_AUTOMAKE} == "latest" ]]; then
434 local pv
435 for pv in ${_LATEST_AUTOMAKE[@]/#*:} ; do
436 # has_version respects ROOT, but in this case, we don't want it to,
437 # thus "ROOT=/" prefix:
438 ROOT=/ has_version "=sys-devel/automake-${pv}*" && export WANT_AUTOMAKE="${pv}"
439 done
440 [[ ${WANT_AUTOMAKE} == "latest" ]] && \
441 die "Cannot find the latest automake! Tried ${_LATEST_AUTOMAKE[*]}"
442 fi
443 [[ ${WANT_AUTOCONF} == "latest" ]] && export WANT_AUTOCONF=2.5
444}
445
446# @FUNCTION: autotools_run_tool
447# @USAGE: [--at-no-fail] [--at-m4flags] [--at-missing] [--at-output] <autotool> [tool-specific flags]
448# @INTERNAL
449# @DESCRIPTION:
450# Run the specified autotool helper, but do logging and error checking
451# around it in the process.
157autotools_run_tool() { 452autotools_run_tool() {
453 # Process our own internal flags first
454 local autofail=true m4flags=false missing_ok=false return_output=false
455 while [[ -n $1 ]] ; do
456 case $1 in
457 --at-no-fail) autofail=false;;
458 --at-m4flags) m4flags=true;;
459 --at-missing) missing_ok=true;;
460 --at-output) return_output=true;;
461 # whatever is left goes to the actual tool
462 *) break;;
463 esac
464 shift
465 done
466
467 if [[ ${EBUILD_PHASE} != "unpack" && ${EBUILD_PHASE} != "prepare" ]]; then
468 ewarn "QA Warning: running $1 in ${EBUILD_PHASE} phase"
469 fi
470
471 if ${missing_ok} && ! type -P ${1} >/dev/null ; then
472 einfo "Skipping '$*' due $1 not installed"
473 return 0
474 fi
475
476 autotools_env_setup
477
158 local STDERR_TARGET="${T}/$$.out" 478 local STDERR_TARGET="${T}/$1.out"
159 local PATCH_TARGET="${T}/$$.patch" 479 # most of the time, there will only be one run, but if there are
480 # more, make sure we get unique log filenames
481 if [[ -e ${STDERR_TARGET} ]] ; then
160 local ris 482 local i=1
483 while :; do
484 STDERR_TARGET="${T}/$1-${i}.out"
485 [[ -e ${STDERR_TARGET} ]] || break
486 : $(( i++ ))
487 done
488 fi
161 489
162 echo "***** $1 *****" > ${STDERR_TARGET%/*}/$1-${STDERR_TARGET##*/} 490 if ${m4flags} ; then
163 echo >> ${STDERR_TARGET%/*}/$1-${STDERR_TARGET##*/} 491 set -- "${1}" $(autotools_m4dir_include) "${@:2}" $(autotools_m4sysdir_include)
492 fi
164 493
494 # If the caller wants to probe something, then let them do it directly.
495 if ${return_output} ; then
496 "$@"
497 return
498 fi
499
500 printf "***** $1 *****\n***** PWD: ${PWD}\n***** $*\n\n" > "${STDERR_TARGET}"
501
165 ebegin "Running $1" 502 ebegin "Running $@"
166 $@ >> ${STDERR_TARGET%/*}/$1-${STDERR_TARGET##*/} 2>&1 503 "$@" >> "${STDERR_TARGET}" 2>&1
167 ris=$? 504 if ! eend $? && ${autofail} ; then
168 eend ${ris}
169
170 if [[ ${ris} != 0 ]]; then
171 echo 505 echo
172 eerror "Failed Running $1 !" 506 eerror "Failed Running $1 !"
173 eerror 507 eerror
174 eerror "Include in your bugreport the contents of:" 508 eerror "Include in your bugreport the contents of:"
175 eerror 509 eerror
176 eerror " ${STDERR_TARGET%/*}/$1-${STDERR_TARGET##*/}" 510 eerror " ${STDERR_TARGET}"
177 echo 511 echo
178 die "Failed Running $1 !" 512 die "Failed Running $1 !"
179 fi 513 fi
180} 514}
181 515
182# Internal function to check for support 516# Internal function to check for support
517
518# Keep a list of all the macros we might use so that we only
519# have to run the trace code once. Order doesn't matter.
520ALL_AUTOTOOLS_MACROS=(
521 A{C,M}_PROG_LIBTOOL LT_INIT
522 A{C,M}_CONFIG_HEADER{S,}
523 AC_CONFIG_SUBDIRS
524 AC_CONFIG_AUX_DIR AC_CONFIG_MACRO_DIR
525 AM_INIT_AUTOMAKE
526 AM_GLIB_GNU_GETTEXT
527 AM_GNU_GETTEXT_VERSION
528 {AC,IT}_PROG_INTLTOOL
529 GTK_DOC_CHECK
530 GNOME_DOC_INIT
531)
183autotools_check_macro() { 532autotools_check_macro() {
184 [[ -f configure.ac || -f configure.in ]] && \ 533 [[ -f configure.ac || -f configure.in ]] || return 0
185 autoconf --trace=$1 2>/dev/null 534
535 # We can run in multiple dirs, so we have to cache the trace
536 # data in $PWD rather than an env var.
537 local trace_file=".__autoconf_trace_data"
538 if [[ ! -e ${trace_file} ]] || [[ ! aclocal.m4 -ot ${trace_file} ]] ; then
539 WANT_AUTOCONF="2.5" autoconf \
540 $(autotools_m4dir_include) \
541 ${ALL_AUTOTOOLS_MACROS[@]/#/--trace=} > ${trace_file} 2>/dev/null
542 fi
543
544 local macro args=()
545 for macro ; do
546 has ${macro} ${ALL_AUTOTOOLS_MACROS[@]} || die "internal error: add ${macro} to ALL_AUTOTOOLS_MACROS"
547 args+=( -e ":${macro}:" )
548 done
549 grep "${args[@]}" ${trace_file}
550}
551
552# @FUNCTION: autotools_check_macro_val
553# @USAGE: <macro> [macros]
554# @INTERNAL
555# @DESCRIPTION:
556# Look for a macro and extract its value.
557autotools_check_macro_val() {
558 local macro scan_out
559
560 for macro ; do
561 autotools_check_macro "${macro}" | \
562 gawk -v macro="${macro}" \
563 '($0 !~ /^[[:space:]]*(#|dnl)/) {
564 if (match($0, macro ":(.*)$", res))
565 print res[1]
566 }' | uniq
567 done
568
186 return 0 569 return 0
187} 570}
188 571
189# Internal function to get additional subdirs to configure 572_autotools_m4dir_include() {
190autotools_get_subdirs() { 573 local x include_opts flag
191 local subdirs_scan_out
192 574
193 subdirs_scan_out=$(autotools_check_macro "AC_CONFIG_SUBDIRS") 575 # Use the right flag to autoconf based on the version #448986
194 [[ -n ${subdirs_scan_out} ]] || return 0 576 [[ ${WANT_AUTOCONF} == "2.1" ]] \
577 && flag="l" \
578 || flag="I"
195 579
196 echo "${subdirs_scan_out}" | gawk \ 580 for x in "$@" ; do
197 '($0 !~ /^[[:space:]]*(#|dnl)/) { 581 case ${x} in
198 if (match($0, "AC_CONFIG_SUBDIRS\\(\\[?([^\\])]*)", res)) { 582 # We handle it below
199 split(res[1], DIRS, /[\])]/) 583 -${flag}) ;;
200 print DIRS[1] 584 *)
201 } 585 [[ ! -d ${x} ]] && ewarn "autotools.eclass: '${x}' does not exist"
202 }' | uniq 586 include_opts+=" -${flag} ${x}"
587 ;;
588 esac
589 done
203 590
204 return 0 591 echo ${include_opts}
205} 592}
593autotools_m4dir_include() { _autotools_m4dir_include ${AT_M4DIR} ; }
594autotools_m4sysdir_include() {
595 # First try to use the paths the system integrator has set up.
596 local paths=( $(eval echo ${AT_SYS_M4DIR}) )
206 597
598 if [[ ${#paths[@]} -eq 0 && -n ${SYSROOT} ]] ; then
599 # If they didn't give us anything, then default to the SYSROOT.
600 # This helps when cross-compiling.
601 local path="${SYSROOT}/usr/share/aclocal"
602 [[ -d ${path} ]] && paths+=( "${path}" )
603 fi
604 _autotools_m4dir_include "${paths[@]}"
605}
606
607fi

Legend:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.177

  ViewVC Help
Powered by ViewVC 1.1.20