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

  ViewVC Help
Powered by ViewVC 1.1.20