annotate libatomic/aclocal.m4 @ 144:8f4e72ab4e11

fix segmentation fault caused by nothing next cur_op to end
author Takahiro SHIMIZU <anatofuz@cr.ie.u-ryukyu.ac.jp>
date Sun, 23 Dec 2018 21:23:56 +0900
parents 84e7813d76e9
children 1830386684a0
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
111
kono
parents:
diff changeset
1 # generated automatically by aclocal 1.11.6 -*- Autoconf -*-
kono
parents:
diff changeset
2
kono
parents:
diff changeset
3 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
kono
parents:
diff changeset
4 # 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation,
kono
parents:
diff changeset
5 # Inc.
kono
parents:
diff changeset
6 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
7 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
8 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
9
kono
parents:
diff changeset
10 # This program is distributed in the hope that it will be useful,
kono
parents:
diff changeset
11 # but WITHOUT ANY WARRANTY, to the extent permitted by law; without
kono
parents:
diff changeset
12 # even the implied warranty of MERCHANTABILITY or FITNESS FOR A
kono
parents:
diff changeset
13 # PARTICULAR PURPOSE.
kono
parents:
diff changeset
14
kono
parents:
diff changeset
15 m4_ifndef([AC_AUTOCONF_VERSION],
kono
parents:
diff changeset
16 [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
kono
parents:
diff changeset
17 m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.64],,
kono
parents:
diff changeset
18 [m4_warning([this file was generated for autoconf 2.64.
kono
parents:
diff changeset
19 You have another version of autoconf. It may work, but is not guaranteed to.
kono
parents:
diff changeset
20 If you have problems, you may need to regenerate the build system entirely.
kono
parents:
diff changeset
21 To do so, use the procedure documented by the package, typically `autoreconf'.])])
kono
parents:
diff changeset
22
kono
parents:
diff changeset
23 # Copyright (C) 2002, 2003, 2005, 2006, 2007, 2008, 2011 Free Software
kono
parents:
diff changeset
24 # Foundation, Inc.
kono
parents:
diff changeset
25 #
kono
parents:
diff changeset
26 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
27 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
28 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
29
kono
parents:
diff changeset
30 # serial 1
kono
parents:
diff changeset
31
kono
parents:
diff changeset
32 # AM_AUTOMAKE_VERSION(VERSION)
kono
parents:
diff changeset
33 # ----------------------------
kono
parents:
diff changeset
34 # Automake X.Y traces this macro to ensure aclocal.m4 has been
kono
parents:
diff changeset
35 # generated from the m4 files accompanying Automake X.Y.
kono
parents:
diff changeset
36 # (This private macro should not be called outside this file.)
kono
parents:
diff changeset
37 AC_DEFUN([AM_AUTOMAKE_VERSION],
kono
parents:
diff changeset
38 [am__api_version='1.11'
kono
parents:
diff changeset
39 dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to
kono
parents:
diff changeset
40 dnl require some minimum version. Point them to the right macro.
kono
parents:
diff changeset
41 m4_if([$1], [1.11.6], [],
kono
parents:
diff changeset
42 [AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl
kono
parents:
diff changeset
43 ])
kono
parents:
diff changeset
44
kono
parents:
diff changeset
45 # _AM_AUTOCONF_VERSION(VERSION)
kono
parents:
diff changeset
46 # -----------------------------
kono
parents:
diff changeset
47 # aclocal traces this macro to find the Autoconf version.
kono
parents:
diff changeset
48 # This is a private macro too. Using m4_define simplifies
kono
parents:
diff changeset
49 # the logic in aclocal, which can simply ignore this definition.
kono
parents:
diff changeset
50 m4_define([_AM_AUTOCONF_VERSION], [])
kono
parents:
diff changeset
51
kono
parents:
diff changeset
52 # AM_SET_CURRENT_AUTOMAKE_VERSION
kono
parents:
diff changeset
53 # -------------------------------
kono
parents:
diff changeset
54 # Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced.
kono
parents:
diff changeset
55 # This function is AC_REQUIREd by AM_INIT_AUTOMAKE.
kono
parents:
diff changeset
56 AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],
kono
parents:
diff changeset
57 [AM_AUTOMAKE_VERSION([1.11.6])dnl
kono
parents:
diff changeset
58 m4_ifndef([AC_AUTOCONF_VERSION],
kono
parents:
diff changeset
59 [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
kono
parents:
diff changeset
60 _AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))])
kono
parents:
diff changeset
61
kono
parents:
diff changeset
62 # Figure out how to run the assembler. -*- Autoconf -*-
kono
parents:
diff changeset
63
kono
parents:
diff changeset
64 # Copyright (C) 2001, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
kono
parents:
diff changeset
65 #
kono
parents:
diff changeset
66 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
67 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
68 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
69
kono
parents:
diff changeset
70 # serial 5
kono
parents:
diff changeset
71
kono
parents:
diff changeset
72 # AM_PROG_AS
kono
parents:
diff changeset
73 # ----------
kono
parents:
diff changeset
74 AC_DEFUN([AM_PROG_AS],
kono
parents:
diff changeset
75 [# By default we simply use the C compiler to build assembly code.
kono
parents:
diff changeset
76 AC_REQUIRE([AC_PROG_CC])
kono
parents:
diff changeset
77 test "${CCAS+set}" = set || CCAS=$CC
kono
parents:
diff changeset
78 test "${CCASFLAGS+set}" = set || CCASFLAGS=$CFLAGS
kono
parents:
diff changeset
79 AC_ARG_VAR([CCAS], [assembler compiler command (defaults to CC)])
kono
parents:
diff changeset
80 AC_ARG_VAR([CCASFLAGS], [assembler compiler flags (defaults to CFLAGS)])
kono
parents:
diff changeset
81 _AM_IF_OPTION([no-dependencies],, [_AM_DEPENDENCIES([CCAS])])dnl
kono
parents:
diff changeset
82 ])
kono
parents:
diff changeset
83
kono
parents:
diff changeset
84 # AM_AUX_DIR_EXPAND -*- Autoconf -*-
kono
parents:
diff changeset
85
kono
parents:
diff changeset
86 # Copyright (C) 2001, 2003, 2005, 2011 Free Software Foundation, Inc.
kono
parents:
diff changeset
87 #
kono
parents:
diff changeset
88 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
89 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
90 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
91
kono
parents:
diff changeset
92 # serial 1
kono
parents:
diff changeset
93
kono
parents:
diff changeset
94 # For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets
kono
parents:
diff changeset
95 # $ac_aux_dir to `$srcdir/foo'. In other projects, it is set to
kono
parents:
diff changeset
96 # `$srcdir', `$srcdir/..', or `$srcdir/../..'.
kono
parents:
diff changeset
97 #
kono
parents:
diff changeset
98 # Of course, Automake must honor this variable whenever it calls a
kono
parents:
diff changeset
99 # tool from the auxiliary directory. The problem is that $srcdir (and
kono
parents:
diff changeset
100 # therefore $ac_aux_dir as well) can be either absolute or relative,
kono
parents:
diff changeset
101 # depending on how configure is run. This is pretty annoying, since
kono
parents:
diff changeset
102 # it makes $ac_aux_dir quite unusable in subdirectories: in the top
kono
parents:
diff changeset
103 # source directory, any form will work fine, but in subdirectories a
kono
parents:
diff changeset
104 # relative path needs to be adjusted first.
kono
parents:
diff changeset
105 #
kono
parents:
diff changeset
106 # $ac_aux_dir/missing
kono
parents:
diff changeset
107 # fails when called from a subdirectory if $ac_aux_dir is relative
kono
parents:
diff changeset
108 # $top_srcdir/$ac_aux_dir/missing
kono
parents:
diff changeset
109 # fails if $ac_aux_dir is absolute,
kono
parents:
diff changeset
110 # fails when called from a subdirectory in a VPATH build with
kono
parents:
diff changeset
111 # a relative $ac_aux_dir
kono
parents:
diff changeset
112 #
kono
parents:
diff changeset
113 # The reason of the latter failure is that $top_srcdir and $ac_aux_dir
kono
parents:
diff changeset
114 # are both prefixed by $srcdir. In an in-source build this is usually
kono
parents:
diff changeset
115 # harmless because $srcdir is `.', but things will broke when you
kono
parents:
diff changeset
116 # start a VPATH build or use an absolute $srcdir.
kono
parents:
diff changeset
117 #
kono
parents:
diff changeset
118 # So we could use something similar to $top_srcdir/$ac_aux_dir/missing,
kono
parents:
diff changeset
119 # iff we strip the leading $srcdir from $ac_aux_dir. That would be:
kono
parents:
diff changeset
120 # am_aux_dir='\$(top_srcdir)/'`expr "$ac_aux_dir" : "$srcdir//*\(.*\)"`
kono
parents:
diff changeset
121 # and then we would define $MISSING as
kono
parents:
diff changeset
122 # MISSING="\${SHELL} $am_aux_dir/missing"
kono
parents:
diff changeset
123 # This will work as long as MISSING is not called from configure, because
kono
parents:
diff changeset
124 # unfortunately $(top_srcdir) has no meaning in configure.
kono
parents:
diff changeset
125 # However there are other variables, like CC, which are often used in
kono
parents:
diff changeset
126 # configure, and could therefore not use this "fixed" $ac_aux_dir.
kono
parents:
diff changeset
127 #
kono
parents:
diff changeset
128 # Another solution, used here, is to always expand $ac_aux_dir to an
kono
parents:
diff changeset
129 # absolute PATH. The drawback is that using absolute paths prevent a
kono
parents:
diff changeset
130 # configured tree to be moved without reconfiguration.
kono
parents:
diff changeset
131
kono
parents:
diff changeset
132 AC_DEFUN([AM_AUX_DIR_EXPAND],
kono
parents:
diff changeset
133 [dnl Rely on autoconf to set up CDPATH properly.
kono
parents:
diff changeset
134 AC_PREREQ([2.50])dnl
kono
parents:
diff changeset
135 # expand $ac_aux_dir to an absolute path
kono
parents:
diff changeset
136 am_aux_dir=`cd $ac_aux_dir && pwd`
kono
parents:
diff changeset
137 ])
kono
parents:
diff changeset
138
kono
parents:
diff changeset
139 # AM_CONDITIONAL -*- Autoconf -*-
kono
parents:
diff changeset
140
kono
parents:
diff changeset
141 # Copyright (C) 1997, 2000, 2001, 2003, 2004, 2005, 2006, 2008
kono
parents:
diff changeset
142 # Free Software Foundation, Inc.
kono
parents:
diff changeset
143 #
kono
parents:
diff changeset
144 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
145 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
146 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
147
kono
parents:
diff changeset
148 # serial 9
kono
parents:
diff changeset
149
kono
parents:
diff changeset
150 # AM_CONDITIONAL(NAME, SHELL-CONDITION)
kono
parents:
diff changeset
151 # -------------------------------------
kono
parents:
diff changeset
152 # Define a conditional.
kono
parents:
diff changeset
153 AC_DEFUN([AM_CONDITIONAL],
kono
parents:
diff changeset
154 [AC_PREREQ(2.52)dnl
kono
parents:
diff changeset
155 ifelse([$1], [TRUE], [AC_FATAL([$0: invalid condition: $1])],
kono
parents:
diff changeset
156 [$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl
kono
parents:
diff changeset
157 AC_SUBST([$1_TRUE])dnl
kono
parents:
diff changeset
158 AC_SUBST([$1_FALSE])dnl
kono
parents:
diff changeset
159 _AM_SUBST_NOTMAKE([$1_TRUE])dnl
kono
parents:
diff changeset
160 _AM_SUBST_NOTMAKE([$1_FALSE])dnl
kono
parents:
diff changeset
161 m4_define([_AM_COND_VALUE_$1], [$2])dnl
kono
parents:
diff changeset
162 if $2; then
kono
parents:
diff changeset
163 $1_TRUE=
kono
parents:
diff changeset
164 $1_FALSE='#'
kono
parents:
diff changeset
165 else
kono
parents:
diff changeset
166 $1_TRUE='#'
kono
parents:
diff changeset
167 $1_FALSE=
kono
parents:
diff changeset
168 fi
kono
parents:
diff changeset
169 AC_CONFIG_COMMANDS_PRE(
kono
parents:
diff changeset
170 [if test -z "${$1_TRUE}" && test -z "${$1_FALSE}"; then
kono
parents:
diff changeset
171 AC_MSG_ERROR([[conditional "$1" was never defined.
kono
parents:
diff changeset
172 Usually this means the macro was only invoked conditionally.]])
kono
parents:
diff changeset
173 fi])])
kono
parents:
diff changeset
174
kono
parents:
diff changeset
175 # Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2009,
kono
parents:
diff changeset
176 # 2010, 2011 Free Software Foundation, Inc.
kono
parents:
diff changeset
177 #
kono
parents:
diff changeset
178 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
179 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
180 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
181
kono
parents:
diff changeset
182 # serial 12
kono
parents:
diff changeset
183
kono
parents:
diff changeset
184 # There are a few dirty hacks below to avoid letting `AC_PROG_CC' be
kono
parents:
diff changeset
185 # written in clear, in which case automake, when reading aclocal.m4,
kono
parents:
diff changeset
186 # will think it sees a *use*, and therefore will trigger all it's
kono
parents:
diff changeset
187 # C support machinery. Also note that it means that autoscan, seeing
kono
parents:
diff changeset
188 # CC etc. in the Makefile, will ask for an AC_PROG_CC use...
kono
parents:
diff changeset
189
kono
parents:
diff changeset
190
kono
parents:
diff changeset
191 # _AM_DEPENDENCIES(NAME)
kono
parents:
diff changeset
192 # ----------------------
kono
parents:
diff changeset
193 # See how the compiler implements dependency checking.
kono
parents:
diff changeset
194 # NAME is "CC", "CXX", "GCJ", or "OBJC".
kono
parents:
diff changeset
195 # We try a few techniques and use that to set a single cache variable.
kono
parents:
diff changeset
196 #
kono
parents:
diff changeset
197 # We don't AC_REQUIRE the corresponding AC_PROG_CC since the latter was
kono
parents:
diff changeset
198 # modified to invoke _AM_DEPENDENCIES(CC); we would have a circular
kono
parents:
diff changeset
199 # dependency, and given that the user is not expected to run this macro,
kono
parents:
diff changeset
200 # just rely on AC_PROG_CC.
kono
parents:
diff changeset
201 AC_DEFUN([_AM_DEPENDENCIES],
kono
parents:
diff changeset
202 [AC_REQUIRE([AM_SET_DEPDIR])dnl
kono
parents:
diff changeset
203 AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMANDS])dnl
kono
parents:
diff changeset
204 AC_REQUIRE([AM_MAKE_INCLUDE])dnl
kono
parents:
diff changeset
205 AC_REQUIRE([AM_DEP_TRACK])dnl
kono
parents:
diff changeset
206
kono
parents:
diff changeset
207 ifelse([$1], CC, [depcc="$CC" am_compiler_list=],
kono
parents:
diff changeset
208 [$1], CXX, [depcc="$CXX" am_compiler_list=],
kono
parents:
diff changeset
209 [$1], OBJC, [depcc="$OBJC" am_compiler_list='gcc3 gcc'],
kono
parents:
diff changeset
210 [$1], UPC, [depcc="$UPC" am_compiler_list=],
kono
parents:
diff changeset
211 [$1], GCJ, [depcc="$GCJ" am_compiler_list='gcc3 gcc'],
kono
parents:
diff changeset
212 [depcc="$$1" am_compiler_list=])
kono
parents:
diff changeset
213
kono
parents:
diff changeset
214 AC_CACHE_CHECK([dependency style of $depcc],
kono
parents:
diff changeset
215 [am_cv_$1_dependencies_compiler_type],
kono
parents:
diff changeset
216 [if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
kono
parents:
diff changeset
217 # We make a subdir and do the tests there. Otherwise we can end up
kono
parents:
diff changeset
218 # making bogus files that we don't know about and never remove. For
kono
parents:
diff changeset
219 # instance it was reported that on HP-UX the gcc test will end up
kono
parents:
diff changeset
220 # making a dummy file named `D' -- because `-MD' means `put the output
kono
parents:
diff changeset
221 # in D'.
kono
parents:
diff changeset
222 rm -rf conftest.dir
kono
parents:
diff changeset
223 mkdir conftest.dir
kono
parents:
diff changeset
224 # Copy depcomp to subdir because otherwise we won't find it if we're
kono
parents:
diff changeset
225 # using a relative directory.
kono
parents:
diff changeset
226 cp "$am_depcomp" conftest.dir
kono
parents:
diff changeset
227 cd conftest.dir
kono
parents:
diff changeset
228 # We will build objects and dependencies in a subdirectory because
kono
parents:
diff changeset
229 # it helps to detect inapplicable dependency modes. For instance
kono
parents:
diff changeset
230 # both Tru64's cc and ICC support -MD to output dependencies as a
kono
parents:
diff changeset
231 # side effect of compilation, but ICC will put the dependencies in
kono
parents:
diff changeset
232 # the current directory while Tru64 will put them in the object
kono
parents:
diff changeset
233 # directory.
kono
parents:
diff changeset
234 mkdir sub
kono
parents:
diff changeset
235
kono
parents:
diff changeset
236 am_cv_$1_dependencies_compiler_type=none
kono
parents:
diff changeset
237 if test "$am_compiler_list" = ""; then
kono
parents:
diff changeset
238 am_compiler_list=`sed -n ['s/^#*\([a-zA-Z0-9]*\))$/\1/p'] < ./depcomp`
kono
parents:
diff changeset
239 fi
kono
parents:
diff changeset
240 am__universal=false
kono
parents:
diff changeset
241 m4_case([$1], [CC],
kono
parents:
diff changeset
242 [case " $depcc " in #(
kono
parents:
diff changeset
243 *\ -arch\ *\ -arch\ *) am__universal=true ;;
kono
parents:
diff changeset
244 esac],
kono
parents:
diff changeset
245 [CXX],
kono
parents:
diff changeset
246 [case " $depcc " in #(
kono
parents:
diff changeset
247 *\ -arch\ *\ -arch\ *) am__universal=true ;;
kono
parents:
diff changeset
248 esac])
kono
parents:
diff changeset
249
kono
parents:
diff changeset
250 for depmode in $am_compiler_list; do
kono
parents:
diff changeset
251 # Setup a source with many dependencies, because some compilers
kono
parents:
diff changeset
252 # like to wrap large dependency lists on column 80 (with \), and
kono
parents:
diff changeset
253 # we should not choose a depcomp mode which is confused by this.
kono
parents:
diff changeset
254 #
kono
parents:
diff changeset
255 # We need to recreate these files for each test, as the compiler may
kono
parents:
diff changeset
256 # overwrite some of them when testing with obscure command lines.
kono
parents:
diff changeset
257 # This happens at least with the AIX C compiler.
kono
parents:
diff changeset
258 : > sub/conftest.c
kono
parents:
diff changeset
259 for i in 1 2 3 4 5 6; do
kono
parents:
diff changeset
260 echo '#include "conftst'$i'.h"' >> sub/conftest.c
kono
parents:
diff changeset
261 # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
kono
parents:
diff changeset
262 # Solaris 8's {/usr,}/bin/sh.
kono
parents:
diff changeset
263 touch sub/conftst$i.h
kono
parents:
diff changeset
264 done
kono
parents:
diff changeset
265 echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
kono
parents:
diff changeset
266
kono
parents:
diff changeset
267 # We check with `-c' and `-o' for the sake of the "dashmstdout"
kono
parents:
diff changeset
268 # mode. It turns out that the SunPro C++ compiler does not properly
kono
parents:
diff changeset
269 # handle `-M -o', and we need to detect this. Also, some Intel
kono
parents:
diff changeset
270 # versions had trouble with output in subdirs
kono
parents:
diff changeset
271 am__obj=sub/conftest.${OBJEXT-o}
kono
parents:
diff changeset
272 am__minus_obj="-o $am__obj"
kono
parents:
diff changeset
273 case $depmode in
kono
parents:
diff changeset
274 gcc)
kono
parents:
diff changeset
275 # This depmode causes a compiler race in universal mode.
kono
parents:
diff changeset
276 test "$am__universal" = false || continue
kono
parents:
diff changeset
277 ;;
kono
parents:
diff changeset
278 nosideeffect)
kono
parents:
diff changeset
279 # after this tag, mechanisms are not by side-effect, so they'll
kono
parents:
diff changeset
280 # only be used when explicitly requested
kono
parents:
diff changeset
281 if test "x$enable_dependency_tracking" = xyes; then
kono
parents:
diff changeset
282 continue
kono
parents:
diff changeset
283 else
kono
parents:
diff changeset
284 break
kono
parents:
diff changeset
285 fi
kono
parents:
diff changeset
286 ;;
kono
parents:
diff changeset
287 msvc7 | msvc7msys | msvisualcpp | msvcmsys)
kono
parents:
diff changeset
288 # This compiler won't grok `-c -o', but also, the minuso test has
kono
parents:
diff changeset
289 # not run yet. These depmodes are late enough in the game, and
kono
parents:
diff changeset
290 # so weak that their functioning should not be impacted.
kono
parents:
diff changeset
291 am__obj=conftest.${OBJEXT-o}
kono
parents:
diff changeset
292 am__minus_obj=
kono
parents:
diff changeset
293 ;;
kono
parents:
diff changeset
294 none) break ;;
kono
parents:
diff changeset
295 esac
kono
parents:
diff changeset
296 if depmode=$depmode \
kono
parents:
diff changeset
297 source=sub/conftest.c object=$am__obj \
kono
parents:
diff changeset
298 depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
kono
parents:
diff changeset
299 $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
kono
parents:
diff changeset
300 >/dev/null 2>conftest.err &&
kono
parents:
diff changeset
301 grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
kono
parents:
diff changeset
302 grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
kono
parents:
diff changeset
303 grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
kono
parents:
diff changeset
304 ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
kono
parents:
diff changeset
305 # icc doesn't choke on unknown options, it will just issue warnings
kono
parents:
diff changeset
306 # or remarks (even with -Werror). So we grep stderr for any message
kono
parents:
diff changeset
307 # that says an option was ignored or not supported.
kono
parents:
diff changeset
308 # When given -MP, icc 7.0 and 7.1 complain thusly:
kono
parents:
diff changeset
309 # icc: Command line warning: ignoring option '-M'; no argument required
kono
parents:
diff changeset
310 # The diagnosis changed in icc 8.0:
kono
parents:
diff changeset
311 # icc: Command line remark: option '-MP' not supported
kono
parents:
diff changeset
312 if (grep 'ignoring option' conftest.err ||
kono
parents:
diff changeset
313 grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
kono
parents:
diff changeset
314 am_cv_$1_dependencies_compiler_type=$depmode
kono
parents:
diff changeset
315 break
kono
parents:
diff changeset
316 fi
kono
parents:
diff changeset
317 fi
kono
parents:
diff changeset
318 done
kono
parents:
diff changeset
319
kono
parents:
diff changeset
320 cd ..
kono
parents:
diff changeset
321 rm -rf conftest.dir
kono
parents:
diff changeset
322 else
kono
parents:
diff changeset
323 am_cv_$1_dependencies_compiler_type=none
kono
parents:
diff changeset
324 fi
kono
parents:
diff changeset
325 ])
kono
parents:
diff changeset
326 AC_SUBST([$1DEPMODE], [depmode=$am_cv_$1_dependencies_compiler_type])
kono
parents:
diff changeset
327 AM_CONDITIONAL([am__fastdep$1], [
kono
parents:
diff changeset
328 test "x$enable_dependency_tracking" != xno \
kono
parents:
diff changeset
329 && test "$am_cv_$1_dependencies_compiler_type" = gcc3])
kono
parents:
diff changeset
330 ])
kono
parents:
diff changeset
331
kono
parents:
diff changeset
332
kono
parents:
diff changeset
333 # AM_SET_DEPDIR
kono
parents:
diff changeset
334 # -------------
kono
parents:
diff changeset
335 # Choose a directory name for dependency files.
kono
parents:
diff changeset
336 # This macro is AC_REQUIREd in _AM_DEPENDENCIES
kono
parents:
diff changeset
337 AC_DEFUN([AM_SET_DEPDIR],
kono
parents:
diff changeset
338 [AC_REQUIRE([AM_SET_LEADING_DOT])dnl
kono
parents:
diff changeset
339 AC_SUBST([DEPDIR], ["${am__leading_dot}deps"])dnl
kono
parents:
diff changeset
340 ])
kono
parents:
diff changeset
341
kono
parents:
diff changeset
342
kono
parents:
diff changeset
343 # AM_DEP_TRACK
kono
parents:
diff changeset
344 # ------------
kono
parents:
diff changeset
345 AC_DEFUN([AM_DEP_TRACK],
kono
parents:
diff changeset
346 [AC_ARG_ENABLE(dependency-tracking,
kono
parents:
diff changeset
347 [ --disable-dependency-tracking speeds up one-time build
kono
parents:
diff changeset
348 --enable-dependency-tracking do not reject slow dependency extractors])
kono
parents:
diff changeset
349 if test "x$enable_dependency_tracking" != xno; then
kono
parents:
diff changeset
350 am_depcomp="$ac_aux_dir/depcomp"
kono
parents:
diff changeset
351 AMDEPBACKSLASH='\'
kono
parents:
diff changeset
352 am__nodep='_no'
kono
parents:
diff changeset
353 fi
kono
parents:
diff changeset
354 AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno])
kono
parents:
diff changeset
355 AC_SUBST([AMDEPBACKSLASH])dnl
kono
parents:
diff changeset
356 _AM_SUBST_NOTMAKE([AMDEPBACKSLASH])dnl
kono
parents:
diff changeset
357 AC_SUBST([am__nodep])dnl
kono
parents:
diff changeset
358 _AM_SUBST_NOTMAKE([am__nodep])dnl
kono
parents:
diff changeset
359 ])
kono
parents:
diff changeset
360
kono
parents:
diff changeset
361 # Generate code to set up dependency tracking. -*- Autoconf -*-
kono
parents:
diff changeset
362
kono
parents:
diff changeset
363 # Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2008
kono
parents:
diff changeset
364 # Free Software Foundation, Inc.
kono
parents:
diff changeset
365 #
kono
parents:
diff changeset
366 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
367 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
368 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
369
kono
parents:
diff changeset
370 #serial 5
kono
parents:
diff changeset
371
kono
parents:
diff changeset
372 # _AM_OUTPUT_DEPENDENCY_COMMANDS
kono
parents:
diff changeset
373 # ------------------------------
kono
parents:
diff changeset
374 AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS],
kono
parents:
diff changeset
375 [{
kono
parents:
diff changeset
376 # Autoconf 2.62 quotes --file arguments for eval, but not when files
kono
parents:
diff changeset
377 # are listed without --file. Let's play safe and only enable the eval
kono
parents:
diff changeset
378 # if we detect the quoting.
kono
parents:
diff changeset
379 case $CONFIG_FILES in
kono
parents:
diff changeset
380 *\'*) eval set x "$CONFIG_FILES" ;;
kono
parents:
diff changeset
381 *) set x $CONFIG_FILES ;;
kono
parents:
diff changeset
382 esac
kono
parents:
diff changeset
383 shift
kono
parents:
diff changeset
384 for mf
kono
parents:
diff changeset
385 do
kono
parents:
diff changeset
386 # Strip MF so we end up with the name of the file.
kono
parents:
diff changeset
387 mf=`echo "$mf" | sed -e 's/:.*$//'`
kono
parents:
diff changeset
388 # Check whether this is an Automake generated Makefile or not.
kono
parents:
diff changeset
389 # We used to match only the files named `Makefile.in', but
kono
parents:
diff changeset
390 # some people rename them; so instead we look at the file content.
kono
parents:
diff changeset
391 # Grep'ing the first line is not enough: some people post-process
kono
parents:
diff changeset
392 # each Makefile.in and add a new line on top of each file to say so.
kono
parents:
diff changeset
393 # Grep'ing the whole file is not good either: AIX grep has a line
kono
parents:
diff changeset
394 # limit of 2048, but all sed's we know have understand at least 4000.
kono
parents:
diff changeset
395 if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then
kono
parents:
diff changeset
396 dirpart=`AS_DIRNAME("$mf")`
kono
parents:
diff changeset
397 else
kono
parents:
diff changeset
398 continue
kono
parents:
diff changeset
399 fi
kono
parents:
diff changeset
400 # Extract the definition of DEPDIR, am__include, and am__quote
kono
parents:
diff changeset
401 # from the Makefile without running `make'.
kono
parents:
diff changeset
402 DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
kono
parents:
diff changeset
403 test -z "$DEPDIR" && continue
kono
parents:
diff changeset
404 am__include=`sed -n 's/^am__include = //p' < "$mf"`
kono
parents:
diff changeset
405 test -z "am__include" && continue
kono
parents:
diff changeset
406 am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
kono
parents:
diff changeset
407 # When using ansi2knr, U may be empty or an underscore; expand it
kono
parents:
diff changeset
408 U=`sed -n 's/^U = //p' < "$mf"`
kono
parents:
diff changeset
409 # Find all dependency output files, they are included files with
kono
parents:
diff changeset
410 # $(DEPDIR) in their names. We invoke sed twice because it is the
kono
parents:
diff changeset
411 # simplest approach to changing $(DEPDIR) to its actual value in the
kono
parents:
diff changeset
412 # expansion.
kono
parents:
diff changeset
413 for file in `sed -n "
kono
parents:
diff changeset
414 s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
kono
parents:
diff changeset
415 sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do
kono
parents:
diff changeset
416 # Make sure the directory exists.
kono
parents:
diff changeset
417 test -f "$dirpart/$file" && continue
kono
parents:
diff changeset
418 fdir=`AS_DIRNAME(["$file"])`
kono
parents:
diff changeset
419 AS_MKDIR_P([$dirpart/$fdir])
kono
parents:
diff changeset
420 # echo "creating $dirpart/$file"
kono
parents:
diff changeset
421 echo '# dummy' > "$dirpart/$file"
kono
parents:
diff changeset
422 done
kono
parents:
diff changeset
423 done
kono
parents:
diff changeset
424 }
kono
parents:
diff changeset
425 ])# _AM_OUTPUT_DEPENDENCY_COMMANDS
kono
parents:
diff changeset
426
kono
parents:
diff changeset
427
kono
parents:
diff changeset
428 # AM_OUTPUT_DEPENDENCY_COMMANDS
kono
parents:
diff changeset
429 # -----------------------------
kono
parents:
diff changeset
430 # This macro should only be invoked once -- use via AC_REQUIRE.
kono
parents:
diff changeset
431 #
kono
parents:
diff changeset
432 # This code is only required when automatic dependency tracking
kono
parents:
diff changeset
433 # is enabled. FIXME. This creates each `.P' file that we will
kono
parents:
diff changeset
434 # need in order to bootstrap the dependency handling code.
kono
parents:
diff changeset
435 AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS],
kono
parents:
diff changeset
436 [AC_CONFIG_COMMANDS([depfiles],
kono
parents:
diff changeset
437 [test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS],
kono
parents:
diff changeset
438 [AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"])
kono
parents:
diff changeset
439 ])
kono
parents:
diff changeset
440
kono
parents:
diff changeset
441 # Do all the work for Automake. -*- Autoconf -*-
kono
parents:
diff changeset
442
kono
parents:
diff changeset
443 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
kono
parents:
diff changeset
444 # 2005, 2006, 2008, 2009 Free Software Foundation, Inc.
kono
parents:
diff changeset
445 #
kono
parents:
diff changeset
446 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
447 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
448 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
449
kono
parents:
diff changeset
450 # serial 16
kono
parents:
diff changeset
451
kono
parents:
diff changeset
452 # This macro actually does too much. Some checks are only needed if
kono
parents:
diff changeset
453 # your package does certain things. But this isn't really a big deal.
kono
parents:
diff changeset
454
kono
parents:
diff changeset
455 # AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE])
kono
parents:
diff changeset
456 # AM_INIT_AUTOMAKE([OPTIONS])
kono
parents:
diff changeset
457 # -----------------------------------------------
kono
parents:
diff changeset
458 # The call with PACKAGE and VERSION arguments is the old style
kono
parents:
diff changeset
459 # call (pre autoconf-2.50), which is being phased out. PACKAGE
kono
parents:
diff changeset
460 # and VERSION should now be passed to AC_INIT and removed from
kono
parents:
diff changeset
461 # the call to AM_INIT_AUTOMAKE.
kono
parents:
diff changeset
462 # We support both call styles for the transition. After
kono
parents:
diff changeset
463 # the next Automake release, Autoconf can make the AC_INIT
kono
parents:
diff changeset
464 # arguments mandatory, and then we can depend on a new Autoconf
kono
parents:
diff changeset
465 # release and drop the old call support.
kono
parents:
diff changeset
466 AC_DEFUN([AM_INIT_AUTOMAKE],
kono
parents:
diff changeset
467 [AC_PREREQ([2.62])dnl
kono
parents:
diff changeset
468 dnl Autoconf wants to disallow AM_ names. We explicitly allow
kono
parents:
diff changeset
469 dnl the ones we care about.
kono
parents:
diff changeset
470 m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl
kono
parents:
diff changeset
471 AC_REQUIRE([AM_SET_CURRENT_AUTOMAKE_VERSION])dnl
kono
parents:
diff changeset
472 AC_REQUIRE([AC_PROG_INSTALL])dnl
kono
parents:
diff changeset
473 if test "`cd $srcdir && pwd`" != "`pwd`"; then
kono
parents:
diff changeset
474 # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
kono
parents:
diff changeset
475 # is not polluted with repeated "-I."
kono
parents:
diff changeset
476 AC_SUBST([am__isrc], [' -I$(srcdir)'])_AM_SUBST_NOTMAKE([am__isrc])dnl
kono
parents:
diff changeset
477 # test to see if srcdir already configured
kono
parents:
diff changeset
478 if test -f $srcdir/config.status; then
kono
parents:
diff changeset
479 AC_MSG_ERROR([source directory already configured; run "make distclean" there first])
kono
parents:
diff changeset
480 fi
kono
parents:
diff changeset
481 fi
kono
parents:
diff changeset
482
kono
parents:
diff changeset
483 # test whether we have cygpath
kono
parents:
diff changeset
484 if test -z "$CYGPATH_W"; then
kono
parents:
diff changeset
485 if (cygpath --version) >/dev/null 2>/dev/null; then
kono
parents:
diff changeset
486 CYGPATH_W='cygpath -w'
kono
parents:
diff changeset
487 else
kono
parents:
diff changeset
488 CYGPATH_W=echo
kono
parents:
diff changeset
489 fi
kono
parents:
diff changeset
490 fi
kono
parents:
diff changeset
491 AC_SUBST([CYGPATH_W])
kono
parents:
diff changeset
492
kono
parents:
diff changeset
493 # Define the identity of the package.
kono
parents:
diff changeset
494 dnl Distinguish between old-style and new-style calls.
kono
parents:
diff changeset
495 m4_ifval([$2],
kono
parents:
diff changeset
496 [m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl
kono
parents:
diff changeset
497 AC_SUBST([PACKAGE], [$1])dnl
kono
parents:
diff changeset
498 AC_SUBST([VERSION], [$2])],
kono
parents:
diff changeset
499 [_AM_SET_OPTIONS([$1])dnl
kono
parents:
diff changeset
500 dnl Diagnose old-style AC_INIT with new-style AM_AUTOMAKE_INIT.
kono
parents:
diff changeset
501 m4_if(m4_ifdef([AC_PACKAGE_NAME], 1)m4_ifdef([AC_PACKAGE_VERSION], 1), 11,,
kono
parents:
diff changeset
502 [m4_fatal([AC_INIT should be called with package and version arguments])])dnl
kono
parents:
diff changeset
503 AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl
kono
parents:
diff changeset
504 AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl
kono
parents:
diff changeset
505
kono
parents:
diff changeset
506 _AM_IF_OPTION([no-define],,
kono
parents:
diff changeset
507 [AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of package])
kono
parents:
diff changeset
508 AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version number of package])])dnl
kono
parents:
diff changeset
509
kono
parents:
diff changeset
510 # Some tools Automake needs.
kono
parents:
diff changeset
511 AC_REQUIRE([AM_SANITY_CHECK])dnl
kono
parents:
diff changeset
512 AC_REQUIRE([AC_ARG_PROGRAM])dnl
kono
parents:
diff changeset
513 AM_MISSING_PROG(ACLOCAL, aclocal-${am__api_version})
kono
parents:
diff changeset
514 AM_MISSING_PROG(AUTOCONF, autoconf)
kono
parents:
diff changeset
515 AM_MISSING_PROG(AUTOMAKE, automake-${am__api_version})
kono
parents:
diff changeset
516 AM_MISSING_PROG(AUTOHEADER, autoheader)
kono
parents:
diff changeset
517 AM_MISSING_PROG(MAKEINFO, makeinfo)
kono
parents:
diff changeset
518 AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
kono
parents:
diff changeset
519 AC_REQUIRE([AM_PROG_INSTALL_STRIP])dnl
kono
parents:
diff changeset
520 AC_REQUIRE([AM_PROG_MKDIR_P])dnl
kono
parents:
diff changeset
521 # We need awk for the "check" target. The system "awk" is bad on
kono
parents:
diff changeset
522 # some platforms.
kono
parents:
diff changeset
523 AC_REQUIRE([AC_PROG_AWK])dnl
kono
parents:
diff changeset
524 AC_REQUIRE([AC_PROG_MAKE_SET])dnl
kono
parents:
diff changeset
525 AC_REQUIRE([AM_SET_LEADING_DOT])dnl
kono
parents:
diff changeset
526 _AM_IF_OPTION([tar-ustar], [_AM_PROG_TAR([ustar])],
kono
parents:
diff changeset
527 [_AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])],
kono
parents:
diff changeset
528 [_AM_PROG_TAR([v7])])])
kono
parents:
diff changeset
529 _AM_IF_OPTION([no-dependencies],,
kono
parents:
diff changeset
530 [AC_PROVIDE_IFELSE([AC_PROG_CC],
kono
parents:
diff changeset
531 [_AM_DEPENDENCIES(CC)],
kono
parents:
diff changeset
532 [define([AC_PROG_CC],
kono
parents:
diff changeset
533 defn([AC_PROG_CC])[_AM_DEPENDENCIES(CC)])])dnl
kono
parents:
diff changeset
534 AC_PROVIDE_IFELSE([AC_PROG_CXX],
kono
parents:
diff changeset
535 [_AM_DEPENDENCIES(CXX)],
kono
parents:
diff changeset
536 [define([AC_PROG_CXX],
kono
parents:
diff changeset
537 defn([AC_PROG_CXX])[_AM_DEPENDENCIES(CXX)])])dnl
kono
parents:
diff changeset
538 AC_PROVIDE_IFELSE([AC_PROG_OBJC],
kono
parents:
diff changeset
539 [_AM_DEPENDENCIES(OBJC)],
kono
parents:
diff changeset
540 [define([AC_PROG_OBJC],
kono
parents:
diff changeset
541 defn([AC_PROG_OBJC])[_AM_DEPENDENCIES(OBJC)])])dnl
kono
parents:
diff changeset
542 ])
kono
parents:
diff changeset
543 _AM_IF_OPTION([silent-rules], [AC_REQUIRE([AM_SILENT_RULES])])dnl
kono
parents:
diff changeset
544 dnl The `parallel-tests' driver may need to know about EXEEXT, so add the
kono
parents:
diff changeset
545 dnl `am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen. This macro
kono
parents:
diff changeset
546 dnl is hooked onto _AC_COMPILER_EXEEXT early, see below.
kono
parents:
diff changeset
547 AC_CONFIG_COMMANDS_PRE(dnl
kono
parents:
diff changeset
548 [m4_provide_if([_AM_COMPILER_EXEEXT],
kono
parents:
diff changeset
549 [AM_CONDITIONAL([am__EXEEXT], [test -n "$EXEEXT"])])])dnl
kono
parents:
diff changeset
550 ])
kono
parents:
diff changeset
551
kono
parents:
diff changeset
552 dnl Hook into `_AC_COMPILER_EXEEXT' early to learn its expansion. Do not
kono
parents:
diff changeset
553 dnl add the conditional right here, as _AC_COMPILER_EXEEXT may be further
kono
parents:
diff changeset
554 dnl mangled by Autoconf and run in a shell conditional statement.
kono
parents:
diff changeset
555 m4_define([_AC_COMPILER_EXEEXT],
kono
parents:
diff changeset
556 m4_defn([_AC_COMPILER_EXEEXT])[m4_provide([_AM_COMPILER_EXEEXT])])
kono
parents:
diff changeset
557
kono
parents:
diff changeset
558
kono
parents:
diff changeset
559 # When config.status generates a header, we must update the stamp-h file.
kono
parents:
diff changeset
560 # This file resides in the same directory as the config header
kono
parents:
diff changeset
561 # that is generated. The stamp files are numbered to have different names.
kono
parents:
diff changeset
562
kono
parents:
diff changeset
563 # Autoconf calls _AC_AM_CONFIG_HEADER_HOOK (when defined) in the
kono
parents:
diff changeset
564 # loop where config.status creates the headers, so we can generate
kono
parents:
diff changeset
565 # our stamp files there.
kono
parents:
diff changeset
566 AC_DEFUN([_AC_AM_CONFIG_HEADER_HOOK],
kono
parents:
diff changeset
567 [# Compute $1's index in $config_headers.
kono
parents:
diff changeset
568 _am_arg=$1
kono
parents:
diff changeset
569 _am_stamp_count=1
kono
parents:
diff changeset
570 for _am_header in $config_headers :; do
kono
parents:
diff changeset
571 case $_am_header in
kono
parents:
diff changeset
572 $_am_arg | $_am_arg:* )
kono
parents:
diff changeset
573 break ;;
kono
parents:
diff changeset
574 * )
kono
parents:
diff changeset
575 _am_stamp_count=`expr $_am_stamp_count + 1` ;;
kono
parents:
diff changeset
576 esac
kono
parents:
diff changeset
577 done
kono
parents:
diff changeset
578 echo "timestamp for $_am_arg" >`AS_DIRNAME(["$_am_arg"])`/stamp-h[]$_am_stamp_count])
kono
parents:
diff changeset
579
kono
parents:
diff changeset
580 # Copyright (C) 2001, 2003, 2005, 2008, 2011 Free Software Foundation,
kono
parents:
diff changeset
581 # Inc.
kono
parents:
diff changeset
582 #
kono
parents:
diff changeset
583 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
584 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
585 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
586
kono
parents:
diff changeset
587 # serial 1
kono
parents:
diff changeset
588
kono
parents:
diff changeset
589 # AM_PROG_INSTALL_SH
kono
parents:
diff changeset
590 # ------------------
kono
parents:
diff changeset
591 # Define $install_sh.
kono
parents:
diff changeset
592 AC_DEFUN([AM_PROG_INSTALL_SH],
kono
parents:
diff changeset
593 [AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
kono
parents:
diff changeset
594 if test x"${install_sh}" != xset; then
kono
parents:
diff changeset
595 case $am_aux_dir in
kono
parents:
diff changeset
596 *\ * | *\ *)
kono
parents:
diff changeset
597 install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
kono
parents:
diff changeset
598 *)
kono
parents:
diff changeset
599 install_sh="\${SHELL} $am_aux_dir/install-sh"
kono
parents:
diff changeset
600 esac
kono
parents:
diff changeset
601 fi
kono
parents:
diff changeset
602 AC_SUBST(install_sh)])
kono
parents:
diff changeset
603
kono
parents:
diff changeset
604 # Add --enable-maintainer-mode option to configure. -*- Autoconf -*-
kono
parents:
diff changeset
605 # From Jim Meyering
kono
parents:
diff changeset
606
kono
parents:
diff changeset
607 # Copyright (C) 1996, 1998, 2000, 2001, 2002, 2003, 2004, 2005, 2008,
kono
parents:
diff changeset
608 # 2011 Free Software Foundation, Inc.
kono
parents:
diff changeset
609 #
kono
parents:
diff changeset
610 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
611 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
612 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
613
kono
parents:
diff changeset
614 # serial 5
kono
parents:
diff changeset
615
kono
parents:
diff changeset
616 # AM_MAINTAINER_MODE([DEFAULT-MODE])
kono
parents:
diff changeset
617 # ----------------------------------
kono
parents:
diff changeset
618 # Control maintainer-specific portions of Makefiles.
kono
parents:
diff changeset
619 # Default is to disable them, unless `enable' is passed literally.
kono
parents:
diff changeset
620 # For symmetry, `disable' may be passed as well. Anyway, the user
kono
parents:
diff changeset
621 # can override the default with the --enable/--disable switch.
kono
parents:
diff changeset
622 AC_DEFUN([AM_MAINTAINER_MODE],
kono
parents:
diff changeset
623 [m4_case(m4_default([$1], [disable]),
kono
parents:
diff changeset
624 [enable], [m4_define([am_maintainer_other], [disable])],
kono
parents:
diff changeset
625 [disable], [m4_define([am_maintainer_other], [enable])],
kono
parents:
diff changeset
626 [m4_define([am_maintainer_other], [enable])
kono
parents:
diff changeset
627 m4_warn([syntax], [unexpected argument to AM@&t@_MAINTAINER_MODE: $1])])
kono
parents:
diff changeset
628 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
kono
parents:
diff changeset
629 dnl maintainer-mode's default is 'disable' unless 'enable' is passed
kono
parents:
diff changeset
630 AC_ARG_ENABLE([maintainer-mode],
kono
parents:
diff changeset
631 [ --][am_maintainer_other][-maintainer-mode am_maintainer_other make rules and dependencies not useful
kono
parents:
diff changeset
632 (and sometimes confusing) to the casual installer],
kono
parents:
diff changeset
633 [USE_MAINTAINER_MODE=$enableval],
kono
parents:
diff changeset
634 [USE_MAINTAINER_MODE=]m4_if(am_maintainer_other, [enable], [no], [yes]))
kono
parents:
diff changeset
635 AC_MSG_RESULT([$USE_MAINTAINER_MODE])
kono
parents:
diff changeset
636 AM_CONDITIONAL([MAINTAINER_MODE], [test $USE_MAINTAINER_MODE = yes])
kono
parents:
diff changeset
637 MAINT=$MAINTAINER_MODE_TRUE
kono
parents:
diff changeset
638 AC_SUBST([MAINT])dnl
kono
parents:
diff changeset
639 ]
kono
parents:
diff changeset
640 )
kono
parents:
diff changeset
641
kono
parents:
diff changeset
642 AU_DEFUN([jm_MAINTAINER_MODE], [AM_MAINTAINER_MODE])
kono
parents:
diff changeset
643
kono
parents:
diff changeset
644 # Check to see how 'make' treats includes. -*- Autoconf -*-
kono
parents:
diff changeset
645
kono
parents:
diff changeset
646 # Copyright (C) 2001, 2002, 2003, 2005, 2009 Free Software Foundation, Inc.
kono
parents:
diff changeset
647 #
kono
parents:
diff changeset
648 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
649 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
650 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
651
kono
parents:
diff changeset
652 # serial 4
kono
parents:
diff changeset
653
kono
parents:
diff changeset
654 # AM_MAKE_INCLUDE()
kono
parents:
diff changeset
655 # -----------------
kono
parents:
diff changeset
656 # Check to see how make treats includes.
kono
parents:
diff changeset
657 AC_DEFUN([AM_MAKE_INCLUDE],
kono
parents:
diff changeset
658 [am_make=${MAKE-make}
kono
parents:
diff changeset
659 cat > confinc << 'END'
kono
parents:
diff changeset
660 am__doit:
kono
parents:
diff changeset
661 @echo this is the am__doit target
kono
parents:
diff changeset
662 .PHONY: am__doit
kono
parents:
diff changeset
663 END
kono
parents:
diff changeset
664 # If we don't find an include directive, just comment out the code.
kono
parents:
diff changeset
665 AC_MSG_CHECKING([for style of include used by $am_make])
kono
parents:
diff changeset
666 am__include="#"
kono
parents:
diff changeset
667 am__quote=
kono
parents:
diff changeset
668 _am_result=none
kono
parents:
diff changeset
669 # First try GNU make style include.
kono
parents:
diff changeset
670 echo "include confinc" > confmf
kono
parents:
diff changeset
671 # Ignore all kinds of additional output from `make'.
kono
parents:
diff changeset
672 case `$am_make -s -f confmf 2> /dev/null` in #(
kono
parents:
diff changeset
673 *the\ am__doit\ target*)
kono
parents:
diff changeset
674 am__include=include
kono
parents:
diff changeset
675 am__quote=
kono
parents:
diff changeset
676 _am_result=GNU
kono
parents:
diff changeset
677 ;;
kono
parents:
diff changeset
678 esac
kono
parents:
diff changeset
679 # Now try BSD make style include.
kono
parents:
diff changeset
680 if test "$am__include" = "#"; then
kono
parents:
diff changeset
681 echo '.include "confinc"' > confmf
kono
parents:
diff changeset
682 case `$am_make -s -f confmf 2> /dev/null` in #(
kono
parents:
diff changeset
683 *the\ am__doit\ target*)
kono
parents:
diff changeset
684 am__include=.include
kono
parents:
diff changeset
685 am__quote="\""
kono
parents:
diff changeset
686 _am_result=BSD
kono
parents:
diff changeset
687 ;;
kono
parents:
diff changeset
688 esac
kono
parents:
diff changeset
689 fi
kono
parents:
diff changeset
690 AC_SUBST([am__include])
kono
parents:
diff changeset
691 AC_SUBST([am__quote])
kono
parents:
diff changeset
692 AC_MSG_RESULT([$_am_result])
kono
parents:
diff changeset
693 rm -f confinc confmf
kono
parents:
diff changeset
694 ])
kono
parents:
diff changeset
695
kono
parents:
diff changeset
696 # Fake the existence of programs that GNU maintainers use. -*- Autoconf -*-
kono
parents:
diff changeset
697
kono
parents:
diff changeset
698 # Copyright (C) 1997, 1999, 2000, 2001, 2003, 2004, 2005, 2008
kono
parents:
diff changeset
699 # Free Software Foundation, Inc.
kono
parents:
diff changeset
700 #
kono
parents:
diff changeset
701 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
702 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
703 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
704
kono
parents:
diff changeset
705 # serial 6
kono
parents:
diff changeset
706
kono
parents:
diff changeset
707 # AM_MISSING_PROG(NAME, PROGRAM)
kono
parents:
diff changeset
708 # ------------------------------
kono
parents:
diff changeset
709 AC_DEFUN([AM_MISSING_PROG],
kono
parents:
diff changeset
710 [AC_REQUIRE([AM_MISSING_HAS_RUN])
kono
parents:
diff changeset
711 $1=${$1-"${am_missing_run}$2"}
kono
parents:
diff changeset
712 AC_SUBST($1)])
kono
parents:
diff changeset
713
kono
parents:
diff changeset
714
kono
parents:
diff changeset
715 # AM_MISSING_HAS_RUN
kono
parents:
diff changeset
716 # ------------------
kono
parents:
diff changeset
717 # Define MISSING if not defined so far and test if it supports --run.
kono
parents:
diff changeset
718 # If it does, set am_missing_run to use it, otherwise, to nothing.
kono
parents:
diff changeset
719 AC_DEFUN([AM_MISSING_HAS_RUN],
kono
parents:
diff changeset
720 [AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
kono
parents:
diff changeset
721 AC_REQUIRE_AUX_FILE([missing])dnl
kono
parents:
diff changeset
722 if test x"${MISSING+set}" != xset; then
kono
parents:
diff changeset
723 case $am_aux_dir in
kono
parents:
diff changeset
724 *\ * | *\ *)
kono
parents:
diff changeset
725 MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;;
kono
parents:
diff changeset
726 *)
kono
parents:
diff changeset
727 MISSING="\${SHELL} $am_aux_dir/missing" ;;
kono
parents:
diff changeset
728 esac
kono
parents:
diff changeset
729 fi
kono
parents:
diff changeset
730 # Use eval to expand $SHELL
kono
parents:
diff changeset
731 if eval "$MISSING --run true"; then
kono
parents:
diff changeset
732 am_missing_run="$MISSING --run "
kono
parents:
diff changeset
733 else
kono
parents:
diff changeset
734 am_missing_run=
kono
parents:
diff changeset
735 AC_MSG_WARN([`missing' script is too old or missing])
kono
parents:
diff changeset
736 fi
kono
parents:
diff changeset
737 ])
kono
parents:
diff changeset
738
kono
parents:
diff changeset
739 # Copyright (C) 2003, 2004, 2005, 2006, 2011 Free Software Foundation,
kono
parents:
diff changeset
740 # Inc.
kono
parents:
diff changeset
741 #
kono
parents:
diff changeset
742 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
743 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
744 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
745
kono
parents:
diff changeset
746 # serial 1
kono
parents:
diff changeset
747
kono
parents:
diff changeset
748 # AM_PROG_MKDIR_P
kono
parents:
diff changeset
749 # ---------------
kono
parents:
diff changeset
750 # Check for `mkdir -p'.
kono
parents:
diff changeset
751 AC_DEFUN([AM_PROG_MKDIR_P],
kono
parents:
diff changeset
752 [AC_PREREQ([2.60])dnl
kono
parents:
diff changeset
753 AC_REQUIRE([AC_PROG_MKDIR_P])dnl
kono
parents:
diff changeset
754 dnl Automake 1.8 to 1.9.6 used to define mkdir_p. We now use MKDIR_P,
kono
parents:
diff changeset
755 dnl while keeping a definition of mkdir_p for backward compatibility.
kono
parents:
diff changeset
756 dnl @MKDIR_P@ is magic: AC_OUTPUT adjusts its value for each Makefile.
kono
parents:
diff changeset
757 dnl However we cannot define mkdir_p as $(MKDIR_P) for the sake of
kono
parents:
diff changeset
758 dnl Makefile.ins that do not define MKDIR_P, so we do our own
kono
parents:
diff changeset
759 dnl adjustment using top_builddir (which is defined more often than
kono
parents:
diff changeset
760 dnl MKDIR_P).
kono
parents:
diff changeset
761 AC_SUBST([mkdir_p], ["$MKDIR_P"])dnl
kono
parents:
diff changeset
762 case $mkdir_p in
kono
parents:
diff changeset
763 [[\\/$]]* | ?:[[\\/]]*) ;;
kono
parents:
diff changeset
764 */*) mkdir_p="\$(top_builddir)/$mkdir_p" ;;
kono
parents:
diff changeset
765 esac
kono
parents:
diff changeset
766 ])
kono
parents:
diff changeset
767
kono
parents:
diff changeset
768 # Helper functions for option handling. -*- Autoconf -*-
kono
parents:
diff changeset
769
kono
parents:
diff changeset
770 # Copyright (C) 2001, 2002, 2003, 2005, 2008, 2010 Free Software
kono
parents:
diff changeset
771 # Foundation, Inc.
kono
parents:
diff changeset
772 #
kono
parents:
diff changeset
773 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
774 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
775 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
776
kono
parents:
diff changeset
777 # serial 5
kono
parents:
diff changeset
778
kono
parents:
diff changeset
779 # _AM_MANGLE_OPTION(NAME)
kono
parents:
diff changeset
780 # -----------------------
kono
parents:
diff changeset
781 AC_DEFUN([_AM_MANGLE_OPTION],
kono
parents:
diff changeset
782 [[_AM_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])])
kono
parents:
diff changeset
783
kono
parents:
diff changeset
784 # _AM_SET_OPTION(NAME)
kono
parents:
diff changeset
785 # --------------------
kono
parents:
diff changeset
786 # Set option NAME. Presently that only means defining a flag for this option.
kono
parents:
diff changeset
787 AC_DEFUN([_AM_SET_OPTION],
kono
parents:
diff changeset
788 [m4_define(_AM_MANGLE_OPTION([$1]), 1)])
kono
parents:
diff changeset
789
kono
parents:
diff changeset
790 # _AM_SET_OPTIONS(OPTIONS)
kono
parents:
diff changeset
791 # ------------------------
kono
parents:
diff changeset
792 # OPTIONS is a space-separated list of Automake options.
kono
parents:
diff changeset
793 AC_DEFUN([_AM_SET_OPTIONS],
kono
parents:
diff changeset
794 [m4_foreach_w([_AM_Option], [$1], [_AM_SET_OPTION(_AM_Option)])])
kono
parents:
diff changeset
795
kono
parents:
diff changeset
796 # _AM_IF_OPTION(OPTION, IF-SET, [IF-NOT-SET])
kono
parents:
diff changeset
797 # -------------------------------------------
kono
parents:
diff changeset
798 # Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
kono
parents:
diff changeset
799 AC_DEFUN([_AM_IF_OPTION],
kono
parents:
diff changeset
800 [m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])])
kono
parents:
diff changeset
801
kono
parents:
diff changeset
802 # Check to make sure that the build environment is sane. -*- Autoconf -*-
kono
parents:
diff changeset
803
kono
parents:
diff changeset
804 # Copyright (C) 1996, 1997, 2000, 2001, 2003, 2005, 2008
kono
parents:
diff changeset
805 # Free Software Foundation, Inc.
kono
parents:
diff changeset
806 #
kono
parents:
diff changeset
807 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
808 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
809 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
810
kono
parents:
diff changeset
811 # serial 5
kono
parents:
diff changeset
812
kono
parents:
diff changeset
813 # AM_SANITY_CHECK
kono
parents:
diff changeset
814 # ---------------
kono
parents:
diff changeset
815 AC_DEFUN([AM_SANITY_CHECK],
kono
parents:
diff changeset
816 [AC_MSG_CHECKING([whether build environment is sane])
kono
parents:
diff changeset
817 # Just in case
kono
parents:
diff changeset
818 sleep 1
kono
parents:
diff changeset
819 echo timestamp > conftest.file
kono
parents:
diff changeset
820 # Reject unsafe characters in $srcdir or the absolute working directory
kono
parents:
diff changeset
821 # name. Accept space and tab only in the latter.
kono
parents:
diff changeset
822 am_lf='
kono
parents:
diff changeset
823 '
kono
parents:
diff changeset
824 case `pwd` in
kono
parents:
diff changeset
825 *[[\\\"\#\$\&\'\`$am_lf]]*)
kono
parents:
diff changeset
826 AC_MSG_ERROR([unsafe absolute working directory name]);;
kono
parents:
diff changeset
827 esac
kono
parents:
diff changeset
828 case $srcdir in
kono
parents:
diff changeset
829 *[[\\\"\#\$\&\'\`$am_lf\ \ ]]*)
kono
parents:
diff changeset
830 AC_MSG_ERROR([unsafe srcdir value: `$srcdir']);;
kono
parents:
diff changeset
831 esac
kono
parents:
diff changeset
832
kono
parents:
diff changeset
833 # Do `set' in a subshell so we don't clobber the current shell's
kono
parents:
diff changeset
834 # arguments. Must try -L first in case configure is actually a
kono
parents:
diff changeset
835 # symlink; some systems play weird games with the mod time of symlinks
kono
parents:
diff changeset
836 # (eg FreeBSD returns the mod time of the symlink's containing
kono
parents:
diff changeset
837 # directory).
kono
parents:
diff changeset
838 if (
kono
parents:
diff changeset
839 set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
kono
parents:
diff changeset
840 if test "$[*]" = "X"; then
kono
parents:
diff changeset
841 # -L didn't work.
kono
parents:
diff changeset
842 set X `ls -t "$srcdir/configure" conftest.file`
kono
parents:
diff changeset
843 fi
kono
parents:
diff changeset
844 rm -f conftest.file
kono
parents:
diff changeset
845 if test "$[*]" != "X $srcdir/configure conftest.file" \
kono
parents:
diff changeset
846 && test "$[*]" != "X conftest.file $srcdir/configure"; then
kono
parents:
diff changeset
847
kono
parents:
diff changeset
848 # If neither matched, then we have a broken ls. This can happen
kono
parents:
diff changeset
849 # if, for instance, CONFIG_SHELL is bash and it inherits a
kono
parents:
diff changeset
850 # broken ls alias from the environment. This has actually
kono
parents:
diff changeset
851 # happened. Such a system could not be considered "sane".
kono
parents:
diff changeset
852 AC_MSG_ERROR([ls -t appears to fail. Make sure there is not a broken
kono
parents:
diff changeset
853 alias in your environment])
kono
parents:
diff changeset
854 fi
kono
parents:
diff changeset
855
kono
parents:
diff changeset
856 test "$[2]" = conftest.file
kono
parents:
diff changeset
857 )
kono
parents:
diff changeset
858 then
kono
parents:
diff changeset
859 # Ok.
kono
parents:
diff changeset
860 :
kono
parents:
diff changeset
861 else
kono
parents:
diff changeset
862 AC_MSG_ERROR([newly created file is older than distributed files!
kono
parents:
diff changeset
863 Check your system clock])
kono
parents:
diff changeset
864 fi
kono
parents:
diff changeset
865 AC_MSG_RESULT(yes)])
kono
parents:
diff changeset
866
kono
parents:
diff changeset
867 # Copyright (C) 2001, 2003, 2005, 2011 Free Software Foundation, Inc.
kono
parents:
diff changeset
868 #
kono
parents:
diff changeset
869 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
870 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
871 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
872
kono
parents:
diff changeset
873 # serial 1
kono
parents:
diff changeset
874
kono
parents:
diff changeset
875 # AM_PROG_INSTALL_STRIP
kono
parents:
diff changeset
876 # ---------------------
kono
parents:
diff changeset
877 # One issue with vendor `install' (even GNU) is that you can't
kono
parents:
diff changeset
878 # specify the program used to strip binaries. This is especially
kono
parents:
diff changeset
879 # annoying in cross-compiling environments, where the build's strip
kono
parents:
diff changeset
880 # is unlikely to handle the host's binaries.
kono
parents:
diff changeset
881 # Fortunately install-sh will honor a STRIPPROG variable, so we
kono
parents:
diff changeset
882 # always use install-sh in `make install-strip', and initialize
kono
parents:
diff changeset
883 # STRIPPROG with the value of the STRIP variable (set by the user).
kono
parents:
diff changeset
884 AC_DEFUN([AM_PROG_INSTALL_STRIP],
kono
parents:
diff changeset
885 [AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
kono
parents:
diff changeset
886 # Installed binaries are usually stripped using `strip' when the user
kono
parents:
diff changeset
887 # run `make install-strip'. However `strip' might not be the right
kono
parents:
diff changeset
888 # tool to use in cross-compilation environments, therefore Automake
kono
parents:
diff changeset
889 # will honor the `STRIP' environment variable to overrule this program.
kono
parents:
diff changeset
890 dnl Don't test for $cross_compiling = yes, because it might be `maybe'.
kono
parents:
diff changeset
891 if test "$cross_compiling" != no; then
kono
parents:
diff changeset
892 AC_CHECK_TOOL([STRIP], [strip], :)
kono
parents:
diff changeset
893 fi
kono
parents:
diff changeset
894 INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
kono
parents:
diff changeset
895 AC_SUBST([INSTALL_STRIP_PROGRAM])])
kono
parents:
diff changeset
896
kono
parents:
diff changeset
897 # Copyright (C) 2006, 2008, 2010 Free Software Foundation, Inc.
kono
parents:
diff changeset
898 #
kono
parents:
diff changeset
899 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
900 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
901 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
902
kono
parents:
diff changeset
903 # serial 3
kono
parents:
diff changeset
904
kono
parents:
diff changeset
905 # _AM_SUBST_NOTMAKE(VARIABLE)
kono
parents:
diff changeset
906 # ---------------------------
kono
parents:
diff changeset
907 # Prevent Automake from outputting VARIABLE = @VARIABLE@ in Makefile.in.
kono
parents:
diff changeset
908 # This macro is traced by Automake.
kono
parents:
diff changeset
909 AC_DEFUN([_AM_SUBST_NOTMAKE])
kono
parents:
diff changeset
910
kono
parents:
diff changeset
911 # AM_SUBST_NOTMAKE(VARIABLE)
kono
parents:
diff changeset
912 # --------------------------
kono
parents:
diff changeset
913 # Public sister of _AM_SUBST_NOTMAKE.
kono
parents:
diff changeset
914 AC_DEFUN([AM_SUBST_NOTMAKE], [_AM_SUBST_NOTMAKE($@)])
kono
parents:
diff changeset
915
kono
parents:
diff changeset
916 # Check how to create a tarball. -*- Autoconf -*-
kono
parents:
diff changeset
917
kono
parents:
diff changeset
918 # Copyright (C) 2004, 2005, 2012 Free Software Foundation, Inc.
kono
parents:
diff changeset
919 #
kono
parents:
diff changeset
920 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
921 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
922 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
923
kono
parents:
diff changeset
924 # serial 2
kono
parents:
diff changeset
925
kono
parents:
diff changeset
926 # _AM_PROG_TAR(FORMAT)
kono
parents:
diff changeset
927 # --------------------
kono
parents:
diff changeset
928 # Check how to create a tarball in format FORMAT.
kono
parents:
diff changeset
929 # FORMAT should be one of `v7', `ustar', or `pax'.
kono
parents:
diff changeset
930 #
kono
parents:
diff changeset
931 # Substitute a variable $(am__tar) that is a command
kono
parents:
diff changeset
932 # writing to stdout a FORMAT-tarball containing the directory
kono
parents:
diff changeset
933 # $tardir.
kono
parents:
diff changeset
934 # tardir=directory && $(am__tar) > result.tar
kono
parents:
diff changeset
935 #
kono
parents:
diff changeset
936 # Substitute a variable $(am__untar) that extract such
kono
parents:
diff changeset
937 # a tarball read from stdin.
kono
parents:
diff changeset
938 # $(am__untar) < result.tar
kono
parents:
diff changeset
939 AC_DEFUN([_AM_PROG_TAR],
kono
parents:
diff changeset
940 [# Always define AMTAR for backward compatibility. Yes, it's still used
kono
parents:
diff changeset
941 # in the wild :-( We should find a proper way to deprecate it ...
kono
parents:
diff changeset
942 AC_SUBST([AMTAR], ['$${TAR-tar}'])
kono
parents:
diff changeset
943 m4_if([$1], [v7],
kono
parents:
diff changeset
944 [am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'],
kono
parents:
diff changeset
945 [m4_case([$1], [ustar],, [pax],,
kono
parents:
diff changeset
946 [m4_fatal([Unknown tar format])])
kono
parents:
diff changeset
947 AC_MSG_CHECKING([how to create a $1 tar archive])
kono
parents:
diff changeset
948 # Loop over all known methods to create a tar archive until one works.
kono
parents:
diff changeset
949 _am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none'
kono
parents:
diff changeset
950 _am_tools=${am_cv_prog_tar_$1-$_am_tools}
kono
parents:
diff changeset
951 # Do not fold the above two line into one, because Tru64 sh and
kono
parents:
diff changeset
952 # Solaris sh will not grok spaces in the rhs of `-'.
kono
parents:
diff changeset
953 for _am_tool in $_am_tools
kono
parents:
diff changeset
954 do
kono
parents:
diff changeset
955 case $_am_tool in
kono
parents:
diff changeset
956 gnutar)
kono
parents:
diff changeset
957 for _am_tar in tar gnutar gtar;
kono
parents:
diff changeset
958 do
kono
parents:
diff changeset
959 AM_RUN_LOG([$_am_tar --version]) && break
kono
parents:
diff changeset
960 done
kono
parents:
diff changeset
961 am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"'
kono
parents:
diff changeset
962 am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"'
kono
parents:
diff changeset
963 am__untar="$_am_tar -xf -"
kono
parents:
diff changeset
964 ;;
kono
parents:
diff changeset
965 plaintar)
kono
parents:
diff changeset
966 # Must skip GNU tar: if it does not support --format= it doesn't create
kono
parents:
diff changeset
967 # ustar tarball either.
kono
parents:
diff changeset
968 (tar --version) >/dev/null 2>&1 && continue
kono
parents:
diff changeset
969 am__tar='tar chf - "$$tardir"'
kono
parents:
diff changeset
970 am__tar_='tar chf - "$tardir"'
kono
parents:
diff changeset
971 am__untar='tar xf -'
kono
parents:
diff changeset
972 ;;
kono
parents:
diff changeset
973 pax)
kono
parents:
diff changeset
974 am__tar='pax -L -x $1 -w "$$tardir"'
kono
parents:
diff changeset
975 am__tar_='pax -L -x $1 -w "$tardir"'
kono
parents:
diff changeset
976 am__untar='pax -r'
kono
parents:
diff changeset
977 ;;
kono
parents:
diff changeset
978 cpio)
kono
parents:
diff changeset
979 am__tar='find "$$tardir" -print | cpio -o -H $1 -L'
kono
parents:
diff changeset
980 am__tar_='find "$tardir" -print | cpio -o -H $1 -L'
kono
parents:
diff changeset
981 am__untar='cpio -i -H $1 -d'
kono
parents:
diff changeset
982 ;;
kono
parents:
diff changeset
983 none)
kono
parents:
diff changeset
984 am__tar=false
kono
parents:
diff changeset
985 am__tar_=false
kono
parents:
diff changeset
986 am__untar=false
kono
parents:
diff changeset
987 ;;
kono
parents:
diff changeset
988 esac
kono
parents:
diff changeset
989
kono
parents:
diff changeset
990 # If the value was cached, stop now. We just wanted to have am__tar
kono
parents:
diff changeset
991 # and am__untar set.
kono
parents:
diff changeset
992 test -n "${am_cv_prog_tar_$1}" && break
kono
parents:
diff changeset
993
kono
parents:
diff changeset
994 # tar/untar a dummy directory, and stop if the command works
kono
parents:
diff changeset
995 rm -rf conftest.dir
kono
parents:
diff changeset
996 mkdir conftest.dir
kono
parents:
diff changeset
997 echo GrepMe > conftest.dir/file
kono
parents:
diff changeset
998 AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar])
kono
parents:
diff changeset
999 rm -rf conftest.dir
kono
parents:
diff changeset
1000 if test -s conftest.tar; then
kono
parents:
diff changeset
1001 AM_RUN_LOG([$am__untar <conftest.tar])
kono
parents:
diff changeset
1002 grep GrepMe conftest.dir/file >/dev/null 2>&1 && break
kono
parents:
diff changeset
1003 fi
kono
parents:
diff changeset
1004 done
kono
parents:
diff changeset
1005 rm -rf conftest.dir
kono
parents:
diff changeset
1006
kono
parents:
diff changeset
1007 AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool])
kono
parents:
diff changeset
1008 AC_MSG_RESULT([$am_cv_prog_tar_$1])])
kono
parents:
diff changeset
1009 AC_SUBST([am__tar])
kono
parents:
diff changeset
1010 AC_SUBST([am__untar])
kono
parents:
diff changeset
1011 ]) # _AM_PROG_TAR
kono
parents:
diff changeset
1012
kono
parents:
diff changeset
1013 m4_include([../config/acx.m4])
kono
parents:
diff changeset
1014 m4_include([../config/depstand.m4])
kono
parents:
diff changeset
1015 m4_include([../config/lead-dot.m4])
kono
parents:
diff changeset
1016 m4_include([../config/lthostflags.m4])
kono
parents:
diff changeset
1017 m4_include([../config/multi.m4])
kono
parents:
diff changeset
1018 m4_include([../config/override.m4])
kono
parents:
diff changeset
1019 m4_include([../config/stdint.m4])
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
1020 m4_include([../config/warnings.m4])
111
kono
parents:
diff changeset
1021 m4_include([../ltoptions.m4])
kono
parents:
diff changeset
1022 m4_include([../ltsugar.m4])
kono
parents:
diff changeset
1023 m4_include([../ltversion.m4])
kono
parents:
diff changeset
1024 m4_include([../lt~obsolete.m4])
kono
parents:
diff changeset
1025 m4_include([acinclude.m4])