annotate libmpx/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
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 # Do all the work for Automake. -*- Autoconf -*-
kono
parents:
diff changeset
154
kono
parents:
diff changeset
155 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
kono
parents:
diff changeset
156 # 2005, 2006, 2008, 2009 Free Software Foundation, Inc.
kono
parents:
diff changeset
157 #
kono
parents:
diff changeset
158 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
159 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
160 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
161
kono
parents:
diff changeset
162 # serial 16
kono
parents:
diff changeset
163
kono
parents:
diff changeset
164 # This macro actually does too much. Some checks are only needed if
kono
parents:
diff changeset
165 # your package does certain things. But this isn't really a big deal.
kono
parents:
diff changeset
166
kono
parents:
diff changeset
167 # AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE])
kono
parents:
diff changeset
168 # AM_INIT_AUTOMAKE([OPTIONS])
kono
parents:
diff changeset
169 # -----------------------------------------------
kono
parents:
diff changeset
170 # The call with PACKAGE and VERSION arguments is the old style
kono
parents:
diff changeset
171 # call (pre autoconf-2.50), which is being phased out. PACKAGE
kono
parents:
diff changeset
172 # and VERSION should now be passed to AC_INIT and removed from
kono
parents:
diff changeset
173 # the call to AM_INIT_AUTOMAKE.
kono
parents:
diff changeset
174 # We support both call styles for the transition. After
kono
parents:
diff changeset
175 # the next Automake release, Autoconf can make the AC_INIT
kono
parents:
diff changeset
176 # arguments mandatory, and then we can depend on a new Autoconf
kono
parents:
diff changeset
177 # release and drop the old call support.
kono
parents:
diff changeset
178 AC_DEFUN([AM_INIT_AUTOMAKE],
kono
parents:
diff changeset
179 [AC_PREREQ([2.62])dnl
kono
parents:
diff changeset
180 dnl Autoconf wants to disallow AM_ names. We explicitly allow
kono
parents:
diff changeset
181 dnl the ones we care about.
kono
parents:
diff changeset
182 m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl
kono
parents:
diff changeset
183 AC_REQUIRE([AM_SET_CURRENT_AUTOMAKE_VERSION])dnl
kono
parents:
diff changeset
184 AC_REQUIRE([AC_PROG_INSTALL])dnl
kono
parents:
diff changeset
185 if test "`cd $srcdir && pwd`" != "`pwd`"; then
kono
parents:
diff changeset
186 # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
kono
parents:
diff changeset
187 # is not polluted with repeated "-I."
kono
parents:
diff changeset
188 AC_SUBST([am__isrc], [' -I$(srcdir)'])_AM_SUBST_NOTMAKE([am__isrc])dnl
kono
parents:
diff changeset
189 # test to see if srcdir already configured
kono
parents:
diff changeset
190 if test -f $srcdir/config.status; then
kono
parents:
diff changeset
191 AC_MSG_ERROR([source directory already configured; run "make distclean" there first])
kono
parents:
diff changeset
192 fi
kono
parents:
diff changeset
193 fi
kono
parents:
diff changeset
194
kono
parents:
diff changeset
195 # test whether we have cygpath
kono
parents:
diff changeset
196 if test -z "$CYGPATH_W"; then
kono
parents:
diff changeset
197 if (cygpath --version) >/dev/null 2>/dev/null; then
kono
parents:
diff changeset
198 CYGPATH_W='cygpath -w'
kono
parents:
diff changeset
199 else
kono
parents:
diff changeset
200 CYGPATH_W=echo
kono
parents:
diff changeset
201 fi
kono
parents:
diff changeset
202 fi
kono
parents:
diff changeset
203 AC_SUBST([CYGPATH_W])
kono
parents:
diff changeset
204
kono
parents:
diff changeset
205 # Define the identity of the package.
kono
parents:
diff changeset
206 dnl Distinguish between old-style and new-style calls.
kono
parents:
diff changeset
207 m4_ifval([$2],
kono
parents:
diff changeset
208 [m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl
kono
parents:
diff changeset
209 AC_SUBST([PACKAGE], [$1])dnl
kono
parents:
diff changeset
210 AC_SUBST([VERSION], [$2])],
kono
parents:
diff changeset
211 [_AM_SET_OPTIONS([$1])dnl
kono
parents:
diff changeset
212 dnl Diagnose old-style AC_INIT with new-style AM_AUTOMAKE_INIT.
kono
parents:
diff changeset
213 m4_if(m4_ifdef([AC_PACKAGE_NAME], 1)m4_ifdef([AC_PACKAGE_VERSION], 1), 11,,
kono
parents:
diff changeset
214 [m4_fatal([AC_INIT should be called with package and version arguments])])dnl
kono
parents:
diff changeset
215 AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl
kono
parents:
diff changeset
216 AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl
kono
parents:
diff changeset
217
kono
parents:
diff changeset
218 _AM_IF_OPTION([no-define],,
kono
parents:
diff changeset
219 [AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of package])
kono
parents:
diff changeset
220 AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version number of package])])dnl
kono
parents:
diff changeset
221
kono
parents:
diff changeset
222 # Some tools Automake needs.
kono
parents:
diff changeset
223 AC_REQUIRE([AM_SANITY_CHECK])dnl
kono
parents:
diff changeset
224 AC_REQUIRE([AC_ARG_PROGRAM])dnl
kono
parents:
diff changeset
225 AM_MISSING_PROG(ACLOCAL, aclocal-${am__api_version})
kono
parents:
diff changeset
226 AM_MISSING_PROG(AUTOCONF, autoconf)
kono
parents:
diff changeset
227 AM_MISSING_PROG(AUTOMAKE, automake-${am__api_version})
kono
parents:
diff changeset
228 AM_MISSING_PROG(AUTOHEADER, autoheader)
kono
parents:
diff changeset
229 AM_MISSING_PROG(MAKEINFO, makeinfo)
kono
parents:
diff changeset
230 AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
kono
parents:
diff changeset
231 AC_REQUIRE([AM_PROG_INSTALL_STRIP])dnl
kono
parents:
diff changeset
232 AC_REQUIRE([AM_PROG_MKDIR_P])dnl
kono
parents:
diff changeset
233 # We need awk for the "check" target. The system "awk" is bad on
kono
parents:
diff changeset
234 # some platforms.
kono
parents:
diff changeset
235 AC_REQUIRE([AC_PROG_AWK])dnl
kono
parents:
diff changeset
236 AC_REQUIRE([AC_PROG_MAKE_SET])dnl
kono
parents:
diff changeset
237 AC_REQUIRE([AM_SET_LEADING_DOT])dnl
kono
parents:
diff changeset
238 _AM_IF_OPTION([tar-ustar], [_AM_PROG_TAR([ustar])],
kono
parents:
diff changeset
239 [_AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])],
kono
parents:
diff changeset
240 [_AM_PROG_TAR([v7])])])
kono
parents:
diff changeset
241 _AM_IF_OPTION([no-dependencies],,
kono
parents:
diff changeset
242 [AC_PROVIDE_IFELSE([AC_PROG_CC],
kono
parents:
diff changeset
243 [_AM_DEPENDENCIES(CC)],
kono
parents:
diff changeset
244 [define([AC_PROG_CC],
kono
parents:
diff changeset
245 defn([AC_PROG_CC])[_AM_DEPENDENCIES(CC)])])dnl
kono
parents:
diff changeset
246 AC_PROVIDE_IFELSE([AC_PROG_CXX],
kono
parents:
diff changeset
247 [_AM_DEPENDENCIES(CXX)],
kono
parents:
diff changeset
248 [define([AC_PROG_CXX],
kono
parents:
diff changeset
249 defn([AC_PROG_CXX])[_AM_DEPENDENCIES(CXX)])])dnl
kono
parents:
diff changeset
250 AC_PROVIDE_IFELSE([AC_PROG_OBJC],
kono
parents:
diff changeset
251 [_AM_DEPENDENCIES(OBJC)],
kono
parents:
diff changeset
252 [define([AC_PROG_OBJC],
kono
parents:
diff changeset
253 defn([AC_PROG_OBJC])[_AM_DEPENDENCIES(OBJC)])])dnl
kono
parents:
diff changeset
254 ])
kono
parents:
diff changeset
255 _AM_IF_OPTION([silent-rules], [AC_REQUIRE([AM_SILENT_RULES])])dnl
kono
parents:
diff changeset
256 dnl The `parallel-tests' driver may need to know about EXEEXT, so add the
kono
parents:
diff changeset
257 dnl `am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen. This macro
kono
parents:
diff changeset
258 dnl is hooked onto _AC_COMPILER_EXEEXT early, see below.
kono
parents:
diff changeset
259 AC_CONFIG_COMMANDS_PRE(dnl
kono
parents:
diff changeset
260 [m4_provide_if([_AM_COMPILER_EXEEXT],
kono
parents:
diff changeset
261 [AM_CONDITIONAL([am__EXEEXT], [test -n "$EXEEXT"])])])dnl
kono
parents:
diff changeset
262 ])
kono
parents:
diff changeset
263
kono
parents:
diff changeset
264 dnl Hook into `_AC_COMPILER_EXEEXT' early to learn its expansion. Do not
kono
parents:
diff changeset
265 dnl add the conditional right here, as _AC_COMPILER_EXEEXT may be further
kono
parents:
diff changeset
266 dnl mangled by Autoconf and run in a shell conditional statement.
kono
parents:
diff changeset
267 m4_define([_AC_COMPILER_EXEEXT],
kono
parents:
diff changeset
268 m4_defn([_AC_COMPILER_EXEEXT])[m4_provide([_AM_COMPILER_EXEEXT])])
kono
parents:
diff changeset
269
kono
parents:
diff changeset
270
kono
parents:
diff changeset
271 # When config.status generates a header, we must update the stamp-h file.
kono
parents:
diff changeset
272 # This file resides in the same directory as the config header
kono
parents:
diff changeset
273 # that is generated. The stamp files are numbered to have different names.
kono
parents:
diff changeset
274
kono
parents:
diff changeset
275 # Autoconf calls _AC_AM_CONFIG_HEADER_HOOK (when defined) in the
kono
parents:
diff changeset
276 # loop where config.status creates the headers, so we can generate
kono
parents:
diff changeset
277 # our stamp files there.
kono
parents:
diff changeset
278 AC_DEFUN([_AC_AM_CONFIG_HEADER_HOOK],
kono
parents:
diff changeset
279 [# Compute $1's index in $config_headers.
kono
parents:
diff changeset
280 _am_arg=$1
kono
parents:
diff changeset
281 _am_stamp_count=1
kono
parents:
diff changeset
282 for _am_header in $config_headers :; do
kono
parents:
diff changeset
283 case $_am_header in
kono
parents:
diff changeset
284 $_am_arg | $_am_arg:* )
kono
parents:
diff changeset
285 break ;;
kono
parents:
diff changeset
286 * )
kono
parents:
diff changeset
287 _am_stamp_count=`expr $_am_stamp_count + 1` ;;
kono
parents:
diff changeset
288 esac
kono
parents:
diff changeset
289 done
kono
parents:
diff changeset
290 echo "timestamp for $_am_arg" >`AS_DIRNAME(["$_am_arg"])`/stamp-h[]$_am_stamp_count])
kono
parents:
diff changeset
291
kono
parents:
diff changeset
292 # Copyright (C) 2001, 2003, 2005, 2008, 2011 Free Software Foundation,
kono
parents:
diff changeset
293 # Inc.
kono
parents:
diff changeset
294 #
kono
parents:
diff changeset
295 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
296 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
297 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
298
kono
parents:
diff changeset
299 # serial 1
kono
parents:
diff changeset
300
kono
parents:
diff changeset
301 # AM_PROG_INSTALL_SH
kono
parents:
diff changeset
302 # ------------------
kono
parents:
diff changeset
303 # Define $install_sh.
kono
parents:
diff changeset
304 AC_DEFUN([AM_PROG_INSTALL_SH],
kono
parents:
diff changeset
305 [AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
kono
parents:
diff changeset
306 if test x"${install_sh}" != xset; then
kono
parents:
diff changeset
307 case $am_aux_dir in
kono
parents:
diff changeset
308 *\ * | *\ *)
kono
parents:
diff changeset
309 install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
kono
parents:
diff changeset
310 *)
kono
parents:
diff changeset
311 install_sh="\${SHELL} $am_aux_dir/install-sh"
kono
parents:
diff changeset
312 esac
kono
parents:
diff changeset
313 fi
kono
parents:
diff changeset
314 AC_SUBST(install_sh)])
kono
parents:
diff changeset
315
kono
parents:
diff changeset
316 # Add --enable-maintainer-mode option to configure. -*- Autoconf -*-
kono
parents:
diff changeset
317 # From Jim Meyering
kono
parents:
diff changeset
318
kono
parents:
diff changeset
319 # Copyright (C) 1996, 1998, 2000, 2001, 2002, 2003, 2004, 2005, 2008,
kono
parents:
diff changeset
320 # 2011 Free Software Foundation, Inc.
kono
parents:
diff changeset
321 #
kono
parents:
diff changeset
322 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
323 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
324 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
325
kono
parents:
diff changeset
326 # serial 5
kono
parents:
diff changeset
327
kono
parents:
diff changeset
328 # AM_MAINTAINER_MODE([DEFAULT-MODE])
kono
parents:
diff changeset
329 # ----------------------------------
kono
parents:
diff changeset
330 # Control maintainer-specific portions of Makefiles.
kono
parents:
diff changeset
331 # Default is to disable them, unless `enable' is passed literally.
kono
parents:
diff changeset
332 # For symmetry, `disable' may be passed as well. Anyway, the user
kono
parents:
diff changeset
333 # can override the default with the --enable/--disable switch.
kono
parents:
diff changeset
334 AC_DEFUN([AM_MAINTAINER_MODE],
kono
parents:
diff changeset
335 [m4_case(m4_default([$1], [disable]),
kono
parents:
diff changeset
336 [enable], [m4_define([am_maintainer_other], [disable])],
kono
parents:
diff changeset
337 [disable], [m4_define([am_maintainer_other], [enable])],
kono
parents:
diff changeset
338 [m4_define([am_maintainer_other], [enable])
kono
parents:
diff changeset
339 m4_warn([syntax], [unexpected argument to AM@&t@_MAINTAINER_MODE: $1])])
kono
parents:
diff changeset
340 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
kono
parents:
diff changeset
341 dnl maintainer-mode's default is 'disable' unless 'enable' is passed
kono
parents:
diff changeset
342 AC_ARG_ENABLE([maintainer-mode],
kono
parents:
diff changeset
343 [ --][am_maintainer_other][-maintainer-mode am_maintainer_other make rules and dependencies not useful
kono
parents:
diff changeset
344 (and sometimes confusing) to the casual installer],
kono
parents:
diff changeset
345 [USE_MAINTAINER_MODE=$enableval],
kono
parents:
diff changeset
346 [USE_MAINTAINER_MODE=]m4_if(am_maintainer_other, [enable], [no], [yes]))
kono
parents:
diff changeset
347 AC_MSG_RESULT([$USE_MAINTAINER_MODE])
kono
parents:
diff changeset
348 AM_CONDITIONAL([MAINTAINER_MODE], [test $USE_MAINTAINER_MODE = yes])
kono
parents:
diff changeset
349 MAINT=$MAINTAINER_MODE_TRUE
kono
parents:
diff changeset
350 AC_SUBST([MAINT])dnl
kono
parents:
diff changeset
351 ]
kono
parents:
diff changeset
352 )
kono
parents:
diff changeset
353
kono
parents:
diff changeset
354 AU_DEFUN([jm_MAINTAINER_MODE], [AM_MAINTAINER_MODE])
kono
parents:
diff changeset
355
kono
parents:
diff changeset
356 # Copyright (C) 1999, 2000, 2001, 2003, 2004, 2005, 2008
kono
parents:
diff changeset
357 # Free Software Foundation, Inc.
kono
parents:
diff changeset
358 #
kono
parents:
diff changeset
359 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
360 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
361 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
362
kono
parents:
diff changeset
363 # serial 6
kono
parents:
diff changeset
364
kono
parents:
diff changeset
365 # AM_PROG_CC_C_O
kono
parents:
diff changeset
366 # --------------
kono
parents:
diff changeset
367 # Like AC_PROG_CC_C_O, but changed for automake.
kono
parents:
diff changeset
368 AC_DEFUN([AM_PROG_CC_C_O],
kono
parents:
diff changeset
369 [AC_REQUIRE([AC_PROG_CC_C_O])dnl
kono
parents:
diff changeset
370 AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
kono
parents:
diff changeset
371 AC_REQUIRE_AUX_FILE([compile])dnl
kono
parents:
diff changeset
372 # FIXME: we rely on the cache variable name because
kono
parents:
diff changeset
373 # there is no other way.
kono
parents:
diff changeset
374 set dummy $CC
kono
parents:
diff changeset
375 am_cc=`echo $[2] | sed ['s/[^a-zA-Z0-9_]/_/g;s/^[0-9]/_/']`
kono
parents:
diff changeset
376 eval am_t=\$ac_cv_prog_cc_${am_cc}_c_o
kono
parents:
diff changeset
377 if test "$am_t" != yes; then
kono
parents:
diff changeset
378 # Losing compiler, so override with the script.
kono
parents:
diff changeset
379 # FIXME: It is wrong to rewrite CC.
kono
parents:
diff changeset
380 # But if we don't then we get into trouble of one sort or another.
kono
parents:
diff changeset
381 # A longer-term fix would be to have automake use am__CC in this case,
kono
parents:
diff changeset
382 # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
kono
parents:
diff changeset
383 CC="$am_aux_dir/compile $CC"
kono
parents:
diff changeset
384 fi
kono
parents:
diff changeset
385 dnl Make sure AC_PROG_CC is never called again, or it will override our
kono
parents:
diff changeset
386 dnl setting of CC.
kono
parents:
diff changeset
387 m4_define([AC_PROG_CC],
kono
parents:
diff changeset
388 [m4_fatal([AC_PROG_CC cannot be called after AM_PROG_CC_C_O])])
kono
parents:
diff changeset
389 ])
kono
parents:
diff changeset
390
kono
parents:
diff changeset
391 # Fake the existence of programs that GNU maintainers use. -*- Autoconf -*-
kono
parents:
diff changeset
392
kono
parents:
diff changeset
393 # Copyright (C) 1997, 1999, 2000, 2001, 2003, 2004, 2005, 2008
kono
parents:
diff changeset
394 # Free Software Foundation, Inc.
kono
parents:
diff changeset
395 #
kono
parents:
diff changeset
396 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
397 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
398 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
399
kono
parents:
diff changeset
400 # serial 6
kono
parents:
diff changeset
401
kono
parents:
diff changeset
402 # AM_MISSING_PROG(NAME, PROGRAM)
kono
parents:
diff changeset
403 # ------------------------------
kono
parents:
diff changeset
404 AC_DEFUN([AM_MISSING_PROG],
kono
parents:
diff changeset
405 [AC_REQUIRE([AM_MISSING_HAS_RUN])
kono
parents:
diff changeset
406 $1=${$1-"${am_missing_run}$2"}
kono
parents:
diff changeset
407 AC_SUBST($1)])
kono
parents:
diff changeset
408
kono
parents:
diff changeset
409
kono
parents:
diff changeset
410 # AM_MISSING_HAS_RUN
kono
parents:
diff changeset
411 # ------------------
kono
parents:
diff changeset
412 # Define MISSING if not defined so far and test if it supports --run.
kono
parents:
diff changeset
413 # If it does, set am_missing_run to use it, otherwise, to nothing.
kono
parents:
diff changeset
414 AC_DEFUN([AM_MISSING_HAS_RUN],
kono
parents:
diff changeset
415 [AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
kono
parents:
diff changeset
416 AC_REQUIRE_AUX_FILE([missing])dnl
kono
parents:
diff changeset
417 if test x"${MISSING+set}" != xset; then
kono
parents:
diff changeset
418 case $am_aux_dir in
kono
parents:
diff changeset
419 *\ * | *\ *)
kono
parents:
diff changeset
420 MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;;
kono
parents:
diff changeset
421 *)
kono
parents:
diff changeset
422 MISSING="\${SHELL} $am_aux_dir/missing" ;;
kono
parents:
diff changeset
423 esac
kono
parents:
diff changeset
424 fi
kono
parents:
diff changeset
425 # Use eval to expand $SHELL
kono
parents:
diff changeset
426 if eval "$MISSING --run true"; then
kono
parents:
diff changeset
427 am_missing_run="$MISSING --run "
kono
parents:
diff changeset
428 else
kono
parents:
diff changeset
429 am_missing_run=
kono
parents:
diff changeset
430 AC_MSG_WARN([`missing' script is too old or missing])
kono
parents:
diff changeset
431 fi
kono
parents:
diff changeset
432 ])
kono
parents:
diff changeset
433
kono
parents:
diff changeset
434 # Copyright (C) 2003, 2004, 2005, 2006, 2011 Free Software Foundation,
kono
parents:
diff changeset
435 # Inc.
kono
parents:
diff changeset
436 #
kono
parents:
diff changeset
437 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
438 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
439 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
440
kono
parents:
diff changeset
441 # serial 1
kono
parents:
diff changeset
442
kono
parents:
diff changeset
443 # AM_PROG_MKDIR_P
kono
parents:
diff changeset
444 # ---------------
kono
parents:
diff changeset
445 # Check for `mkdir -p'.
kono
parents:
diff changeset
446 AC_DEFUN([AM_PROG_MKDIR_P],
kono
parents:
diff changeset
447 [AC_PREREQ([2.60])dnl
kono
parents:
diff changeset
448 AC_REQUIRE([AC_PROG_MKDIR_P])dnl
kono
parents:
diff changeset
449 dnl Automake 1.8 to 1.9.6 used to define mkdir_p. We now use MKDIR_P,
kono
parents:
diff changeset
450 dnl while keeping a definition of mkdir_p for backward compatibility.
kono
parents:
diff changeset
451 dnl @MKDIR_P@ is magic: AC_OUTPUT adjusts its value for each Makefile.
kono
parents:
diff changeset
452 dnl However we cannot define mkdir_p as $(MKDIR_P) for the sake of
kono
parents:
diff changeset
453 dnl Makefile.ins that do not define MKDIR_P, so we do our own
kono
parents:
diff changeset
454 dnl adjustment using top_builddir (which is defined more often than
kono
parents:
diff changeset
455 dnl MKDIR_P).
kono
parents:
diff changeset
456 AC_SUBST([mkdir_p], ["$MKDIR_P"])dnl
kono
parents:
diff changeset
457 case $mkdir_p in
kono
parents:
diff changeset
458 [[\\/$]]* | ?:[[\\/]]*) ;;
kono
parents:
diff changeset
459 */*) mkdir_p="\$(top_builddir)/$mkdir_p" ;;
kono
parents:
diff changeset
460 esac
kono
parents:
diff changeset
461 ])
kono
parents:
diff changeset
462
kono
parents:
diff changeset
463 # Helper functions for option handling. -*- Autoconf -*-
kono
parents:
diff changeset
464
kono
parents:
diff changeset
465 # Copyright (C) 2001, 2002, 2003, 2005, 2008, 2010 Free Software
kono
parents:
diff changeset
466 # Foundation, Inc.
kono
parents:
diff changeset
467 #
kono
parents:
diff changeset
468 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
469 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
470 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
471
kono
parents:
diff changeset
472 # serial 5
kono
parents:
diff changeset
473
kono
parents:
diff changeset
474 # _AM_MANGLE_OPTION(NAME)
kono
parents:
diff changeset
475 # -----------------------
kono
parents:
diff changeset
476 AC_DEFUN([_AM_MANGLE_OPTION],
kono
parents:
diff changeset
477 [[_AM_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])])
kono
parents:
diff changeset
478
kono
parents:
diff changeset
479 # _AM_SET_OPTION(NAME)
kono
parents:
diff changeset
480 # --------------------
kono
parents:
diff changeset
481 # Set option NAME. Presently that only means defining a flag for this option.
kono
parents:
diff changeset
482 AC_DEFUN([_AM_SET_OPTION],
kono
parents:
diff changeset
483 [m4_define(_AM_MANGLE_OPTION([$1]), 1)])
kono
parents:
diff changeset
484
kono
parents:
diff changeset
485 # _AM_SET_OPTIONS(OPTIONS)
kono
parents:
diff changeset
486 # ------------------------
kono
parents:
diff changeset
487 # OPTIONS is a space-separated list of Automake options.
kono
parents:
diff changeset
488 AC_DEFUN([_AM_SET_OPTIONS],
kono
parents:
diff changeset
489 [m4_foreach_w([_AM_Option], [$1], [_AM_SET_OPTION(_AM_Option)])])
kono
parents:
diff changeset
490
kono
parents:
diff changeset
491 # _AM_IF_OPTION(OPTION, IF-SET, [IF-NOT-SET])
kono
parents:
diff changeset
492 # -------------------------------------------
kono
parents:
diff changeset
493 # Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
kono
parents:
diff changeset
494 AC_DEFUN([_AM_IF_OPTION],
kono
parents:
diff changeset
495 [m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])])
kono
parents:
diff changeset
496
kono
parents:
diff changeset
497 # Check to make sure that the build environment is sane. -*- Autoconf -*-
kono
parents:
diff changeset
498
kono
parents:
diff changeset
499 # Copyright (C) 1996, 1997, 2000, 2001, 2003, 2005, 2008
kono
parents:
diff changeset
500 # Free Software Foundation, Inc.
kono
parents:
diff changeset
501 #
kono
parents:
diff changeset
502 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
503 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
504 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
505
kono
parents:
diff changeset
506 # serial 5
kono
parents:
diff changeset
507
kono
parents:
diff changeset
508 # AM_SANITY_CHECK
kono
parents:
diff changeset
509 # ---------------
kono
parents:
diff changeset
510 AC_DEFUN([AM_SANITY_CHECK],
kono
parents:
diff changeset
511 [AC_MSG_CHECKING([whether build environment is sane])
kono
parents:
diff changeset
512 # Just in case
kono
parents:
diff changeset
513 sleep 1
kono
parents:
diff changeset
514 echo timestamp > conftest.file
kono
parents:
diff changeset
515 # Reject unsafe characters in $srcdir or the absolute working directory
kono
parents:
diff changeset
516 # name. Accept space and tab only in the latter.
kono
parents:
diff changeset
517 am_lf='
kono
parents:
diff changeset
518 '
kono
parents:
diff changeset
519 case `pwd` in
kono
parents:
diff changeset
520 *[[\\\"\#\$\&\'\`$am_lf]]*)
kono
parents:
diff changeset
521 AC_MSG_ERROR([unsafe absolute working directory name]);;
kono
parents:
diff changeset
522 esac
kono
parents:
diff changeset
523 case $srcdir in
kono
parents:
diff changeset
524 *[[\\\"\#\$\&\'\`$am_lf\ \ ]]*)
kono
parents:
diff changeset
525 AC_MSG_ERROR([unsafe srcdir value: `$srcdir']);;
kono
parents:
diff changeset
526 esac
kono
parents:
diff changeset
527
kono
parents:
diff changeset
528 # Do `set' in a subshell so we don't clobber the current shell's
kono
parents:
diff changeset
529 # arguments. Must try -L first in case configure is actually a
kono
parents:
diff changeset
530 # symlink; some systems play weird games with the mod time of symlinks
kono
parents:
diff changeset
531 # (eg FreeBSD returns the mod time of the symlink's containing
kono
parents:
diff changeset
532 # directory).
kono
parents:
diff changeset
533 if (
kono
parents:
diff changeset
534 set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
kono
parents:
diff changeset
535 if test "$[*]" = "X"; then
kono
parents:
diff changeset
536 # -L didn't work.
kono
parents:
diff changeset
537 set X `ls -t "$srcdir/configure" conftest.file`
kono
parents:
diff changeset
538 fi
kono
parents:
diff changeset
539 rm -f conftest.file
kono
parents:
diff changeset
540 if test "$[*]" != "X $srcdir/configure conftest.file" \
kono
parents:
diff changeset
541 && test "$[*]" != "X conftest.file $srcdir/configure"; then
kono
parents:
diff changeset
542
kono
parents:
diff changeset
543 # If neither matched, then we have a broken ls. This can happen
kono
parents:
diff changeset
544 # if, for instance, CONFIG_SHELL is bash and it inherits a
kono
parents:
diff changeset
545 # broken ls alias from the environment. This has actually
kono
parents:
diff changeset
546 # happened. Such a system could not be considered "sane".
kono
parents:
diff changeset
547 AC_MSG_ERROR([ls -t appears to fail. Make sure there is not a broken
kono
parents:
diff changeset
548 alias in your environment])
kono
parents:
diff changeset
549 fi
kono
parents:
diff changeset
550
kono
parents:
diff changeset
551 test "$[2]" = conftest.file
kono
parents:
diff changeset
552 )
kono
parents:
diff changeset
553 then
kono
parents:
diff changeset
554 # Ok.
kono
parents:
diff changeset
555 :
kono
parents:
diff changeset
556 else
kono
parents:
diff changeset
557 AC_MSG_ERROR([newly created file is older than distributed files!
kono
parents:
diff changeset
558 Check your system clock])
kono
parents:
diff changeset
559 fi
kono
parents:
diff changeset
560 AC_MSG_RESULT(yes)])
kono
parents:
diff changeset
561
kono
parents:
diff changeset
562 # Copyright (C) 2001, 2003, 2005, 2011 Free Software Foundation, Inc.
kono
parents:
diff changeset
563 #
kono
parents:
diff changeset
564 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
565 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
566 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
567
kono
parents:
diff changeset
568 # serial 1
kono
parents:
diff changeset
569
kono
parents:
diff changeset
570 # AM_PROG_INSTALL_STRIP
kono
parents:
diff changeset
571 # ---------------------
kono
parents:
diff changeset
572 # One issue with vendor `install' (even GNU) is that you can't
kono
parents:
diff changeset
573 # specify the program used to strip binaries. This is especially
kono
parents:
diff changeset
574 # annoying in cross-compiling environments, where the build's strip
kono
parents:
diff changeset
575 # is unlikely to handle the host's binaries.
kono
parents:
diff changeset
576 # Fortunately install-sh will honor a STRIPPROG variable, so we
kono
parents:
diff changeset
577 # always use install-sh in `make install-strip', and initialize
kono
parents:
diff changeset
578 # STRIPPROG with the value of the STRIP variable (set by the user).
kono
parents:
diff changeset
579 AC_DEFUN([AM_PROG_INSTALL_STRIP],
kono
parents:
diff changeset
580 [AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
kono
parents:
diff changeset
581 # Installed binaries are usually stripped using `strip' when the user
kono
parents:
diff changeset
582 # run `make install-strip'. However `strip' might not be the right
kono
parents:
diff changeset
583 # tool to use in cross-compilation environments, therefore Automake
kono
parents:
diff changeset
584 # will honor the `STRIP' environment variable to overrule this program.
kono
parents:
diff changeset
585 dnl Don't test for $cross_compiling = yes, because it might be `maybe'.
kono
parents:
diff changeset
586 if test "$cross_compiling" != no; then
kono
parents:
diff changeset
587 AC_CHECK_TOOL([STRIP], [strip], :)
kono
parents:
diff changeset
588 fi
kono
parents:
diff changeset
589 INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
kono
parents:
diff changeset
590 AC_SUBST([INSTALL_STRIP_PROGRAM])])
kono
parents:
diff changeset
591
kono
parents:
diff changeset
592 # Copyright (C) 2006, 2008, 2010 Free Software Foundation, Inc.
kono
parents:
diff changeset
593 #
kono
parents:
diff changeset
594 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
595 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
596 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
597
kono
parents:
diff changeset
598 # serial 3
kono
parents:
diff changeset
599
kono
parents:
diff changeset
600 # _AM_SUBST_NOTMAKE(VARIABLE)
kono
parents:
diff changeset
601 # ---------------------------
kono
parents:
diff changeset
602 # Prevent Automake from outputting VARIABLE = @VARIABLE@ in Makefile.in.
kono
parents:
diff changeset
603 # This macro is traced by Automake.
kono
parents:
diff changeset
604 AC_DEFUN([_AM_SUBST_NOTMAKE])
kono
parents:
diff changeset
605
kono
parents:
diff changeset
606 # AM_SUBST_NOTMAKE(VARIABLE)
kono
parents:
diff changeset
607 # --------------------------
kono
parents:
diff changeset
608 # Public sister of _AM_SUBST_NOTMAKE.
kono
parents:
diff changeset
609 AC_DEFUN([AM_SUBST_NOTMAKE], [_AM_SUBST_NOTMAKE($@)])
kono
parents:
diff changeset
610
kono
parents:
diff changeset
611 # Check how to create a tarball. -*- Autoconf -*-
kono
parents:
diff changeset
612
kono
parents:
diff changeset
613 # Copyright (C) 2004, 2005, 2012 Free Software Foundation, Inc.
kono
parents:
diff changeset
614 #
kono
parents:
diff changeset
615 # This file is free software; the Free Software Foundation
kono
parents:
diff changeset
616 # gives unlimited permission to copy and/or distribute it,
kono
parents:
diff changeset
617 # with or without modifications, as long as this notice is preserved.
kono
parents:
diff changeset
618
kono
parents:
diff changeset
619 # serial 2
kono
parents:
diff changeset
620
kono
parents:
diff changeset
621 # _AM_PROG_TAR(FORMAT)
kono
parents:
diff changeset
622 # --------------------
kono
parents:
diff changeset
623 # Check how to create a tarball in format FORMAT.
kono
parents:
diff changeset
624 # FORMAT should be one of `v7', `ustar', or `pax'.
kono
parents:
diff changeset
625 #
kono
parents:
diff changeset
626 # Substitute a variable $(am__tar) that is a command
kono
parents:
diff changeset
627 # writing to stdout a FORMAT-tarball containing the directory
kono
parents:
diff changeset
628 # $tardir.
kono
parents:
diff changeset
629 # tardir=directory && $(am__tar) > result.tar
kono
parents:
diff changeset
630 #
kono
parents:
diff changeset
631 # Substitute a variable $(am__untar) that extract such
kono
parents:
diff changeset
632 # a tarball read from stdin.
kono
parents:
diff changeset
633 # $(am__untar) < result.tar
kono
parents:
diff changeset
634 AC_DEFUN([_AM_PROG_TAR],
kono
parents:
diff changeset
635 [# Always define AMTAR for backward compatibility. Yes, it's still used
kono
parents:
diff changeset
636 # in the wild :-( We should find a proper way to deprecate it ...
kono
parents:
diff changeset
637 AC_SUBST([AMTAR], ['$${TAR-tar}'])
kono
parents:
diff changeset
638 m4_if([$1], [v7],
kono
parents:
diff changeset
639 [am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'],
kono
parents:
diff changeset
640 [m4_case([$1], [ustar],, [pax],,
kono
parents:
diff changeset
641 [m4_fatal([Unknown tar format])])
kono
parents:
diff changeset
642 AC_MSG_CHECKING([how to create a $1 tar archive])
kono
parents:
diff changeset
643 # Loop over all known methods to create a tar archive until one works.
kono
parents:
diff changeset
644 _am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none'
kono
parents:
diff changeset
645 _am_tools=${am_cv_prog_tar_$1-$_am_tools}
kono
parents:
diff changeset
646 # Do not fold the above two line into one, because Tru64 sh and
kono
parents:
diff changeset
647 # Solaris sh will not grok spaces in the rhs of `-'.
kono
parents:
diff changeset
648 for _am_tool in $_am_tools
kono
parents:
diff changeset
649 do
kono
parents:
diff changeset
650 case $_am_tool in
kono
parents:
diff changeset
651 gnutar)
kono
parents:
diff changeset
652 for _am_tar in tar gnutar gtar;
kono
parents:
diff changeset
653 do
kono
parents:
diff changeset
654 AM_RUN_LOG([$_am_tar --version]) && break
kono
parents:
diff changeset
655 done
kono
parents:
diff changeset
656 am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"'
kono
parents:
diff changeset
657 am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"'
kono
parents:
diff changeset
658 am__untar="$_am_tar -xf -"
kono
parents:
diff changeset
659 ;;
kono
parents:
diff changeset
660 plaintar)
kono
parents:
diff changeset
661 # Must skip GNU tar: if it does not support --format= it doesn't create
kono
parents:
diff changeset
662 # ustar tarball either.
kono
parents:
diff changeset
663 (tar --version) >/dev/null 2>&1 && continue
kono
parents:
diff changeset
664 am__tar='tar chf - "$$tardir"'
kono
parents:
diff changeset
665 am__tar_='tar chf - "$tardir"'
kono
parents:
diff changeset
666 am__untar='tar xf -'
kono
parents:
diff changeset
667 ;;
kono
parents:
diff changeset
668 pax)
kono
parents:
diff changeset
669 am__tar='pax -L -x $1 -w "$$tardir"'
kono
parents:
diff changeset
670 am__tar_='pax -L -x $1 -w "$tardir"'
kono
parents:
diff changeset
671 am__untar='pax -r'
kono
parents:
diff changeset
672 ;;
kono
parents:
diff changeset
673 cpio)
kono
parents:
diff changeset
674 am__tar='find "$$tardir" -print | cpio -o -H $1 -L'
kono
parents:
diff changeset
675 am__tar_='find "$tardir" -print | cpio -o -H $1 -L'
kono
parents:
diff changeset
676 am__untar='cpio -i -H $1 -d'
kono
parents:
diff changeset
677 ;;
kono
parents:
diff changeset
678 none)
kono
parents:
diff changeset
679 am__tar=false
kono
parents:
diff changeset
680 am__tar_=false
kono
parents:
diff changeset
681 am__untar=false
kono
parents:
diff changeset
682 ;;
kono
parents:
diff changeset
683 esac
kono
parents:
diff changeset
684
kono
parents:
diff changeset
685 # If the value was cached, stop now. We just wanted to have am__tar
kono
parents:
diff changeset
686 # and am__untar set.
kono
parents:
diff changeset
687 test -n "${am_cv_prog_tar_$1}" && break
kono
parents:
diff changeset
688
kono
parents:
diff changeset
689 # tar/untar a dummy directory, and stop if the command works
kono
parents:
diff changeset
690 rm -rf conftest.dir
kono
parents:
diff changeset
691 mkdir conftest.dir
kono
parents:
diff changeset
692 echo GrepMe > conftest.dir/file
kono
parents:
diff changeset
693 AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar])
kono
parents:
diff changeset
694 rm -rf conftest.dir
kono
parents:
diff changeset
695 if test -s conftest.tar; then
kono
parents:
diff changeset
696 AM_RUN_LOG([$am__untar <conftest.tar])
kono
parents:
diff changeset
697 grep GrepMe conftest.dir/file >/dev/null 2>&1 && break
kono
parents:
diff changeset
698 fi
kono
parents:
diff changeset
699 done
kono
parents:
diff changeset
700 rm -rf conftest.dir
kono
parents:
diff changeset
701
kono
parents:
diff changeset
702 AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool])
kono
parents:
diff changeset
703 AC_MSG_RESULT([$am_cv_prog_tar_$1])])
kono
parents:
diff changeset
704 AC_SUBST([am__tar])
kono
parents:
diff changeset
705 AC_SUBST([am__untar])
kono
parents:
diff changeset
706 ]) # _AM_PROG_TAR
kono
parents:
diff changeset
707
kono
parents:
diff changeset
708 m4_include([../config/acx.m4])
kono
parents:
diff changeset
709 m4_include([../config/lead-dot.m4])
kono
parents:
diff changeset
710 m4_include([../config/multi.m4])
kono
parents:
diff changeset
711 m4_include([../config/override.m4])
kono
parents:
diff changeset
712 m4_include([../ltoptions.m4])
kono
parents:
diff changeset
713 m4_include([../ltsugar.m4])
kono
parents:
diff changeset
714 m4_include([../ltversion.m4])
kono
parents:
diff changeset
715 m4_include([../lt~obsolete.m4])
kono
parents:
diff changeset
716 m4_include([acinclude.m4])