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

Diff of /eclass/autotools.eclass

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

Revision 1.64 Revision 1.169
1# Copyright 1999-2007 Gentoo Foundation 1# Copyright 1999-2014 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.64 2007/01/19 23:39:29 vapier Exp $ 3# $Header: /var/cvsroot/gentoo-x86/eclass/autotools.eclass,v 1.169 2014/11/15 07:50:02 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 libtool 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[[ -z ${WANT_AUTOCONF} ]] && WANT_AUTOCONF="latest" 16if [[ ${__AUTOTOOLS_AUTO_DEPEND+set} == "set" ]] ; then
16[[ -z ${WANT_AUTOMAKE} ]] && WANT_AUTOMAKE="latest" 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
24fi
25
26if [[ -z ${_AUTOTOOLS_ECLASS} ]]; then
27_AUTOTOOLS_ECLASS=1
28
29inherit libtool multiprocessing
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.13:1.13 1.14:1.14 )
17 60
18_automake_atom="sys-devel/automake" 61_automake_atom="sys-devel/automake"
19_autoconf_atom="sys-devel/autoconf" 62_autoconf_atom="sys-devel/autoconf"
20if [[ -n ${WANT_AUTOMAKE} ]]; then 63if [[ -n ${WANT_AUTOMAKE} ]]; then
21 case ${WANT_AUTOMAKE} in 64 case ${WANT_AUTOMAKE} in
22 # workaround while we have different versions of automake in arch and ~arch 65 # Even if the package doesn't use automake, we still need to depend
23 none) _automake_atom="" ;; # some packages don't require automake at all 66 # on it because we run aclocal to process m4 macros. This matches
24 latest) _automake_atom="=sys-devel/automake-1.10*" ;; 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 ;;
25 *) _automake_atom="=sys-devel/automake-${WANT_AUTOMAKE}*" ;; 77 *) _automake_atom="=sys-devel/automake-${WANT_AUTOMAKE}*" ;;
26 esac 78 esac
27 [[ ${WANT_AUTOMAKE} == "latest" ]] && WANT_AUTOMAKE="1.10"
28 export WANT_AUTOMAKE 79 export WANT_AUTOMAKE
29fi 80fi
30 81
31if [[ -n ${WANT_AUTOCONF} ]] ; then 82if [[ -n ${WANT_AUTOCONF} ]] ; then
32 case ${WANT_AUTOCONF} in 83 case ${WANT_AUTOCONF} in
84 none) _autoconf_atom="" ;; # some packages don't require autoconf at all
33 2.1) _autoconf_atom="=sys-devel/autoconf-${WANT_AUTOCONF}*" ;; 85 2.1) _autoconf_atom="=sys-devel/autoconf-${WANT_AUTOCONF}*" ;;
86 # if you change the "latest" version here, change also autotools_env_setup
34 latest | 2.5) _autoconf_atom=">=sys-devel/autoconf-2.59" ;; 87 latest|2.5) _autoconf_atom=">=sys-devel/autoconf-2.69" ;;
88 *) die "Invalid WANT_AUTOCONF value '${WANT_AUTOCONF}'" ;;
35 esac 89 esac
36 [[ ${WANT_AUTOCONF} == "latest" ]] && WANT_AUTOCONF="2.5"
37 export WANT_AUTOCONF 90 export WANT_AUTOCONF
38fi 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
39DEPEND="${_automake_atom} 106 ${_automake_atom}
40 ${_autoconf_atom} 107 ${_autoconf_atom}
41 sys-devel/libtool" 108 ${_libtool_atom}"
42RDEPEND="" 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
43unset _automake_atom _autoconf_atom 122unset _automake_atom _autoconf_atom
44 123
45# Variables: 124# @ECLASS-VARIABLE: AM_OPTS
46# 125# @DEFAULT_UNSET
47# AT_M4DIR - Additional director(y|ies) aclocal should search 126# @DESCRIPTION:
48# AM_OPTS - Additional options to pass to automake during 127# Additional options to pass to automake during
49# eautoreconf call. 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:
50# AT_NOELIBTOOLIZE - Don't run elibtoolize command if set to 'yes', 140# Don't run elibtoolize command if set to 'yes',
51# useful when elibtoolize needs to be ran with 141# useful when elibtoolize needs to be ran with
52# particular options 142# particular options
53 143
54# Functions: 144# @ECLASS-VARIABLE: AT_M4DIR
55# 145# @DESCRIPTION:
56# eautoreconf() - Should do a full autoreconf - normally what most people 146# Additional director(y|ies) aclocal should search
57# will be interested in. Also should handle additional 147: ${AT_M4DIR:=}
58# directories specified by AC_CONFIG_SUBDIRS.
59# eaclocal() - Runs aclocal. Respects AT_M4DIR for additional directories
60# to search for macro's.
61# _elibtoolize() - Runs libtoolize. Note the '_' prefix .. to not collide
62# with elibtoolize() from libtool.eclass
63# eautoconf - Runs autoconf.
64# eautoheader - Runs autoheader.
65# eautomake - Runs automake
66#
67 148
68# XXX: M4DIR should be depreciated 149# @ECLASS-VARIABLE: AT_SYS_M4DIR
69AT_M4DIR=${AT_M4DIR:-${M4DIR}} 150# @INTERNAL
70AT_GNUCONF_UPDATE="no" 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:=}
71 156
72 157# @FUNCTION: eautoreconf
158# @DESCRIPTION:
73# This function mimes the behavior of autoreconf, but uses the different 159# This function mimes the behavior of autoreconf, but uses the different
74# 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
75# 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.
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.
76eautoreconf() { 165eautoreconf() {
77 local pwd=$(pwd) x auxdir 166 local x g multitop
78 167
168 if [[ -z ${AT_TOPLEVEL_EAUTORECONF} ]] ; then
169 AT_TOPLEVEL_EAUTORECONF="yes"
170 multitop="yes"
171 multijob_init
172 fi
173
79 if [[ -z ${AT_NO_RECURSIVE} ]]; then 174 if [[ -z ${AT_NO_RECURSIVE} ]] ; then
80 # Take care of subdirs 175 # Take care of subdirs
81 for x in $(autotools_get_subdirs); do 176 for x in $(autotools_check_macro_val AC_CONFIG_SUBDIRS) ; do
82 if [[ -d ${x} ]] ; then 177 if [[ -d ${x} ]] ; then
83 cd "${x}" 178 pushd "${x}" >/dev/null
179 if [[ -z ${PAST_TOPLEVEL_EAUTORECONF} ]] ; then
180 PAST_TOPLEVEL_EAUTORECONF="yes" AT_NOELIBTOOLIZE="yes" \
181 multijob_child_init eautoreconf || die
182 else
183 # Avoid unsafe nested multijob_finish_one for bug #426512.
84 AT_NOELIBTOOLIZE="yes" eautoreconf 184 AT_NOELIBTOOLIZE="yes" eautoreconf || die
85 cd "${pwd}" 185 fi
186 popd >/dev/null
86 fi 187 fi
87 done 188 done
88 fi 189 fi
89 190
90 auxdir=$(autotools_get_auxdir)
91
92 einfo "Running eautoreconf in '$(pwd)' ..." 191 einfo "Running eautoreconf in '${PWD}' ..."
192
193 local m4dirs=$(autotools_check_macro_val AC_CONFIG_{AUX,MACRO}_DIR)
93 [[ -n ${auxdir} ]] && mkdir -p ${auxdir} 194 [[ -n ${m4dirs} ]] && mkdir -p ${m4dirs}
195
196 # Run all the tools before aclocal so we can gather the .m4 files.
197 local i tools=(
198 # <tool> <was run> <command>
199 glibgettext false "autotools_run_tool glib-gettextize --copy --force"
200 gettext false "autotools_run_tool --at-missing autopoint --force"
201 # intltool must come after autopoint.
202 intltool false "autotools_run_tool intltoolize --automake --copy --force"
203 gtkdoc false "autotools_run_tool --at-missing gtkdocize --copy"
204 gnomedoc false "autotools_run_tool --at-missing gnome-doc-prepare --copy --force"
205 libtool false "_elibtoolize --install --copy --force"
206 )
207 for (( i = 0; i < ${#tools[@]}; i += 3 )) ; do
208 if _at_uses_${tools[i]} ; then
209 tools[i+1]=true
210 ${tools[i+2]}
211 fi
212 done
213
214 # Generate aclocal.m4 with our up-to-date m4 files.
215 local rerun_aclocal=false
94 eaclocal 216 eaclocal
95 _elibtoolize --copy --force 217
218 # Check to see if we had macros expanded by other macros or in other
219 # m4 files that we couldn't detect early. This is uncommon, but some
220 # packages do this, so we have to handle it correctly.
221 for (( i = 0; i < ${#tools[@]}; i += 3 )) ; do
222 if ! ${tools[i+1]} && _at_uses_${tools[i]} ; then
223 ${tools[i+2]}
224 rerun_aclocal=true
225 fi
226 done
227 ${rerun_aclocal} && eaclocal
228
96 eautoconf 229 eautoconf
97 eautoheader 230 eautoheader
98 FROM_EAUTORECONF="yes" eautomake ${AM_OPTS} 231 [[ ${AT_NOEAUTOMAKE} != "yes" ]] && FROM_EAUTORECONF="yes" eautomake ${AM_OPTS}
99 232
100 [[ ${AT_NOELIBTOOLIZE} == "yes" ]] && return 0 233 if [[ ${AT_NOELIBTOOLIZE} != "yes" ]] ; then
101
102 # Call it here to prevent failures due to elibtoolize called _before_ 234 # Call it here to prevent failures due to elibtoolize called _before_
103 # eautoreconf. 235 # eautoreconf.
104 elibtoolize 236 elibtoolize --force "${PWD}"
237 fi
238
239 if [[ -n ${multitop} ]] ; then
240 unset AT_TOPLEVEL_EAUTORECONF
241 multijob_finish || die
242 fi
105 243
106 return 0 244 return 0
107} 245}
108 246
247# @FUNCTION: _at_uses_pkg
248# @USAGE: <macros>
249# @INTERNAL
250# See if the specified macros are enabled.
251_at_uses_pkg() {
252 if [[ -n $(autotools_check_macro "$@") ]] ; then
253 return 0
254 else
255 # If the trace didn't find it (perhaps because aclocal.m4 hasn't
256 # been generated yet), cheat, but be conservative.
257 local macro args=()
258 for macro ; do
259 args+=( -e "^[[:space:]]*${macro}\>" )
260 done
261 egrep -q "${args[@]}" configure.??
262 fi
263}
264_at_uses_autoheader() { _at_uses_pkg A{C,M}_CONFIG_HEADER{S,}; }
265_at_uses_automake() { _at_uses_pkg AM_INIT_AUTOMAKE; }
266_at_uses_gettext() { _at_uses_pkg AM_GNU_GETTEXT_VERSION; }
267_at_uses_glibgettext() { _at_uses_pkg AM_GLIB_GNU_GETTEXT; }
268_at_uses_intltool() { _at_uses_pkg {AC,IT}_PROG_INTLTOOL; }
269_at_uses_gtkdoc() { _at_uses_pkg GTK_DOC_CHECK; }
270_at_uses_gnomedoc() { _at_uses_pkg GNOME_DOC_INIT; }
271_at_uses_libtool() { _at_uses_pkg A{C,M}_PROG_LIBTOOL LT_INIT; }
272
273# @FUNCTION: eaclocal_amflags
274# @DESCRIPTION:
275# Extract the ACLOCAL_AMFLAGS value from the Makefile.am and try to handle
276# (most) of the crazy crap that people throw at us.
277eaclocal_amflags() {
278 local aclocal_opts amflags_file
279
280 for amflags_file in GNUmakefile.am Makefile.am GNUmakefile.in Makefile.in ; do
281 [[ -e ${amflags_file} ]] || continue
282 # setup the env in case the pkg does something crazy
283 # in their ACLOCAL_AMFLAGS. like run a shell script
284 # which turns around and runs autotools. #365401
285 # or split across multiple lines. #383525
286 autotools_env_setup
287 aclocal_opts=$(sed -n \
288 "/^ACLOCAL_AMFLAGS[[:space:]]*=/{ \
289 # match the first line
290 s:[^=]*=::p; \
291 # then gobble up all escaped lines
292 : nextline /\\\\$/{ n; p; b nextline; } \
293 }" ${amflags_file})
294 eval aclocal_opts=\""${aclocal_opts}"\"
295 break
296 done
297
298 echo ${aclocal_opts}
299}
300
301# @FUNCTION: eaclocal
302# @DESCRIPTION:
109# These functions runs the autotools using autotools_run_tool with the 303# These functions runs the autotools using autotools_run_tool with the
110# specified parametes. The name of the tool run is the same of the function 304# specified parametes. The name of the tool run is the same of the function
111# without e prefix. 305# without e prefix.
112# They also force installing the support files for safety. 306# They also force installing the support files for safety.
307# Respects AT_M4DIR for additional directories to search for macro's.
113eaclocal() { 308eaclocal() {
114 local aclocal_opts
115
116 if [[ -n ${AT_M4DIR} ]] ; then
117 for x in ${AT_M4DIR} ; do
118 case "${x}" in
119 "-I")
120 # We handle it below
121 ;;
122 *)
123 [[ ! -d ${x} ]] && ewarn "eaclocal: '${x}' does not exist"
124 aclocal_opts="${aclocal_opts} -I ${x}"
125 ;;
126 esac
127 done
128 fi
129
130 [[ ! -f aclocal.m4 || -n $(grep -e 'generated.*by aclocal' aclocal.m4) ]] && \ 309 [[ ! -f aclocal.m4 || -n $(grep -e 'generated.*by aclocal' aclocal.m4) ]] && \
131 autotools_run_tool aclocal "$@" ${aclocal_opts} 310 autotools_run_tool --at-m4flags aclocal "$@" $(eaclocal_amflags)
132} 311}
133 312
313# @FUNCTION: _elibtoolize
314# @DESCRIPTION:
315# Runs libtoolize.
316#
317# Note the '_' prefix: avoid collision with elibtoolize() from libtool.eclass.
134_elibtoolize() { 318_elibtoolize() {
135 local opts 319 local LIBTOOLIZE=${LIBTOOLIZE:-$(type -P glibtoolize > /dev/null && echo glibtoolize || echo libtoolize)}
136 local lttest
137 320
138 # Check if we should run libtoolize (AM_PROG_LIBTOOL is an older macro, 321 [[ -f GNUmakefile.am || -f Makefile.am ]] && set -- "$@" --automake
139 # check for both it and the current AC_PROG_LIBTOOL)
140 lttest="$(autotools_check_macro "AC_PROG_LIBTOOL")$(autotools_check_macro "AM_PROG_LIBTOOL")"
141 [[ -n $lttest ]] || return 0
142 322
143 [[ -f Makefile.am ]] && opts="--automake"
144
145 [[ "${USERLAND}" == "Darwin" ]] && LIBTOOLIZE="glibtoolize"
146 autotools_run_tool ${LIBTOOLIZE:-libtoolize} "$@" ${opts} 323 autotools_run_tool ${LIBTOOLIZE} "$@"
147
148 # Need to rerun aclocal
149 eaclocal
150} 324}
151 325
326# @FUNCTION: eautoheader
327# @DESCRIPTION:
328# Runs autoheader.
152eautoheader() { 329eautoheader() {
153 # Check if we should run autoheader 330 _at_uses_autoheader || return 0
154 [[ -n $(autotools_check_macro "AC_CONFIG_HEADERS") ]] || return 0 331 autotools_run_tool --at-no-fail --at-m4flags autoheader "$@"
155 NO_FAIL=1 autotools_run_tool autoheader "$@"
156} 332}
157 333
334# @FUNCTION: eautoconf
335# @DESCRIPTION:
336# Runs autoconf.
158eautoconf() { 337eautoconf() {
159 if [[ ! -f configure.ac && ! -f configure.in ]] ; then 338 if [[ ! -f configure.ac && ! -f configure.in ]] ; then
160 echo 339 echo
161 eerror "No configure.{ac,in} present in '$(pwd | sed -e 's:.*/::')'!" 340 eerror "No configure.{ac,in} present in '${PWD}'!"
162 echo 341 echo
163 die "No configure.{ac,in} present!" 342 die "No configure.{ac,in} present!"
164 fi 343 fi
344 if [[ -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
165 349
166 autotools_run_tool autoconf "$@" 350 autotools_run_tool --at-m4flags autoconf "$@"
167} 351}
168 352
353# @FUNCTION: eautomake
354# @DESCRIPTION:
355# Runs automake.
169eautomake() { 356eautomake() {
170 local extra_opts 357 local extra_opts=()
358 local makefile_name
171 359
172 [[ -f Makefile.am ]] || return 0 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
173 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
174 if [[ -z ${FROM_EAUTORECONF} && -f Makefile.in ]]; then 375 elif [[ -z ${FROM_EAUTORECONF} && -f ${makefile_name%.am}.in ]]; then
175 local used_automake 376 local used_automake
176 local installed_automake 377 local installed_automake
177 378
178 installed_automake=$(automake --version | head -n 1 | \ 379 installed_automake=$(WANT_AUTOMAKE= _automake_version)
179 sed -e 's:.*(GNU automake) ::')
180 used_automake=$(head -n 1 < Makefile.in | \ 380 used_automake=$(head -n 1 < ${makefile_name%.am}.in | \
181 sed -e 's:.*by automake \(.*\) from .*:\1:') 381 sed -e 's:.*by automake \(.*\) from .*:\1:')
182 382
183 if [[ ${installed_automake} != ${used_automake} ]]; then 383 if [[ ${installed_automake} != ${used_automake} ]]; then
184 einfo "Automake used for the package (${used_automake}) differs from" 384 ewarn "Automake used for the package (${used_automake}) differs from" \
185 einfo "the installed version (${installed_automake})." 385 "the installed version (${installed_automake})."
386 ewarn "Forcing a full rebuild of the autotools to workaround."
186 eautoreconf 387 eautoreconf
187 return 0 388 return 0
188 fi 389 fi
189 fi 390 fi
190 391
191 [[ -f INSTALL && -f AUTHORS && -f ChangeLog && -f NEWS ]] \ 392 [[ -f INSTALL && -f AUTHORS && -f ChangeLog && -f NEWS && -f README ]] \
192 || extra_opts="${extra_opts} --foreign" 393 || extra_opts+=( --foreign )
193 394
194 # --force-missing seems not to be recognized by some flavours of automake 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
195 autotools_run_tool automake --add-missing --copy ${extra_opts} "$@" 402 autotools_run_tool automake --add-missing --copy "${extra_opts[@]}" "$@"
196} 403}
197 404
198# Internal function to run an autotools' tool 405# @FUNCTION: eautopoint
406# @DESCRIPTION:
407# Runs autopoint (from the gettext package).
408eautopoint() {
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.
418config_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.
435autotools_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.
199autotools_run_tool() { 457autotools_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
200 local STDERR_TARGET="${T}/$$.out" 483 local STDERR_TARGET="${T}/$1.out"
484 # most of the time, there will only be one run, but if there are
485 # more, make sure we get unique log filenames
486 if [[ -e ${STDERR_TARGET} ]] ; then
201 local ris 487 local i=1
488 while :; do
489 STDERR_TARGET="${T}/$1-${i}.out"
490 [[ -e ${STDERR_TARGET} ]] || break
491 : $(( i++ ))
492 done
493 fi
202 494
203 echo "***** $1 *****" > ${STDERR_TARGET%/*}/$1-${STDERR_TARGET##*/} 495 if ${m4flags} ; then
204 echo >> ${STDERR_TARGET%/*}/$1-${STDERR_TARGET##*/} 496 set -- "${1}" $(autotools_m4dir_include) "${@:2}" $(autotools_m4sysdir_include)
497 fi
498
499 # If the caller wants to probe something, then let them do it directly.
500 if ${return_output} ; then
501 "$@"
502 return
503 fi
504
505 printf "***** $1 *****\n***** PWD: ${PWD}\n***** $*\n\n" > "${STDERR_TARGET}"
205 506
206 ebegin "Running $@" 507 ebegin "Running $@"
207 $@ >> ${STDERR_TARGET%/*}/$1-${STDERR_TARGET##*/} 2>&1 508 "$@" >> "${STDERR_TARGET}" 2>&1
208 ris=$? 509 if ! eend $? && ${autofail} ; then
209 eend ${ris}
210
211 if [[ ${ris} != 0 && ${NO_FAIL} != 1 ]]; then
212 echo 510 echo
213 eerror "Failed Running $1 !" 511 eerror "Failed Running $1 !"
214 eerror 512 eerror
215 eerror "Include in your bugreport the contents of:" 513 eerror "Include in your bugreport the contents of:"
216 eerror 514 eerror
217 eerror " ${STDERR_TARGET%/*}/$1-${STDERR_TARGET##*/}" 515 eerror " ${STDERR_TARGET}"
218 echo 516 echo
219 die "Failed Running $1 !" 517 die "Failed Running $1 !"
220 fi 518 fi
221} 519}
222 520
223# Internal function to check for support 521# Internal function to check for support
522
523# Keep a list of all the macros we might use so that we only
524# have to run the trace code once. Order doesn't matter.
525ALL_AUTOTOOLS_MACROS=(
526 A{C,M}_PROG_LIBTOOL LT_INIT
527 A{C,M}_CONFIG_HEADER{S,}
528 AC_CONFIG_SUBDIRS
529 AC_CONFIG_AUX_DIR AC_CONFIG_MACRO_DIR
530 AM_INIT_AUTOMAKE
531 AM_GLIB_GNU_GETTEXT
532 AM_GNU_GETTEXT_VERSION
533 {AC,IT}_PROG_INTLTOOL
534 GTK_DOC_CHECK
535 GNOME_DOC_INIT
536)
224autotools_check_macro() { 537autotools_check_macro() {
225 [[ -f configure.ac || -f configure.in ]] && \ 538 [[ -f configure.ac || -f configure.in ]] || return 0
226 WANT_AUTOCONF="2.5" autoconf --trace=$1 2>/dev/null 539
540 # We can run in multiple dirs, so we have to cache the trace
541 # data in $PWD rather than an env var.
542 local trace_file=".__autoconf_trace_data"
543 if [[ ! -e ${trace_file} ]] || [[ ! aclocal.m4 -ot ${trace_file} ]] ; then
544 WANT_AUTOCONF="2.5" autoconf \
545 $(autotools_m4dir_include) \
546 ${ALL_AUTOTOOLS_MACROS[@]/#/--trace=} > ${trace_file} 2>/dev/null
547 fi
548
549 local macro args=()
550 for macro ; do
551 has ${macro} ${ALL_AUTOTOOLS_MACROS[@]} || die "internal error: add ${macro} to ALL_AUTOTOOLS_MACROS"
552 args+=( -e ":${macro}:" )
553 done
554 grep "${args[@]}" ${trace_file}
555}
556
557# @FUNCTION: autotools_check_macro_val
558# @USAGE: <macro> [macros]
559# @INTERNAL
560# @DESCRIPTION:
561# Look for a macro and extract its value.
562autotools_check_macro_val() {
563 local macro scan_out
564
565 for macro ; do
566 autotools_check_macro "${macro}" | \
567 gawk -v macro="${macro}" \
568 '($0 !~ /^[[:space:]]*(#|dnl)/) {
569 if (match($0, macro ":(.*)$", res))
570 print res[1]
571 }' | uniq
572 done
573
227 return 0 574 return 0
228} 575}
229 576
230# Internal function to get additional subdirs to configure 577_autotools_m4dir_include() {
231autotools_get_subdirs() { 578 local x include_opts flag
232 local subdirs_scan_out
233 579
234 subdirs_scan_out=$(autotools_check_macro "AC_CONFIG_SUBDIRS") 580 # Use the right flag to autoconf based on the version #448986
235 [[ -n ${subdirs_scan_out} ]] || return 0 581 [[ ${WANT_AUTOCONF} == "2.1" ]] \
582 && flag="l" \
583 || flag="I"
236 584
237 echo "${subdirs_scan_out}" | gawk \ 585 for x in "$@" ; do
238 '($0 !~ /^[[:space:]]*(#|dnl)/) { 586 case ${x} in
239 if (match($0, /AC_CONFIG_SUBDIRS:(.*)$/, res)) 587 # We handle it below
240 print res[1] 588 -${flag}) ;;
241 }' | uniq 589 *)
590 [[ ! -d ${x} ]] && ewarn "autotools.eclass: '${x}' does not exist"
591 include_opts+=" -${flag} ${x}"
592 ;;
593 esac
594 done
242 595
243 return 0 596 echo ${include_opts}
244} 597}
598autotools_m4dir_include() { _autotools_m4dir_include ${AT_M4DIR} ; }
599autotools_m4sysdir_include() { _autotools_m4dir_include $(eval echo ${AT_SYS_M4DIR}) ; }
245 600
246autotools_get_auxdir() { 601fi
247 local auxdir_scan_out
248
249 auxdir_scan_out=$(autotools_check_macro "AC_CONFIG_AUX_DIR")
250 [[ -n ${auxdir_scan_out} ]] || return 0
251
252 echo ${auxdir_scan_out} | gawk \
253 '($0 !~ /^[[:space:]]*(#|dnl)/) {
254 if (match($0, /AC_CONFIG_AUX_DIR:(.*)$/, res))
255 print res[1]
256 }' | uniq
257
258 return 0
259}

Legend:
Removed from v.1.64  
changed lines
  Added in v.1.169

  ViewVC Help
Powered by ViewVC 1.1.20