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