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