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

Diff of /eclass/autotools.eclass

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

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

Legend:
Removed from v.1.82  
changed lines
  Added in v.1.166

  ViewVC Help
Powered by ViewVC 1.1.20