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

  ViewVC Help
Powered by ViewVC 1.1.20