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

Contents of /eclass/autotools.eclass

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.142 - (show annotations) (download)
Thu May 24 01:13:32 2012 UTC (2 years, 1 month ago) by vapier
Branch: MAIN
Changes since 1.141: +5 -5 lines
do not require aclocal.m4 to trace macros as simpler packages might not end up generating one, yet will expand autoconf macros all the time that might be the ones we are looking for #417275 by Rick Farina

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

  ViewVC Help
Powered by ViewVC 1.1.20