ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/svn/ircd-hybrid/branches/8.2.x/aclocal.m4

Comparing:
ircd-hybrid-7.3/aclocal.m4 (file contents), Revision 1084 by michael, Sat Mar 13 23:24:10 2010 UTC vs.
ircd-hybrid/branches/8.2.x/aclocal.m4 (file contents), Revision 7107 by michael, Sat Jan 23 20:17:49 2016 UTC

#	Line 1 | Line 1
1	<	# generated automatically by aclocal 1.11.1 -*- Autoconf -*-
1	>	# generated automatically by aclocal 1.15 -*- Autoconf -*-
2	>
3	>	# Copyright (C) 1996-2014 Free Software Foundation, Inc.
4
3	–	# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
4	–	# 2005, 2006, 2007, 2008, 2009  Free Software Foundation, Inc.
5		# This file is free software; the Free Software Foundation
6		# gives unlimited permission to copy and/or distribute it,
7		# with or without modifications, as long as this notice is preserved.
#	Line 11 | Line 11
11		# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
12		# PARTICULAR PURPOSE.
13
14	+	m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])])
15		m4_ifndef([AC_AUTOCONF_VERSION],
16		[m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
17	<	m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.65],,
18	<	[m4_warning([this file was generated for autoconf 2.65.
17	>	m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.69],,
18	>	[m4_warning([this file was generated for autoconf 2.69.
19		You have another version of autoconf.  It may work, but is not guaranteed to.
20		If you have problems, you may need to regenerate the build system entirely.
21	<	To do so, use the procedure documented by the package, typically `autoreconf'.])])
21	<
22	<	# Portability macros for glibc argz.                    -*- Autoconf -*-
23	<	#
24	<	#   Copyright (C) 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
25	<	#   Written by Gary V. Vaughan <gary@gnu.org>
26	<	#
27	<	# This file is free software; the Free Software Foundation gives
28	<	# unlimited permission to copy and/or distribute it, with or without
29	<	# modifications, as long as this notice is preserved.
30	<
31	<	# serial 5 argz.m4
32	<
33	<	AC_DEFUN([gl_FUNC_ARGZ],
34	<	[gl_PREREQ_ARGZ
35	<
36	<	AC_CHECK_HEADERS([argz.h], [], [], [AC_INCLUDES_DEFAULT])
37	<
38	<	AC_CHECK_TYPES([error_t],
39	<	[],
40	<	[AC_DEFINE([error_t], [int],
41	<	[Define to a type to use for `error_t' if it is not otherwise available.])
42	<	AC_DEFINE([__error_t_defined], [1], [Define so that glibc/gnulib argp.h
43	<	does not typedef error_t.])],
44	<	[#if defined(HAVE_ARGZ_H)
45	<	#  include <argz.h>
46	<	#endif])
47	<
48	<	ARGZ_H=
49	<	AC_CHECK_FUNCS([argz_add argz_append argz_count argz_create_sep argz_insert \
50	<	argz_next argz_stringify], [], [ARGZ_H=argz.h; AC_LIBOBJ([argz])])
51	<
52	<	dnl if have system argz functions, allow forced use of
53	<	dnl libltdl-supplied implementation (and default to do so
54	<	dnl on "known bad" systems). Could use a runtime check, but
55	<	dnl (a) detecting malloc issues is notoriously unreliable
56	<	dnl (b) only known system that declares argz functions,
57	<	dnl     provides them, yet they are broken, is cygwin
58	<	dnl     releases prior to 16-Mar-2007 (1.5.24 and earlier)
59	<	dnl So, it's more straightforward simply to special case
60	<	dnl this for known bad systems.
61	<	AS_IF([test -z "$ARGZ_H"],
62	<	[AC_CACHE_CHECK(
63	<	[if argz actually works],
64	<	[lt_cv_sys_argz_works],
65	<	[[case $host_os in #(
66	<	*cygwin*)
67	<	lt_cv_sys_argz_works=no
68	<	if test "$cross_compiling" != no; then
69	<	lt_cv_sys_argz_works="guessing no"
70	<	else
71	<	lt_sed_extract_leading_digits='s/^\([0-9\.]*\).*/\1/'
72	<	save_IFS=$IFS
73	<	IFS=-.
74	<	set x `uname -r | sed -e "$lt_sed_extract_leading_digits"`
75	<	IFS=$save_IFS
76	<	lt_os_major=${2-0}
77	<	lt_os_minor=${3-0}
78	<	lt_os_micro=${4-0}
79	<	if test "$lt_os_major" -gt 1 \
80	<	|| { test "$lt_os_major" -eq 1 \
81	<	&& { test "$lt_os_minor" -gt 5 \
82	<	|| { test "$lt_os_minor" -eq 5 \
83	<	&& test "$lt_os_micro" -gt 24; }; }; }; then
84	<	lt_cv_sys_argz_works=yes
85	<	fi
86	<	fi
87	<	;; #(
88	<	*) lt_cv_sys_argz_works=yes ;;
89	<	esac]])
90	<	AS_IF([test $lt_cv_sys_argz_works = yes],
91	<	[AC_DEFINE([HAVE_WORKING_ARGZ], 1,
92	<	[This value is set to 1 to indicate that the system argz facility works])],
93	<	[ARGZ_H=argz.h
94	<	AC_LIBOBJ([argz])])])
95	<
96	<	AC_SUBST([ARGZ_H])
97	<	])
98	<
99	<	# Prerequisites of lib/argz.c.
100	<	AC_DEFUN([gl_PREREQ_ARGZ], [:])
101	<
102	<	# libtool.m4 - Configure libtool for the host system. -*-Autoconf-*-
103	<	#
104	<	#   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,
105	<	#                 2006, 2007, 2008 Free Software Foundation, Inc.
106	<	#   Written by Gordon Matzigkeit, 1996
107	<	#
108	<	# This file is free software; the Free Software Foundation gives
109	<	# unlimited permission to copy and/or distribute it, with or without
110	<	# modifications, as long as this notice is preserved.
111	<
112	<	m4_define([_LT_COPYING], [dnl
113	<	#   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,
114	<	#                 2006, 2007, 2008 Free Software Foundation, Inc.
115	<	#   Written by Gordon Matzigkeit, 1996
116	<	#
117	<	#   This file is part of GNU Libtool.
118	<	#
119	<	# GNU Libtool is free software; you can redistribute it and/or
120	<	# modify it under the terms of the GNU General Public License as
121	<	# published by the Free Software Foundation; either version 2 of
122	<	# the License, or (at your option) any later version.
123	<	#
124	<	# As a special exception to the GNU General Public License,
125	<	# if you distribute this file as part of a program or library that
126	<	# is built using GNU Libtool, you may include this file under the
127	<	# same distribution terms that you use for the rest of that program.
128	<	#
129	<	# GNU Libtool is distributed in the hope that it will be useful,
130	<	# but WITHOUT ANY WARRANTY; without even the implied warranty of
131	<	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
132	<	# GNU General Public License for more details.
133	<	#
134	<	# You should have received a copy of the GNU General Public License
135	<	# along with GNU Libtool; see the file COPYING.  If not, a copy
136	<	# can be downloaded from http://www.gnu.org/licenses/gpl.html, or
137	<	# obtained by writing to the Free Software Foundation, Inc.,
138	<	# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
139	<	])
140	<
141	<	# serial 56 LT_INIT
142	<
143	<
144	<	# LT_PREREQ(VERSION)
145	<	# ------------------
146	<	# Complain and exit if this libtool version is less that VERSION.
147	<	m4_defun([LT_PREREQ],
148	<	[m4_if(m4_version_compare(m4_defn([LT_PACKAGE_VERSION]), [$1]), -1,
149	<	[m4_default([$3],
150	<	[m4_fatal([Libtool version $1 or higher is required],
151	<	63)])],
152	<	[$2])])
153	<
154	<
155	<	# _LT_CHECK_BUILDDIR
156	<	# ------------------
157	<	# Complain if the absolute build directory name contains unusual characters
158	<	m4_defun([_LT_CHECK_BUILDDIR],
159	<	[case `pwd` in
160	<	*\ * | *\     *)
161	<	AC_MSG_WARN([Libtool does not cope well with whitespace in `pwd`]) ;;
162	<	esac
163	<	])
164	<
165	<
166	<	# LT_INIT([OPTIONS])
167	<	# ------------------
168	<	AC_DEFUN([LT_INIT],
169	<	[AC_PREREQ([2.58])dnl We use AC_INCLUDES_DEFAULT
170	<	AC_BEFORE([$0], [LT_LANG])dnl
171	<	AC_BEFORE([$0], [LT_OUTPUT])dnl
172	<	AC_BEFORE([$0], [LTDL_INIT])dnl
173	<	m4_require([_LT_CHECK_BUILDDIR])dnl
174	<
175	<	dnl Autoconf doesn't catch unexpanded LT_ macros by default:
176	<	m4_pattern_forbid([^_?LT_[A-Z_]+$])dnl
177	<	m4_pattern_allow([^(_LT_EOF|LT_DLGLOBAL|LT_DLLAZY_OR_NOW|LT_MULTI_MODULE)$])dnl
178	<	dnl aclocal doesn't pull ltoptions.m4, ltsugar.m4, or ltversion.m4
179	<	dnl unless we require an AC_DEFUNed macro:
180	<	AC_REQUIRE([LTOPTIONS_VERSION])dnl
181	<	AC_REQUIRE([LTSUGAR_VERSION])dnl
182	<	AC_REQUIRE([LTVERSION_VERSION])dnl
183	<	AC_REQUIRE([LTOBSOLETE_VERSION])dnl
184	<	m4_require([_LT_PROG_LTMAIN])dnl
185	<
186	<	dnl Parse OPTIONS
187	<	_LT_SET_OPTIONS([$0], [$1])
188	<
189	<	# This can be used to rebuild libtool when needed
190	<	LIBTOOL_DEPS="$ltmain"
191	<
192	<	# Always use our own libtool.
193	<	LIBTOOL='$(SHELL) $(top_builddir)/libtool'
194	<	AC_SUBST(LIBTOOL)dnl
195	<
196	<	_LT_SETUP
197	<
198	<	# Only expand once:
199	<	m4_define([LT_INIT])
200	<	])# LT_INIT
201	<
202	<	# Old names:
203	<	AU_ALIAS([AC_PROG_LIBTOOL], [LT_INIT])
204	<	AU_ALIAS([AM_PROG_LIBTOOL], [LT_INIT])
205	<	dnl aclocal-1.4 backwards compatibility:
206	<	dnl AC_DEFUN([AC_PROG_LIBTOOL], [])
207	<	dnl AC_DEFUN([AM_PROG_LIBTOOL], [])
208	<
209	<
210	<	# _LT_CC_BASENAME(CC)
211	<	# -------------------
212	<	# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
213	<	m4_defun([_LT_CC_BASENAME],
214	<	[for cc_temp in $1""; do
215	<	case $cc_temp in
216	<	compile | *[[\\/]]compile | ccache | *[[\\/]]ccache ) ;;
217	<	distcc | *[[\\/]]distcc | purify | *[[\\/]]purify ) ;;
218	<	\-*) ;;
219	<	*) break;;
220	<	esac
221	<	done
222	<	cc_basename=`$ECHO "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`
223	<	])
224	<
225	<
226	<	# _LT_FILEUTILS_DEFAULTS
227	<	# ----------------------
228	<	# It is okay to use these file commands and assume they have been set
229	<	# sensibly after `m4_require([_LT_FILEUTILS_DEFAULTS])'.
230	<	m4_defun([_LT_FILEUTILS_DEFAULTS],
231	<	[: ${CP="cp -f"}
232	<	: ${MV="mv -f"}
233	<	: ${RM="rm -f"}
234	<	])# _LT_FILEUTILS_DEFAULTS
235	<
236	<
237	<	# _LT_SETUP
238	<	# ---------
239	<	m4_defun([_LT_SETUP],
240	<	[AC_REQUIRE([AC_CANONICAL_HOST])dnl
241	<	AC_REQUIRE([AC_CANONICAL_BUILD])dnl
242	<	_LT_DECL([], [host_alias], [0], [The host system])dnl
243	<	_LT_DECL([], [host], [0])dnl
244	<	_LT_DECL([], [host_os], [0])dnl
245	<	dnl
246	<	_LT_DECL([], [build_alias], [0], [The build system])dnl
247	<	_LT_DECL([], [build], [0])dnl
248	<	_LT_DECL([], [build_os], [0])dnl
249	<	dnl
250	<	AC_REQUIRE([AC_PROG_CC])dnl
251	<	AC_REQUIRE([LT_PATH_LD])dnl
252	<	AC_REQUIRE([LT_PATH_NM])dnl
253	<	dnl
254	<	AC_REQUIRE([AC_PROG_LN_S])dnl
255	<	test -z "$LN_S" && LN_S="ln -s"
256	<	_LT_DECL([], [LN_S], [1], [Whether we need soft or hard links])dnl
257	<	dnl
258	<	AC_REQUIRE([LT_CMD_MAX_LEN])dnl
259	<	_LT_DECL([objext], [ac_objext], [0], [Object file suffix (normally "o")])dnl
260	<	_LT_DECL([], [exeext], [0], [Executable file suffix (normally "")])dnl
261	<	dnl
262	<	m4_require([_LT_FILEUTILS_DEFAULTS])dnl
263	<	m4_require([_LT_CHECK_SHELL_FEATURES])dnl
264	<	m4_require([_LT_CMD_RELOAD])dnl
265	<	m4_require([_LT_CHECK_MAGIC_METHOD])dnl
266	<	m4_require([_LT_CMD_OLD_ARCHIVE])dnl
267	<	m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl
268	<
269	<	_LT_CONFIG_LIBTOOL_INIT([
270	<	# See if we are running on zsh, and set the options which allow our
271	<	# commands through without removal of \ escapes INIT.
272	<	if test -n "\${ZSH_VERSION+set}" ; then
273	<	setopt NO_GLOB_SUBST
274	<	fi
275	<	])
276	<	if test -n "${ZSH_VERSION+set}" ; then
277	<	setopt NO_GLOB_SUBST
278	<	fi
279	<
280	<	_LT_CHECK_OBJDIR
281	<
282	<	m4_require([_LT_TAG_COMPILER])dnl
283	<	_LT_PROG_ECHO_BACKSLASH
284	<
285	<	case $host_os in
286	<	aix3*)
287	<	# AIX sometimes has problems with the GCC collect2 program.  For some
288	<	# reason, if we set the COLLECT_NAMES environment variable, the problems
289	<	# vanish in a puff of smoke.
290	<	if test "X${COLLECT_NAMES+set}" != Xset; then
291	<	COLLECT_NAMES=
292	<	export COLLECT_NAMES
293	<	fi
294	<	;;
295	<	esac
296	<
297	<	# Sed substitution that helps us do robust quoting.  It backslashifies
298	<	# metacharacters that are still active within double-quoted strings.
299	<	sed_quote_subst='s/\([["`$\\]]\)/\\\1/g'
300	<
301	<	# Same as above, but do not quote variable references.
302	<	double_quote_subst='s/\([["`\\]]\)/\\\1/g'
303	<
304	<	# Sed substitution to delay expansion of an escaped shell variable in a
305	<	# double_quote_subst'ed string.
306	<	delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
307	<
308	<	# Sed substitution to delay expansion of an escaped single quote.
309	<	delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g'
310	<
311	<	# Sed substitution to avoid accidental globbing in evaled expressions
312	<	no_glob_subst='s/\*/\\\*/g'
313	<
314	<	# Global variables:
315	<	ofile=libtool
316	<	can_build_shared=yes
317	<
318	<	# All known linkers require a `.a' archive for static linking (except MSVC,
319	<	# which needs '.lib').
320	<	libext=a
321	<
322	<	with_gnu_ld="$lt_cv_prog_gnu_ld"
323	<
324	<	old_CC="$CC"
325	<	old_CFLAGS="$CFLAGS"
326	<
327	<	# Set sane defaults for various variables
328	<	test -z "$CC" && CC=cc
329	<	test -z "$LTCC" && LTCC=$CC
330	<	test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
331	<	test -z "$LD" && LD=ld
332	<	test -z "$ac_objext" && ac_objext=o
333	<
334	<	_LT_CC_BASENAME([$compiler])
335	<
336	<	# Only perform the check for file, if the check method requires it
337	<	test -z "$MAGIC_CMD" && MAGIC_CMD=file
338	<	case $deplibs_check_method in
339	<	file_magic*)
340	<	if test "$file_magic_cmd" = '$MAGIC_CMD'; then
341	<	_LT_PATH_MAGIC
342	<	fi
343	<	;;
344	<	esac
345	<
346	<	# Use C for the default configuration in the libtool script
347	<	LT_SUPPORTED_TAG([CC])
348	<	_LT_LANG_C_CONFIG
349	<	_LT_LANG_DEFAULT_CONFIG
350	<	_LT_CONFIG_COMMANDS
351	<	])# _LT_SETUP
352	<
353	<
354	<	# _LT_PROG_LTMAIN
355	<	# ---------------
356	<	# Note that this code is called both from `configure', and `config.status'
357	<	# now that we use AC_CONFIG_COMMANDS to generate libtool.  Notably,
358	<	# `config.status' has no value for ac_aux_dir unless we are using Automake,
359	<	# so we pass a copy along to make sure it has a sensible value anyway.
360	<	m4_defun([_LT_PROG_LTMAIN],
361	<	[m4_ifdef([AC_REQUIRE_AUX_FILE], [AC_REQUIRE_AUX_FILE([ltmain.sh])])dnl
362	<	_LT_CONFIG_LIBTOOL_INIT([ac_aux_dir='$ac_aux_dir'])
363	<	ltmain="$ac_aux_dir/ltmain.sh"
364	<	])# _LT_PROG_LTMAIN
365	<
366	<
367	<
368	<	# So that we can recreate a full libtool script including additional
369	<	# tags, we accumulate the chunks of code to send to AC_CONFIG_COMMANDS
370	<	# in macros and then make a single call at the end using the `libtool'
371	<	# label.
372	<
373	<
374	<	# _LT_CONFIG_LIBTOOL_INIT([INIT-COMMANDS])
375	<	# ----------------------------------------
376	<	# Register INIT-COMMANDS to be passed to AC_CONFIG_COMMANDS later.
377	<	m4_define([_LT_CONFIG_LIBTOOL_INIT],
378	<	[m4_ifval([$1],
379	<	[m4_append([_LT_OUTPUT_LIBTOOL_INIT],
380	<	[$1
381	<	])])])
382	<
383	<	# Initialize.
384	<	m4_define([_LT_OUTPUT_LIBTOOL_INIT])
385	<
386	<
387	<	# _LT_CONFIG_LIBTOOL([COMMANDS])
388	<	# ------------------------------
389	<	# Register COMMANDS to be passed to AC_CONFIG_COMMANDS later.
390	<	m4_define([_LT_CONFIG_LIBTOOL],
391	<	[m4_ifval([$1],
392	<	[m4_append([_LT_OUTPUT_LIBTOOL_COMMANDS],
393	<	[$1
394	<	])])])
395	<
396	<	# Initialize.
397	<	m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS])
398	<
399	<
400	<	# _LT_CONFIG_SAVE_COMMANDS([COMMANDS], [INIT_COMMANDS])
401	<	# -----------------------------------------------------
402	<	m4_defun([_LT_CONFIG_SAVE_COMMANDS],
403	<	[_LT_CONFIG_LIBTOOL([$1])
404	<	_LT_CONFIG_LIBTOOL_INIT([$2])
405	<	])
406	<
407	<
408	<	# _LT_FORMAT_COMMENT([COMMENT])
409	<	# -----------------------------
410	<	# Add leading comment marks to the start of each line, and a trailing
411	<	# full-stop to the whole comment if one is not present already.
412	<	m4_define([_LT_FORMAT_COMMENT],
413	<	[m4_ifval([$1], [
414	<	m4_bpatsubst([m4_bpatsubst([$1], [^ *], [# ])],
415	<	[['`$\]], [\\\&])]m4_bmatch([$1], [[!?.]$], [], [.])
416	<	)])
417	<
418	<
419	<
420	<
421	<
422	<	# _LT_DECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION], [IS-TAGGED?])
423	<	# -------------------------------------------------------------------
424	<	# CONFIGNAME is the name given to the value in the libtool script.
425	<	# VARNAME is the (base) name used in the configure script.
426	<	# VALUE may be 0, 1 or 2 for a computed quote escaped value based on
427	<	# VARNAME.  Any other value will be used directly.
428	<	m4_define([_LT_DECL],
429	<	[lt_if_append_uniq([lt_decl_varnames], [$2], [, ],
430	<	[lt_dict_add_subkey([lt_decl_dict], [$2], [libtool_name],
431	<	[m4_ifval([$1], [$1], [$2])])
432	<	lt_dict_add_subkey([lt_decl_dict], [$2], [value], [$3])
433	<	m4_ifval([$4],
434	<	[lt_dict_add_subkey([lt_decl_dict], [$2], [description], [$4])])
435	<	lt_dict_add_subkey([lt_decl_dict], [$2],
436	<	[tagged?], [m4_ifval([$5], [yes], [no])])])
437	<	])
438	<
439	<
440	<	# _LT_TAGDECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION])
441	<	# --------------------------------------------------------
442	<	m4_define([_LT_TAGDECL], [_LT_DECL([$1], [$2], [$3], [$4], [yes])])
443	<
444	<
445	<	# lt_decl_tag_varnames([SEPARATOR], [VARNAME1...])
446	<	# ------------------------------------------------
447	<	m4_define([lt_decl_tag_varnames],
448	<	[_lt_decl_filter([tagged?], [yes], $@)])
449	<
450	<
451	<	# _lt_decl_filter(SUBKEY, VALUE, [SEPARATOR], [VARNAME1..])
452	<	# ---------------------------------------------------------
453	<	m4_define([_lt_decl_filter],
454	<	[m4_case([$#],
455	<	[0], [m4_fatal([$0: too few arguments: $#])],
456	<	[1], [m4_fatal([$0: too few arguments: $#: $1])],
457	<	[2], [lt_dict_filter([lt_decl_dict], [$1], [$2], [], lt_decl_varnames)],
458	<	[3], [lt_dict_filter([lt_decl_dict], [$1], [$2], [$3], lt_decl_varnames)],
459	<	[lt_dict_filter([lt_decl_dict], $@)])[]dnl
460	<	])
461	<
462	<
463	<	# lt_decl_quote_varnames([SEPARATOR], [VARNAME1...])
464	<	# --------------------------------------------------
465	<	m4_define([lt_decl_quote_varnames],
466	<	[_lt_decl_filter([value], [1], $@)])
467	<
468	<
469	<	# lt_decl_dquote_varnames([SEPARATOR], [VARNAME1...])
470	<	# ---------------------------------------------------
471	<	m4_define([lt_decl_dquote_varnames],
472	<	[_lt_decl_filter([value], [2], $@)])
473	<
474	<
475	<	# lt_decl_varnames_tagged([SEPARATOR], [VARNAME1...])
476	<	# ---------------------------------------------------
477	<	m4_define([lt_decl_varnames_tagged],
478	<	[m4_assert([$# <= 2])dnl
479	<	_$0(m4_quote(m4_default([$1], [[, ]])),
480	<	m4_ifval([$2], [[$2]], [m4_dquote(lt_decl_tag_varnames)]),
481	<	m4_split(m4_normalize(m4_quote(_LT_TAGS)), [ ]))])
482	<	m4_define([_lt_decl_varnames_tagged],
483	<	[m4_ifval([$3], [lt_combine([$1], [$2], [_], $3)])])
484	<
485	<
486	<	# lt_decl_all_varnames([SEPARATOR], [VARNAME1...])
487	<	# ------------------------------------------------
488	<	m4_define([lt_decl_all_varnames],
489	<	[_$0(m4_quote(m4_default([$1], [[, ]])),
490	<	m4_if([$2], [],
491	<	m4_quote(lt_decl_varnames),
492	<	m4_quote(m4_shift($@))))[]dnl
493	<	])
494	<	m4_define([_lt_decl_all_varnames],
495	<	[lt_join($@, lt_decl_varnames_tagged([$1],
496	<	lt_decl_tag_varnames([[, ]], m4_shift($@))))dnl
497	<	])
498	<
499	<
500	<	# _LT_CONFIG_STATUS_DECLARE([VARNAME])
501	<	# ------------------------------------
502	<	# Quote a variable value, and forward it to `config.status' so that its
503	<	# declaration there will have the same value as in `configure'.  VARNAME
504	<	# must have a single quote delimited value for this to work.
505	<	m4_define([_LT_CONFIG_STATUS_DECLARE],
506	<	[$1='`$ECHO "X$][$1" | $Xsed -e "$delay_single_quote_subst"`'])
507	<
508	<
509	<	# _LT_CONFIG_STATUS_DECLARATIONS
510	<	# ------------------------------
511	<	# We delimit libtool config variables with single quotes, so when
512	<	# we write them to config.status, we have to be sure to quote all
513	<	# embedded single quotes properly.  In configure, this macro expands
514	<	# each variable declared with _LT_DECL (and _LT_TAGDECL) into:
515	<	#
516	<	#    <var>='`$ECHO "X$<var>" | $Xsed -e "$delay_single_quote_subst"`'
517	<	m4_defun([_LT_CONFIG_STATUS_DECLARATIONS],
518	<	[m4_foreach([_lt_var], m4_quote(lt_decl_all_varnames),
519	<	[m4_n([_LT_CONFIG_STATUS_DECLARE(_lt_var)])])])
520	<
521	<
522	<	# _LT_LIBTOOL_TAGS
523	<	# ----------------
524	<	# Output comment and list of tags supported by the script
525	<	m4_defun([_LT_LIBTOOL_TAGS],
526	<	[_LT_FORMAT_COMMENT([The names of the tagged configurations supported by this script])dnl
527	<	available_tags="_LT_TAGS"dnl
528	<	])
529	<
530	<
531	<	# _LT_LIBTOOL_DECLARE(VARNAME, [TAG])
532	<	# -----------------------------------
533	<	# Extract the dictionary values for VARNAME (optionally with TAG) and
534	<	# expand to a commented shell variable setting:
535	<	#
536	<	#    # Some comment about what VAR is for.
537	<	#    visible_name=$lt_internal_name
538	<	m4_define([_LT_LIBTOOL_DECLARE],
539	<	[_LT_FORMAT_COMMENT(m4_quote(lt_dict_fetch([lt_decl_dict], [$1],
540	<	[description])))[]dnl
541	<	m4_pushdef([_libtool_name],
542	<	m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [libtool_name])))[]dnl
543	<	m4_case(m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [value])),
544	<	[0], [_libtool_name=[$]$1],
545	<	[1], [_libtool_name=$lt_[]$1],
546	<	[2], [_libtool_name=$lt_[]$1],
547	<	[_libtool_name=lt_dict_fetch([lt_decl_dict], [$1], [value])])[]dnl
548	<	m4_ifval([$2], [_$2])[]m4_popdef([_libtool_name])[]dnl
549	<	])
550	<
551	<
552	<	# _LT_LIBTOOL_CONFIG_VARS
553	<	# -----------------------
554	<	# Produce commented declarations of non-tagged libtool config variables
555	<	# suitable for insertion in the LIBTOOL CONFIG section of the `libtool'
556	<	# script.  Tagged libtool config variables (even for the LIBTOOL CONFIG
557	<	# section) are produced by _LT_LIBTOOL_TAG_VARS.
558	<	m4_defun([_LT_LIBTOOL_CONFIG_VARS],
559	<	[m4_foreach([_lt_var],
560	<	m4_quote(_lt_decl_filter([tagged?], [no], [], lt_decl_varnames)),
561	<	[m4_n([_LT_LIBTOOL_DECLARE(_lt_var)])])])
562	<
563	<
564	<	# _LT_LIBTOOL_TAG_VARS(TAG)
565	<	# -------------------------
566	<	m4_define([_LT_LIBTOOL_TAG_VARS],
567	<	[m4_foreach([_lt_var], m4_quote(lt_decl_tag_varnames),
568	<	[m4_n([_LT_LIBTOOL_DECLARE(_lt_var, [$1])])])])
569	<
570	<
571	<	# _LT_TAGVAR(VARNAME, [TAGNAME])
572	<	# ------------------------------
573	<	m4_define([_LT_TAGVAR], [m4_ifval([$2], [$1_$2], [$1])])
574	<
575	<
576	<	# _LT_CONFIG_COMMANDS
577	<	# -------------------
578	<	# Send accumulated output to $CONFIG_STATUS.  Thanks to the lists of
579	<	# variables for single and double quote escaping we saved from calls
580	<	# to _LT_DECL, we can put quote escaped variables declarations
581	<	# into `config.status', and then the shell code to quote escape them in
582	<	# for loops in `config.status'.  Finally, any additional code accumulated
583	<	# from calls to _LT_CONFIG_LIBTOOL_INIT is expanded.
584	<	m4_defun([_LT_CONFIG_COMMANDS],
585	<	[AC_PROVIDE_IFELSE([LT_OUTPUT],
586	<	dnl If the libtool generation code has been placed in $CONFIG_LT,
587	<	dnl instead of duplicating it all over again into config.status,
588	<	dnl then we will have config.status run $CONFIG_LT later, so it
589	<	dnl needs to know what name is stored there:
590	<	[AC_CONFIG_COMMANDS([libtool],
591	<	[$SHELL $CONFIG_LT || AS_EXIT(1)], [CONFIG_LT='$CONFIG_LT'])],
592	<	dnl If the libtool generation code is destined for config.status,
593	<	dnl expand the accumulated commands and init code now:
594	<	[AC_CONFIG_COMMANDS([libtool],
595	<	[_LT_OUTPUT_LIBTOOL_COMMANDS], [_LT_OUTPUT_LIBTOOL_COMMANDS_INIT])])
596	<	])#_LT_CONFIG_COMMANDS
597	<
598	<
599	<	# Initialize.
600	<	m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS_INIT],
601	<	[
602	<
603	<	# The HP-UX ksh and POSIX shell print the target directory to stdout
604	<	# if CDPATH is set.
605	<	(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
606	<
607	<	sed_quote_subst='$sed_quote_subst'
608	<	double_quote_subst='$double_quote_subst'
609	<	delay_variable_subst='$delay_variable_subst'
610	<	_LT_CONFIG_STATUS_DECLARATIONS
611	<	LTCC='$LTCC'
612	<	LTCFLAGS='$LTCFLAGS'
613	<	compiler='$compiler_DEFAULT'
614	<
615	<	# Quote evaled strings.
616	<	for var in lt_decl_all_varnames([[ \
617	<	]], lt_decl_quote_varnames); do
618	<	case \`eval \\\\\$ECHO "X\\\\\$\$var"\` in
619	<	*[[\\\\\\\`\\"\\\$]]*)
620	<	eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"X\\\$\$var\\" | \\\$Xsed -e \\"\\\$sed_quote_subst\\"\\\`\\\\\\""
621	<	;;
622	<	*)
623	<	eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
624	<	;;
625	<	esac
626	<	done
627	<
628	<	# Double-quote double-evaled strings.
629	<	for var in lt_decl_all_varnames([[ \
630	<	]], lt_decl_dquote_varnames); do
631	<	case \`eval \\\\\$ECHO "X\\\\\$\$var"\` in
632	<	*[[\\\\\\\`\\"\\\$]]*)
633	<	eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"X\\\$\$var\\" | \\\$Xsed -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\""
634	<	;;
635	<	*)
636	<	eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
637	<	;;
638	<	esac
639	<	done
640	<
641	<	# Fix-up fallback echo if it was mangled by the above quoting rules.
642	<	case \$lt_ECHO in
643	<	*'\\\[$]0 --fallback-echo"')dnl "
644	<	lt_ECHO=\`\$ECHO "X\$lt_ECHO" | \$Xsed -e 's/\\\\\\\\\\\\\\\[$]0 --fallback-echo"\[$]/\[$]0 --fallback-echo"/'\`
645	<	;;
646	<	esac
647	<
648	<	_LT_OUTPUT_LIBTOOL_INIT
649	<	])
650	<
651	<
652	<	# LT_OUTPUT
653	<	# ---------
654	<	# This macro allows early generation of the libtool script (before
655	<	# AC_OUTPUT is called), incase it is used in configure for compilation
656	<	# tests.
657	<	AC_DEFUN([LT_OUTPUT],
658	<	[: ${CONFIG_LT=./config.lt}
659	<	AC_MSG_NOTICE([creating $CONFIG_LT])
660	<	cat >"$CONFIG_LT" <<_LTEOF
661	<	#! $SHELL
662	<	# Generated by $as_me.
663	<	# Run this file to recreate a libtool stub with the current configuration.
664	<
665	<	lt_cl_silent=false
666	<	SHELL=\${CONFIG_SHELL-$SHELL}
667	<	_LTEOF
668	<
669	<	cat >>"$CONFIG_LT" <<\_LTEOF
670	<	AS_SHELL_SANITIZE
671	<	_AS_PREPARE
672	<
673	<	exec AS_MESSAGE_FD>&1
674	<	exec AS_MESSAGE_LOG_FD>>config.log
675	<	{
676	<	echo
677	<	AS_BOX([Running $as_me.])
678	<	} >&AS_MESSAGE_LOG_FD
679	<
680	<	lt_cl_help="\
681	<	\`$as_me' creates a local libtool stub from the current configuration,
682	<	for use in further configure time tests before the real libtool is
683	<	generated.
684	<
685	<	Usage: $[0] [[OPTIONS]]
686	<
687	<	-h, --help      print this help, then exit
688	<	-V, --version   print version number, then exit
689	<	-q, --quiet     do not print progress messages
690	<	-d, --debug     don't remove temporary files
691	<
692	<	Report bugs to <bug-libtool@gnu.org>."
693	<
694	<	lt_cl_version="\
695	<	m4_ifset([AC_PACKAGE_NAME], [AC_PACKAGE_NAME ])config.lt[]dnl
696	<	m4_ifset([AC_PACKAGE_VERSION], [ AC_PACKAGE_VERSION])
697	<	configured by $[0], generated by m4_PACKAGE_STRING.
698	<
699	<	Copyright (C) 2008 Free Software Foundation, Inc.
700	<	This config.lt script is free software; the Free Software Foundation
701	<	gives unlimited permision to copy, distribute and modify it."
702	<
703	<	while test $[#] != 0
704	<	do
705	<	case $[1] in
706	<	--version | --v* | -V )
707	<	echo "$lt_cl_version"; exit 0 ;;
708	<	--help | --h* | -h )
709	<	echo "$lt_cl_help"; exit 0 ;;
710	<	--debug | --d* | -d )
711	<	debug=: ;;
712	<	--quiet | --q* | --silent | --s* | -q )
713	<	lt_cl_silent=: ;;
714	<
715	<	-*) AC_MSG_ERROR([unrecognized option: $[1]
716	<	Try \`$[0] --help' for more information.]) ;;
717	<
718	<	*) AC_MSG_ERROR([unrecognized argument: $[1]
719	<	Try \`$[0] --help' for more information.]) ;;
720	<	esac
721	<	shift
722	<	done
723	<
724	<	if $lt_cl_silent; then
725	<	exec AS_MESSAGE_FD>/dev/null
726	<	fi
727	<	_LTEOF
728	<
729	<	cat >>"$CONFIG_LT" <<_LTEOF
730	<	_LT_OUTPUT_LIBTOOL_COMMANDS_INIT
731	<	_LTEOF
732	<
733	<	cat >>"$CONFIG_LT" <<\_LTEOF
734	<	AC_MSG_NOTICE([creating $ofile])
735	<	_LT_OUTPUT_LIBTOOL_COMMANDS
736	<	AS_EXIT(0)
737	<	_LTEOF
738	<	chmod +x "$CONFIG_LT"
739	<
740	<	# configure is writing to config.log, but config.lt does its own redirection,
741	<	# appending to config.log, which fails on DOS, as config.log is still kept
742	<	# open by configure.  Here we exec the FD to /dev/null, effectively closing
743	<	# config.log, so it can be properly (re)opened and appended to by config.lt.
744	<	if test "$no_create" != yes; then
745	<	lt_cl_success=:
746	<	test "$silent" = yes &&
747	<	lt_config_lt_args="$lt_config_lt_args --quiet"
748	<	exec AS_MESSAGE_LOG_FD>/dev/null
749	<	$SHELL "$CONFIG_LT" $lt_config_lt_args || lt_cl_success=false
750	<	exec AS_MESSAGE_LOG_FD>>config.log
751	<	$lt_cl_success || AS_EXIT(1)
752	<	fi
753	<	])# LT_OUTPUT
754	<
755	<
756	<	# _LT_CONFIG(TAG)
757	<	# ---------------
758	<	# If TAG is the built-in tag, create an initial libtool script with a
759	<	# default configuration from the untagged config vars.  Otherwise add code
760	<	# to config.status for appending the configuration named by TAG from the
761	<	# matching tagged config vars.
762	<	m4_defun([_LT_CONFIG],
763	<	[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
764	<	_LT_CONFIG_SAVE_COMMANDS([
765	<	m4_define([_LT_TAG], m4_if([$1], [], [C], [$1]))dnl
766	<	m4_if(_LT_TAG, [C], [
767	<	# See if we are running on zsh, and set the options which allow our
768	<	# commands through without removal of \ escapes.
769	<	if test -n "${ZSH_VERSION+set}" ; then
770	<	setopt NO_GLOB_SUBST
771	<	fi
772	<
773	<	cfgfile="${ofile}T"
774	<	trap "$RM \"$cfgfile\"; exit 1" 1 2 15
775	<	$RM "$cfgfile"
776	<
777	<	cat <<_LT_EOF >> "$cfgfile"
778	<	#! $SHELL
779	<
780	<	# `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services.
781	<	# Generated automatically by $as_me ($PACKAGE$TIMESTAMP) $VERSION
782	<	# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
783	<	# NOTE: Changes made to this file will be lost: look at ltmain.sh.
784	<	#
785	<	_LT_COPYING
786	<	_LT_LIBTOOL_TAGS
787	<
788	<	# ### BEGIN LIBTOOL CONFIG
789	<	_LT_LIBTOOL_CONFIG_VARS
790	<	_LT_LIBTOOL_TAG_VARS
791	<	# ### END LIBTOOL CONFIG
792	<
793	<	_LT_EOF
794	<
795	<	case $host_os in
796	<	aix3*)
797	<	cat <<\_LT_EOF >> "$cfgfile"
798	<	# AIX sometimes has problems with the GCC collect2 program.  For some
799	<	# reason, if we set the COLLECT_NAMES environment variable, the problems
800	<	# vanish in a puff of smoke.
801	<	if test "X${COLLECT_NAMES+set}" != Xset; then
802	<	COLLECT_NAMES=
803	<	export COLLECT_NAMES
804	<	fi
805	<	_LT_EOF
806	<	;;
807	<	esac
808	<
809	<	_LT_PROG_LTMAIN
810	<
811	<	# We use sed instead of cat because bash on DJGPP gets confused if
812	<	# if finds mixed CR/LF and LF-only lines.  Since sed operates in
813	<	# text mode, it properly converts lines to CR/LF.  This bash problem
814	<	# is reportedly fixed, but why not run on old versions too?
815	<	sed '/^# Generated shell functions inserted here/q' "$ltmain" >> "$cfgfile" \
816	<	|| (rm -f "$cfgfile"; exit 1)
817	<
818	<	_LT_PROG_XSI_SHELLFNS
819	<
820	<	sed -n '/^# Generated shell functions inserted here/,$p' "$ltmain" >> "$cfgfile" \
821	<	|| (rm -f "$cfgfile"; exit 1)
822	<
823	<	mv -f "$cfgfile" "$ofile" ||
824	<	(rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")
825	<	chmod +x "$ofile"
826	<	],
827	<	[cat <<_LT_EOF >> "$ofile"
828	<
829	<	dnl Unfortunately we have to use $1 here, since _LT_TAG is not expanded
830	<	dnl in a comment (ie after a #).
831	<	# ### BEGIN LIBTOOL TAG CONFIG: $1
832	<	_LT_LIBTOOL_TAG_VARS(_LT_TAG)
833	<	# ### END LIBTOOL TAG CONFIG: $1
834	<	_LT_EOF
835	<	])dnl /m4_if
836	<	],
837	<	[m4_if([$1], [], [
838	<	PACKAGE='$PACKAGE'
839	<	VERSION='$VERSION'
840	<	TIMESTAMP='$TIMESTAMP'
841	<	RM='$RM'
842	<	ofile='$ofile'], [])
843	<	])dnl /_LT_CONFIG_SAVE_COMMANDS
844	<	])# _LT_CONFIG
845	<
846	<
847	<	# LT_SUPPORTED_TAG(TAG)
848	<	# ---------------------
849	<	# Trace this macro to discover what tags are supported by the libtool
850	<	# --tag option, using:
851	<	#    autoconf --trace 'LT_SUPPORTED_TAG:$1'
852	<	AC_DEFUN([LT_SUPPORTED_TAG], [])
853	<
854	<
855	<	# C support is built-in for now
856	<	m4_define([_LT_LANG_C_enabled], [])
857	<	m4_define([_LT_TAGS], [])
858	<
859	<
860	<	# LT_LANG(LANG)
861	<	# -------------
862	<	# Enable libtool support for the given language if not already enabled.
863	<	AC_DEFUN([LT_LANG],
864	<	[AC_BEFORE([$0], [LT_OUTPUT])dnl
865	<	m4_case([$1],
866	<	[C],                  [_LT_LANG(C)],
867	<	[C++],                [_LT_LANG(CXX)],
868	<	[Java],               [_LT_LANG(GCJ)],
869	<	[Fortran 77],         [_LT_LANG(F77)],
870	<	[Fortran],            [_LT_LANG(FC)],
871	<	[Windows Resource],   [_LT_LANG(RC)],
872	<	[m4_ifdef([_LT_LANG_]$1[_CONFIG],
873	<	[_LT_LANG($1)],
874	<	[m4_fatal([$0: unsupported language: "$1"])])])dnl
875	<	])# LT_LANG
876	<
877	<
878	<	# _LT_LANG(LANGNAME)
879	<	# ------------------
880	<	m4_defun([_LT_LANG],
881	<	[m4_ifdef([_LT_LANG_]$1[_enabled], [],
882	<	[LT_SUPPORTED_TAG([$1])dnl
883	<	m4_append([_LT_TAGS], [$1 ])dnl
884	<	m4_define([_LT_LANG_]$1[_enabled], [])dnl
885	<	_LT_LANG_$1_CONFIG($1)])dnl
886	<	])# _LT_LANG
887	<
888	<
889	<	# _LT_LANG_DEFAULT_CONFIG
890	<	# -----------------------
891	<	m4_defun([_LT_LANG_DEFAULT_CONFIG],
892	<	[AC_PROVIDE_IFELSE([AC_PROG_CXX],
893	<	[LT_LANG(CXX)],
894	<	[m4_define([AC_PROG_CXX], defn([AC_PROG_CXX])[LT_LANG(CXX)])])
895	<
896	<	AC_PROVIDE_IFELSE([AC_PROG_F77],
897	<	[LT_LANG(F77)],
898	<	[m4_define([AC_PROG_F77], defn([AC_PROG_F77])[LT_LANG(F77)])])
899	<
900	<	AC_PROVIDE_IFELSE([AC_PROG_FC],
901	<	[LT_LANG(FC)],
902	<	[m4_define([AC_PROG_FC], defn([AC_PROG_FC])[LT_LANG(FC)])])
903	<
904	<	dnl The call to [A][M_PROG_GCJ] is quoted like that to stop aclocal
905	<	dnl pulling things in needlessly.
906	<	AC_PROVIDE_IFELSE([AC_PROG_GCJ],
907	<	[LT_LANG(GCJ)],
908	<	[AC_PROVIDE_IFELSE([A][M_PROG_GCJ],
909	<	[LT_LANG(GCJ)],
910	<	[AC_PROVIDE_IFELSE([LT_PROG_GCJ],
911	<	[LT_LANG(GCJ)],
912	<	[m4_ifdef([AC_PROG_GCJ],
913	<	[m4_define([AC_PROG_GCJ], defn([AC_PROG_GCJ])[LT_LANG(GCJ)])])
914	<	m4_ifdef([A][M_PROG_GCJ],
915	<	[m4_define([A][M_PROG_GCJ], defn([A][M_PROG_GCJ])[LT_LANG(GCJ)])])
916	<	m4_ifdef([LT_PROG_GCJ],
917	<	[m4_define([LT_PROG_GCJ], defn([LT_PROG_GCJ])[LT_LANG(GCJ)])])])])])
918	<
919	<	AC_PROVIDE_IFELSE([LT_PROG_RC],
920	<	[LT_LANG(RC)],
921	<	[m4_define([LT_PROG_RC], defn([LT_PROG_RC])[LT_LANG(RC)])])
922	<	])# _LT_LANG_DEFAULT_CONFIG
923	<
924	<	# Obsolete macros:
925	<	AU_DEFUN([AC_LIBTOOL_CXX], [LT_LANG(C++)])
926	<	AU_DEFUN([AC_LIBTOOL_F77], [LT_LANG(Fortran 77)])
927	<	AU_DEFUN([AC_LIBTOOL_FC], [LT_LANG(Fortran)])
928	<	AU_DEFUN([AC_LIBTOOL_GCJ], [LT_LANG(Java)])
929	<	dnl aclocal-1.4 backwards compatibility:
930	<	dnl AC_DEFUN([AC_LIBTOOL_CXX], [])
931	<	dnl AC_DEFUN([AC_LIBTOOL_F77], [])
932	<	dnl AC_DEFUN([AC_LIBTOOL_FC], [])
933	<	dnl AC_DEFUN([AC_LIBTOOL_GCJ], [])
934	<
935	<
936	<	# _LT_TAG_COMPILER
937	<	# ----------------
938	<	m4_defun([_LT_TAG_COMPILER],
939	<	[AC_REQUIRE([AC_PROG_CC])dnl
940	<
941	<	_LT_DECL([LTCC], [CC], [1], [A C compiler])dnl
942	<	_LT_DECL([LTCFLAGS], [CFLAGS], [1], [LTCC compiler flags])dnl
943	<	_LT_TAGDECL([CC], [compiler], [1], [A language specific compiler])dnl
944	<	_LT_TAGDECL([with_gcc], [GCC], [0], [Is the compiler the GNU compiler?])dnl
945	<
946	<	# If no C compiler was specified, use CC.
947	<	LTCC=${LTCC-"$CC"}
948	<
949	<	# If no C compiler flags were specified, use CFLAGS.
950	<	LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
951	<
952	<	# Allow CC to be a program name with arguments.
953	<	compiler=$CC
954	<	])# _LT_TAG_COMPILER
955	<
956	<
957	<	# _LT_COMPILER_BOILERPLATE
958	<	# ------------------------
959	<	# Check for compiler boilerplate output or warnings with
960	<	# the simple compiler test code.
961	<	m4_defun([_LT_COMPILER_BOILERPLATE],
962	<	[m4_require([_LT_DECL_SED])dnl
963	<	ac_outfile=conftest.$ac_objext
964	<	echo "$lt_simple_compile_test_code" >conftest.$ac_ext
965	<	eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
966	<	_lt_compiler_boilerplate=`cat conftest.err`
967	<	$RM conftest*
968	<	])# _LT_COMPILER_BOILERPLATE
969	<
970	<
971	<	# _LT_LINKER_BOILERPLATE
972	<	# ----------------------
973	<	# Check for linker boilerplate output or warnings with
974	<	# the simple link test code.
975	<	m4_defun([_LT_LINKER_BOILERPLATE],
976	<	[m4_require([_LT_DECL_SED])dnl
977	<	ac_outfile=conftest.$ac_objext
978	<	echo "$lt_simple_link_test_code" >conftest.$ac_ext
979	<	eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
980	<	_lt_linker_boilerplate=`cat conftest.err`
981	<	$RM -r conftest*
982	<	])# _LT_LINKER_BOILERPLATE
983	<
984	<	# _LT_REQUIRED_DARWIN_CHECKS
985	<	# -------------------------
986	<	m4_defun_once([_LT_REQUIRED_DARWIN_CHECKS],[
987	<	case $host_os in
988	<	rhapsody* | darwin*)
989	<	AC_CHECK_TOOL([DSYMUTIL], [dsymutil], [:])
990	<	AC_CHECK_TOOL([NMEDIT], [nmedit], [:])
991	<	AC_CHECK_TOOL([LIPO], [lipo], [:])
992	<	AC_CHECK_TOOL([OTOOL], [otool], [:])
993	<	AC_CHECK_TOOL([OTOOL64], [otool64], [:])
994	<	_LT_DECL([], [DSYMUTIL], [1],
995	<	[Tool to manipulate archived DWARF debug symbol files on Mac OS X])
996	<	_LT_DECL([], [NMEDIT], [1],
997	<	[Tool to change global to local symbols on Mac OS X])
998	<	_LT_DECL([], [LIPO], [1],
999	<	[Tool to manipulate fat objects and archives on Mac OS X])
1000	<	_LT_DECL([], [OTOOL], [1],
1001	<	[ldd/readelf like tool for Mach-O binaries on Mac OS X])
1002	<	_LT_DECL([], [OTOOL64], [1],
1003	<	[ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4])
1004	<
1005	<	AC_CACHE_CHECK([for -single_module linker flag],[lt_cv_apple_cc_single_mod],
1006	<	[lt_cv_apple_cc_single_mod=no
1007	<	if test -z "${LT_MULTI_MODULE}"; then
1008	<	# By default we will add the -single_module flag. You can override
1009	<	# by either setting the environment variable LT_MULTI_MODULE
1010	<	# non-empty at configure time, or by adding -multi_module to the
1011	<	# link flags.
1012	<	rm -rf libconftest.dylib*
1013	<	echo "int foo(void){return 1;}" > conftest.c
1014	<	echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
1015	<	-dynamiclib -Wl,-single_module conftest.c" >&AS_MESSAGE_LOG_FD
1016	<	$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
1017	<	-dynamiclib -Wl,-single_module conftest.c 2>conftest.err
1018	<	_lt_result=$?
1019	<	if test -f libconftest.dylib && test ! -s conftest.err && test $_lt_result = 0; then
1020	<	lt_cv_apple_cc_single_mod=yes
1021	<	else
1022	<	cat conftest.err >&AS_MESSAGE_LOG_FD
1023	<	fi
1024	<	rm -rf libconftest.dylib*
1025	<	rm -f conftest.*
1026	<	fi])
1027	<	AC_CACHE_CHECK([for -exported_symbols_list linker flag],
1028	<	[lt_cv_ld_exported_symbols_list],
1029	<	[lt_cv_ld_exported_symbols_list=no
1030	<	save_LDFLAGS=$LDFLAGS
1031	<	echo "_main" > conftest.sym
1032	<	LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym"
1033	<	AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])],
1034	<	[lt_cv_ld_exported_symbols_list=yes],
1035	<	[lt_cv_ld_exported_symbols_list=no])
1036	<	LDFLAGS="$save_LDFLAGS"
1037	<	])
1038	<	case $host_os in
1039	<	rhapsody* | darwin1.[[012]])
1040	<	_lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;;
1041	<	darwin1.*)
1042	<	_lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;
1043	<	darwin*) # darwin 5.x on
1044	<	# if running on 10.5 or later, the deployment target defaults
1045	<	# to the OS version, if on x86, and 10.4, the deployment
1046	<	# target defaults to 10.4. Don't you love it?
1047	<	case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in
1048	<	10.0,*86*-darwin8*|10.0,*-darwin[[91]]*)
1049	<	_lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;
1050	<	10.[[012]]*)
1051	<	_lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;
1052	<	10.*)
1053	<	_lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;
1054	<	esac
1055	<	;;
1056	<	esac
1057	<	if test "$lt_cv_apple_cc_single_mod" = "yes"; then
1058	<	_lt_dar_single_mod='$single_module'
1059	<	fi
1060	<	if test "$lt_cv_ld_exported_symbols_list" = "yes"; then
1061	<	_lt_dar_export_syms=' ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym'
1062	<	else
1063	<	_lt_dar_export_syms='~$NMEDIT -s $output_objdir/${libname}-symbols.expsym ${lib}'
1064	<	fi
1065	<	if test "$DSYMUTIL" != ":"; then
1066	<	_lt_dsymutil='~$DSYMUTIL $lib || :'
1067	<	else
1068	<	_lt_dsymutil=
1069	<	fi
1070	<	;;
1071	<	esac
1072	<	])
1073	<
1074	<
1075	<	# _LT_DARWIN_LINKER_FEATURES
1076	<	# --------------------------
1077	<	# Checks for linker and compiler features on darwin
1078	<	m4_defun([_LT_DARWIN_LINKER_FEATURES],
1079	<	[
1080	<	m4_require([_LT_REQUIRED_DARWIN_CHECKS])
1081	<	_LT_TAGVAR(archive_cmds_need_lc, $1)=no
1082	<	_LT_TAGVAR(hardcode_direct, $1)=no
1083	<	_LT_TAGVAR(hardcode_automatic, $1)=yes
1084	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
1085	<	_LT_TAGVAR(whole_archive_flag_spec, $1)=''
1086	<	_LT_TAGVAR(link_all_deplibs, $1)=yes
1087	<	_LT_TAGVAR(allow_undefined_flag, $1)="$_lt_dar_allow_undefined"
1088	<	case $cc_basename in
1089	<	ifort*) _lt_dar_can_shared=yes ;;
1090	<	*) _lt_dar_can_shared=$GCC ;;
1091	<	esac
1092	<	if test "$_lt_dar_can_shared" = "yes"; then
1093	<	output_verbose_link_cmd=echo
1094	<	_LT_TAGVAR(archive_cmds, $1)="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}"
1095	<	_LT_TAGVAR(module_cmds, $1)="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}"
1096	<	_LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}"
1097	<	_LT_TAGVAR(module_expsym_cmds, $1)="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}"
1098	<	m4_if([$1], [CXX],
1099	<	[   if test "$lt_cv_apple_cc_single_mod" != "yes"; then
1100	<	_LT_TAGVAR(archive_cmds, $1)="\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dsymutil}"
1101	<	_LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dar_export_syms}${_lt_dsymutil}"
1102	<	fi
1103	<	],[])
1104	<	else
1105	<	_LT_TAGVAR(ld_shlibs, $1)=no
1106	<	fi
1107	<	])
1108	<
1109	<	# _LT_SYS_MODULE_PATH_AIX
1110	<	# -----------------------
1111	<	# Links a minimal program and checks the executable
1112	<	# for the system default hardcoded library path. In most cases,
1113	<	# this is /usr/lib:/lib, but when the MPI compilers are used
1114	<	# the location of the communication and MPI libs are included too.
1115	<	# If we don't find anything, use the default library path according
1116	<	# to the aix ld manual.
1117	<	m4_defun([_LT_SYS_MODULE_PATH_AIX],
1118	<	[m4_require([_LT_DECL_SED])dnl
1119	<	AC_LINK_IFELSE(AC_LANG_PROGRAM,[
1120	<	lt_aix_libpath_sed='
1121	<	/Import File Strings/,/^$/ {
1122	<	/^0/ {
1123	<	s/^0  *\(.*\)$/\1/
1124	<	p
1125	<	}
1126	<	}'
1127	<	aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
1128	<	# Check for a 64-bit object if we didn't find anything.
1129	<	if test -z "$aix_libpath"; then
1130	<	aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
1131	<	fi],[])
1132	<	if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
1133	<	])# _LT_SYS_MODULE_PATH_AIX
1134	<
1135	<
1136	<	# _LT_SHELL_INIT(ARG)
1137	<	# -------------------
1138	<	m4_define([_LT_SHELL_INIT],
1139	<	[ifdef([AC_DIVERSION_NOTICE],
1140	<	[AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)],
1141	<	[AC_DIVERT_PUSH(NOTICE)])
1142	<	$1
1143	<	AC_DIVERT_POP
1144	<	])# _LT_SHELL_INIT
1145	<
1146	<
1147	<	# _LT_PROG_ECHO_BACKSLASH
1148	<	# -----------------------
1149	<	# Add some code to the start of the generated configure script which
1150	<	# will find an echo command which doesn't interpret backslashes.
1151	<	m4_defun([_LT_PROG_ECHO_BACKSLASH],
1152	<	[_LT_SHELL_INIT([
1153	<	# Check that we are running under the correct shell.
1154	<	SHELL=${CONFIG_SHELL-/bin/sh}
1155	<
1156	<	case X$lt_ECHO in
1157	<	X*--fallback-echo)
1158	<	# Remove one level of quotation (which was required for Make).
1159	<	ECHO=`echo "$lt_ECHO" | sed 's,\\\\\[$]\\[$]0,'[$]0','`
1160	<	;;
1161	<	esac
1162	<
1163	<	ECHO=${lt_ECHO-echo}
1164	<	if test "X[$]1" = X--no-reexec; then
1165	<	# Discard the --no-reexec flag, and continue.
1166	<	shift
1167	<	elif test "X[$]1" = X--fallback-echo; then
1168	<	# Avoid inline document here, it may be left over
1169	<	:
1170	<	elif test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t' ; then
1171	<	# Yippee, $ECHO works!
1172	<	:
1173	<	else
1174	<	# Restart under the correct shell.
1175	<	exec $SHELL "[$]0" --no-reexec ${1+"[$]@"}
1176	<	fi
1177	<
1178	<	if test "X[$]1" = X--fallback-echo; then
1179	<	# used as fallback echo
1180	<	shift
1181	<	cat <<_LT_EOF
1182	<	[$]*
1183	<	_LT_EOF
1184	<	exit 0
1185	<	fi
1186	<
1187	<	# The HP-UX ksh and POSIX shell print the target directory to stdout
1188	<	# if CDPATH is set.
1189	<	(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
1190	<
1191	<	if test -z "$lt_ECHO"; then
1192	<	if test "X${echo_test_string+set}" != Xset; then
1193	<	# find a string as large as possible, as long as the shell can cope with it
1194	<	for cmd in 'sed 50q "[$]0"' 'sed 20q "[$]0"' 'sed 10q "[$]0"' 'sed 2q "[$]0"' 'echo test'; do
1195	<	# expected sizes: less than 2Kb, 1Kb, 512 bytes, 16 bytes, ...
1196	<	if { echo_test_string=`eval $cmd`; } 2>/dev/null &&
1197	<	{ test "X$echo_test_string" = "X$echo_test_string"; } 2>/dev/null
1198	<	then
1199	<	break
1200	<	fi
1201	<	done
1202	<	fi
1203	<
1204	<	if test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t' &&
1205	<	echo_testing_string=`{ $ECHO "$echo_test_string"; } 2>/dev/null` &&
1206	<	test "X$echo_testing_string" = "X$echo_test_string"; then
1207	<	:
1208	<	else
1209	<	# The Solaris, AIX, and Digital Unix default echo programs unquote
1210	<	# backslashes.  This makes it impossible to quote backslashes using
1211	<	#   echo "$something" | sed 's/\\/\\\\/g'
1212	<	#
1213	<	# So, first we look for a working echo in the user's PATH.
1214	<
1215	<	lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
1216	<	for dir in $PATH /usr/ucb; do
1217	<	IFS="$lt_save_ifs"
1218	<	if (test -f $dir/echo || test -f $dir/echo$ac_exeext) &&
1219	<	test "X`($dir/echo '\t') 2>/dev/null`" = 'X\t' &&
1220	<	echo_testing_string=`($dir/echo "$echo_test_string") 2>/dev/null` &&
1221	<	test "X$echo_testing_string" = "X$echo_test_string"; then
1222	<	ECHO="$dir/echo"
1223	<	break
1224	<	fi
1225	<	done
1226	<	IFS="$lt_save_ifs"
1227	<
1228	<	if test "X$ECHO" = Xecho; then
1229	<	# We didn't find a better echo, so look for alternatives.
1230	<	if test "X`{ print -r '\t'; } 2>/dev/null`" = 'X\t' &&
1231	<	echo_testing_string=`{ print -r "$echo_test_string"; } 2>/dev/null` &&
1232	<	test "X$echo_testing_string" = "X$echo_test_string"; then
1233	<	# This shell has a builtin print -r that does the trick.
1234	<	ECHO='print -r'
1235	<	elif { test -f /bin/ksh || test -f /bin/ksh$ac_exeext; } &&
1236	<	test "X$CONFIG_SHELL" != X/bin/ksh; then
1237	<	# If we have ksh, try running configure again with it.
1238	<	ORIGINAL_CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
1239	<	export ORIGINAL_CONFIG_SHELL
1240	<	CONFIG_SHELL=/bin/ksh
1241	<	export CONFIG_SHELL
1242	<	exec $CONFIG_SHELL "[$]0" --no-reexec ${1+"[$]@"}
1243	<	else
1244	<	# Try using printf.
1245	<	ECHO='printf %s\n'
1246	<	if test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t' &&
1247	<	echo_testing_string=`{ $ECHO "$echo_test_string"; } 2>/dev/null` &&
1248	<	test "X$echo_testing_string" = "X$echo_test_string"; then
1249	<	# Cool, printf works
1250	<	:
1251	<	elif echo_testing_string=`($ORIGINAL_CONFIG_SHELL "[$]0" --fallback-echo '\t') 2>/dev/null` &&
1252	<	test "X$echo_testing_string" = 'X\t' &&
1253	<	echo_testing_string=`($ORIGINAL_CONFIG_SHELL "[$]0" --fallback-echo "$echo_test_string") 2>/dev/null` &&
1254	<	test "X$echo_testing_string" = "X$echo_test_string"; then
1255	<	CONFIG_SHELL=$ORIGINAL_CONFIG_SHELL
1256	<	export CONFIG_SHELL
1257	<	SHELL="$CONFIG_SHELL"
1258	<	export SHELL
1259	<	ECHO="$CONFIG_SHELL [$]0 --fallback-echo"
1260	<	elif echo_testing_string=`($CONFIG_SHELL "[$]0" --fallback-echo '\t') 2>/dev/null` &&
1261	<	test "X$echo_testing_string" = 'X\t' &&
1262	<	echo_testing_string=`($CONFIG_SHELL "[$]0" --fallback-echo "$echo_test_string") 2>/dev/null` &&
1263	<	test "X$echo_testing_string" = "X$echo_test_string"; then
1264	<	ECHO="$CONFIG_SHELL [$]0 --fallback-echo"
1265	<	else
1266	<	# maybe with a smaller string...
1267	<	prev=:
1268	<
1269	<	for cmd in 'echo test' 'sed 2q "[$]0"' 'sed 10q "[$]0"' 'sed 20q "[$]0"' 'sed 50q "[$]0"'; do
1270	<	if { test "X$echo_test_string" = "X`eval $cmd`"; } 2>/dev/null
1271	<	then
1272	<	break
1273	<	fi
1274	<	prev="$cmd"
1275	<	done
1276	<
1277	<	if test "$prev" != 'sed 50q "[$]0"'; then
1278	<	echo_test_string=`eval $prev`
1279	<	export echo_test_string
1280	<	exec ${ORIGINAL_CONFIG_SHELL-${CONFIG_SHELL-/bin/sh}} "[$]0" ${1+"[$]@"}
1281	<	else
1282	<	# Oops.  We lost completely, so just stick with echo.
1283	<	ECHO=echo
1284	<	fi
1285	<	fi
1286	<	fi
1287	<	fi
1288	<	fi
1289	<	fi
1290	<
1291	<	# Copy echo and quote the copy suitably for passing to libtool from
1292	<	# the Makefile, instead of quoting the original, which is used later.
1293	<	lt_ECHO=$ECHO
1294	<	if test "X$lt_ECHO" = "X$CONFIG_SHELL [$]0 --fallback-echo"; then
1295	<	lt_ECHO="$CONFIG_SHELL \\\$\[$]0 --fallback-echo"
1296	<	fi
1297	<
1298	<	AC_SUBST(lt_ECHO)
1299	<	])
1300	<	_LT_DECL([], [SHELL], [1], [Shell to use when invoking shell scripts])
1301	<	_LT_DECL([], [ECHO], [1],
1302	<	[An echo program that does not interpret backslashes])
1303	<	])# _LT_PROG_ECHO_BACKSLASH
1304	<
1305	<
1306	<	# _LT_ENABLE_LOCK
1307	<	# ---------------
1308	<	m4_defun([_LT_ENABLE_LOCK],
1309	<	[AC_ARG_ENABLE([libtool-lock],
1310	<	[AS_HELP_STRING([--disable-libtool-lock],
1311	<	[avoid locking (might break parallel builds)])])
1312	<	test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes
1313	<
1314	<	# Some flags need to be propagated to the compiler or linker for good
1315	<	# libtool support.
1316	<	case $host in
1317	<	ia64-*-hpux*)
1318	<	# Find out which ABI we are using.
1319	<	echo 'int i;' > conftest.$ac_ext
1320	<	if AC_TRY_EVAL(ac_compile); then
1321	<	case `/usr/bin/file conftest.$ac_objext` in
1322	<	*ELF-32*)
1323	<	HPUX_IA64_MODE="32"
1324	<	;;
1325	<	*ELF-64*)
1326	<	HPUX_IA64_MODE="64"
1327	<	;;
1328	<	esac
1329	<	fi
1330	<	rm -rf conftest*
1331	<	;;
1332	<	*-*-irix6*)
1333	<	# Find out which ABI we are using.
1334	<	echo '[#]line __oline__ "configure"' > conftest.$ac_ext
1335	<	if AC_TRY_EVAL(ac_compile); then
1336	<	if test "$lt_cv_prog_gnu_ld" = yes; then
1337	<	case `/usr/bin/file conftest.$ac_objext` in
1338	<	*32-bit*)
1339	<	LD="${LD-ld} -melf32bsmip"
1340	<	;;
1341	<	*N32*)
1342	<	LD="${LD-ld} -melf32bmipn32"
1343	<	;;
1344	<	*64-bit*)
1345	<	LD="${LD-ld} -melf64bmip"
1346	<	;;
1347	<	esac
1348	<	else
1349	<	case `/usr/bin/file conftest.$ac_objext` in
1350	<	*32-bit*)
1351	<	LD="${LD-ld} -32"
1352	<	;;
1353	<	*N32*)
1354	<	LD="${LD-ld} -n32"
1355	<	;;
1356	<	*64-bit*)
1357	<	LD="${LD-ld} -64"
1358	<	;;
1359	<	esac
1360	<	fi
1361	<	fi
1362	<	rm -rf conftest*
1363	<	;;
1364	<
1365	<	x86_64-*kfreebsd*-gnu|x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*| \
1366	<	s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
1367	<	# Find out which ABI we are using.
1368	<	echo 'int i;' > conftest.$ac_ext
1369	<	if AC_TRY_EVAL(ac_compile); then
1370	<	case `/usr/bin/file conftest.o` in
1371	<	*32-bit*)
1372	<	case $host in
1373	<	x86_64-*kfreebsd*-gnu)
1374	<	LD="${LD-ld} -m elf_i386_fbsd"
1375	<	;;
1376	<	x86_64-*linux*)
1377	<	LD="${LD-ld} -m elf_i386"
1378	<	;;
1379	<	ppc64-*linux*|powerpc64-*linux*)
1380	<	LD="${LD-ld} -m elf32ppclinux"
1381	<	;;
1382	<	s390x-*linux*)
1383	<	LD="${LD-ld} -m elf_s390"
1384	<	;;
1385	<	sparc64-*linux*)
1386	<	LD="${LD-ld} -m elf32_sparc"
1387	<	;;
1388	<	esac
1389	<	;;
1390	<	*64-bit*)
1391	<	case $host in
1392	<	x86_64-*kfreebsd*-gnu)
1393	<	LD="${LD-ld} -m elf_x86_64_fbsd"
1394	<	;;
1395	<	x86_64-*linux*)
1396	<	LD="${LD-ld} -m elf_x86_64"
1397	<	;;
1398	<	ppc*-*linux*|powerpc*-*linux*)
1399	<	LD="${LD-ld} -m elf64ppc"
1400	<	;;
1401	<	s390*-*linux*|s390*-*tpf*)
1402	<	LD="${LD-ld} -m elf64_s390"
1403	<	;;
1404	<	sparc*-*linux*)
1405	<	LD="${LD-ld} -m elf64_sparc"
1406	<	;;
1407	<	esac
1408	<	;;
1409	<	esac
1410	<	fi
1411	<	rm -rf conftest*
1412	<	;;
1413	<
1414	<	*-*-sco3.2v5*)
1415	<	# On SCO OpenServer 5, we need -belf to get full-featured binaries.
1416	<	SAVE_CFLAGS="$CFLAGS"
1417	<	CFLAGS="$CFLAGS -belf"
1418	<	AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf,
1419	<	[AC_LANG_PUSH(C)
1420	<	AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],[[]])],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no])
1421	<	AC_LANG_POP])
1422	<	if test x"$lt_cv_cc_needs_belf" != x"yes"; then
1423	<	# this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
1424	<	CFLAGS="$SAVE_CFLAGS"
1425	<	fi
1426	<	;;
1427	<	sparc*-*solaris*)
1428	<	# Find out which ABI we are using.
1429	<	echo 'int i;' > conftest.$ac_ext
1430	<	if AC_TRY_EVAL(ac_compile); then
1431	<	case `/usr/bin/file conftest.o` in
1432	<	*64-bit*)
1433	<	case $lt_cv_prog_gnu_ld in
1434	<	yes*) LD="${LD-ld} -m elf64_sparc" ;;
1435	<	*)
1436	<	if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then
1437	<	LD="${LD-ld} -64"
1438	<	fi
1439	<	;;
1440	<	esac
1441	<	;;
1442	<	esac
1443	<	fi
1444	<	rm -rf conftest*
1445	<	;;
1446	<	esac
1447	<
1448	<	need_locks="$enable_libtool_lock"
1449	<	])# _LT_ENABLE_LOCK
1450	<
1451	<
1452	<	# _LT_CMD_OLD_ARCHIVE
1453	<	# -------------------
1454	<	m4_defun([_LT_CMD_OLD_ARCHIVE],
1455	<	[AC_CHECK_TOOL(AR, ar, false)
1456	<	test -z "$AR" && AR=ar
1457	<	test -z "$AR_FLAGS" && AR_FLAGS=cru
1458	<	_LT_DECL([], [AR], [1], [The archiver])
1459	<	_LT_DECL([], [AR_FLAGS], [1])
1460	<
1461	<	AC_CHECK_TOOL(STRIP, strip, :)
1462	<	test -z "$STRIP" && STRIP=:
1463	<	_LT_DECL([], [STRIP], [1], [A symbol stripping program])
1464	<
1465	<	AC_CHECK_TOOL(RANLIB, ranlib, :)
1466	<	test -z "$RANLIB" && RANLIB=:
1467	<	_LT_DECL([], [RANLIB], [1],
1468	<	[Commands used to install an old-style archive])
1469	<
1470	<	# Determine commands to create old-style static archives.
1471	<	old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs'
1472	<	old_postinstall_cmds='chmod 644 $oldlib'
1473	<	old_postuninstall_cmds=
1474	<
1475	<	if test -n "$RANLIB"; then
1476	<	case $host_os in
1477	<	openbsd*)
1478	<	old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$oldlib"
1479	<	;;
1480	<	*)
1481	<	old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$oldlib"
1482	<	;;
1483	<	esac
1484	<	old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib"
1485	<	fi
1486	<	_LT_DECL([], [old_postinstall_cmds], [2])
1487	<	_LT_DECL([], [old_postuninstall_cmds], [2])
1488	<	_LT_TAGDECL([], [old_archive_cmds], [2],
1489	<	[Commands used to build an old-style archive])
1490	<	])# _LT_CMD_OLD_ARCHIVE
1491	<
1492	<
1493	<	# _LT_COMPILER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,
1494	<	#               [OUTPUT-FILE], [ACTION-SUCCESS], [ACTION-FAILURE])
1495	<	# ----------------------------------------------------------------
1496	<	# Check whether the given compiler option works
1497	<	AC_DEFUN([_LT_COMPILER_OPTION],
1498	<	[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
1499	<	m4_require([_LT_DECL_SED])dnl
1500	<	AC_CACHE_CHECK([$1], [$2],
1501	<	[$2=no
1502	<	m4_if([$4], , [ac_outfile=conftest.$ac_objext], [ac_outfile=$4])
1503	<	echo "$lt_simple_compile_test_code" > conftest.$ac_ext
1504	<	lt_compiler_flag="$3"
1505	<	# Insert the option either (1) after the last *FLAGS variable, or
1506	<	# (2) before a word containing "conftest.", or (3) at the end.
1507	<	# Note that $ac_compile itself does not contain backslashes and begins
1508	<	# with a dollar sign (not a hyphen), so the echo should work correctly.
1509	<	# The option is referenced via a variable to avoid confusing sed.
1510	<	lt_compile=`echo "$ac_compile" | $SED \
1511	<	-e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
1512	<	-e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \
1513	<	-e 's:$: $lt_compiler_flag:'`
1514	<	(eval echo "\"\$as_me:__oline__: $lt_compile\"" >&AS_MESSAGE_LOG_FD)
1515	<	(eval "$lt_compile" 2>conftest.err)
1516	<	ac_status=$?
1517	<	cat conftest.err >&AS_MESSAGE_LOG_FD
1518	<	echo "$as_me:__oline__: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
1519	<	if (exit $ac_status) && test -s "$ac_outfile"; then
1520	<	# The compiler can only warn and ignore the option if not recognized
1521	<	# So say no if there are warnings other than the usual output.
1522	<	$ECHO "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp
1523	<	$SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
1524	<	if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
1525	<	$2=yes
1526	<	fi
1527	<	fi
1528	<	$RM conftest*
1529	<	])
1530	<
1531	<	if test x"[$]$2" = xyes; then
1532	<	m4_if([$5], , :, [$5])
1533	<	else
1534	<	m4_if([$6], , :, [$6])
1535	<	fi
1536	<	])# _LT_COMPILER_OPTION
1537	<
1538	<	# Old name:
1539	<	AU_ALIAS([AC_LIBTOOL_COMPILER_OPTION], [_LT_COMPILER_OPTION])
1540	<	dnl aclocal-1.4 backwards compatibility:
1541	<	dnl AC_DEFUN([AC_LIBTOOL_COMPILER_OPTION], [])
1542	<
1543	<
1544	<	# _LT_LINKER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,
1545	<	#                  [ACTION-SUCCESS], [ACTION-FAILURE])
1546	<	# ----------------------------------------------------
1547	<	# Check whether the given linker option works
1548	<	AC_DEFUN([_LT_LINKER_OPTION],
1549	<	[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
1550	<	m4_require([_LT_DECL_SED])dnl
1551	<	AC_CACHE_CHECK([$1], [$2],
1552	<	[$2=no
1553	<	save_LDFLAGS="$LDFLAGS"
1554	<	LDFLAGS="$LDFLAGS $3"
1555	<	echo "$lt_simple_link_test_code" > conftest.$ac_ext
1556	<	if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
1557	<	# The linker can only warn and ignore the option if not recognized
1558	<	# So say no if there are warnings
1559	<	if test -s conftest.err; then
1560	<	# Append any errors to the config.log.
1561	<	cat conftest.err 1>&AS_MESSAGE_LOG_FD
1562	<	$ECHO "X$_lt_linker_boilerplate" | $Xsed -e '/^$/d' > conftest.exp
1563	<	$SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
1564	<	if diff conftest.exp conftest.er2 >/dev/null; then
1565	<	$2=yes
1566	<	fi
1567	<	else
1568	<	$2=yes
1569	<	fi
1570	<	fi
1571	<	$RM -r conftest*
1572	<	LDFLAGS="$save_LDFLAGS"
1573	<	])
1574	<
1575	<	if test x"[$]$2" = xyes; then
1576	<	m4_if([$4], , :, [$4])
1577	<	else
1578	<	m4_if([$5], , :, [$5])
1579	<	fi
1580	<	])# _LT_LINKER_OPTION
1581	<
1582	<	# Old name:
1583	<	AU_ALIAS([AC_LIBTOOL_LINKER_OPTION], [_LT_LINKER_OPTION])
1584	<	dnl aclocal-1.4 backwards compatibility:
1585	<	dnl AC_DEFUN([AC_LIBTOOL_LINKER_OPTION], [])
1586	<
1587	<
1588	<	# LT_CMD_MAX_LEN
1589	<	#---------------
1590	<	AC_DEFUN([LT_CMD_MAX_LEN],
1591	<	[AC_REQUIRE([AC_CANONICAL_HOST])dnl
1592	<	# find the maximum length of command line arguments
1593	<	AC_MSG_CHECKING([the maximum length of command line arguments])
1594	<	AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl
1595	<	i=0
1596	<	teststring="ABCD"
1597	<
1598	<	case $build_os in
1599	<	msdosdjgpp*)
1600	<	# On DJGPP, this test can blow up pretty badly due to problems in libc
1601	<	# (any single argument exceeding 2000 bytes causes a buffer overrun
1602	<	# during glob expansion).  Even if it were fixed, the result of this
1603	<	# check would be larger than it should be.
1604	<	lt_cv_sys_max_cmd_len=12288;    # 12K is about right
1605	<	;;
1606	<
1607	<	gnu*)
1608	<	# Under GNU Hurd, this test is not required because there is
1609	<	# no limit to the length of command line arguments.
1610	<	# Libtool will interpret -1 as no limit whatsoever
1611	<	lt_cv_sys_max_cmd_len=-1;
1612	<	;;
1613	<
1614	<	cygwin* | mingw* | cegcc*)
1615	<	# On Win9x/ME, this test blows up -- it succeeds, but takes
1616	<	# about 5 minutes as the teststring grows exponentially.
1617	<	# Worse, since 9x/ME are not pre-emptively multitasking,
1618	<	# you end up with a "frozen" computer, even though with patience
1619	<	# the test eventually succeeds (with a max line length of 256k).
1620	<	# Instead, let's just punt: use the minimum linelength reported by
1621	<	# all of the supported platforms: 8192 (on NT/2K/XP).
1622	<	lt_cv_sys_max_cmd_len=8192;
1623	<	;;
1624	<
1625	<	amigaos*)
1626	<	# On AmigaOS with pdksh, this test takes hours, literally.
1627	<	# So we just punt and use a minimum line length of 8192.
1628	<	lt_cv_sys_max_cmd_len=8192;
1629	<	;;
1630	<
1631	<	netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)
1632	<	# This has been around since 386BSD, at least.  Likely further.
1633	<	if test -x /sbin/sysctl; then
1634	<	lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
1635	<	elif test -x /usr/sbin/sysctl; then
1636	<	lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
1637	<	else
1638	<	lt_cv_sys_max_cmd_len=65536       # usable default for all BSDs
1639	<	fi
1640	<	# And add a safety zone
1641	<	lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
1642	<	lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
1643	<	;;
1644	<
1645	<	interix*)
1646	<	# We know the value 262144 and hardcode it with a safety zone (like BSD)
1647	<	lt_cv_sys_max_cmd_len=196608
1648	<	;;
1649	<
1650	<	osf*)
1651	<	# Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure
1652	<	# due to this test when exec_disable_arg_limit is 1 on Tru64. It is not
1653	<	# nice to cause kernel panics so lets avoid the loop below.
1654	<	# First set a reasonable default.
1655	<	lt_cv_sys_max_cmd_len=16384
1656	<	#
1657	<	if test -x /sbin/sysconfig; then
1658	<	case `/sbin/sysconfig -q proc exec_disable_arg_limit` in
1659	<	*1*) lt_cv_sys_max_cmd_len=-1 ;;
1660	<	esac
1661	<	fi
1662	<	;;
1663	<	sco3.2v5*)
1664	<	lt_cv_sys_max_cmd_len=102400
1665	<	;;
1666	<	sysv5* | sco5v6* | sysv4.2uw2*)
1667	<	kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`
1668	<	if test -n "$kargmax"; then
1669	<	lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[[         ]]//'`
1670	<	else
1671	<	lt_cv_sys_max_cmd_len=32768
1672	<	fi
1673	<	;;
1674	<	*)
1675	<	lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null`
1676	<	if test -n "$lt_cv_sys_max_cmd_len"; then
1677	<	lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
1678	<	lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
1679	<	else
1680	<	# Make teststring a little bigger before we do anything with it.
1681	<	# a 1K string should be a reasonable start.
1682	<	for i in 1 2 3 4 5 6 7 8 ; do
1683	<	teststring=$teststring$teststring
1684	<	done
1685	<	SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
1686	<	# If test is not a shell built-in, we'll probably end up computing a
1687	<	# maximum length that is only half of the actual maximum length, but
1688	<	# we can't tell.
1689	<	while { test "X"`$SHELL [$]0 --fallback-echo "X$teststring$teststring" 2>/dev/null` \
1690	<	= "XX$teststring$teststring"; } >/dev/null 2>&1 &&
1691	<	test $i != 17 # 1/2 MB should be enough
1692	<	do
1693	<	i=`expr $i + 1`
1694	<	teststring=$teststring$teststring
1695	<	done
1696	<	# Only check the string length outside the loop.
1697	<	lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1`
1698	<	teststring=
1699	<	# Add a significant safety factor because C++ compilers can tack on
1700	<	# massive amounts of additional arguments before passing them to the
1701	<	# linker.  It appears as though 1/2 is a usable value.
1702	<	lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`
1703	<	fi
1704	<	;;
1705	<	esac
1706	<	])
1707	<	if test -n $lt_cv_sys_max_cmd_len ; then
1708	<	AC_MSG_RESULT($lt_cv_sys_max_cmd_len)
1709	<	else
1710	<	AC_MSG_RESULT(none)
1711	<	fi
1712	<	max_cmd_len=$lt_cv_sys_max_cmd_len
1713	<	_LT_DECL([], [max_cmd_len], [0],
1714	<	[What is the maximum length of a command?])
1715	<	])# LT_CMD_MAX_LEN
1716	<
1717	<	# Old name:
1718	<	AU_ALIAS([AC_LIBTOOL_SYS_MAX_CMD_LEN], [LT_CMD_MAX_LEN])
1719	<	dnl aclocal-1.4 backwards compatibility:
1720	<	dnl AC_DEFUN([AC_LIBTOOL_SYS_MAX_CMD_LEN], [])
1721	<
1722	<
1723	<	# _LT_HEADER_DLFCN
1724	<	# ----------------
1725	<	m4_defun([_LT_HEADER_DLFCN],
1726	<	[AC_CHECK_HEADERS([dlfcn.h], [], [], [AC_INCLUDES_DEFAULT])dnl
1727	<	])# _LT_HEADER_DLFCN
1728	<
1729	<
1730	<	# _LT_TRY_DLOPEN_SELF (ACTION-IF-TRUE, ACTION-IF-TRUE-W-USCORE,
1731	<	#                      ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING)
1732	<	# ----------------------------------------------------------------
1733	<	m4_defun([_LT_TRY_DLOPEN_SELF],
1734	<	[m4_require([_LT_HEADER_DLFCN])dnl
1735	<	if test "$cross_compiling" = yes; then :
1736	<	[$4]
1737	<	else
1738	<	lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
1739	<	lt_status=$lt_dlunknown
1740	<	cat > conftest.$ac_ext <<_LT_EOF
1741	<	[#line __oline__ "configure"
1742	<	#include "confdefs.h"
1743	<
1744	<	#if HAVE_DLFCN_H
1745	<	#include <dlfcn.h>
1746	<	#endif
1747	<
1748	<	#include <stdio.h>
1749	<
1750	<	#ifdef RTLD_GLOBAL
1751	<	#  define LT_DLGLOBAL           RTLD_GLOBAL
1752	<	#else
1753	<	#  ifdef DL_GLOBAL
1754	<	#    define LT_DLGLOBAL         DL_GLOBAL
1755	<	#  else
1756	<	#    define LT_DLGLOBAL         0
1757	<	#  endif
1758	<	#endif
1759	<
1760	<	/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
1761	<	find out it does not work in some platform. */
1762	<	#ifndef LT_DLLAZY_OR_NOW
1763	<	#  ifdef RTLD_LAZY
1764	<	#    define LT_DLLAZY_OR_NOW            RTLD_LAZY
1765	<	#  else
1766	<	#    ifdef DL_LAZY
1767	<	#      define LT_DLLAZY_OR_NOW          DL_LAZY
1768	<	#    else
1769	<	#      ifdef RTLD_NOW
1770	<	#        define LT_DLLAZY_OR_NOW        RTLD_NOW
1771	<	#      else
1772	<	#        ifdef DL_NOW
1773	<	#          define LT_DLLAZY_OR_NOW      DL_NOW
1774	<	#        else
1775	<	#          define LT_DLLAZY_OR_NOW      0
1776	<	#        endif
1777	<	#      endif
1778	<	#    endif
1779	<	#  endif
1780	<	#endif
1781	<
1782	<	void fnord() { int i=42;}
1783	<	int main ()
1784	<	{
1785	<	void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
1786	<	int status = $lt_dlunknown;
1787	<
1788	<	if (self)
1789	<	{
1790	<	if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;
1791	<	else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore;
1792	<	/* dlclose (self); */
1793	<	}
1794	<	else
1795	<	puts (dlerror ());
1796	<
1797	<	return status;
1798	<	}]
1799	<	_LT_EOF
1800	<	if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext} 2>/dev/null; then
1801	<	(./conftest; exit; ) >&AS_MESSAGE_LOG_FD 2>/dev/null
1802	<	lt_status=$?
1803	<	case x$lt_status in
1804	<	x$lt_dlno_uscore) $1 ;;
1805	<	x$lt_dlneed_uscore) $2 ;;
1806	<	x$lt_dlunknown|x*) $3 ;;
1807	<	esac
1808	<	else :
1809	<	# compilation failed
1810	<	$3
1811	<	fi
1812	<	fi
1813	<	rm -fr conftest*
1814	<	])# _LT_TRY_DLOPEN_SELF
1815	<
1816	<
1817	<	# LT_SYS_DLOPEN_SELF
1818	<	# ------------------
1819	<	AC_DEFUN([LT_SYS_DLOPEN_SELF],
1820	<	[m4_require([_LT_HEADER_DLFCN])dnl
1821	<	if test "x$enable_dlopen" != xyes; then
1822	<	enable_dlopen=unknown
1823	<	enable_dlopen_self=unknown
1824	<	enable_dlopen_self_static=unknown
1825	<	else
1826	<	lt_cv_dlopen=no
1827	<	lt_cv_dlopen_libs=
1828	<
1829	<	case $host_os in
1830	<	beos*)
1831	<	lt_cv_dlopen="load_add_on"
1832	<	lt_cv_dlopen_libs=
1833	<	lt_cv_dlopen_self=yes
1834	<	;;
1835	<
1836	<	mingw* | pw32* | cegcc*)
1837	<	lt_cv_dlopen="LoadLibrary"
1838	<	lt_cv_dlopen_libs=
1839	<	;;
1840	<
1841	<	cygwin*)
1842	<	lt_cv_dlopen="dlopen"
1843	<	lt_cv_dlopen_libs=
1844	<	;;
1845	<
1846	<	darwin*)
1847	<	# if libdl is installed we need to link against it
1848	<	AC_CHECK_LIB([dl], [dlopen],
1849	<	[lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],[
1850	<	lt_cv_dlopen="dyld"
1851	<	lt_cv_dlopen_libs=
1852	<	lt_cv_dlopen_self=yes
1853	<	])
1854	<	;;
1855	<
1856	<	*)
1857	<	AC_CHECK_FUNC([shl_load],
1858	<	[lt_cv_dlopen="shl_load"],
1859	<	[AC_CHECK_LIB([dld], [shl_load],
1860	<	[lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-ldld"],
1861	<	[AC_CHECK_FUNC([dlopen],
1862	<	[lt_cv_dlopen="dlopen"],
1863	<	[AC_CHECK_LIB([dl], [dlopen],
1864	<	[lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],
1865	<	[AC_CHECK_LIB([svld], [dlopen],
1866	<	[lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"],
1867	<	[AC_CHECK_LIB([dld], [dld_link],
1868	<	[lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-ldld"])
1869	<	])
1870	<	])
1871	<	])
1872	<	])
1873	<	])
1874	<	;;
1875	<	esac
1876	<
1877	<	if test "x$lt_cv_dlopen" != xno; then
1878	<	enable_dlopen=yes
1879	<	else
1880	<	enable_dlopen=no
1881	<	fi
1882	<
1883	<	case $lt_cv_dlopen in
1884	<	dlopen)
1885	<	save_CPPFLAGS="$CPPFLAGS"
1886	<	test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"
1887	<
1888	<	save_LDFLAGS="$LDFLAGS"
1889	<	wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"
1890	<
1891	<	save_LIBS="$LIBS"
1892	<	LIBS="$lt_cv_dlopen_libs $LIBS"
1893	<
1894	<	AC_CACHE_CHECK([whether a program can dlopen itself],
1895	<	lt_cv_dlopen_self, [dnl
1896	<	_LT_TRY_DLOPEN_SELF(
1897	<	lt_cv_dlopen_self=yes, lt_cv_dlopen_self=yes,
1898	<	lt_cv_dlopen_self=no, lt_cv_dlopen_self=cross)
1899	<	])
1900	<
1901	<	if test "x$lt_cv_dlopen_self" = xyes; then
1902	<	wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\"
1903	<	AC_CACHE_CHECK([whether a statically linked program can dlopen itself],
1904	<	lt_cv_dlopen_self_static, [dnl
1905	<	_LT_TRY_DLOPEN_SELF(
1906	<	lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=yes,
1907	<	lt_cv_dlopen_self_static=no,  lt_cv_dlopen_self_static=cross)
1908	<	])
1909	<	fi
1910	<
1911	<	CPPFLAGS="$save_CPPFLAGS"
1912	<	LDFLAGS="$save_LDFLAGS"
1913	<	LIBS="$save_LIBS"
1914	<	;;
1915	<	esac
1916	<
1917	<	case $lt_cv_dlopen_self in
1918	<	yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;;
1919	<	*) enable_dlopen_self=unknown ;;
1920	<	esac
1921	<
1922	<	case $lt_cv_dlopen_self_static in
1923	<	yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;;
1924	<	*) enable_dlopen_self_static=unknown ;;
1925	<	esac
1926	<	fi
1927	<	_LT_DECL([dlopen_support], [enable_dlopen], [0],
1928	<	[Whether dlopen is supported])
1929	<	_LT_DECL([dlopen_self], [enable_dlopen_self], [0],
1930	<	[Whether dlopen of programs is supported])
1931	<	_LT_DECL([dlopen_self_static], [enable_dlopen_self_static], [0],
1932	<	[Whether dlopen of statically linked programs is supported])
1933	<	])# LT_SYS_DLOPEN_SELF
1934	<
1935	<	# Old name:
1936	<	AU_ALIAS([AC_LIBTOOL_DLOPEN_SELF], [LT_SYS_DLOPEN_SELF])
1937	<	dnl aclocal-1.4 backwards compatibility:
1938	<	dnl AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF], [])
1939	<
1940	<
1941	<	# _LT_COMPILER_C_O([TAGNAME])
1942	<	# ---------------------------
1943	<	# Check to see if options -c and -o are simultaneously supported by compiler.
1944	<	# This macro does not hard code the compiler like AC_PROG_CC_C_O.
1945	<	m4_defun([_LT_COMPILER_C_O],
1946	<	[m4_require([_LT_DECL_SED])dnl
1947	<	m4_require([_LT_FILEUTILS_DEFAULTS])dnl
1948	<	m4_require([_LT_TAG_COMPILER])dnl
1949	<	AC_CACHE_CHECK([if $compiler supports -c -o file.$ac_objext],
1950	<	[_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)],
1951	<	[_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=no
1952	<	$RM -r conftest 2>/dev/null
1953	<	mkdir conftest
1954	<	cd conftest
1955	<	mkdir out
1956	<	echo "$lt_simple_compile_test_code" > conftest.$ac_ext
1957	<
1958	<	lt_compiler_flag="-o out/conftest2.$ac_objext"
1959	<	# Insert the option either (1) after the last *FLAGS variable, or
1960	<	# (2) before a word containing "conftest.", or (3) at the end.
1961	<	# Note that $ac_compile itself does not contain backslashes and begins
1962	<	# with a dollar sign (not a hyphen), so the echo should work correctly.
1963	<	lt_compile=`echo "$ac_compile" | $SED \
1964	<	-e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
1965	<	-e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \
1966	<	-e 's:$: $lt_compiler_flag:'`
1967	<	(eval echo "\"\$as_me:__oline__: $lt_compile\"" >&AS_MESSAGE_LOG_FD)
1968	<	(eval "$lt_compile" 2>out/conftest.err)
1969	<	ac_status=$?
1970	<	cat out/conftest.err >&AS_MESSAGE_LOG_FD
1971	<	echo "$as_me:__oline__: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
1972	<	if (exit $ac_status) && test -s out/conftest2.$ac_objext
1973	<	then
1974	<	# The compiler can only warn and ignore the option if not recognized
1975	<	# So say no if there are warnings
1976	<	$ECHO "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' > out/conftest.exp
1977	<	$SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
1978	<	if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
1979	<	_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes
1980	<	fi
1981	<	fi
1982	<	chmod u+w . 2>&AS_MESSAGE_LOG_FD
1983	<	$RM conftest*
1984	<	# SGI C++ compiler will create directory out/ii_files/ for
1985	<	# template instantiation
1986	<	test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
1987	<	$RM out/* && rmdir out
1988	<	cd ..
1989	<	$RM -r conftest
1990	<	$RM conftest*
1991	<	])
1992	<	_LT_TAGDECL([compiler_c_o], [lt_cv_prog_compiler_c_o], [1],
1993	<	[Does compiler simultaneously support -c and -o options?])
1994	<	])# _LT_COMPILER_C_O
1995	<
1996	<
1997	<	# _LT_COMPILER_FILE_LOCKS([TAGNAME])
1998	<	# ----------------------------------
1999	<	# Check to see if we can do hard links to lock some files if needed
2000	<	m4_defun([_LT_COMPILER_FILE_LOCKS],
2001	<	[m4_require([_LT_ENABLE_LOCK])dnl
2002	<	m4_require([_LT_FILEUTILS_DEFAULTS])dnl
2003	<	_LT_COMPILER_C_O([$1])
2004	<
2005	<	hard_links="nottested"
2006	<	if test "$_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)" = no && test "$need_locks" != no; then
2007	<	# do not overwrite the value of need_locks provided by the user
2008	<	AC_MSG_CHECKING([if we can lock with hard links])
2009	<	hard_links=yes
2010	<	$RM conftest*
2011	<	ln conftest.a conftest.b 2>/dev/null && hard_links=no
2012	<	touch conftest.a
2013	<	ln conftest.a conftest.b 2>&5 || hard_links=no
2014	<	ln conftest.a conftest.b 2>/dev/null && hard_links=no
2015	<	AC_MSG_RESULT([$hard_links])
2016	<	if test "$hard_links" = no; then
2017	<	AC_MSG_WARN([`$CC' does not support `-c -o', so `make -j' may be unsafe])
2018	<	need_locks=warn
2019	<	fi
2020	<	else
2021	<	need_locks=no
2022	<	fi
2023	<	_LT_DECL([], [need_locks], [1], [Must we lock files when doing compilation?])
2024	<	])# _LT_COMPILER_FILE_LOCKS
2025	<
2026	<
2027	<	# _LT_CHECK_OBJDIR
2028	<	# ----------------
2029	<	m4_defun([_LT_CHECK_OBJDIR],
2030	<	[AC_CACHE_CHECK([for objdir], [lt_cv_objdir],
2031	<	[rm -f .libs 2>/dev/null
2032	<	mkdir .libs 2>/dev/null
2033	<	if test -d .libs; then
2034	<	lt_cv_objdir=.libs
2035	<	else
2036	<	# MS-DOS does not allow filenames that begin with a dot.
2037	<	lt_cv_objdir=_libs
2038	<	fi
2039	<	rmdir .libs 2>/dev/null])
2040	<	objdir=$lt_cv_objdir
2041	<	_LT_DECL([], [objdir], [0],
2042	<	[The name of the directory that contains temporary libtool files])dnl
2043	<	m4_pattern_allow([LT_OBJDIR])dnl
2044	<	AC_DEFINE_UNQUOTED(LT_OBJDIR, "$lt_cv_objdir/",
2045	<	[Define to the sub-directory in which libtool stores uninstalled libraries.])
2046	<	])# _LT_CHECK_OBJDIR
2047	<
2048	<
2049	<	# _LT_LINKER_HARDCODE_LIBPATH([TAGNAME])
2050	<	# --------------------------------------
2051	<	# Check hardcoding attributes.
2052	<	m4_defun([_LT_LINKER_HARDCODE_LIBPATH],
2053	<	[AC_MSG_CHECKING([how to hardcode library paths into programs])
2054	<	_LT_TAGVAR(hardcode_action, $1)=
2055	<	if test -n "$_LT_TAGVAR(hardcode_libdir_flag_spec, $1)" ||
2056	<	test -n "$_LT_TAGVAR(runpath_var, $1)" ||
2057	<	test "X$_LT_TAGVAR(hardcode_automatic, $1)" = "Xyes" ; then
2058	<
2059	<	# We can hardcode non-existent directories.
2060	<	if test "$_LT_TAGVAR(hardcode_direct, $1)" != no &&
2061	<	# If the only mechanism to avoid hardcoding is shlibpath_var, we
2062	<	# have to relink, otherwise we might link with an installed library
2063	<	# when we should be linking with a yet-to-be-installed one
2064	<	## test "$_LT_TAGVAR(hardcode_shlibpath_var, $1)" != no &&
2065	<	test "$_LT_TAGVAR(hardcode_minus_L, $1)" != no; then
2066	<	# Linking always hardcodes the temporary library directory.
2067	<	_LT_TAGVAR(hardcode_action, $1)=relink
2068	<	else
2069	<	# We can link without hardcoding, and we can hardcode nonexisting dirs.
2070	<	_LT_TAGVAR(hardcode_action, $1)=immediate
2071	<	fi
2072	<	else
2073	<	# We cannot hardcode anything, or else we can only hardcode existing
2074	<	# directories.
2075	<	_LT_TAGVAR(hardcode_action, $1)=unsupported
2076	<	fi
2077	<	AC_MSG_RESULT([$_LT_TAGVAR(hardcode_action, $1)])
2078	<
2079	<	if test "$_LT_TAGVAR(hardcode_action, $1)" = relink ||
2080	<	test "$_LT_TAGVAR(inherit_rpath, $1)" = yes; then
2081	<	# Fast installation is not supported
2082	<	enable_fast_install=no
2083	<	elif test "$shlibpath_overrides_runpath" = yes ||
2084	<	test "$enable_shared" = no; then
2085	<	# Fast installation is not necessary
2086	<	enable_fast_install=needless
2087	<	fi
2088	<	_LT_TAGDECL([], [hardcode_action], [0],
2089	<	[How to hardcode a shared library path into an executable])
2090	<	])# _LT_LINKER_HARDCODE_LIBPATH
2091	<
2092	<
2093	<	# _LT_CMD_STRIPLIB
2094	<	# ----------------
2095	<	m4_defun([_LT_CMD_STRIPLIB],
2096	<	[m4_require([_LT_DECL_EGREP])
2097	<	striplib=
2098	<	old_striplib=
2099	<	AC_MSG_CHECKING([whether stripping libraries is possible])
2100	<	if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then
2101	<	test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"
2102	<	test -z "$striplib" && striplib="$STRIP --strip-unneeded"
2103	<	AC_MSG_RESULT([yes])
2104	<	else
2105	<	# FIXME - insert some real tests, host_os isn't really good enough
2106	<	case $host_os in
2107	<	darwin*)
2108	<	if test -n "$STRIP" ; then
2109	<	striplib="$STRIP -x"
2110	<	old_striplib="$STRIP -S"
2111	<	AC_MSG_RESULT([yes])
2112	<	else
2113	<	AC_MSG_RESULT([no])
2114	<	fi
2115	<	;;
2116	<	*)
2117	<	AC_MSG_RESULT([no])
2118	<	;;
2119	<	esac
2120	<	fi
2121	<	_LT_DECL([], [old_striplib], [1], [Commands to strip libraries])
2122	<	_LT_DECL([], [striplib], [1])
2123	<	])# _LT_CMD_STRIPLIB
2124	<
2125	<
2126	<	# _LT_SYS_DYNAMIC_LINKER([TAG])
2127	<	# -----------------------------
2128	<	# PORTME Fill in your ld.so characteristics
2129	<	m4_defun([_LT_SYS_DYNAMIC_LINKER],
2130	<	[AC_REQUIRE([AC_CANONICAL_HOST])dnl
2131	<	m4_require([_LT_DECL_EGREP])dnl
2132	<	m4_require([_LT_FILEUTILS_DEFAULTS])dnl
2133	<	m4_require([_LT_DECL_OBJDUMP])dnl
2134	<	m4_require([_LT_DECL_SED])dnl
2135	<	AC_MSG_CHECKING([dynamic linker characteristics])
2136	<	m4_if([$1],
2137	<	[], [
2138	<	if test "$GCC" = yes; then
2139	<	case $host_os in
2140	<	darwin*) lt_awk_arg="/^libraries:/,/LR/" ;;
2141	<	*) lt_awk_arg="/^libraries:/" ;;
2142	<	esac
2143	<	lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e "s,=/,/,g"`
2144	<	if $ECHO "$lt_search_path_spec" | $GREP ';' >/dev/null ; then
2145	<	# if the path contains ";" then we assume it to be the separator
2146	<	# otherwise default to the standard path separator (i.e. ":") - it is
2147	<	# assumed that no part of a normal pathname contains ";" but that should
2148	<	# okay in the real world where ";" in dirpaths is itself problematic.
2149	<	lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED -e 's/;/ /g'`
2150	<	else
2151	<	lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`
2152	<	fi
2153	<	# Ok, now we have the path, separated by spaces, we can step through it
2154	<	# and add multilib dir if necessary.
2155	<	lt_tmp_lt_search_path_spec=
2156	<	lt_multi_os_dir=`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null`
2157	<	for lt_sys_path in $lt_search_path_spec; do
2158	<	if test -d "$lt_sys_path/$lt_multi_os_dir"; then
2159	<	lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path/$lt_multi_os_dir"
2160	<	else
2161	<	test -d "$lt_sys_path" && \
2162	<	lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path"
2163	<	fi
2164	<	done
2165	<	lt_search_path_spec=`$ECHO $lt_tmp_lt_search_path_spec | awk '
2166	<	BEGIN {RS=" "; FS="/|\n";} {
2167	<	lt_foo="";
2168	<	lt_count=0;
2169	<	for (lt_i = NF; lt_i > 0; lt_i--) {
2170	<	if ($lt_i != "" && $lt_i != ".") {
2171	<	if ($lt_i == "..") {
2172	<	lt_count++;
2173	<	} else {
2174	<	if (lt_count == 0) {
2175	<	lt_foo="/" $lt_i lt_foo;
2176	<	} else {
2177	<	lt_count--;
2178	<	}
2179	<	}
2180	<	}
2181	<	}
2182	<	if (lt_foo != "") { lt_freq[[lt_foo]]++; }
2183	<	if (lt_freq[[lt_foo]] == 1) { print lt_foo; }
2184	<	}'`
2185	<	sys_lib_search_path_spec=`$ECHO $lt_search_path_spec`
2186	<	else
2187	<	sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
2188	<	fi])
2189	<	library_names_spec=
2190	<	libname_spec='lib$name'
2191	<	soname_spec=
2192	<	shrext_cmds=".so"
2193	<	postinstall_cmds=
2194	<	postuninstall_cmds=
2195	<	finish_cmds=
2196	<	finish_eval=
2197	<	shlibpath_var=
2198	<	shlibpath_overrides_runpath=unknown
2199	<	version_type=none
2200	<	dynamic_linker="$host_os ld.so"
2201	<	sys_lib_dlsearch_path_spec="/lib /usr/lib"
2202	<	need_lib_prefix=unknown
2203	<	hardcode_into_libs=no
2204	<
2205	<	# when you set need_version to no, make sure it does not cause -set_version
2206	<	# flags to be left without arguments
2207	<	need_version=unknown
2208	<
2209	<	case $host_os in
2210	<	aix3*)
2211	<	version_type=linux
2212	<	library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'
2213	<	shlibpath_var=LIBPATH
2214	<
2215	<	# AIX 3 has no versioning support, so we append a major version to the name.
2216	<	soname_spec='${libname}${release}${shared_ext}$major'
2217	<	;;
2218	<
2219	<	aix[[4-9]]*)
2220	<	version_type=linux
2221	<	need_lib_prefix=no
2222	<	need_version=no
2223	<	hardcode_into_libs=yes
2224	<	if test "$host_cpu" = ia64; then
2225	<	# AIX 5 supports IA64
2226	<	library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'
2227	<	shlibpath_var=LD_LIBRARY_PATH
2228	<	else
2229	<	# With GCC up to 2.95.x, collect2 would create an import file
2230	<	# for dependence libraries.  The import file would start with
2231	<	# the line `#! .'.  This would cause the generated library to
2232	<	# depend on `.', always an invalid library.  This was fixed in
2233	<	# development snapshots of GCC prior to 3.0.
2234	<	case $host_os in
2235	<	aix4 | aix4.[[01]] | aix4.[[01]].*)
2236	<	if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
2237	<	echo ' yes '
2238	<	echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then
2239	<	:
2240	<	else
2241	<	can_build_shared=no
2242	<	fi
2243	<	;;
2244	<	esac
2245	<	# AIX (on Power*) has no versioning support, so currently we can not hardcode correct
2246	<	# soname into executable. Probably we can add versioning support to
2247	<	# collect2, so additional links can be useful in future.
2248	<	if test "$aix_use_runtimelinking" = yes; then
2249	<	# If using run time linking (on AIX 4.2 or later) use lib<name>.so
2250	<	# instead of lib<name>.a to let people know that these are not
2251	<	# typical AIX shared libraries.
2252	<	library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
2253	<	else
2254	<	# We preserve .a as extension for shared libraries through AIX4.2
2255	<	# and later when we are not doing run time linking.
2256	<	library_names_spec='${libname}${release}.a $libname.a'
2257	<	soname_spec='${libname}${release}${shared_ext}$major'
2258	<	fi
2259	<	shlibpath_var=LIBPATH
2260	<	fi
2261	<	;;
2262	<
2263	<	amigaos*)
2264	<	case $host_cpu in
2265	<	powerpc)
2266	<	# Since July 2007 AmigaOS4 officially supports .so libraries.
2267	<	# When compiling the executable, add -use-dynld -Lsobjs: to the compileline.
2268	<	library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
2269	<	;;
2270	<	m68k)
2271	<	library_names_spec='$libname.ixlibrary $libname.a'
2272	<	# Create ${libname}_ixlibrary.a entries in /sys/libs.
2273	<	finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$ECHO "X$lib" | $Xsed -e '\''s%^.*/\([[^/]]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
2274	<	;;
2275	<	esac
2276	<	;;
2277	<
2278	<	beos*)
2279	<	library_names_spec='${libname}${shared_ext}'
2280	<	dynamic_linker="$host_os ld.so"
2281	<	shlibpath_var=LIBRARY_PATH
2282	<	;;
2283	<
2284	<	bsdi[[45]]*)
2285	<	version_type=linux
2286	<	need_version=no
2287	<	library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
2288	<	soname_spec='${libname}${release}${shared_ext}$major'
2289	<	finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
2290	<	shlibpath_var=LD_LIBRARY_PATH
2291	<	sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
2292	<	sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
2293	<	# the default ld.so.conf also contains /usr/contrib/lib and
2294	<	# /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
2295	<	# libtool to hard-code these into programs
2296	<	;;
2297	<
2298	<	cygwin* | mingw* | pw32* | cegcc*)
2299	<	version_type=windows
2300	<	shrext_cmds=".dll"
2301	<	need_version=no
2302	<	need_lib_prefix=no
2303	<
2304	<	case $GCC,$host_os in
2305	<	yes,cygwin* | yes,mingw* | yes,pw32* | yes,cegcc*)
2306	<	library_names_spec='$libname.dll.a'
2307	<	# DLL is installed to $(libdir)/../bin by postinstall_cmds
2308	<	postinstall_cmds='base_file=`basename \${file}`~
2309	<	dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~
2310	<	dldir=$destdir/`dirname \$dlpath`~
2311	<	test -d \$dldir || mkdir -p \$dldir~
2312	<	$install_prog $dir/$dlname \$dldir/$dlname~
2313	<	chmod a+x \$dldir/$dlname~
2314	<	if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
2315	<	eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
2316	<	fi'
2317	<	postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
2318	<	dlpath=$dir/\$dldll~
2319	<	$RM \$dlpath'
2320	<	shlibpath_overrides_runpath=yes
2321	<
2322	<	case $host_os in
2323	<	cygwin*)
2324	<	# Cygwin DLLs use 'cyg' prefix rather than 'lib'
2325	<	soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
2326	<	sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib"
2327	<	;;
2328	<	mingw* | cegcc*)
2329	<	# MinGW DLLs use traditional 'lib' prefix
2330	<	soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
2331	<	sys_lib_search_path_spec=`$CC -print-search-dirs | $GREP "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`
2332	<	if $ECHO "$sys_lib_search_path_spec" | [$GREP ';[c-zC-Z]:/' >/dev/null]; then
2333	<	# It is most probably a Windows format PATH printed by
2334	<	# mingw gcc, but we are running on Cygwin. Gcc prints its search
2335	<	# path with ; separators, and with drive letters. We can handle the
2336	<	# drive letters (cygwin fileutils understands them), so leave them,
2337	<	# especially as we might pass files found there to a mingw objdump,
2338	<	# which wouldn't understand a cygwinified path. Ahh.
2339	<	sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
2340	<	else
2341	<	sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`
2342	<	fi
2343	<	;;
2344	<	pw32*)
2345	<	# pw32 DLLs use 'pw' prefix rather than 'lib'
2346	<	library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
2347	<	;;
2348	<	esac
2349	<	;;
2350	<
2351	<	*)
2352	<	library_names_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext} $libname.lib'
2353	<	;;
2354	<	esac
2355	<	dynamic_linker='Win32 ld.exe'
2356	<	# FIXME: first we should search . and the directory the executable is in
2357	<	shlibpath_var=PATH
2358	<	;;
2359	<
2360	<	darwin* | rhapsody*)
2361	<	dynamic_linker="$host_os dyld"
2362	<	version_type=darwin
2363	<	need_lib_prefix=no
2364	<	need_version=no
2365	<	library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext'
2366	<	soname_spec='${libname}${release}${major}$shared_ext'
2367	<	shlibpath_overrides_runpath=yes
2368	<	shlibpath_var=DYLD_LIBRARY_PATH
2369	<	shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'
2370	<	m4_if([$1], [],[
2371	<	sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/local/lib"])
2372	<	sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
2373	<	;;
2374	<
2375	<	dgux*)
2376	<	version_type=linux
2377	<	need_lib_prefix=no
2378	<	need_version=no
2379	<	library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'
2380	<	soname_spec='${libname}${release}${shared_ext}$major'
2381	<	shlibpath_var=LD_LIBRARY_PATH
2382	<	;;
2383	<
2384	<	freebsd1*)
2385	<	dynamic_linker=no
2386	<	;;
2387	<
2388	<	freebsd* | dragonfly*)
2389	<	# DragonFly does not have aout.  When/if they implement a new
2390	<	# versioning mechanism, adjust this.
2391	<	if test -x /usr/bin/objformat; then
2392	<	objformat=`/usr/bin/objformat`
2393	<	else
2394	<	case $host_os in
2395	<	freebsd[[123]]*) objformat=aout ;;
2396	<	*) objformat=elf ;;
2397	<	esac
2398	<	fi
2399	<	version_type=freebsd-$objformat
2400	<	case $version_type in
2401	<	freebsd-elf*)
2402	<	library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
2403	<	need_version=no
2404	<	need_lib_prefix=no
2405	<	;;
2406	<	freebsd-*)
2407	<	library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'
2408	<	need_version=yes
2409	<	;;
2410	<	esac
2411	<	shlibpath_var=LD_LIBRARY_PATH
2412	<	case $host_os in
2413	<	freebsd2*)
2414	<	shlibpath_overrides_runpath=yes
2415	<	;;
2416	<	freebsd3.[[01]]* | freebsdelf3.[[01]]*)
2417	<	shlibpath_overrides_runpath=yes
2418	<	hardcode_into_libs=yes
2419	<	;;
2420	<	freebsd3.[[2-9]]* | freebsdelf3.[[2-9]]* | \
2421	<	freebsd4.[[0-5]] | freebsdelf4.[[0-5]] | freebsd4.1.1 | freebsdelf4.1.1)
2422	<	shlibpath_overrides_runpath=no
2423	<	hardcode_into_libs=yes
2424	<	;;
2425	<	*) # from 4.6 on, and DragonFly
2426	<	shlibpath_overrides_runpath=yes
2427	<	hardcode_into_libs=yes
2428	<	;;
2429	<	esac
2430	<	;;
2431	<
2432	<	gnu*)
2433	<	version_type=linux
2434	<	need_lib_prefix=no
2435	<	need_version=no
2436	<	library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
2437	<	soname_spec='${libname}${release}${shared_ext}$major'
2438	<	shlibpath_var=LD_LIBRARY_PATH
2439	<	hardcode_into_libs=yes
2440	<	;;
2441	<
2442	<	hpux9* | hpux10* | hpux11*)
2443	<	# Give a soname corresponding to the major version so that dld.sl refuses to
2444	<	# link against other versions.
2445	<	version_type=sunos
2446	<	need_lib_prefix=no
2447	<	need_version=no
2448	<	case $host_cpu in
2449	<	ia64*)
2450	<	shrext_cmds='.so'
2451	<	hardcode_into_libs=yes
2452	<	dynamic_linker="$host_os dld.so"
2453	<	shlibpath_var=LD_LIBRARY_PATH
2454	<	shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
2455	<	library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
2456	<	soname_spec='${libname}${release}${shared_ext}$major'
2457	<	if test "X$HPUX_IA64_MODE" = X32; then
2458	<	sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
2459	<	else
2460	<	sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
2461	<	fi
2462	<	sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
2463	<	;;
2464	<	hppa*64*)
2465	<	shrext_cmds='.sl'
2466	<	hardcode_into_libs=yes
2467	<	dynamic_linker="$host_os dld.sl"
2468	<	shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
2469	<	shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
2470	<	library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
2471	<	soname_spec='${libname}${release}${shared_ext}$major'
2472	<	sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
2473	<	sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
2474	<	;;
2475	<	*)
2476	<	shrext_cmds='.sl'
2477	<	dynamic_linker="$host_os dld.sl"
2478	<	shlibpath_var=SHLIB_PATH
2479	<	shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
2480	<	library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
2481	<	soname_spec='${libname}${release}${shared_ext}$major'
2482	<	;;
2483	<	esac
2484	<	# HP-UX runs *really* slowly unless shared libraries are mode 555.
2485	<	postinstall_cmds='chmod 555 $lib'
2486	<	;;
2487	<
2488	<	interix[[3-9]]*)
2489	<	version_type=linux
2490	<	need_lib_prefix=no
2491	<	need_version=no
2492	<	library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
2493	<	soname_spec='${libname}${release}${shared_ext}$major'
2494	<	dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
2495	<	shlibpath_var=LD_LIBRARY_PATH
2496	<	shlibpath_overrides_runpath=no
2497	<	hardcode_into_libs=yes
2498	<	;;
2499	<
2500	<	irix5* | irix6* | nonstopux*)
2501	<	case $host_os in
2502	<	nonstopux*) version_type=nonstopux ;;
2503	<	*)
2504	<	if test "$lt_cv_prog_gnu_ld" = yes; then
2505	<	version_type=linux
2506	<	else
2507	<	version_type=irix
2508	<	fi ;;
2509	<	esac
2510	<	need_lib_prefix=no
2511	<	need_version=no
2512	<	soname_spec='${libname}${release}${shared_ext}$major'
2513	<	library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'
2514	<	case $host_os in
2515	<	irix5* | nonstopux*)
2516	<	libsuff= shlibsuff=
2517	<	;;
2518	<	*)
2519	<	case $LD in # libtool.m4 will add one of these switches to LD
2520	<	*-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
2521	<	libsuff= shlibsuff= libmagic=32-bit;;
2522	<	*-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")
2523	<	libsuff=32 shlibsuff=N32 libmagic=N32;;
2524	<	*-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")
2525	<	libsuff=64 shlibsuff=64 libmagic=64-bit;;
2526	<	*) libsuff= shlibsuff= libmagic=never-match;;
2527	<	esac
2528	<	;;
2529	<	esac
2530	<	shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
2531	<	shlibpath_overrides_runpath=no
2532	<	sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"
2533	<	sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"
2534	<	hardcode_into_libs=yes
2535	<	;;
2536	<
2537	<	# No shared lib support for Linux oldld, aout, or coff.
2538	<	linux*oldld* | linux*aout* | linux*coff*)
2539	<	dynamic_linker=no
2540	<	;;
2541	<
2542	<	# This must be Linux ELF.
2543	<	linux* | k*bsd*-gnu)
2544	<	version_type=linux
2545	<	need_lib_prefix=no
2546	<	need_version=no
2547	<	library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
2548	<	soname_spec='${libname}${release}${shared_ext}$major'
2549	<	finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
2550	<	shlibpath_var=LD_LIBRARY_PATH
2551	<	shlibpath_overrides_runpath=no
2552	<	# Some binutils ld are patched to set DT_RUNPATH
2553	<	save_LDFLAGS=$LDFLAGS
2554	<	save_libdir=$libdir
2555	<	eval "libdir=/foo; wl=\"$_LT_TAGVAR(lt_prog_compiler_wl, $1)\"; \
2556	<	LDFLAGS=\"\$LDFLAGS $_LT_TAGVAR(hardcode_libdir_flag_spec, $1)\""
2557	<	AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])],
2558	<	[AS_IF([ ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null],
2559	<	[shlibpath_overrides_runpath=yes])])
2560	<	LDFLAGS=$save_LDFLAGS
2561	<	libdir=$save_libdir
2562	<
2563	<	# This implies no fast_install, which is unacceptable.
2564	<	# Some rework will be needed to allow for fast_install
2565	<	# before this can be enabled.
2566	<	hardcode_into_libs=yes
2567	<
2568	<	# Append ld.so.conf contents to the search path
2569	<	if test -f /etc/ld.so.conf; then
2570	<	lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \[$]2)); skip = 1; } { if (!skip) print \[$]0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[   ]*hwcap[        ]/d;s/[:,      ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;/^$/d' | tr '\n' ' '`
2571	<	sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
2572	<	fi
2573	<
2574	<	# We used to test for /lib/ld.so.1 and disable shared libraries on
2575	<	# powerpc, because MkLinux only supported shared libraries with the
2576	<	# GNU dynamic linker.  Since this was broken with cross compilers,
2577	<	# most powerpc-linux boxes support dynamic linking these days and
2578	<	# people can always --disable-shared, the test was removed, and we
2579	<	# assume the GNU/Linux dynamic linker is in use.
2580	<	dynamic_linker='GNU/Linux ld.so'
2581	<	;;
2582	<
2583	<	netbsd*)
2584	<	version_type=sunos
2585	<	need_lib_prefix=no
2586	<	need_version=no
2587	<	if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
2588	<	library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
2589	<	finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
2590	<	dynamic_linker='NetBSD (a.out) ld.so'
2591	<	else
2592	<	library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
2593	<	soname_spec='${libname}${release}${shared_ext}$major'
2594	<	dynamic_linker='NetBSD ld.elf_so'
2595	<	fi
2596	<	shlibpath_var=LD_LIBRARY_PATH
2597	<	shlibpath_overrides_runpath=yes
2598	<	hardcode_into_libs=yes
2599	<	;;
2600	<
2601	<	newsos6)
2602	<	version_type=linux
2603	<	library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
2604	<	shlibpath_var=LD_LIBRARY_PATH
2605	<	shlibpath_overrides_runpath=yes
2606	<	;;
2607	<
2608	<	*nto* | *qnx*)
2609	<	version_type=qnx
2610	<	need_lib_prefix=no
2611	<	need_version=no
2612	<	library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
2613	<	soname_spec='${libname}${release}${shared_ext}$major'
2614	<	shlibpath_var=LD_LIBRARY_PATH
2615	<	shlibpath_overrides_runpath=no
2616	<	hardcode_into_libs=yes
2617	<	dynamic_linker='ldqnx.so'
2618	<	;;
2619	<
2620	<	openbsd*)
2621	<	version_type=sunos
2622	<	sys_lib_dlsearch_path_spec="/usr/lib"
2623	<	need_lib_prefix=no
2624	<	# Some older versions of OpenBSD (3.3 at least) *do* need versioned libs.
2625	<	case $host_os in
2626	<	openbsd3.3 | openbsd3.3.*)  need_version=yes ;;
2627	<	*)                          need_version=no  ;;
2628	<	esac
2629	<	library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
2630	<	finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
2631	<	shlibpath_var=LD_LIBRARY_PATH
2632	<	if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
2633	<	case $host_os in
2634	<	openbsd2.[[89]] | openbsd2.[[89]].*)
2635	<	shlibpath_overrides_runpath=no
2636	<	;;
2637	<	*)
2638	<	shlibpath_overrides_runpath=yes
2639	<	;;
2640	<	esac
2641	<	else
2642	<	shlibpath_overrides_runpath=yes
2643	<	fi
2644	<	;;
2645	<
2646	<	os2*)
2647	<	libname_spec='$name'
2648	<	shrext_cmds=".dll"
2649	<	need_lib_prefix=no
2650	<	library_names_spec='$libname${shared_ext} $libname.a'
2651	<	dynamic_linker='OS/2 ld.exe'
2652	<	shlibpath_var=LIBPATH
2653	<	;;
2654	<
2655	<	osf3* | osf4* | osf5*)
2656	<	version_type=osf
2657	<	need_lib_prefix=no
2658	<	need_version=no
2659	<	soname_spec='${libname}${release}${shared_ext}$major'
2660	<	library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
2661	<	shlibpath_var=LD_LIBRARY_PATH
2662	<	sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
2663	<	sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"
2664	<	;;
2665	<
2666	<	rdos*)
2667	<	dynamic_linker=no
2668	<	;;
2669	<
2670	<	solaris*)
2671	<	version_type=linux
2672	<	need_lib_prefix=no
2673	<	need_version=no
2674	<	library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
2675	<	soname_spec='${libname}${release}${shared_ext}$major'
2676	<	shlibpath_var=LD_LIBRARY_PATH
2677	<	shlibpath_overrides_runpath=yes
2678	<	hardcode_into_libs=yes
2679	<	# ldd complains unless libraries are executable
2680	<	postinstall_cmds='chmod +x $lib'
2681	<	;;
2682	<
2683	<	sunos4*)
2684	<	version_type=sunos
2685	<	library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
2686	<	finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
2687	<	shlibpath_var=LD_LIBRARY_PATH
2688	<	shlibpath_overrides_runpath=yes
2689	<	if test "$with_gnu_ld" = yes; then
2690	<	need_lib_prefix=no
2691	<	fi
2692	<	need_version=yes
2693	<	;;
2694	<
2695	<	sysv4 | sysv4.3*)
2696	<	version_type=linux
2697	<	library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
2698	<	soname_spec='${libname}${release}${shared_ext}$major'
2699	<	shlibpath_var=LD_LIBRARY_PATH
2700	<	case $host_vendor in
2701	<	sni)
2702	<	shlibpath_overrides_runpath=no
2703	<	need_lib_prefix=no
2704	<	runpath_var=LD_RUN_PATH
2705	<	;;
2706	<	siemens)
2707	<	need_lib_prefix=no
2708	<	;;
2709	<	motorola)
2710	<	need_lib_prefix=no
2711	<	need_version=no
2712	<	shlibpath_overrides_runpath=no
2713	<	sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
2714	<	;;
2715	<	esac
2716	<	;;
2717	<
2718	<	sysv4*MP*)
2719	<	if test -d /usr/nec ;then
2720	<	version_type=linux
2721	<	library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'
2722	<	soname_spec='$libname${shared_ext}.$major'
2723	<	shlibpath_var=LD_LIBRARY_PATH
2724	<	fi
2725	<	;;
2726	<
2727	<	sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
2728	<	version_type=freebsd-elf
2729	<	need_lib_prefix=no
2730	<	need_version=no
2731	<	library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
2732	<	soname_spec='${libname}${release}${shared_ext}$major'
2733	<	shlibpath_var=LD_LIBRARY_PATH
2734	<	shlibpath_overrides_runpath=yes
2735	<	hardcode_into_libs=yes
2736	<	if test "$with_gnu_ld" = yes; then
2737	<	sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
2738	<	else
2739	<	sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
2740	<	case $host_os in
2741	<	sco3.2v5*)
2742	<	sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"
2743	<	;;
2744	<	esac
2745	<	fi
2746	<	sys_lib_dlsearch_path_spec='/usr/lib'
2747	<	;;
2748	<
2749	<	tpf*)
2750	<	# TPF is a cross-target only.  Preferred cross-host = GNU/Linux.
2751	<	version_type=linux
2752	<	need_lib_prefix=no
2753	<	need_version=no
2754	<	library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
2755	<	shlibpath_var=LD_LIBRARY_PATH
2756	<	shlibpath_overrides_runpath=no
2757	<	hardcode_into_libs=yes
2758	<	;;
2759	<
2760	<	uts4*)
2761	<	version_type=linux
2762	<	library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
2763	<	soname_spec='${libname}${release}${shared_ext}$major'
2764	<	shlibpath_var=LD_LIBRARY_PATH
2765	<	;;
2766	<
2767	<	*)
2768	<	dynamic_linker=no
2769	<	;;
2770	<	esac
2771	<	AC_MSG_RESULT([$dynamic_linker])
2772	<	test "$dynamic_linker" = no && can_build_shared=no
2773	<
2774	<	variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
2775	<	if test "$GCC" = yes; then
2776	<	variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
2777	<	fi
2778	<
2779	<	if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then
2780	<	sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec"
2781	<	fi
2782	<	if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then
2783	<	sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec"
2784	<	fi
2785	<
2786	<	_LT_DECL([], [variables_saved_for_relink], [1],
2787	<	[Variables whose values should be saved in libtool wrapper scripts and
2788	<	restored at link time])
2789	<	_LT_DECL([], [need_lib_prefix], [0],
2790	<	[Do we need the "lib" prefix for modules?])
2791	<	_LT_DECL([], [need_version], [0], [Do we need a version for libraries?])
2792	<	_LT_DECL([], [version_type], [0], [Library versioning type])
2793	<	_LT_DECL([], [runpath_var], [0],  [Shared library runtime path variable])
2794	<	_LT_DECL([], [shlibpath_var], [0],[Shared library path variable])
2795	<	_LT_DECL([], [shlibpath_overrides_runpath], [0],
2796	<	[Is shlibpath searched before the hard-coded library search path?])
2797	<	_LT_DECL([], [libname_spec], [1], [Format of library name prefix])
2798	<	_LT_DECL([], [library_names_spec], [1],
2799	<	[[List of archive names.  First name is the real one, the rest are links.
2800	<	The last name is the one that the linker finds with -lNAME]])
2801	<	_LT_DECL([], [soname_spec], [1],
2802	<	[[The coded name of the library, if different from the real name]])
2803	<	_LT_DECL([], [postinstall_cmds], [2],
2804	<	[Command to use after installation of a shared archive])
2805	<	_LT_DECL([], [postuninstall_cmds], [2],
2806	<	[Command to use after uninstallation of a shared archive])
2807	<	_LT_DECL([], [finish_cmds], [2],
2808	<	[Commands used to finish a libtool library installation in a directory])
2809	<	_LT_DECL([], [finish_eval], [1],
2810	<	[[As "finish_cmds", except a single script fragment to be evaled but
2811	<	not shown]])
2812	<	_LT_DECL([], [hardcode_into_libs], [0],
2813	<	[Whether we should hardcode library paths into libraries])
2814	<	_LT_DECL([], [sys_lib_search_path_spec], [2],
2815	<	[Compile-time system search path for libraries])
2816	<	_LT_DECL([], [sys_lib_dlsearch_path_spec], [2],
2817	<	[Run-time system search path for libraries])
2818	<	])# _LT_SYS_DYNAMIC_LINKER
2819	<
2820	<
2821	<	# _LT_PATH_TOOL_PREFIX(TOOL)
2822	<	# --------------------------
2823	<	# find a file program which can recognize shared library
2824	<	AC_DEFUN([_LT_PATH_TOOL_PREFIX],
2825	<	[m4_require([_LT_DECL_EGREP])dnl
2826	<	AC_MSG_CHECKING([for $1])
2827	<	AC_CACHE_VAL(lt_cv_path_MAGIC_CMD,
2828	<	[case $MAGIC_CMD in
2829	<	[[\\/*] |  ?:[\\/]*])
2830	<	lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
2831	<	;;
2832	<	*)
2833	<	lt_save_MAGIC_CMD="$MAGIC_CMD"
2834	<	lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
2835	<	dnl $ac_dummy forces splitting on constant user-supplied paths.
2836	<	dnl POSIX.2 word splitting is done only on the output of word expansions,
2837	<	dnl not every word.  This closes a longstanding sh security hole.
2838	<	ac_dummy="m4_if([$2], , $PATH, [$2])"
2839	<	for ac_dir in $ac_dummy; do
2840	<	IFS="$lt_save_ifs"
2841	<	test -z "$ac_dir" && ac_dir=.
2842	<	if test -f $ac_dir/$1; then
2843	<	lt_cv_path_MAGIC_CMD="$ac_dir/$1"
2844	<	if test -n "$file_magic_test_file"; then
2845	<	case $deplibs_check_method in
2846	<	"file_magic "*)
2847	<	file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
2848	<	MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
2849	<	if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
2850	<	$EGREP "$file_magic_regex" > /dev/null; then
2851	<	:
2852	<	else
2853	<	cat <<_LT_EOF 1>&2
2854	<
2855	<	*** Warning: the command libtool uses to detect shared libraries,
2856	<	*** $file_magic_cmd, produces output that libtool cannot recognize.
2857	<	*** The result is that libtool may fail to recognize shared libraries
2858	<	*** as such.  This will affect the creation of libtool libraries that
2859	<	*** depend on shared libraries, but programs linked with such libtool
2860	<	*** libraries will work regardless of this problem.  Nevertheless, you
2861	<	*** may want to report the problem to your system manager and/or to
2862	<	*** bug-libtool@gnu.org
2863	<
2864	<	_LT_EOF
2865	<	fi ;;
2866	<	esac
2867	<	fi
2868	<	break
2869	<	fi
2870	<	done
2871	<	IFS="$lt_save_ifs"
2872	<	MAGIC_CMD="$lt_save_MAGIC_CMD"
2873	<	;;
2874	<	esac])
2875	<	MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
2876	<	if test -n "$MAGIC_CMD"; then
2877	<	AC_MSG_RESULT($MAGIC_CMD)
2878	<	else
2879	<	AC_MSG_RESULT(no)
2880	<	fi
2881	<	_LT_DECL([], [MAGIC_CMD], [0],
2882	<	[Used to examine libraries when file_magic_cmd begins with "file"])dnl
2883	<	])# _LT_PATH_TOOL_PREFIX
2884	<
2885	<	# Old name:
2886	<	AU_ALIAS([AC_PATH_TOOL_PREFIX], [_LT_PATH_TOOL_PREFIX])
2887	<	dnl aclocal-1.4 backwards compatibility:
2888	<	dnl AC_DEFUN([AC_PATH_TOOL_PREFIX], [])
2889	<
2890	<
2891	<	# _LT_PATH_MAGIC
2892	<	# --------------
2893	<	# find a file program which can recognize a shared library
2894	<	m4_defun([_LT_PATH_MAGIC],
2895	<	[_LT_PATH_TOOL_PREFIX(${ac_tool_prefix}file, /usr/bin$PATH_SEPARATOR$PATH)
2896	<	if test -z "$lt_cv_path_MAGIC_CMD"; then
2897	<	if test -n "$ac_tool_prefix"; then
2898	<	_LT_PATH_TOOL_PREFIX(file, /usr/bin$PATH_SEPARATOR$PATH)
2899	<	else
2900	<	MAGIC_CMD=:
2901	<	fi
2902	<	fi
2903	<	])# _LT_PATH_MAGIC
2904	<
2905	<
2906	<	# LT_PATH_LD
2907	<	# ----------
2908	<	# find the pathname to the GNU or non-GNU linker
2909	<	AC_DEFUN([LT_PATH_LD],
2910	<	[AC_REQUIRE([AC_PROG_CC])dnl
2911	<	AC_REQUIRE([AC_CANONICAL_HOST])dnl
2912	<	AC_REQUIRE([AC_CANONICAL_BUILD])dnl
2913	<	m4_require([_LT_DECL_SED])dnl
2914	<	m4_require([_LT_DECL_EGREP])dnl
2915	<
2916	<	AC_ARG_WITH([gnu-ld],
2917	<	[AS_HELP_STRING([--with-gnu-ld],
2918	<	[assume the C compiler uses GNU ld @<:@default=no@:>@])],
2919	<	[test "$withval" = no || with_gnu_ld=yes],
2920	<	[with_gnu_ld=no])dnl
2921	<
2922	<	ac_prog=ld
2923	<	if test "$GCC" = yes; then
2924	<	# Check if gcc -print-prog-name=ld gives a path.
2925	<	AC_MSG_CHECKING([for ld used by $CC])
2926	<	case $host in
2927	<	*-*-mingw*)
2928	<	# gcc leaves a trailing carriage return which upsets mingw
2929	<	ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
2930	<	*)
2931	<	ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
2932	<	esac
2933	<	case $ac_prog in
2934	<	# Accept absolute paths.
2935	<	[[\\/]]* | ?:[[\\/]]*)
2936	<	re_direlt='/[[^/]][[^/]]*/\.\./'
2937	<	# Canonicalize the pathname of ld
2938	<	ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'`
2939	<	while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do
2940	<	ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"`
2941	<	done
2942	<	test -z "$LD" && LD="$ac_prog"
2943	<	;;
2944	<	"")
2945	<	# If it fails, then pretend we aren't using GCC.
2946	<	ac_prog=ld
2947	<	;;
2948	<	*)
2949	<	# If it is relative, then search for the first ld in PATH.
2950	<	with_gnu_ld=unknown
2951	<	;;
2952	<	esac
2953	<	elif test "$with_gnu_ld" = yes; then
2954	<	AC_MSG_CHECKING([for GNU ld])
2955	<	else
2956	<	AC_MSG_CHECKING([for non-GNU ld])
2957	<	fi
2958	<	AC_CACHE_VAL(lt_cv_path_LD,
2959	<	[if test -z "$LD"; then
2960	<	lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
2961	<	for ac_dir in $PATH; do
2962	<	IFS="$lt_save_ifs"
2963	<	test -z "$ac_dir" && ac_dir=.
2964	<	if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
2965	<	lt_cv_path_LD="$ac_dir/$ac_prog"
2966	<	# Check to see if the program is GNU ld.  I'd rather use --version,
2967	<	# but apparently some variants of GNU ld only accept -v.
2968	<	# Break only if it was the GNU/non-GNU ld that we prefer.
2969	<	case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
2970	<	*GNU* | *'with BFD'*)
2971	<	test "$with_gnu_ld" != no && break
2972	<	;;
2973	<	*)
2974	<	test "$with_gnu_ld" != yes && break
2975	<	;;
2976	<	esac
2977	<	fi
2978	<	done
2979	<	IFS="$lt_save_ifs"
2980	<	else
2981	<	lt_cv_path_LD="$LD" # Let the user override the test with a path.
2982	<	fi])
2983	<	LD="$lt_cv_path_LD"
2984	<	if test -n "$LD"; then
2985	<	AC_MSG_RESULT($LD)
2986	<	else
2987	<	AC_MSG_RESULT(no)
2988	<	fi
2989	<	test -z "$LD" && AC_MSG_ERROR([no acceptable ld found in \$PATH])
2990	<	_LT_PATH_LD_GNU
2991	<	AC_SUBST([LD])
2992	<
2993	<	_LT_TAGDECL([], [LD], [1], [The linker used to build libraries])
2994	<	])# LT_PATH_LD
2995	<
2996	<	# Old names:
2997	<	AU_ALIAS([AM_PROG_LD], [LT_PATH_LD])
2998	<	AU_ALIAS([AC_PROG_LD], [LT_PATH_LD])
2999	<	dnl aclocal-1.4 backwards compatibility:
3000	<	dnl AC_DEFUN([AM_PROG_LD], [])
3001	<	dnl AC_DEFUN([AC_PROG_LD], [])
3002	<
3003	<
3004	<	# _LT_PATH_LD_GNU
3005	<	#- --------------
3006	<	m4_defun([_LT_PATH_LD_GNU],
3007	<	[AC_CACHE_CHECK([if the linker ($LD) is GNU ld], lt_cv_prog_gnu_ld,
3008	<	[# I'd rather use --version here, but apparently some GNU lds only accept -v.
3009	<	case `$LD -v 2>&1 </dev/null` in
3010	<	*GNU* | *'with BFD'*)
3011	<	lt_cv_prog_gnu_ld=yes
3012	<	;;
3013	<	*)
3014	<	lt_cv_prog_gnu_ld=no
3015	<	;;
3016	<	esac])
3017	<	with_gnu_ld=$lt_cv_prog_gnu_ld
3018	<	])# _LT_PATH_LD_GNU
3019	<
3020	<
3021	<	# _LT_CMD_RELOAD
3022	<	# --------------
3023	<	# find reload flag for linker
3024	<	#   -- PORTME Some linkers may need a different reload flag.
3025	<	m4_defun([_LT_CMD_RELOAD],
3026	<	[AC_CACHE_CHECK([for $LD option to reload object files],
3027	<	lt_cv_ld_reload_flag,
3028	<	[lt_cv_ld_reload_flag='-r'])
3029	<	reload_flag=$lt_cv_ld_reload_flag
3030	<	case $reload_flag in
3031	<	"" | " "*) ;;
3032	<	*) reload_flag=" $reload_flag" ;;
3033	<	esac
3034	<	reload_cmds='$LD$reload_flag -o $output$reload_objs'
3035	<	case $host_os in
3036	<	darwin*)
3037	<	if test "$GCC" = yes; then
3038	<	reload_cmds='$LTCC $LTCFLAGS -nostdlib ${wl}-r -o $output$reload_objs'
3039	<	else
3040	<	reload_cmds='$LD$reload_flag -o $output$reload_objs'
3041	<	fi
3042	<	;;
3043	<	esac
3044	<	_LT_DECL([], [reload_flag], [1], [How to create reloadable object files])dnl
3045	<	_LT_DECL([], [reload_cmds], [2])dnl
3046	<	])# _LT_CMD_RELOAD
3047	<
3048	<
3049	<	# _LT_CHECK_MAGIC_METHOD
3050	<	# ----------------------
3051	<	# how to check for library dependencies
3052	<	#  -- PORTME fill in with the dynamic library characteristics
3053	<	m4_defun([_LT_CHECK_MAGIC_METHOD],
3054	<	[m4_require([_LT_DECL_EGREP])
3055	<	m4_require([_LT_DECL_OBJDUMP])
3056	<	AC_CACHE_CHECK([how to recognize dependent libraries],
3057	<	lt_cv_deplibs_check_method,
3058	<	[lt_cv_file_magic_cmd='$MAGIC_CMD'
3059	<	lt_cv_file_magic_test_file=
3060	<	lt_cv_deplibs_check_method='unknown'
3061	<	# Need to set the preceding variable on all platforms that support
3062	<	# interlibrary dependencies.
3063	<	# 'none' -- dependencies not supported.
3064	<	# `unknown' -- same as none, but documents that we really don't know.
3065	<	# 'pass_all' -- all dependencies passed with no checks.
3066	<	# 'test_compile' -- check by making test program.
3067	<	# 'file_magic [[regex]]' -- check by looking for files in library path
3068	<	# which responds to the $file_magic_cmd with a given extended regex.
3069	<	# If you have `file' or equivalent on your system and you're not sure
3070	<	# whether `pass_all' will *always* work, you probably want this one.
3071	<
3072	<	case $host_os in
3073	<	aix[[4-9]]*)
3074	<	lt_cv_deplibs_check_method=pass_all
3075	<	;;
3076	<
3077	<	beos*)
3078	<	lt_cv_deplibs_check_method=pass_all
3079	<	;;
3080	<
3081	<	bsdi[[45]]*)
3082	<	lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib)'
3083	<	lt_cv_file_magic_cmd='/usr/bin/file -L'
3084	<	lt_cv_file_magic_test_file=/shlib/libc.so
3085	<	;;
3086	<
3087	<	cygwin*)
3088	<	# func_win32_libid is a shell function defined in ltmain.sh
3089	<	lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
3090	<	lt_cv_file_magic_cmd='func_win32_libid'
3091	<	;;
3092	<
3093	<	mingw* | pw32*)
3094	<	# Base MSYS/MinGW do not provide the 'file' command needed by
3095	<	# func_win32_libid shell function, so use a weaker test based on 'objdump',
3096	<	# unless we find 'file', for example because we are cross-compiling.
3097	<	if ( file / ) >/dev/null 2>&1; then
3098	<	lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
3099	<	lt_cv_file_magic_cmd='func_win32_libid'
3100	<	else
3101	<	lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
3102	<	lt_cv_file_magic_cmd='$OBJDUMP -f'
3103	<	fi
3104	<	;;
3105	<
3106	<	cegcc)
3107	<	# use the weaker test based on 'objdump'. See mingw*.
3108	<	lt_cv_deplibs_check_method='file_magic file format pe-arm-.*little(.*architecture: arm)?'
3109	<	lt_cv_file_magic_cmd='$OBJDUMP -f'
3110	<	;;
3111	<
3112	<	darwin* | rhapsody*)
3113	<	lt_cv_deplibs_check_method=pass_all
3114	<	;;
3115	<
3116	<	freebsd* | dragonfly*)
3117	<	if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
3118	<	case $host_cpu in
3119	<	i*86 )
3120	<	# Not sure whether the presence of OpenBSD here was a mistake.
3121	<	# Let's accept both of them until this is cleared up.
3122	<	lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[[3-9]]86 (compact )?demand paged shared library'
3123	<	lt_cv_file_magic_cmd=/usr/bin/file
3124	<	lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
3125	<	;;
3126	<	esac
3127	<	else
3128	<	lt_cv_deplibs_check_method=pass_all
3129	<	fi
3130	<	;;
3131	<
3132	<	gnu*)
3133	<	lt_cv_deplibs_check_method=pass_all
3134	<	;;
3135	<
3136	<	hpux10.20* | hpux11*)
3137	<	lt_cv_file_magic_cmd=/usr/bin/file
3138	<	case $host_cpu in
3139	<	ia64*)
3140	<	lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|ELF-[[0-9]][[0-9]]) shared object file - IA64'
3141	<	lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
3142	<	;;
3143	<	hppa*64*)
3144	<	[lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - PA-RISC [0-9].[0-9]']
3145	<	lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl
3146	<	;;
3147	<	*)
3148	<	lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|PA-RISC[[0-9]].[[0-9]]) shared library'
3149	<	lt_cv_file_magic_test_file=/usr/lib/libc.sl
3150	<	;;
3151	<	esac
3152	<	;;
3153	<
3154	<	interix[[3-9]]*)
3155	<	# PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here
3156	<	lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|\.a)$'
3157	<	;;
3158	<
3159	<	irix5* | irix6* | nonstopux*)
3160	<	case $LD in
3161	<	*-32|*"-32 ") libmagic=32-bit;;
3162	<	*-n32|*"-n32 ") libmagic=N32;;
3163	<	*-64|*"-64 ") libmagic=64-bit;;
3164	<	*) libmagic=never-match;;
3165	<	esac
3166	<	lt_cv_deplibs_check_method=pass_all
3167	<	;;
3168	<
3169	<	# This must be Linux ELF.
3170	<	linux* | k*bsd*-gnu)
3171	<	lt_cv_deplibs_check_method=pass_all
3172	<	;;
3173	<
3174	<	netbsd*)
3175	<	if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
3176	<	lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$'
3177	<	else
3178	<	lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|_pic\.a)$'
3179	<	fi
3180	<	;;
3181	<
3182	<	newos6*)
3183	<	lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (executable|dynamic lib)'
3184	<	lt_cv_file_magic_cmd=/usr/bin/file
3185	<	lt_cv_file_magic_test_file=/usr/lib/libnls.so
3186	<	;;
3187	<
3188	<	*nto* | *qnx*)
3189	<	lt_cv_deplibs_check_method=pass_all
3190	<	;;
3191	<
3192	<	openbsd*)
3193	<	if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
3194	<	lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|\.so|_pic\.a)$'
3195	<	else
3196	<	lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$'
3197	<	fi
3198	<	;;
3199	<
3200	<	osf3* | osf4* | osf5*)
3201	<	lt_cv_deplibs_check_method=pass_all
3202	<	;;
3203	<
3204	<	rdos*)
3205	<	lt_cv_deplibs_check_method=pass_all
3206	<	;;
3207	<
3208	<	solaris*)
3209	<	lt_cv_deplibs_check_method=pass_all
3210	<	;;
3211	<
3212	<	sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
3213	<	lt_cv_deplibs_check_method=pass_all
3214	<	;;
3215	<
3216	<	sysv4 | sysv4.3*)
3217	<	case $host_vendor in
3218	<	motorola)
3219	<	lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib) M[[0-9]][[0-9]]* Version [[0-9]]'
3220	<	lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
3221	<	;;
3222	<	ncr)
3223	<	lt_cv_deplibs_check_method=pass_all
3224	<	;;
3225	<	sequent)
3226	<	lt_cv_file_magic_cmd='/bin/file'
3227	<	lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )'
3228	<	;;
3229	<	sni)
3230	<	lt_cv_file_magic_cmd='/bin/file'
3231	<	lt_cv_deplibs_check_method="file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB dynamic lib"
3232	<	lt_cv_file_magic_test_file=/lib/libc.so
3233	<	;;
3234	<	siemens)
3235	<	lt_cv_deplibs_check_method=pass_all
3236	<	;;
3237	<	pc)
3238	<	lt_cv_deplibs_check_method=pass_all
3239	<	;;
3240	<	esac
3241	<	;;
3242	<
3243	<	tpf*)
3244	<	lt_cv_deplibs_check_method=pass_all
3245	<	;;
3246	<	esac
3247	<	])
3248	<	file_magic_cmd=$lt_cv_file_magic_cmd
3249	<	deplibs_check_method=$lt_cv_deplibs_check_method
3250	<	test -z "$deplibs_check_method" && deplibs_check_method=unknown
3251	<
3252	<	_LT_DECL([], [deplibs_check_method], [1],
3253	<	[Method to check whether dependent libraries are shared objects])
3254	<	_LT_DECL([], [file_magic_cmd], [1],
3255	<	[Command to use when deplibs_check_method == "file_magic"])
3256	<	])# _LT_CHECK_MAGIC_METHOD
3257	<
3258	<
3259	<	# LT_PATH_NM
3260	<	# ----------
3261	<	# find the pathname to a BSD- or MS-compatible name lister
3262	<	AC_DEFUN([LT_PATH_NM],
3263	<	[AC_REQUIRE([AC_PROG_CC])dnl
3264	<	AC_CACHE_CHECK([for BSD- or MS-compatible name lister (nm)], lt_cv_path_NM,
3265	<	[if test -n "$NM"; then
3266	<	# Let the user override the test.
3267	<	lt_cv_path_NM="$NM"
3268	<	else
3269	<	lt_nm_to_check="${ac_tool_prefix}nm"
3270	<	if test -n "$ac_tool_prefix" && test "$build" = "$host"; then
3271	<	lt_nm_to_check="$lt_nm_to_check nm"
3272	<	fi
3273	<	for lt_tmp_nm in $lt_nm_to_check; do
3274	<	lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
3275	<	for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do
3276	<	IFS="$lt_save_ifs"
3277	<	test -z "$ac_dir" && ac_dir=.
3278	<	tmp_nm="$ac_dir/$lt_tmp_nm"
3279	<	if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then
3280	<	# Check to see if the nm accepts a BSD-compat flag.
3281	<	# Adding the `sed 1q' prevents false positives on HP-UX, which says:
3282	<	#   nm: unknown option "B" ignored
3283	<	# Tru64's nm complains that /dev/null is an invalid object file
3284	<	case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in
3285	<	*/dev/null* | *'Invalid file or object type'*)
3286	<	lt_cv_path_NM="$tmp_nm -B"
3287	<	break
3288	<	;;
3289	<	*)
3290	<	case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
3291	<	*/dev/null*)
3292	<	lt_cv_path_NM="$tmp_nm -p"
3293	<	break
3294	<	;;
3295	<	*)
3296	<	lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
3297	<	continue # so that we can try to find one that supports BSD flags
3298	<	;;
3299	<	esac
3300	<	;;
3301	<	esac
3302	<	fi
3303	<	done
3304	<	IFS="$lt_save_ifs"
3305	<	done
3306	<	: ${lt_cv_path_NM=no}
3307	<	fi])
3308	<	if test "$lt_cv_path_NM" != "no"; then
3309	<	NM="$lt_cv_path_NM"
3310	<	else
3311	<	# Didn't find any BSD compatible name lister, look for dumpbin.
3312	<	AC_CHECK_TOOLS(DUMPBIN, ["dumpbin -symbols" "link -dump -symbols"], :)
3313	<	AC_SUBST([DUMPBIN])
3314	<	if test "$DUMPBIN" != ":"; then
3315	<	NM="$DUMPBIN"
3316	<	fi
3317	<	fi
3318	<	test -z "$NM" && NM=nm
3319	<	AC_SUBST([NM])
3320	<	_LT_DECL([], [NM], [1], [A BSD- or MS-compatible name lister])dnl
3321	<
3322	<	AC_CACHE_CHECK([the name lister ($NM) interface], [lt_cv_nm_interface],
3323	<	[lt_cv_nm_interface="BSD nm"
3324	<	echo "int some_variable = 0;" > conftest.$ac_ext
3325	<	(eval echo "\"\$as_me:__oline__: $ac_compile\"" >&AS_MESSAGE_LOG_FD)
3326	<	(eval "$ac_compile" 2>conftest.err)
3327	<	cat conftest.err >&AS_MESSAGE_LOG_FD
3328	<	(eval echo "\"\$as_me:__oline__: $NM \\\"conftest.$ac_objext\\\"\"" >&AS_MESSAGE_LOG_FD)
3329	<	(eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out)
3330	<	cat conftest.err >&AS_MESSAGE_LOG_FD
3331	<	(eval echo "\"\$as_me:__oline__: output\"" >&AS_MESSAGE_LOG_FD)
3332	<	cat conftest.out >&AS_MESSAGE_LOG_FD
3333	<	if $GREP 'External.*some_variable' conftest.out > /dev/null; then
3334	<	lt_cv_nm_interface="MS dumpbin"
3335	<	fi
3336	<	rm -f conftest*])
3337	<	])# LT_PATH_NM
3338	<
3339	<	# Old names:
3340	<	AU_ALIAS([AM_PROG_NM], [LT_PATH_NM])
3341	<	AU_ALIAS([AC_PROG_NM], [LT_PATH_NM])
3342	<	dnl aclocal-1.4 backwards compatibility:
3343	<	dnl AC_DEFUN([AM_PROG_NM], [])
3344	<	dnl AC_DEFUN([AC_PROG_NM], [])
3345	<
3346	<
3347	<	# LT_LIB_M
3348	<	# --------
3349	<	# check for math library
3350	<	AC_DEFUN([LT_LIB_M],
3351	<	[AC_REQUIRE([AC_CANONICAL_HOST])dnl
3352	<	LIBM=
3353	<	case $host in
3354	<	*-*-beos* | *-*-cygwin* | *-*-pw32* | *-*-darwin*)
3355	<	# These system don't have libm, or don't need it
3356	<	;;
3357	<	*-ncr-sysv4.3*)
3358	<	AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM="-lmw")
3359	<	AC_CHECK_LIB(m, cos, LIBM="$LIBM -lm")
3360	<	;;
3361	<	*)
3362	<	AC_CHECK_LIB(m, cos, LIBM="-lm")
3363	<	;;
3364	<	esac
3365	<	AC_SUBST([LIBM])
3366	<	])# LT_LIB_M
3367	<
3368	<	# Old name:
3369	<	AU_ALIAS([AC_CHECK_LIBM], [LT_LIB_M])
3370	<	dnl aclocal-1.4 backwards compatibility:
3371	<	dnl AC_DEFUN([AC_CHECK_LIBM], [])
3372	<
3373	<
3374	<	# _LT_COMPILER_NO_RTTI([TAGNAME])
3375	<	# -------------------------------
3376	<	m4_defun([_LT_COMPILER_NO_RTTI],
3377	<	[m4_require([_LT_TAG_COMPILER])dnl
3378	<
3379	<	_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=
3380	<
3381	<	if test "$GCC" = yes; then
3382	<	_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin'
3383	<
3384	<	_LT_COMPILER_OPTION([if $compiler supports -fno-rtti -fno-exceptions],
3385	<	lt_cv_prog_compiler_rtti_exceptions,
3386	<	[-fno-rtti -fno-exceptions], [],
3387	<	[_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)="$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1) -fno-rtti -fno-exceptions"])
3388	<	fi
3389	<	_LT_TAGDECL([no_builtin_flag], [lt_prog_compiler_no_builtin_flag], [1],
3390	<	[Compiler flag to turn off builtin functions])
3391	<	])# _LT_COMPILER_NO_RTTI
3392	<
3393	<
3394	<	# _LT_CMD_GLOBAL_SYMBOLS
3395	<	# ----------------------
3396	<	m4_defun([_LT_CMD_GLOBAL_SYMBOLS],
3397	<	[AC_REQUIRE([AC_CANONICAL_HOST])dnl
3398	<	AC_REQUIRE([AC_PROG_CC])dnl
3399	<	AC_REQUIRE([LT_PATH_NM])dnl
3400	<	AC_REQUIRE([LT_PATH_LD])dnl
3401	<	m4_require([_LT_DECL_SED])dnl
3402	<	m4_require([_LT_DECL_EGREP])dnl
3403	<	m4_require([_LT_TAG_COMPILER])dnl
3404	<
3405	<	# Check for command to grab the raw symbol name followed by C symbol from nm.
3406	<	AC_MSG_CHECKING([command to parse $NM output from $compiler object])
3407	<	AC_CACHE_VAL([lt_cv_sys_global_symbol_pipe],
3408	<	[
3409	<	# These are sane defaults that work on at least a few old systems.
3410	<	# [They come from Ultrix.  What could be older than Ultrix?!! ;)]
3411	<
3412	<	# Character class describing NM global symbol codes.
3413	<	symcode='[[BCDEGRST]]'
3414	<
3415	<	# Regexp to match symbols that can be accessed directly from C.
3416	<	sympat='\([[_A-Za-z]][[_A-Za-z0-9]]*\)'
3417	<
3418	<	# Define system-specific variables.
3419	<	case $host_os in
3420	<	aix*)
3421	<	symcode='[[BCDT]]'
3422	<	;;
3423	<	cygwin* | mingw* | pw32* | cegcc*)
3424	<	symcode='[[ABCDGISTW]]'
3425	<	;;
3426	<	hpux*)
3427	<	if test "$host_cpu" = ia64; then
3428	<	symcode='[[ABCDEGRST]]'
3429	<	fi
3430	<	;;
3431	<	irix* | nonstopux*)
3432	<	symcode='[[BCDEGRST]]'
3433	<	;;
3434	<	osf*)
3435	<	symcode='[[BCDEGQRST]]'
3436	<	;;
3437	<	solaris*)
3438	<	symcode='[[BDRT]]'
3439	<	;;
3440	<	sco3.2v5*)
3441	<	symcode='[[DT]]'
3442	<	;;
3443	<	sysv4.2uw2*)
3444	<	symcode='[[DT]]'
3445	<	;;
3446	<	sysv5* | sco5v6* | unixware* | OpenUNIX*)
3447	<	symcode='[[ABDT]]'
3448	<	;;
3449	<	sysv4)
3450	<	symcode='[[DFNSTU]]'
3451	<	;;
3452	<	esac
3453	<
3454	<	# If we're using GNU nm, then use its standard symbol codes.
3455	<	case `$NM -V 2>&1` in
3456	<	*GNU* | *'with BFD'*)
3457	<	symcode='[[ABCDGIRSTW]]' ;;
3458	<	esac
3459	<
3460	<	# Transform an extracted symbol line into a proper C declaration.
3461	<	# Some systems (esp. on ia64) link data and code symbols differently,
3462	<	# so use this general approach.
3463	<	lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
3464	<
3465	<	# Transform an extracted symbol line into symbol name and symbol address
3466	<	lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\) $/  {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/  {\"\2\", (void *) \&\2},/p'"
3467	<	lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \([[^ ]]*\) $/  {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \(lib[[^ ]]*\)$/  {\"\2\", (void *) \&\2},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/  {\"lib\2\", (void *) \&\2},/p'"
3468	<
3469	<	# Handle CRLF in mingw tool chain
3470	<	opt_cr=
3471	<	case $build_os in
3472	<	mingw*)
3473	<	opt_cr=`$ECHO 'x\{0,1\}' | tr x '\015'` # option cr in regexp
3474	<	;;
3475	<	esac
3476	<
3477	<	# Try without a prefix underscore, then with it.
3478	<	for ac_symprfx in "" "_"; do
3479	<
3480	<	# Transform symcode, sympat, and symprfx into a raw symbol and a C symbol.
3481	<	symxfrm="\\1 $ac_symprfx\\2 \\2"
3482	<
3483	<	# Write the raw and C identifiers.
3484	<	if test "$lt_cv_nm_interface" = "MS dumpbin"; then
3485	<	# Fake it for dumpbin and say T for any non-static function
3486	<	# and D for any global variable.
3487	<	# Also find C++ and __fastcall symbols from MSVC++,
3488	<	# which start with @ or ?.
3489	<	lt_cv_sys_global_symbol_pipe="$AWK ['"\
3490	<	"     {last_section=section; section=\$ 3};"\
3491	<	"     /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\
3492	<	"     \$ 0!~/External *\|/{next};"\
3493	<	"     / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\
3494	<	"     {if(hide[section]) next};"\
3495	<	"     {f=0}; \$ 0~/\(\).*\|/{f=1}; {printf f ? \"T \" : \"D \"};"\
3496	<	"     {split(\$ 0, a, /\||\r/); split(a[2], s)};"\
3497	<	"     s[1]~/^[@?]/{print s[1], s[1]; next};"\
3498	<	"     s[1]~prfx {split(s[1],t,\"@\"); print t[1], substr(t[1],length(prfx))}"\
3499	<	"     ' prfx=^$ac_symprfx]"
3500	<	else
3501	<	lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[[     ]]\($symcode$symcode*\)[[       ]][[    ]]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
3502	<	fi
3503	<
3504	<	# Check to see that the pipe works correctly.
3505	<	pipe_works=no
3506	<
3507	<	rm -f conftest*
3508	<	cat > conftest.$ac_ext <<_LT_EOF
3509	<	#ifdef __cplusplus
3510	<	extern "C" {
3511	<	#endif
3512	<	char nm_test_var;
3513	<	void nm_test_func(void);
3514	<	void nm_test_func(void){}
3515	<	#ifdef __cplusplus
3516	<	}
3517	<	#endif
3518	<	int main(){nm_test_var='a';nm_test_func();return(0);}
3519	<	_LT_EOF
3520	<
3521	<	if AC_TRY_EVAL(ac_compile); then
3522	<	# Now try to grab the symbols.
3523	<	nlist=conftest.nm
3524	<	if AC_TRY_EVAL(NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist) && test -s "$nlist"; then
3525	<	# Try sorting and uniquifying the output.
3526	<	if sort "$nlist" | uniq > "$nlist"T; then
3527	<	mv -f "$nlist"T "$nlist"
3528	<	else
3529	<	rm -f "$nlist"T
3530	<	fi
3531	<
3532	<	# Make sure that we snagged all the symbols we need.
3533	<	if $GREP ' nm_test_var$' "$nlist" >/dev/null; then
3534	<	if $GREP ' nm_test_func$' "$nlist" >/dev/null; then
3535	<	cat <<_LT_EOF > conftest.$ac_ext
3536	<	#ifdef __cplusplus
3537	<	extern "C" {
3538	<	#endif
3539	<
3540	<	_LT_EOF
3541	<	# Now generate the symbol file.
3542	<	eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext'
3543	<
3544	<	cat <<_LT_EOF >> conftest.$ac_ext
3545	<
3546	<	/* The mapping between symbol names and symbols.  */
3547	<	const struct {
3548	<	const char *name;
3549	<	void       *address;
3550	<	}
3551	<	lt__PROGRAM__LTX_preloaded_symbols[[]] =
3552	<	{
3553	<	{ "@PROGRAM@", (void *) 0 },
3554	<	_LT_EOF
3555	<	$SED "s/^$symcode$symcode* \(.*\) \(.*\)$/  {\"\2\", (void *) \&\2},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext
3556	<	cat <<\_LT_EOF >> conftest.$ac_ext
3557	<	{0, (void *) 0}
3558	<	};
3559	<
3560	<	/* This works around a problem in FreeBSD linker */
3561	<	#ifdef FREEBSD_WORKAROUND
3562	<	static const void *lt_preloaded_setup() {
3563	<	return lt__PROGRAM__LTX_preloaded_symbols;
3564	<	}
3565	<	#endif
3566	<
3567	<	#ifdef __cplusplus
3568	<	}
3569	<	#endif
3570	<	_LT_EOF
3571	<	# Now try linking the two files.
3572	<	mv conftest.$ac_objext conftstm.$ac_objext
3573	<	lt_save_LIBS="$LIBS"
3574	<	lt_save_CFLAGS="$CFLAGS"
3575	<	LIBS="conftstm.$ac_objext"
3576	<	CFLAGS="$CFLAGS$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)"
3577	<	if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext}; then
3578	<	pipe_works=yes
3579	<	fi
3580	<	LIBS="$lt_save_LIBS"
3581	<	CFLAGS="$lt_save_CFLAGS"
3582	<	else
3583	<	echo "cannot find nm_test_func in $nlist" >&AS_MESSAGE_LOG_FD
3584	<	fi
3585	<	else
3586	<	echo "cannot find nm_test_var in $nlist" >&AS_MESSAGE_LOG_FD
3587	<	fi
3588	<	else
3589	<	echo "cannot run $lt_cv_sys_global_symbol_pipe" >&AS_MESSAGE_LOG_FD
3590	<	fi
3591	<	else
3592	<	echo "$progname: failed program was:" >&AS_MESSAGE_LOG_FD
3593	<	cat conftest.$ac_ext >&5
3594	<	fi
3595	<	rm -rf conftest* conftst*
3596	<
3597	<	# Do not use the global_symbol_pipe unless it works.
3598	<	if test "$pipe_works" = yes; then
3599	<	break
3600	<	else
3601	<	lt_cv_sys_global_symbol_pipe=
3602	<	fi
3603	<	done
3604	<	])
3605	<	if test -z "$lt_cv_sys_global_symbol_pipe"; then
3606	<	lt_cv_sys_global_symbol_to_cdecl=
3607	<	fi
3608	<	if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then
3609	<	AC_MSG_RESULT(failed)
3610	<	else
3611	<	AC_MSG_RESULT(ok)
3612	<	fi
3613	<
3614	<	_LT_DECL([global_symbol_pipe], [lt_cv_sys_global_symbol_pipe], [1],
3615	<	[Take the output of nm and produce a listing of raw symbols and C names])
3616	<	_LT_DECL([global_symbol_to_cdecl], [lt_cv_sys_global_symbol_to_cdecl], [1],
3617	<	[Transform the output of nm in a proper C declaration])
3618	<	_LT_DECL([global_symbol_to_c_name_address],
3619	<	[lt_cv_sys_global_symbol_to_c_name_address], [1],
3620	<	[Transform the output of nm in a C name address pair])
3621	<	_LT_DECL([global_symbol_to_c_name_address_lib_prefix],
3622	<	[lt_cv_sys_global_symbol_to_c_name_address_lib_prefix], [1],
3623	<	[Transform the output of nm in a C name address pair when lib prefix is needed])
3624	<	]) # _LT_CMD_GLOBAL_SYMBOLS
3625	<
3626	<
3627	<	# _LT_COMPILER_PIC([TAGNAME])
3628	<	# ---------------------------
3629	<	m4_defun([_LT_COMPILER_PIC],
3630	<	[m4_require([_LT_TAG_COMPILER])dnl
3631	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)=
3632	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)=
3633	<	_LT_TAGVAR(lt_prog_compiler_static, $1)=
3634	<
3635	<	AC_MSG_CHECKING([for $compiler option to produce PIC])
3636	<	m4_if([$1], [CXX], [
3637	<	# C++ specific cases for pic, static, wl, etc.
3638	<	if test "$GXX" = yes; then
3639	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
3640	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
3641	<
3642	<	case $host_os in
3643	<	aix*)
3644	<	# All AIX code is PIC.
3645	<	if test "$host_cpu" = ia64; then
3646	<	# AIX 5 now supports IA64 processor
3647	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
3648	<	fi
3649	<	;;
3650	<
3651	<	amigaos*)
3652	<	case $host_cpu in
3653	<	powerpc)
3654	<	# see comment about AmigaOS4 .so support
3655	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
3656	<	;;
3657	<	m68k)
3658	<	# FIXME: we need at least 68020 code to build shared libraries, but
3659	<	# adding the `-m68020' flag to GCC prevents building anything better,
3660	<	# like `-m68040'.
3661	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4'
3662	<	;;
3663	<	esac
3664	<	;;
3665	<
3666	<	beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
3667	<	# PIC is the default for these OSes.
3668	<	;;
3669	<	mingw* | cygwin* | os2* | pw32* | cegcc*)
3670	<	# This hack is so that the source file can tell whether it is being
3671	<	# built for inclusion in a dll (and should export symbols for example).
3672	<	# Although the cygwin gcc ignores -fPIC, still need this for old-style
3673	<	# (--disable-auto-import) libraries
3674	<	m4_if([$1], [GCJ], [],
3675	<	[_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'])
3676	<	;;
3677	<	darwin* | rhapsody*)
3678	<	# PIC is the default on this platform
3679	<	# Common symbols not allowed in MH_DYLIB files
3680	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'
3681	<	;;
3682	<	*djgpp*)
3683	<	# DJGPP does not support shared libraries at all
3684	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)=
3685	<	;;
3686	<	interix[[3-9]]*)
3687	<	# Interix 3.x gcc -fpic/-fPIC options generate broken code.
3688	<	# Instead, we relocate shared libraries at runtime.
3689	<	;;
3690	<	sysv4*MP*)
3691	<	if test -d /usr/nec; then
3692	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic
3693	<	fi
3694	<	;;
3695	<	hpux*)
3696	<	# PIC is the default for 64-bit PA HP-UX, but not for 32-bit
3697	<	# PA HP-UX.  On IA64 HP-UX, PIC is the default but the pic flag
3698	<	# sets the default TLS model and affects inlining.
3699	<	case $host_cpu in
3700	<	hppa*64*)
3701	<	;;
3702	<	*)
3703	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
3704	<	;;
3705	<	esac
3706	<	;;
3707	<	*qnx* | *nto*)
3708	<	# QNX uses GNU C++, but need to define -shared option too, otherwise
3709	<	# it will coredump.
3710	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared'
3711	<	;;
3712	<	*)
3713	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
3714	<	;;
3715	<	esac
3716	<	else
3717	<	case $host_os in
3718	<	aix[[4-9]]*)
3719	<	# All AIX code is PIC.
3720	<	if test "$host_cpu" = ia64; then
3721	<	# AIX 5 now supports IA64 processor
3722	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
3723	<	else
3724	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp'
3725	<	fi
3726	<	;;
3727	<	chorus*)
3728	<	case $cc_basename in
3729	<	cxch68*)
3730	<	# Green Hills C++ Compiler
3731	<	# _LT_TAGVAR(lt_prog_compiler_static, $1)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a"
3732	<	;;
3733	<	esac
3734	<	;;
3735	<	dgux*)
3736	<	case $cc_basename in
3737	<	ec++*)
3738	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
3739	<	;;
3740	<	ghcx*)
3741	<	# Green Hills C++ Compiler
3742	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
3743	<	;;
3744	<	*)
3745	<	;;
3746	<	esac
3747	<	;;
3748	<	freebsd* | dragonfly*)
3749	<	# FreeBSD uses GNU C++
3750	<	;;
3751	<	hpux9* | hpux10* | hpux11*)
3752	<	case $cc_basename in
3753	<	CC*)
3754	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
3755	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive'
3756	<	if test "$host_cpu" != ia64; then
3757	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
3758	<	fi
3759	<	;;
3760	<	aCC*)
3761	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
3762	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive'
3763	<	case $host_cpu in
3764	<	hppa*64*|ia64*)
3765	<	# +Z the default
3766	<	;;
3767	<	*)
3768	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
3769	<	;;
3770	<	esac
3771	<	;;
3772	<	*)
3773	<	;;
3774	<	esac
3775	<	;;
3776	<	interix*)
3777	<	# This is c89, which is MS Visual C++ (no shared libs)
3778	<	# Anyone wants to do a port?
3779	<	;;
3780	<	irix5* | irix6* | nonstopux*)
3781	<	case $cc_basename in
3782	<	CC*)
3783	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
3784	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
3785	<	# CC pic flag -KPIC is the default.
3786	<	;;
3787	<	*)
3788	<	;;
3789	<	esac
3790	<	;;
3791	<	linux* | k*bsd*-gnu)
3792	<	case $cc_basename in
3793	<	KCC*)
3794	<	# KAI C++ Compiler
3795	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,'
3796	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
3797	<	;;
3798	<	ecpc* )
3799	<	# old Intel C++ for x86_64 which still supported -KPIC.
3800	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
3801	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
3802	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
3803	<	;;
3804	<	icpc* )
3805	<	# Intel C++, used to be incompatible with GCC.
3806	<	# ICC 10 doesn't accept -KPIC any more.
3807	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
3808	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
3809	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
3810	<	;;
3811	<	pgCC* | pgcpp*)
3812	<	# Portland Group C++ compiler
3813	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
3814	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic'
3815	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
3816	<	;;
3817	<	cxx*)
3818	<	# Compaq C++
3819	<	# Make sure the PIC flag is empty.  It appears that all Alpha
3820	<	# Linux and Compaq Tru64 Unix objects are PIC.
3821	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)=
3822	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
3823	<	;;
3824	<	xlc* | xlC*)
3825	<	# IBM XL 8.0 on PPC
3826	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
3827	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic'
3828	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink'
3829	<	;;
3830	<	*)
3831	<	case `$CC -V 2>&1 | sed 5q` in
3832	<	*Sun\ C*)
3833	<	# Sun C++ 5.9
3834	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
3835	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
3836	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
3837	<	;;
3838	<	esac
3839	<	;;
3840	<	esac
3841	<	;;
3842	<	lynxos*)
3843	<	;;
3844	<	m88k*)
3845	<	;;
3846	<	mvs*)
3847	<	case $cc_basename in
3848	<	cxx*)
3849	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-W c,exportall'
3850	<	;;
3851	<	*)
3852	<	;;
3853	<	esac
3854	<	;;
3855	<	netbsd*)
3856	<	;;
3857	<	*qnx* | *nto*)
3858	<	# QNX uses GNU C++, but need to define -shared option too, otherwise
3859	<	# it will coredump.
3860	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared'
3861	<	;;
3862	<	osf3* | osf4* | osf5*)
3863	<	case $cc_basename in
3864	<	KCC*)
3865	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,'
3866	<	;;
3867	<	RCC*)
3868	<	# Rational C++ 2.4.1
3869	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
3870	<	;;
3871	<	cxx*)
3872	<	# Digital/Compaq C++
3873	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
3874	<	# Make sure the PIC flag is empty.  It appears that all Alpha
3875	<	# Linux and Compaq Tru64 Unix objects are PIC.
3876	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)=
3877	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
3878	<	;;
3879	<	*)
3880	<	;;
3881	<	esac
3882	<	;;
3883	<	psos*)
3884	<	;;
3885	<	solaris*)
3886	<	case $cc_basename in
3887	<	CC*)
3888	<	# Sun C++ 4.2, 5.x and Centerline C++
3889	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
3890	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
3891	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
3892	<	;;
3893	<	gcx*)
3894	<	# Green Hills C++ Compiler
3895	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
3896	<	;;
3897	<	*)
3898	<	;;
3899	<	esac
3900	<	;;
3901	<	sunos4*)
3902	<	case $cc_basename in
3903	<	CC*)
3904	<	# Sun C++ 4.x
3905	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
3906	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
3907	<	;;
3908	<	lcc*)
3909	<	# Lucid
3910	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
3911	<	;;
3912	<	*)
3913	<	;;
3914	<	esac
3915	<	;;
3916	<	sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
3917	<	case $cc_basename in
3918	<	CC*)
3919	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
3920	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
3921	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
3922	<	;;
3923	<	esac
3924	<	;;
3925	<	tandem*)
3926	<	case $cc_basename in
3927	<	NCC*)
3928	<	# NonStop-UX NCC 3.20
3929	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
3930	<	;;
3931	<	*)
3932	<	;;
3933	<	esac
3934	<	;;
3935	<	vxworks*)
3936	<	;;
3937	<	*)
3938	<	_LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
3939	<	;;
3940	<	esac
3941	<	fi
3942	<	],
3943	<	[
3944	<	if test "$GCC" = yes; then
3945	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
3946	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
3947	<
3948	<	case $host_os in
3949	<	aix*)
3950	<	# All AIX code is PIC.
3951	<	if test "$host_cpu" = ia64; then
3952	<	# AIX 5 now supports IA64 processor
3953	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
3954	<	fi
3955	<	;;
3956	<
3957	<	amigaos*)
3958	<	case $host_cpu in
3959	<	powerpc)
3960	<	# see comment about AmigaOS4 .so support
3961	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
3962	<	;;
3963	<	m68k)
3964	<	# FIXME: we need at least 68020 code to build shared libraries, but
3965	<	# adding the `-m68020' flag to GCC prevents building anything better,
3966	<	# like `-m68040'.
3967	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4'
3968	<	;;
3969	<	esac
3970	<	;;
3971	<
3972	<	beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
3973	<	# PIC is the default for these OSes.
3974	<	;;
3975	<
3976	<	mingw* | cygwin* | pw32* | os2* | cegcc*)
3977	<	# This hack is so that the source file can tell whether it is being
3978	<	# built for inclusion in a dll (and should export symbols for example).
3979	<	# Although the cygwin gcc ignores -fPIC, still need this for old-style
3980	<	# (--disable-auto-import) libraries
3981	<	m4_if([$1], [GCJ], [],
3982	<	[_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'])
3983	<	;;
3984	<
3985	<	darwin* | rhapsody*)
3986	<	# PIC is the default on this platform
3987	<	# Common symbols not allowed in MH_DYLIB files
3988	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'
3989	<	;;
3990	<
3991	<	hpux*)
3992	<	# PIC is the default for 64-bit PA HP-UX, but not for 32-bit
3993	<	# PA HP-UX.  On IA64 HP-UX, PIC is the default but the pic flag
3994	<	# sets the default TLS model and affects inlining.
3995	<	case $host_cpu in
3996	<	hppa*64*)
3997	<	# +Z the default
3998	<	;;
3999	<	*)
4000	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
4001	<	;;
4002	<	esac
4003	<	;;
4004	<
4005	<	interix[[3-9]]*)
4006	<	# Interix 3.x gcc -fpic/-fPIC options generate broken code.
4007	<	# Instead, we relocate shared libraries at runtime.
4008	<	;;
4009	<
4010	<	msdosdjgpp*)
4011	<	# Just because we use GCC doesn't mean we suddenly get shared libraries
4012	<	# on systems that don't support them.
4013	<	_LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
4014	<	enable_shared=no
4015	<	;;
4016	<
4017	<	*nto* | *qnx*)
4018	<	# QNX uses GNU C++, but need to define -shared option too, otherwise
4019	<	# it will coredump.
4020	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared'
4021	<	;;
4022	<
4023	<	sysv4*MP*)
4024	<	if test -d /usr/nec; then
4025	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic
4026	<	fi
4027	<	;;
4028	<
4029	<	*)
4030	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
4031	<	;;
4032	<	esac
4033	<	else
4034	<	# PORTME Check for flag to pass linker flags through the system compiler.
4035	<	case $host_os in
4036	<	aix*)
4037	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
4038	<	if test "$host_cpu" = ia64; then
4039	<	# AIX 5 now supports IA64 processor
4040	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
4041	<	else
4042	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp'
4043	<	fi
4044	<	;;
4045	<
4046	<	mingw* | cygwin* | pw32* | os2* | cegcc*)
4047	<	# This hack is so that the source file can tell whether it is being
4048	<	# built for inclusion in a dll (and should export symbols for example).
4049	<	m4_if([$1], [GCJ], [],
4050	<	[_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'])
4051	<	;;
4052	<
4053	<	hpux9* | hpux10* | hpux11*)
4054	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
4055	<	# PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
4056	<	# not for PA HP-UX.
4057	<	case $host_cpu in
4058	<	hppa*64*|ia64*)
4059	<	# +Z the default
4060	<	;;
4061	<	*)
4062	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
4063	<	;;
4064	<	esac
4065	<	# Is there a better lt_prog_compiler_static that works with the bundled CC?
4066	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive'
4067	<	;;
4068	<
4069	<	irix5* | irix6* | nonstopux*)
4070	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
4071	<	# PIC (with -KPIC) is the default.
4072	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
4073	<	;;
4074	<
4075	<	linux* | k*bsd*-gnu)
4076	<	case $cc_basename in
4077	<	# old Intel for x86_64 which still supported -KPIC.
4078	<	ecc*)
4079	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
4080	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
4081	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
4082	<	;;
4083	<	# icc used to be incompatible with GCC.
4084	<	# ICC 10 doesn't accept -KPIC any more.
4085	<	icc* | ifort*)
4086	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
4087	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
4088	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
4089	<	;;
4090	<	# Lahey Fortran 8.1.
4091	<	lf95*)
4092	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
4093	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='--shared'
4094	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='--static'
4095	<	;;
4096	<	pgcc* | pgf77* | pgf90* | pgf95*)
4097	<	# Portland Group compilers (*not* the Pentium gcc compiler,
4098	<	# which looks to be a dead project)
4099	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
4100	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic'
4101	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
4102	<	;;
4103	<	ccc*)
4104	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
4105	<	# All Alpha code is PIC.
4106	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
4107	<	;;
4108	<	xl*)
4109	<	# IBM XL C 8.0/Fortran 10.1 on PPC
4110	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
4111	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic'
4112	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink'
4113	<	;;
4114	<	*)
4115	<	case `$CC -V 2>&1 | sed 5q` in
4116	<	*Sun\ C*)
4117	<	# Sun C 5.9
4118	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
4119	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
4120	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
4121	<	;;
4122	<	*Sun\ F*)
4123	<	# Sun Fortran 8.3 passes all unrecognized flags to the linker
4124	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
4125	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
4126	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)=''
4127	<	;;
4128	<	esac
4129	<	;;
4130	<	esac
4131	<	;;
4132	<
4133	<	newsos6)
4134	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
4135	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
4136	<	;;
4137	<
4138	<	*nto* | *qnx*)
4139	<	# QNX uses GNU C++, but need to define -shared option too, otherwise
4140	<	# it will coredump.
4141	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared'
4142	<	;;
4143	<
4144	<	osf3* | osf4* | osf5*)
4145	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
4146	<	# All OSF/1 code is PIC.
4147	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
4148	<	;;
4149	<
4150	<	rdos*)
4151	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
4152	<	;;
4153	<
4154	<	solaris*)
4155	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
4156	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
4157	<	case $cc_basename in
4158	<	f77* | f90* | f95*)
4159	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ';;
4160	<	*)
4161	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,';;
4162	<	esac
4163	<	;;
4164	<
4165	<	sunos4*)
4166	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
4167	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
4168	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
4169	<	;;
4170	<
4171	<	sysv4 | sysv4.2uw2* | sysv4.3*)
4172	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
4173	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
4174	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
4175	<	;;
4176	<
4177	<	sysv4*MP*)
4178	<	if test -d /usr/nec ;then
4179	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-Kconform_pic'
4180	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
4181	<	fi
4182	<	;;
4183	<
4184	<	sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
4185	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
4186	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
4187	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
4188	<	;;
4189	<
4190	<	unicos*)
4191	<	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
4192	<	_LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
4193	<	;;
4194	<
4195	<	uts4*)
4196	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
4197	<	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
4198	<	;;
4199	<
4200	<	*)
4201	<	_LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
4202	<	;;
4203	<	esac
4204	<	fi
4205	<	])
4206	<	case $host_os in
4207	<	# For platforms which do not support PIC, -DPIC is meaningless:
4208	<	*djgpp*)
4209	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)=
4210	<	;;
4211	<	*)
4212	<	_LT_TAGVAR(lt_prog_compiler_pic, $1)="$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])"
4213	<	;;
4214	<	esac
4215	<	AC_MSG_RESULT([$_LT_TAGVAR(lt_prog_compiler_pic, $1)])
4216	<	_LT_TAGDECL([wl], [lt_prog_compiler_wl], [1],
4217	<	[How to pass a linker flag through the compiler])
4218	<
4219	<	#
4220	<	# Check to make sure the PIC flag actually works.
4221	<	#
4222	<	if test -n "$_LT_TAGVAR(lt_prog_compiler_pic, $1)"; then
4223	<	_LT_COMPILER_OPTION([if $compiler PIC flag $_LT_TAGVAR(lt_prog_compiler_pic, $1) works],
4224	<	[_LT_TAGVAR(lt_cv_prog_compiler_pic_works, $1)],
4225	<	[$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])], [],
4226	<	[case $_LT_TAGVAR(lt_prog_compiler_pic, $1) in
4227	<	"" | " "*) ;;
4228	<	*) _LT_TAGVAR(lt_prog_compiler_pic, $1)=" $_LT_TAGVAR(lt_prog_compiler_pic, $1)" ;;
4229	<	esac],
4230	<	[_LT_TAGVAR(lt_prog_compiler_pic, $1)=
4231	<	_LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no])
4232	<	fi
4233	<	_LT_TAGDECL([pic_flag], [lt_prog_compiler_pic], [1],
4234	<	[Additional compiler flags for building library objects])
4235	<
4236	<	#
4237	<	# Check to make sure the static flag actually works.
4238	<	#
4239	<	wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1) eval lt_tmp_static_flag=\"$_LT_TAGVAR(lt_prog_compiler_static, $1)\"
4240	<	_LT_LINKER_OPTION([if $compiler static flag $lt_tmp_static_flag works],
4241	<	_LT_TAGVAR(lt_cv_prog_compiler_static_works, $1),
4242	<	$lt_tmp_static_flag,
4243	<	[],
4244	<	[_LT_TAGVAR(lt_prog_compiler_static, $1)=])
4245	<	_LT_TAGDECL([link_static_flag], [lt_prog_compiler_static], [1],
4246	<	[Compiler flag to prevent dynamic linking])
4247	<	])# _LT_COMPILER_PIC
4248	<
4249	<
4250	<	# _LT_LINKER_SHLIBS([TAGNAME])
4251	<	# ----------------------------
4252	<	# See if the linker supports building shared libraries.
4253	<	m4_defun([_LT_LINKER_SHLIBS],
4254	<	[AC_REQUIRE([LT_PATH_LD])dnl
4255	<	AC_REQUIRE([LT_PATH_NM])dnl
4256	<	m4_require([_LT_FILEUTILS_DEFAULTS])dnl
4257	<	m4_require([_LT_DECL_EGREP])dnl
4258	<	m4_require([_LT_DECL_SED])dnl
4259	<	m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl
4260	<	m4_require([_LT_TAG_COMPILER])dnl
4261	<	AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries])
4262	<	m4_if([$1], [CXX], [
4263	<	_LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
4264	<	case $host_os in
4265	<	aix[[4-9]]*)
4266	<	# If we're using GNU nm, then we don't want the "-C" option.
4267	<	# -C means demangle to AIX nm, but means don't demangle with GNU nm
4268	<	if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
4269	<	_LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
4270	<	else
4271	<	_LT_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
4272	<	fi
4273	<	;;
4274	<	pw32*)
4275	<	_LT_TAGVAR(export_symbols_cmds, $1)="$ltdll_cmds"
4276	<	;;
4277	<	cygwin* | mingw* | cegcc*)
4278	<	_LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1 DATA/;/^.*[[ ]]__nm__/s/^.*[[ ]]__nm__\([[^ ]]*\)[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols'
4279	<	;;
4280	<	*)
4281	<	_LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
4282	<	;;
4283	<	esac
4284	<	_LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*']
4285	<	], [
4286	<	runpath_var=
4287	<	_LT_TAGVAR(allow_undefined_flag, $1)=
4288	<	_LT_TAGVAR(always_export_symbols, $1)=no
4289	<	_LT_TAGVAR(archive_cmds, $1)=
4290	<	_LT_TAGVAR(archive_expsym_cmds, $1)=
4291	<	_LT_TAGVAR(compiler_needs_object, $1)=no
4292	<	_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no
4293	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)=
4294	<	_LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
4295	<	_LT_TAGVAR(hardcode_automatic, $1)=no
4296	<	_LT_TAGVAR(hardcode_direct, $1)=no
4297	<	_LT_TAGVAR(hardcode_direct_absolute, $1)=no
4298	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
4299	<	_LT_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=
4300	<	_LT_TAGVAR(hardcode_libdir_separator, $1)=
4301	<	_LT_TAGVAR(hardcode_minus_L, $1)=no
4302	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
4303	<	_LT_TAGVAR(inherit_rpath, $1)=no
4304	<	_LT_TAGVAR(link_all_deplibs, $1)=unknown
4305	<	_LT_TAGVAR(module_cmds, $1)=
4306	<	_LT_TAGVAR(module_expsym_cmds, $1)=
4307	<	_LT_TAGVAR(old_archive_from_new_cmds, $1)=
4308	<	_LT_TAGVAR(old_archive_from_expsyms_cmds, $1)=
4309	<	_LT_TAGVAR(thread_safe_flag_spec, $1)=
4310	<	_LT_TAGVAR(whole_archive_flag_spec, $1)=
4311	<	# include_expsyms should be a list of space-separated symbols to be *always*
4312	<	# included in the symbol list
4313	<	_LT_TAGVAR(include_expsyms, $1)=
4314	<	# exclude_expsyms can be an extended regexp of symbols to exclude
4315	<	# it will be wrapped by ` (' and `)$', so one must not match beginning or
4316	<	# end of line.  Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc',
4317	<	# as well as any symbol that contains `d'.
4318	<	_LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*']
4319	<	# Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out
4320	<	# platforms (ab)use it in PIC code, but their linkers get confused if
4321	<	# the symbol is explicitly referenced.  Since portable code cannot
4322	<	# rely on this symbol name, it's probably fine to never include it in
4323	<	# preloaded symbol tables.
4324	<	# Exclude shared library initialization/finalization symbols.
4325	<	dnl Note also adjust exclude_expsyms for C++ above.
4326	<	extract_expsyms_cmds=
4327	<
4328	<	case $host_os in
4329	<	cygwin* | mingw* | pw32* | cegcc*)
4330	<	# FIXME: the MSVC++ port hasn't been tested in a loooong time
4331	<	# When not using gcc, we currently assume that we are using
4332	<	# Microsoft Visual C++.
4333	<	if test "$GCC" != yes; then
4334	<	with_gnu_ld=no
4335	<	fi
4336	<	;;
4337	<	interix*)
4338	<	# we just hope/assume this is gcc and not c89 (= MSVC++)
4339	<	with_gnu_ld=yes
4340	<	;;
4341	<	openbsd*)
4342	<	with_gnu_ld=no
4343	<	;;
4344	<	esac
4345	<
4346	<	_LT_TAGVAR(ld_shlibs, $1)=yes
4347	<	if test "$with_gnu_ld" = yes; then
4348	<	# If archive_cmds runs LD, not CC, wlarc should be empty
4349	<	wlarc='${wl}'
4350	<
4351	<	# Set some defaults for GNU ld with shared library support. These
4352	<	# are reset later if shared libraries are not supported. Putting them
4353	<	# here allows them to be overridden if necessary.
4354	<	runpath_var=LD_RUN_PATH
4355	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
4356	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
4357	<	# ancient GNU ld didn't support --whole-archive et. al.
4358	<	if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then
4359	<	_LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
4360	<	else
4361	<	_LT_TAGVAR(whole_archive_flag_spec, $1)=
4362	<	fi
4363	<	supports_anon_versioning=no
4364	<	case `$LD -v 2>&1` in
4365	<	*\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.10.*) ;; # catch versions < 2.11
4366	<	*\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
4367	<	*\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
4368	<	*\ 2.11.*) ;; # other 2.11 versions
4369	<	*) supports_anon_versioning=yes ;;
4370	<	esac
4371	<
4372	<	# See if GNU ld supports shared libraries.
4373	<	case $host_os in
4374	<	aix[[3-9]]*)
4375	<	# On AIX/PPC, the GNU linker is very broken
4376	<	if test "$host_cpu" != ia64; then
4377	<	_LT_TAGVAR(ld_shlibs, $1)=no
4378	<	cat <<_LT_EOF 1>&2
4379	<
4380	<	*** Warning: the GNU linker, at least up to release 2.9.1, is reported
4381	<	*** to be unable to reliably create shared libraries on AIX.
4382	<	*** Therefore, libtool is disabling shared libraries support.  If you
4383	<	*** really care for shared libraries, you may want to modify your PATH
4384	<	*** so that a non-GNU linker is found, and then restart.
4385	<
4386	<	_LT_EOF
4387	<	fi
4388	<	;;
4389	<
4390	<	amigaos*)
4391	<	case $host_cpu in
4392	<	powerpc)
4393	<	# see comment about AmigaOS4 .so support
4394	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
4395	<	_LT_TAGVAR(archive_expsym_cmds, $1)=''
4396	<	;;
4397	<	m68k)
4398	<	_LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
4399	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
4400	<	_LT_TAGVAR(hardcode_minus_L, $1)=yes
4401	<	;;
4402	<	esac
4403	<	;;
4404	<
4405	<	beos*)
4406	<	if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
4407	<	_LT_TAGVAR(allow_undefined_flag, $1)=unsupported
4408	<	# Joseph Beckenbach <jrb3@best.com> says some releases of gcc
4409	<	# support --undefined.  This deserves some investigation.  FIXME
4410	<	_LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
4411	<	else
4412	<	_LT_TAGVAR(ld_shlibs, $1)=no
4413	<	fi
4414	<	;;
4415	<
4416	<	cygwin* | mingw* | pw32* | cegcc*)
4417	<	# _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,
4418	<	# as there is no search path for DLLs.
4419	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
4420	<	_LT_TAGVAR(allow_undefined_flag, $1)=unsupported
4421	<	_LT_TAGVAR(always_export_symbols, $1)=no
4422	<	_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
4423	<	_LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1 DATA/'\'' | $SED -e '\''/^[[AITW]][[ ]]/s/.*[[ ]]//'\'' | sort | uniq > $export_symbols'
4424	<
4425	<	if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
4426	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
4427	<	# If the export-symbols file already is a .def file (1st line
4428	<	# is EXPORTS), use it as is; otherwise, prepend...
4429	<	_LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
4430	<	cp $export_symbols $output_objdir/$soname.def;
4431	<	else
4432	<	echo EXPORTS > $output_objdir/$soname.def;
4433	<	cat $export_symbols >> $output_objdir/$soname.def;
4434	<	fi~
4435	<	$CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
4436	<	else
4437	<	_LT_TAGVAR(ld_shlibs, $1)=no
4438	<	fi
4439	<	;;
4440	<
4441	<	interix[[3-9]]*)
4442	<	_LT_TAGVAR(hardcode_direct, $1)=no
4443	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
4444	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
4445	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
4446	<	# Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
4447	<	# Instead, shared libraries are loaded at an image base (0x10000000 by
4448	<	# default) and relocated if they conflict, which is a slow very memory
4449	<	# consuming and fragmenting process.  To avoid this, we pick a random,
4450	<	# 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
4451	<	# time.  Moving up from 0x10000000 also allows more sbrk(2) space.
4452	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
4453	<	_LT_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
4454	<	;;
4455	<
4456	<	gnu* | linux* | tpf* | k*bsd*-gnu)
4457	<	tmp_diet=no
4458	<	if test "$host_os" = linux-dietlibc; then
4459	<	case $cc_basename in
4460	<	diet\ *) tmp_diet=yes;;       # linux-dietlibc with static linking (!diet-dyn)
4461	<	esac
4462	<	fi
4463	<	if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \
4464	<	&& test "$tmp_diet" = no
4465	<	then
4466	<	tmp_addflag=
4467	<	tmp_sharedflag='-shared'
4468	<	case $cc_basename,$host_cpu in
4469	<	pgcc*)                          # Portland Group C compiler
4470	<	_LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $ECHO \"$new_convenience\"` ${wl}--no-whole-archive'
4471	<	tmp_addflag=' $pic_flag'
4472	<	;;
4473	<	pgf77* | pgf90* | pgf95*)       # Portland Group f77 and f90 compilers
4474	<	_LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $ECHO \"$new_convenience\"` ${wl}--no-whole-archive'
4475	<	tmp_addflag=' $pic_flag -Mnomain' ;;
4476	<	ecc*,ia64* | icc*,ia64*)        # Intel C compiler on ia64
4477	<	tmp_addflag=' -i_dynamic' ;;
4478	<	efc*,ia64* | ifort*,ia64*)      # Intel Fortran compiler on ia64
4479	<	tmp_addflag=' -i_dynamic -nofor_main' ;;
4480	<	ifc* | ifort*)                  # Intel Fortran compiler
4481	<	tmp_addflag=' -nofor_main' ;;
4482	<	lf95*)                          # Lahey Fortran 8.1
4483	<	_LT_TAGVAR(whole_archive_flag_spec, $1)=
4484	<	tmp_sharedflag='--shared' ;;
4485	<	xl[[cC]]*)                      # IBM XL C 8.0 on PPC (deal with xlf below)
4486	<	tmp_sharedflag='-qmkshrobj'
4487	<	tmp_addflag= ;;
4488	<	esac
4489	<	case `$CC -V 2>&1 | sed 5q` in
4490	<	*Sun\ C*)                       # Sun C 5.9
4491	<	_LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; $ECHO \"$new_convenience\"` ${wl}--no-whole-archive'
4492	<	_LT_TAGVAR(compiler_needs_object, $1)=yes
4493	<	tmp_sharedflag='-G' ;;
4494	<	*Sun\ F*)                       # Sun Fortran 8.3
4495	<	tmp_sharedflag='-G' ;;
4496	<	esac
4497	<	_LT_TAGVAR(archive_cmds, $1)='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
4498	<
4499	<	if test "x$supports_anon_versioning" = xyes; then
4500	<	_LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~
4501	<	cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
4502	<	echo "local: *; };" >> $output_objdir/$libname.ver~
4503	<	$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
4504	<	fi
4505	<
4506	<	case $cc_basename in
4507	<	xlf*)
4508	<	# IBM XL Fortran 10.1 on PPC cannot create shared libs itself
4509	<	_LT_TAGVAR(whole_archive_flag_spec, $1)='--whole-archive$convenience --no-whole-archive'
4510	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
4511	<	_LT_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='-rpath $libdir'
4512	<	_LT_TAGVAR(archive_cmds, $1)='$LD -shared $libobjs $deplibs $compiler_flags -soname $soname -o $lib'
4513	<	if test "x$supports_anon_versioning" = xyes; then
4514	<	_LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~
4515	<	cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
4516	<	echo "local: *; };" >> $output_objdir/$libname.ver~
4517	<	$LD -shared $libobjs $deplibs $compiler_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib'
4518	<	fi
4519	<	;;
4520	<	esac
4521	<	else
4522	<	_LT_TAGVAR(ld_shlibs, $1)=no
4523	<	fi
4524	<	;;
4525	<
4526	<	netbsd*)
4527	<	if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
4528	<	_LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
4529	<	wlarc=
4530	<	else
4531	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
4532	<	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
4533	<	fi
4534	<	;;
4535	<
4536	<	solaris*)
4537	<	if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then
4538	<	_LT_TAGVAR(ld_shlibs, $1)=no
4539	<	cat <<_LT_EOF 1>&2
4540	<
4541	<	*** Warning: The releases 2.8.* of the GNU linker cannot reliably
4542	<	*** create shared libraries on Solaris systems.  Therefore, libtool
4543	<	*** is disabling shared libraries support.  We urge you to upgrade GNU
4544	<	*** binutils to release 2.9.1 or newer.  Another option is to modify
4545	<	*** your PATH or compiler configuration so that the native linker is
4546	<	*** used, and then restart.
4547	<
4548	<	_LT_EOF
4549	<	elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
4550	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
4551	<	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
4552	<	else
4553	<	_LT_TAGVAR(ld_shlibs, $1)=no
4554	<	fi
4555	<	;;
4556	<
4557	<	sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)
4558	<	case `$LD -v 2>&1` in
4559	<	*\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.1[[0-5]].*)
4560	<	_LT_TAGVAR(ld_shlibs, $1)=no
4561	<	cat <<_LT_EOF 1>&2
4562	<
4563	<	*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not
4564	<	*** reliably create shared libraries on SCO systems.  Therefore, libtool
4565	<	*** is disabling shared libraries support.  We urge you to upgrade GNU
4566	<	*** binutils to release 2.16.91.0.3 or newer.  Another option is to modify
4567	<	*** your PATH or compiler configuration so that the native linker is
4568	<	*** used, and then restart.
4569	<
4570	<	_LT_EOF
4571	<	;;
4572	<	*)
4573	<	# For security reasons, it is highly recommended that you always
4574	<	# use absolute paths for naming shared libraries, and exclude the
4575	<	# DT_RUNPATH tag from executables and libraries.  But doing so
4576	<	# requires that you compile everything twice, which is a pain.
4577	<	if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
4578	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
4579	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
4580	<	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
4581	<	else
4582	<	_LT_TAGVAR(ld_shlibs, $1)=no
4583	<	fi
4584	<	;;
4585	<	esac
4586	<	;;
4587	<
4588	<	sunos4*)
4589	<	_LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'
4590	<	wlarc=
4591	<	_LT_TAGVAR(hardcode_direct, $1)=yes
4592	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
4593	<	;;
4594	<
4595	<	*)
4596	<	if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
4597	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
4598	<	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
4599	<	else
4600	<	_LT_TAGVAR(ld_shlibs, $1)=no
4601	<	fi
4602	<	;;
4603	<	esac
4604	<
4605	<	if test "$_LT_TAGVAR(ld_shlibs, $1)" = no; then
4606	<	runpath_var=
4607	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
4608	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)=
4609	<	_LT_TAGVAR(whole_archive_flag_spec, $1)=
4610	<	fi
4611	<	else
4612	<	# PORTME fill in a description of your system's linker (not GNU ld)
4613	<	case $host_os in
4614	<	aix3*)
4615	<	_LT_TAGVAR(allow_undefined_flag, $1)=unsupported
4616	<	_LT_TAGVAR(always_export_symbols, $1)=yes
4617	<	_LT_TAGVAR(archive_expsym_cmds, $1)='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'
4618	<	# Note: this linker hardcodes the directories in LIBPATH if there
4619	<	# are no directories specified by -L.
4620	<	_LT_TAGVAR(hardcode_minus_L, $1)=yes
4621	<	if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then
4622	<	# Neither direct hardcoding nor static linking is supported with a
4623	<	# broken collect2.
4624	<	_LT_TAGVAR(hardcode_direct, $1)=unsupported
4625	<	fi
4626	<	;;
4627	<
4628	<	aix[[4-9]]*)
4629	<	if test "$host_cpu" = ia64; then
4630	<	# On IA64, the linker does run time linking by default, so we don't
4631	<	# have to do anything special.
4632	<	aix_use_runtimelinking=no
4633	<	exp_sym_flag='-Bexport'
4634	<	no_entry_flag=""
4635	<	else
4636	<	# If we're using GNU nm, then we don't want the "-C" option.
4637	<	# -C means demangle to AIX nm, but means don't demangle with GNU nm
4638	<	if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
4639	<	_LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
4640	<	else
4641	<	_LT_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
4642	<	fi
4643	<	aix_use_runtimelinking=no
4644	<
4645	<	# Test if we are trying to use run time linking or normal
4646	<	# AIX style linking. If -brtl is somewhere in LDFLAGS, we
4647	<	# need to do runtime linking.
4648	<	case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*)
4649	<	for ld_flag in $LDFLAGS; do
4650	<	if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then
4651	<	aix_use_runtimelinking=yes
4652	<	break
4653	<	fi
4654	<	done
4655	<	;;
4656	<	esac
4657	<
4658	<	exp_sym_flag='-bexport'
4659	<	no_entry_flag='-bnoentry'
4660	<	fi
4661	<
4662	<	# When large executables or shared objects are built, AIX ld can
4663	<	# have problems creating the table of contents.  If linking a library
4664	<	# or program results in "error TOC overflow" add -mminimal-toc to
4665	<	# CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
4666	<	# enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
4667	<
4668	<	_LT_TAGVAR(archive_cmds, $1)=''
4669	<	_LT_TAGVAR(hardcode_direct, $1)=yes
4670	<	_LT_TAGVAR(hardcode_direct_absolute, $1)=yes
4671	<	_LT_TAGVAR(hardcode_libdir_separator, $1)=':'
4672	<	_LT_TAGVAR(link_all_deplibs, $1)=yes
4673	<	_LT_TAGVAR(file_list_spec, $1)='${wl}-f,'
4674	<
4675	<	if test "$GCC" = yes; then
4676	<	case $host_os in aix4.[[012]]|aix4.[[012]].*)
4677	<	# We only want to do this on AIX 4.2 and lower, the check
4678	<	# below for broken collect2 doesn't work under 4.3+
4679	<	collect2name=`${CC} -print-prog-name=collect2`
4680	<	if test -f "$collect2name" &&
4681	<	strings "$collect2name" | $GREP resolve_lib_name >/dev/null
4682	<	then
4683	<	# We have reworked collect2
4684	<	:
4685	<	else
4686	<	# We have old collect2
4687	<	_LT_TAGVAR(hardcode_direct, $1)=unsupported
4688	<	# It fails to find uninstalled libraries when the uninstalled
4689	<	# path is not listed in the libpath.  Setting hardcode_minus_L
4690	<	# to unsupported forces relinking
4691	<	_LT_TAGVAR(hardcode_minus_L, $1)=yes
4692	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
4693	<	_LT_TAGVAR(hardcode_libdir_separator, $1)=
4694	<	fi
4695	<	;;
4696	<	esac
4697	<	shared_flag='-shared'
4698	<	if test "$aix_use_runtimelinking" = yes; then
4699	<	shared_flag="$shared_flag "'${wl}-G'
4700	<	fi
4701	<	else
4702	<	# not using gcc
4703	<	if test "$host_cpu" = ia64; then
4704	<	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
4705	<	# chokes on -Wl,-G. The following line is correct:
4706	<	shared_flag='-G'
4707	<	else
4708	<	if test "$aix_use_runtimelinking" = yes; then
4709	<	shared_flag='${wl}-G'
4710	<	else
4711	<	shared_flag='${wl}-bM:SRE'
4712	<	fi
4713	<	fi
4714	<	fi
4715	<
4716	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-bexpall'
4717	<	# It seems that -bexpall does not export symbols beginning with
4718	<	# underscore (_), so it is better to generate a list of symbols to export.
4719	<	_LT_TAGVAR(always_export_symbols, $1)=yes
4720	<	if test "$aix_use_runtimelinking" = yes; then
4721	<	# Warning - without using the other runtime loading flags (-brtl),
4722	<	# -berok will link without error, but may produce a broken library.
4723	<	_LT_TAGVAR(allow_undefined_flag, $1)='-berok'
4724	<	# Determine the default libpath from the value encoded in an
4725	<	# empty executable.
4726	<	_LT_SYS_MODULE_PATH_AIX
4727	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
4728	<	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then $ECHO "X${wl}${allow_undefined_flag}" | $Xsed; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
4729	<	else
4730	<	if test "$host_cpu" = ia64; then
4731	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib'
4732	<	_LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs"
4733	<	_LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
4734	<	else
4735	<	# Determine the default libpath from the value encoded in an
4736	<	# empty executable.
4737	<	_LT_SYS_MODULE_PATH_AIX
4738	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
4739	<	# Warning - without using the other run time loading flags,
4740	<	# -berok will link without error, but may produce a broken library.
4741	<	_LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok'
4742	<	_LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok'
4743	<	# Exported symbols can be pulled into shared objects from archives
4744	<	_LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience'
4745	<	_LT_TAGVAR(archive_cmds_need_lc, $1)=yes
4746	<	# This is similar to how AIX traditionally builds its shared libraries.
4747	<	_LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
4748	<	fi
4749	<	fi
4750	<	;;
4751	<
4752	<	amigaos*)
4753	<	case $host_cpu in
4754	<	powerpc)
4755	<	# see comment about AmigaOS4 .so support
4756	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
4757	<	_LT_TAGVAR(archive_expsym_cmds, $1)=''
4758	<	;;
4759	<	m68k)
4760	<	_LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
4761	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
4762	<	_LT_TAGVAR(hardcode_minus_L, $1)=yes
4763	<	;;
4764	<	esac
4765	<	;;
4766	<
4767	<	bsdi[[45]]*)
4768	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)=-rdynamic
4769	<	;;
4770	<
4771	<	cygwin* | mingw* | pw32* | cegcc*)
4772	<	# When not using gcc, we currently assume that we are using
4773	<	# Microsoft Visual C++.
4774	<	# hardcode_libdir_flag_spec is actually meaningless, as there is
4775	<	# no search path for DLLs.
4776	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' '
4777	<	_LT_TAGVAR(allow_undefined_flag, $1)=unsupported
4778	<	# Tell ltmain to make .lib files, not .a files.
4779	<	libext=lib
4780	<	# Tell ltmain to make .dll files, not .so files.
4781	<	shrext_cmds=".dll"
4782	<	# FIXME: Setting linknames here is a bad hack.
4783	<	_LT_TAGVAR(archive_cmds, $1)='$CC -o $lib $libobjs $compiler_flags `$ECHO "X$deplibs" | $Xsed -e '\''s/ -lc$//'\''` -link -dll~linknames='
4784	<	# The linker will automatically build a .lib file if we build a DLL.
4785	<	_LT_TAGVAR(old_archive_from_new_cmds, $1)='true'
4786	<	# FIXME: Should let the user specify the lib program.
4787	<	_LT_TAGVAR(old_archive_cmds, $1)='lib -OUT:$oldlib$oldobjs$old_deplibs'
4788	<	_LT_TAGVAR(fix_srcfile_path, $1)='`cygpath -w "$srcfile"`'
4789	<	_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
4790	<	;;
4791	<
4792	<	darwin* | rhapsody*)
4793	<	_LT_DARWIN_LINKER_FEATURES($1)
4794	<	;;
4795	<
4796	<	dgux*)
4797	<	_LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
4798	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
4799	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
4800	<	;;
4801	<
4802	<	freebsd1*)
4803	<	_LT_TAGVAR(ld_shlibs, $1)=no
4804	<	;;
4805	<
4806	<	# FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor
4807	<	# support.  Future versions do this automatically, but an explicit c++rt0.o
4808	<	# does not break anything, and helps significantly (at the cost of a little
4809	<	# extra space).
4810	<	freebsd2.2*)
4811	<	_LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'
4812	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
4813	<	_LT_TAGVAR(hardcode_direct, $1)=yes
4814	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
4815	<	;;
4816	<
4817	<	# Unfortunately, older versions of FreeBSD 2 do not have this feature.
4818	<	freebsd2*)
4819	<	_LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
4820	<	_LT_TAGVAR(hardcode_direct, $1)=yes
4821	<	_LT_TAGVAR(hardcode_minus_L, $1)=yes
4822	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
4823	<	;;
4824	<
4825	<	# FreeBSD 3 and greater uses gcc -shared to do shared libraries.
4826	<	freebsd* | dragonfly*)
4827	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared -o $lib $libobjs $deplibs $compiler_flags'
4828	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
4829	<	_LT_TAGVAR(hardcode_direct, $1)=yes
4830	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
4831	<	;;
4832	<
4833	<	hpux9*)
4834	<	if test "$GCC" = yes; then
4835	<	_LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
4836	<	else
4837	<	_LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
4838	<	fi
4839	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
4840	<	_LT_TAGVAR(hardcode_libdir_separator, $1)=:
4841	<	_LT_TAGVAR(hardcode_direct, $1)=yes
4842	<
4843	<	# hardcode_minus_L: Not really in the search PATH,
4844	<	# but as the default location of the library.
4845	<	_LT_TAGVAR(hardcode_minus_L, $1)=yes
4846	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
4847	<	;;
4848	<
4849	<	hpux10*)
4850	<	if test "$GCC" = yes -a "$with_gnu_ld" = no; then
4851	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
4852	<	else
4853	<	_LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
4854	<	fi
4855	<	if test "$with_gnu_ld" = no; then
4856	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
4857	<	_LT_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='+b $libdir'
4858	<	_LT_TAGVAR(hardcode_libdir_separator, $1)=:
4859	<	_LT_TAGVAR(hardcode_direct, $1)=yes
4860	<	_LT_TAGVAR(hardcode_direct_absolute, $1)=yes
4861	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
4862	<	# hardcode_minus_L: Not really in the search PATH,
4863	<	# but as the default location of the library.
4864	<	_LT_TAGVAR(hardcode_minus_L, $1)=yes
4865	<	fi
4866	<	;;
4867	<
4868	<	hpux11*)
4869	<	if test "$GCC" = yes -a "$with_gnu_ld" = no; then
4870	<	case $host_cpu in
4871	<	hppa*64*)
4872	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
4873	<	;;
4874	<	ia64*)
4875	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
4876	<	;;
4877	<	*)
4878	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
4879	<	;;
4880	<	esac
4881	<	else
4882	<	case $host_cpu in
4883	<	hppa*64*)
4884	<	_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
4885	<	;;
4886	<	ia64*)
4887	<	_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
4888	<	;;
4889	<	*)
4890	<	_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
4891	<	;;
4892	<	esac
4893	<	fi
4894	<	if test "$with_gnu_ld" = no; then
4895	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
4896	<	_LT_TAGVAR(hardcode_libdir_separator, $1)=:
4897	<
4898	<	case $host_cpu in
4899	<	hppa*64*|ia64*)
4900	<	_LT_TAGVAR(hardcode_direct, $1)=no
4901	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
4902	<	;;
4903	<	*)
4904	<	_LT_TAGVAR(hardcode_direct, $1)=yes
4905	<	_LT_TAGVAR(hardcode_direct_absolute, $1)=yes
4906	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
4907	<
4908	<	# hardcode_minus_L: Not really in the search PATH,
4909	<	# but as the default location of the library.
4910	<	_LT_TAGVAR(hardcode_minus_L, $1)=yes
4911	<	;;
4912	<	esac
4913	<	fi
4914	<	;;
4915	<
4916	<	irix5* | irix6* | nonstopux*)
4917	<	if test "$GCC" = yes; then
4918	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "X${wl}-set_version ${wl}$verstring" | $Xsed` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
4919	<	# Try to use the -exported_symbol ld option, if it does not
4920	<	# work, assume that -exports_file does not work either and
4921	<	# implicitly export all symbols.
4922	<	save_LDFLAGS="$LDFLAGS"
4923	<	LDFLAGS="$LDFLAGS -shared ${wl}-exported_symbol ${wl}foo ${wl}-update_registry ${wl}/dev/null"
4924	<	AC_LINK_IFELSE(int foo(void) {},
4925	<	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "X${wl}-set_version ${wl}$verstring" | $Xsed` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib'
4926	<	)
4927	<	LDFLAGS="$save_LDFLAGS"
4928	<	else
4929	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib'
4930	<	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -exports_file $export_symbols -o $lib'
4931	<	fi
4932	<	_LT_TAGVAR(archive_cmds_need_lc, $1)='no'
4933	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
4934	<	_LT_TAGVAR(hardcode_libdir_separator, $1)=:
4935	<	_LT_TAGVAR(inherit_rpath, $1)=yes
4936	<	_LT_TAGVAR(link_all_deplibs, $1)=yes
4937	<	;;
4938	<
4939	<	netbsd*)
4940	<	if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
4941	<	_LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out
4942	<	else
4943	<	_LT_TAGVAR(archive_cmds, $1)='$LD -shared -o $lib $libobjs $deplibs $linker_flags'      # ELF
4944	<	fi
4945	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
4946	<	_LT_TAGVAR(hardcode_direct, $1)=yes
4947	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
4948	<	;;
4949	<
4950	<	newsos6)
4951	<	_LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
4952	<	_LT_TAGVAR(hardcode_direct, $1)=yes
4953	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
4954	<	_LT_TAGVAR(hardcode_libdir_separator, $1)=:
4955	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
4956	<	;;
4957	<
4958	<	*nto* | *qnx*)
4959	<	;;
4960	<
4961	<	openbsd*)
4962	<	if test -f /usr/libexec/ld.so; then
4963	<	_LT_TAGVAR(hardcode_direct, $1)=yes
4964	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
4965	<	_LT_TAGVAR(hardcode_direct_absolute, $1)=yes
4966	<	if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
4967	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
4968	<	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols'
4969	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
4970	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
4971	<	else
4972	<	case $host_os in
4973	<	openbsd[[01]].* | openbsd2.[[0-7]] | openbsd2.[[0-7]].*)
4974	<	_LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
4975	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
4976	<	;;
4977	<	*)
4978	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
4979	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
4980	<	;;
4981	<	esac
4982	<	fi
4983	<	else
4984	<	_LT_TAGVAR(ld_shlibs, $1)=no
4985	<	fi
4986	<	;;
4987	<
4988	<	os2*)
4989	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
4990	<	_LT_TAGVAR(hardcode_minus_L, $1)=yes
4991	<	_LT_TAGVAR(allow_undefined_flag, $1)=unsupported
4992	<	_LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~$ECHO DATA >> $output_objdir/$libname.def~$ECHO " SINGLE NONSHARED" >> $output_objdir/$libname.def~$ECHO EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'
4993	<	_LT_TAGVAR(old_archive_from_new_cmds, $1)='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'
4994	<	;;
4995	<
4996	<	osf3*)
4997	<	if test "$GCC" = yes; then
4998	<	_LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
4999	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "X${wl}-set_version ${wl}$verstring" | $Xsed` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
5000	<	else
5001	<	_LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
5002	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib'
5003	<	fi
5004	<	_LT_TAGVAR(archive_cmds_need_lc, $1)='no'
5005	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
5006	<	_LT_TAGVAR(hardcode_libdir_separator, $1)=:
5007	<	;;
5008	<
5009	<	osf4* | osf5*)      # as osf3* with the addition of -msym flag
5010	<	if test "$GCC" = yes; then
5011	<	_LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
5012	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "X${wl}-set_version ${wl}$verstring" | $Xsed` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
5013	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
5014	<	else
5015	<	_LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
5016	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib'
5017	<	_LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~
5018	<	$CC -shared${allow_undefined_flag} ${wl}-input ${wl}$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib~$RM $lib.exp'
5019	<
5020	<	# Both c and cxx compiler support -rpath directly
5021	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
5022	<	fi
5023	<	_LT_TAGVAR(archive_cmds_need_lc, $1)='no'
5024	<	_LT_TAGVAR(hardcode_libdir_separator, $1)=:
5025	<	;;
5026	<
5027	<	solaris*)
5028	<	_LT_TAGVAR(no_undefined_flag, $1)=' -z defs'
5029	<	if test "$GCC" = yes; then
5030	<	wlarc='${wl}'
5031	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-z ${wl}text ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
5032	<	_LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
5033	<	$CC -shared ${wl}-z ${wl}text ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
5034	<	else
5035	<	case `$CC -V 2>&1` in
5036	<	*"Compilers 5.0"*)
5037	<	wlarc=''
5038	<	_LT_TAGVAR(archive_cmds, $1)='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'
5039	<	_LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
5040	<	$LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp'
5041	<	;;
5042	<	*)
5043	<	wlarc='${wl}'
5044	<	_LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $compiler_flags'
5045	<	_LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
5046	<	$CC -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
5047	<	;;
5048	<	esac
5049	<	fi
5050	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
5051	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
5052	<	case $host_os in
5053	<	solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
5054	<	*)
5055	<	# The compiler driver will combine and reorder linker options,
5056	<	# but understands `-z linker_flag'.  GCC discards it without `$wl',
5057	<	# but is careful enough not to reorder.
5058	<	# Supported since Solaris 2.6 (maybe 2.5.1?)
5059	<	if test "$GCC" = yes; then
5060	<	_LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract'
5061	<	else
5062	<	_LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract'
5063	<	fi
5064	<	;;
5065	<	esac
5066	<	_LT_TAGVAR(link_all_deplibs, $1)=yes
5067	<	;;
5068	<
5069	<	sunos4*)
5070	<	if test "x$host_vendor" = xsequent; then
5071	<	# Use $CC to link under sequent, because it throws in some extra .o
5072	<	# files that make .init and .fini sections work.
5073	<	_LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags'
5074	<	else
5075	<	_LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'
5076	<	fi
5077	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
5078	<	_LT_TAGVAR(hardcode_direct, $1)=yes
5079	<	_LT_TAGVAR(hardcode_minus_L, $1)=yes
5080	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
5081	<	;;
5082	<
5083	<	sysv4)
5084	<	case $host_vendor in
5085	<	sni)
5086	<	_LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
5087	<	_LT_TAGVAR(hardcode_direct, $1)=yes # is this really true???
5088	<	;;
5089	<	siemens)
5090	<	## LD is ld it makes a PLAMLIB
5091	<	## CC just makes a GrossModule.
5092	<	_LT_TAGVAR(archive_cmds, $1)='$LD -G -o $lib $libobjs $deplibs $linker_flags'
5093	<	_LT_TAGVAR(reload_cmds, $1)='$CC -r -o $output$reload_objs'
5094	<	_LT_TAGVAR(hardcode_direct, $1)=no
5095	<	;;
5096	<	motorola)
5097	<	_LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
5098	<	_LT_TAGVAR(hardcode_direct, $1)=no #Motorola manual says yes, but my tests say they lie
5099	<	;;
5100	<	esac
5101	<	runpath_var='LD_RUN_PATH'
5102	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
5103	<	;;
5104	<
5105	<	sysv4.3*)
5106	<	_LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
5107	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
5108	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)='-Bexport'
5109	<	;;
5110	<
5111	<	sysv4*MP*)
5112	<	if test -d /usr/nec; then
5113	<	_LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
5114	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
5115	<	runpath_var=LD_RUN_PATH
5116	<	hardcode_runpath_var=yes
5117	<	_LT_TAGVAR(ld_shlibs, $1)=yes
5118	<	fi
5119	<	;;
5120	<
5121	<	sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*)
5122	<	_LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
5123	<	_LT_TAGVAR(archive_cmds_need_lc, $1)=no
5124	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
5125	<	runpath_var='LD_RUN_PATH'
5126	<
5127	<	if test "$GCC" = yes; then
5128	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
5129	<	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
5130	<	else
5131	<	_LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
5132	<	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
5133	<	fi
5134	<	;;
5135	<
5136	<	sysv5* | sco3.2v5* | sco5v6*)
5137	<	# Note: We can NOT use -z defs as we might desire, because we do not
5138	<	# link with -lc, and that would cause any symbols used from libc to
5139	<	# always be unresolved, which means just about no library would
5140	<	# ever link correctly.  If we're not using GNU ld we use -z text
5141	<	# though, which does catch some bad symbols but isn't as heavy-handed
5142	<	# as -z defs.
5143	<	_LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
5144	<	_LT_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs'
5145	<	_LT_TAGVAR(archive_cmds_need_lc, $1)=no
5146	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
5147	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R,$libdir'
5148	<	_LT_TAGVAR(hardcode_libdir_separator, $1)=':'
5149	<	_LT_TAGVAR(link_all_deplibs, $1)=yes
5150	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport'
5151	<	runpath_var='LD_RUN_PATH'
5152	<
5153	<	if test "$GCC" = yes; then
5154	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
5155	<	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
5156	<	else
5157	<	_LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
5158	<	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
5159	<	fi
5160	<	;;
5161	<
5162	<	uts4*)
5163	<	_LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
5164	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
5165	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
5166	<	;;
5167	<
5168	<	*)
5169	<	_LT_TAGVAR(ld_shlibs, $1)=no
5170	<	;;
5171	<	esac
5172	<
5173	<	if test x$host_vendor = xsni; then
5174	<	case $host in
5175	<	sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
5176	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Blargedynsym'
5177	<	;;
5178	<	esac
5179	<	fi
5180	<	fi
5181	<	])
5182	<	AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)])
5183	<	test "$_LT_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no
5184	<
5185	<	_LT_TAGVAR(with_gnu_ld, $1)=$with_gnu_ld
5186	<
5187	<	_LT_DECL([], [libext], [0], [Old archive suffix (normally "a")])dnl
5188	<	_LT_DECL([], [shrext_cmds], [1], [Shared library suffix (normally ".so")])dnl
5189	<	_LT_DECL([], [extract_expsyms_cmds], [2],
5190	<	[The commands to extract the exported symbol list from a shared archive])
5191	<
5192	<	#
5193	<	# Do we need to explicitly link libc?
5194	<	#
5195	<	case "x$_LT_TAGVAR(archive_cmds_need_lc, $1)" in
5196	<	x|xyes)
5197	<	# Assume -lc should be added
5198	<	_LT_TAGVAR(archive_cmds_need_lc, $1)=yes
5199	<
5200	<	if test "$enable_shared" = yes && test "$GCC" = yes; then
5201	<	case $_LT_TAGVAR(archive_cmds, $1) in
5202	<	*'~'*)
5203	<	# FIXME: we may have to deal with multi-command sequences.
5204	<	;;
5205	<	'$CC '*)
5206	<	# Test whether the compiler implicitly links with -lc since on some
5207	<	# systems, -lgcc has to come before -lc. If gcc already passes -lc
5208	<	# to ld, don't add -lc before -lgcc.
5209	<	AC_MSG_CHECKING([whether -lc should be explicitly linked in])
5210	<	$RM conftest*
5211	<	echo "$lt_simple_compile_test_code" > conftest.$ac_ext
5212	<
5213	<	if AC_TRY_EVAL(ac_compile) 2>conftest.err; then
5214	<	soname=conftest
5215	<	lib=conftest
5216	<	libobjs=conftest.$ac_objext
5217	<	deplibs=
5218	<	wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1)
5219	<	pic_flag=$_LT_TAGVAR(lt_prog_compiler_pic, $1)
5220	<	compiler_flags=-v
5221	<	linker_flags=-v
5222	<	verstring=
5223	<	output_objdir=.
5224	<	libname=conftest
5225	<	lt_save_allow_undefined_flag=$_LT_TAGVAR(allow_undefined_flag, $1)
5226	<	_LT_TAGVAR(allow_undefined_flag, $1)=
5227	<	if AC_TRY_EVAL(_LT_TAGVAR(archive_cmds, $1) 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1)
5228	<	then
5229	<	_LT_TAGVAR(archive_cmds_need_lc, $1)=no
5230	<	else
5231	<	_LT_TAGVAR(archive_cmds_need_lc, $1)=yes
5232	<	fi
5233	<	_LT_TAGVAR(allow_undefined_flag, $1)=$lt_save_allow_undefined_flag
5234	<	else
5235	<	cat conftest.err 1>&5
5236	<	fi
5237	<	$RM conftest*
5238	<	AC_MSG_RESULT([$_LT_TAGVAR(archive_cmds_need_lc, $1)])
5239	<	;;
5240	<	esac
5241	<	fi
5242	<	;;
5243	<	esac
5244	<
5245	<	_LT_TAGDECL([build_libtool_need_lc], [archive_cmds_need_lc], [0],
5246	<	[Whether or not to add -lc for building shared libraries])
5247	<	_LT_TAGDECL([allow_libtool_libs_with_static_runtimes],
5248	<	[enable_shared_with_static_runtimes], [0],
5249	<	[Whether or not to disallow shared libs when runtime libs are static])
5250	<	_LT_TAGDECL([], [export_dynamic_flag_spec], [1],
5251	<	[Compiler flag to allow reflexive dlopens])
5252	<	_LT_TAGDECL([], [whole_archive_flag_spec], [1],
5253	<	[Compiler flag to generate shared objects directly from archives])
5254	<	_LT_TAGDECL([], [compiler_needs_object], [1],
5255	<	[Whether the compiler copes with passing no objects directly])
5256	<	_LT_TAGDECL([], [old_archive_from_new_cmds], [2],
5257	<	[Create an old-style archive from a shared archive])
5258	<	_LT_TAGDECL([], [old_archive_from_expsyms_cmds], [2],
5259	<	[Create a temporary old-style archive to link instead of a shared archive])
5260	<	_LT_TAGDECL([], [archive_cmds], [2], [Commands used to build a shared archive])
5261	<	_LT_TAGDECL([], [archive_expsym_cmds], [2])
5262	<	_LT_TAGDECL([], [module_cmds], [2],
5263	<	[Commands used to build a loadable module if different from building
5264	<	a shared archive.])
5265	<	_LT_TAGDECL([], [module_expsym_cmds], [2])
5266	<	_LT_TAGDECL([], [with_gnu_ld], [1],
5267	<	[Whether we are building with GNU ld or not])
5268	<	_LT_TAGDECL([], [allow_undefined_flag], [1],
5269	<	[Flag that allows shared libraries with undefined symbols to be built])
5270	<	_LT_TAGDECL([], [no_undefined_flag], [1],
5271	<	[Flag that enforces no undefined symbols])
5272	<	_LT_TAGDECL([], [hardcode_libdir_flag_spec], [1],
5273	<	[Flag to hardcode $libdir into a binary during linking.
5274	<	This must work even if $libdir does not exist])
5275	<	_LT_TAGDECL([], [hardcode_libdir_flag_spec_ld], [1],
5276	<	[[If ld is used when linking, flag to hardcode $libdir into a binary
5277	<	during linking.  This must work even if $libdir does not exist]])
5278	<	_LT_TAGDECL([], [hardcode_libdir_separator], [1],
5279	<	[Whether we need a single "-rpath" flag with a separated argument])
5280	<	_LT_TAGDECL([], [hardcode_direct], [0],
5281	<	[Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes
5282	<	DIR into the resulting binary])
5283	<	_LT_TAGDECL([], [hardcode_direct_absolute], [0],
5284	<	[Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes
5285	<	DIR into the resulting binary and the resulting library dependency is
5286	<	"absolute", i.e impossible to change by setting ${shlibpath_var} if the
5287	<	library is relocated])
5288	<	_LT_TAGDECL([], [hardcode_minus_L], [0],
5289	<	[Set to "yes" if using the -LDIR flag during linking hardcodes DIR
5290	<	into the resulting binary])
5291	<	_LT_TAGDECL([], [hardcode_shlibpath_var], [0],
5292	<	[Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
5293	<	into the resulting binary])
5294	<	_LT_TAGDECL([], [hardcode_automatic], [0],
5295	<	[Set to "yes" if building a shared library automatically hardcodes DIR
5296	<	into the library and all subsequent libraries and executables linked
5297	<	against it])
5298	<	_LT_TAGDECL([], [inherit_rpath], [0],
5299	<	[Set to yes if linker adds runtime paths of dependent libraries
5300	<	to runtime path list])
5301	<	_LT_TAGDECL([], [link_all_deplibs], [0],
5302	<	[Whether libtool must link a program against all its dependency libraries])
5303	<	_LT_TAGDECL([], [fix_srcfile_path], [1],
5304	<	[Fix the shell variable $srcfile for the compiler])
5305	<	_LT_TAGDECL([], [always_export_symbols], [0],
5306	<	[Set to "yes" if exported symbols are required])
5307	<	_LT_TAGDECL([], [export_symbols_cmds], [2],
5308	<	[The commands to list exported symbols])
5309	<	_LT_TAGDECL([], [exclude_expsyms], [1],
5310	<	[Symbols that should not be listed in the preloaded symbols])
5311	<	_LT_TAGDECL([], [include_expsyms], [1],
5312	<	[Symbols that must always be exported])
5313	<	_LT_TAGDECL([], [prelink_cmds], [2],
5314	<	[Commands necessary for linking programs (against libraries) with templates])
5315	<	_LT_TAGDECL([], [file_list_spec], [1],
5316	<	[Specify filename containing input files])
5317	<	dnl FIXME: Not yet implemented
5318	<	dnl _LT_TAGDECL([], [thread_safe_flag_spec], [1],
5319	<	dnl    [Compiler flag to generate thread safe objects])
5320	<	])# _LT_LINKER_SHLIBS
5321	<
5322	<
5323	<	# _LT_LANG_C_CONFIG([TAG])
5324	<	# ------------------------
5325	<	# Ensure that the configuration variables for a C compiler are suitably
5326	<	# defined.  These variables are subsequently used by _LT_CONFIG to write
5327	<	# the compiler configuration to `libtool'.
5328	<	m4_defun([_LT_LANG_C_CONFIG],
5329	<	[m4_require([_LT_DECL_EGREP])dnl
5330	<	lt_save_CC="$CC"
5331	<	AC_LANG_PUSH(C)
5332	<
5333	<	# Source file extension for C test sources.
5334	<	ac_ext=c
5335	<
5336	<	# Object file extension for compiled C test sources.
5337	<	objext=o
5338	<	_LT_TAGVAR(objext, $1)=$objext
5339	<
5340	<	# Code to be used in simple compile tests
5341	<	lt_simple_compile_test_code="int some_variable = 0;"
5342	<
5343	<	# Code to be used in simple link tests
5344	<	lt_simple_link_test_code='int main(){return(0);}'
5345	<
5346	<	_LT_TAG_COMPILER
5347	<	# Save the default compiler, since it gets overwritten when the other
5348	<	# tags are being tested, and _LT_TAGVAR(compiler, []) is a NOP.
5349	<	compiler_DEFAULT=$CC
5350	<
5351	<	# save warnings/boilerplate of simple test code
5352	<	_LT_COMPILER_BOILERPLATE
5353	<	_LT_LINKER_BOILERPLATE
5354	<
5355	<	if test -n "$compiler"; then
5356	<	_LT_COMPILER_NO_RTTI($1)
5357	<	_LT_COMPILER_PIC($1)
5358	<	_LT_COMPILER_C_O($1)
5359	<	_LT_COMPILER_FILE_LOCKS($1)
5360	<	_LT_LINKER_SHLIBS($1)
5361	<	_LT_SYS_DYNAMIC_LINKER($1)
5362	<	_LT_LINKER_HARDCODE_LIBPATH($1)
5363	<	LT_SYS_DLOPEN_SELF
5364	<	_LT_CMD_STRIPLIB
5365	<
5366	<	# Report which library types will actually be built
5367	<	AC_MSG_CHECKING([if libtool supports shared libraries])
5368	<	AC_MSG_RESULT([$can_build_shared])
5369	<
5370	<	AC_MSG_CHECKING([whether to build shared libraries])
5371	<	test "$can_build_shared" = "no" && enable_shared=no
5372	<
5373	<	# On AIX, shared libraries and static libraries use the same namespace, and
5374	<	# are all built from PIC.
5375	<	case $host_os in
5376	<	aix3*)
5377	<	test "$enable_shared" = yes && enable_static=no
5378	<	if test -n "$RANLIB"; then
5379	<	archive_cmds="$archive_cmds~\$RANLIB \$lib"
5380	<	postinstall_cmds='$RANLIB $lib'
5381	<	fi
5382	<	;;
5383	<
5384	<	aix[[4-9]]*)
5385	<	if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
5386	<	test "$enable_shared" = yes && enable_static=no
5387	<	fi
5388	<	;;
5389	<	esac
5390	<	AC_MSG_RESULT([$enable_shared])
5391	<
5392	<	AC_MSG_CHECKING([whether to build static libraries])
5393	<	# Make sure either enable_shared or enable_static is yes.
5394	<	test "$enable_shared" = yes || enable_static=yes
5395	<	AC_MSG_RESULT([$enable_static])
5396	<
5397	<	_LT_CONFIG($1)
5398	<	fi
5399	<	AC_LANG_POP
5400	<	CC="$lt_save_CC"
5401	<	])# _LT_LANG_C_CONFIG
5402	<
5403	<
5404	<	# _LT_PROG_CXX
5405	<	# ------------
5406	<	# Since AC_PROG_CXX is broken, in that it returns g++ if there is no c++
5407	<	# compiler, we have our own version here.
5408	<	m4_defun([_LT_PROG_CXX],
5409	<	[
5410	<	pushdef([AC_MSG_ERROR], [_lt_caught_CXX_error=yes])
5411	<	AC_PROG_CXX
5412	<	if test -n "$CXX" && ( test "X$CXX" != "Xno" &&
5413	<	( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||
5414	<	(test "X$CXX" != "Xg++"))) ; then
5415	<	AC_PROG_CXXCPP
5416	<	else
5417	<	_lt_caught_CXX_error=yes
5418	<	fi
5419	<	popdef([AC_MSG_ERROR])
5420	<	])# _LT_PROG_CXX
5421	<
5422	<	dnl aclocal-1.4 backwards compatibility:
5423	<	dnl AC_DEFUN([_LT_PROG_CXX], [])
5424	<
5425	<
5426	<	# _LT_LANG_CXX_CONFIG([TAG])
5427	<	# --------------------------
5428	<	# Ensure that the configuration variables for a C++ compiler are suitably
5429	<	# defined.  These variables are subsequently used by _LT_CONFIG to write
5430	<	# the compiler configuration to `libtool'.
5431	<	m4_defun([_LT_LANG_CXX_CONFIG],
5432	<	[AC_REQUIRE([_LT_PROG_CXX])dnl
5433	<	m4_require([_LT_FILEUTILS_DEFAULTS])dnl
5434	<	m4_require([_LT_DECL_EGREP])dnl
5435	<
5436	<	AC_LANG_PUSH(C++)
5437	<	_LT_TAGVAR(archive_cmds_need_lc, $1)=no
5438	<	_LT_TAGVAR(allow_undefined_flag, $1)=
5439	<	_LT_TAGVAR(always_export_symbols, $1)=no
5440	<	_LT_TAGVAR(archive_expsym_cmds, $1)=
5441	<	_LT_TAGVAR(compiler_needs_object, $1)=no
5442	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)=
5443	<	_LT_TAGVAR(hardcode_direct, $1)=no
5444	<	_LT_TAGVAR(hardcode_direct_absolute, $1)=no
5445	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
5446	<	_LT_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=
5447	<	_LT_TAGVAR(hardcode_libdir_separator, $1)=
5448	<	_LT_TAGVAR(hardcode_minus_L, $1)=no
5449	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
5450	<	_LT_TAGVAR(hardcode_automatic, $1)=no
5451	<	_LT_TAGVAR(inherit_rpath, $1)=no
5452	<	_LT_TAGVAR(module_cmds, $1)=
5453	<	_LT_TAGVAR(module_expsym_cmds, $1)=
5454	<	_LT_TAGVAR(link_all_deplibs, $1)=unknown
5455	<	_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
5456	<	_LT_TAGVAR(no_undefined_flag, $1)=
5457	<	_LT_TAGVAR(whole_archive_flag_spec, $1)=
5458	<	_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no
5459	<
5460	<	# Source file extension for C++ test sources.
5461	<	ac_ext=cpp
5462	<
5463	<	# Object file extension for compiled C++ test sources.
5464	<	objext=o
5465	<	_LT_TAGVAR(objext, $1)=$objext
5466	<
5467	<	# No sense in running all these tests if we already determined that
5468	<	# the CXX compiler isn't working.  Some variables (like enable_shared)
5469	<	# are currently assumed to apply to all compilers on this platform,
5470	<	# and will be corrupted by setting them based on a non-working compiler.
5471	<	if test "$_lt_caught_CXX_error" != yes; then
5472	<	# Code to be used in simple compile tests
5473	<	lt_simple_compile_test_code="int some_variable = 0;"
5474	<
5475	<	# Code to be used in simple link tests
5476	<	lt_simple_link_test_code='int main(int, char *[[]]) { return(0); }'
5477	<
5478	<	# ltmain only uses $CC for tagged configurations so make sure $CC is set.
5479	<	_LT_TAG_COMPILER
5480	<
5481	<	# save warnings/boilerplate of simple test code
5482	<	_LT_COMPILER_BOILERPLATE
5483	<	_LT_LINKER_BOILERPLATE
5484	<
5485	<	# Allow CC to be a program name with arguments.
5486	<	lt_save_CC=$CC
5487	<	lt_save_LD=$LD
5488	<	lt_save_GCC=$GCC
5489	<	GCC=$GXX
5490	<	lt_save_with_gnu_ld=$with_gnu_ld
5491	<	lt_save_path_LD=$lt_cv_path_LD
5492	<	if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then
5493	<	lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx
5494	<	else
5495	<	$as_unset lt_cv_prog_gnu_ld
5496	<	fi
5497	<	if test -n "${lt_cv_path_LDCXX+set}"; then
5498	<	lt_cv_path_LD=$lt_cv_path_LDCXX
5499	<	else
5500	<	$as_unset lt_cv_path_LD
5501	<	fi
5502	<	test -z "${LDCXX+set}" || LD=$LDCXX
5503	<	CC=${CXX-"c++"}
5504	<	compiler=$CC
5505	<	_LT_TAGVAR(compiler, $1)=$CC
5506	<	_LT_CC_BASENAME([$compiler])
5507	<
5508	<	if test -n "$compiler"; then
5509	<	# We don't want -fno-exception when compiling C++ code, so set the
5510	<	# no_builtin_flag separately
5511	<	if test "$GXX" = yes; then
5512	<	_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin'
5513	<	else
5514	<	_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=
5515	<	fi
5516	<
5517	<	if test "$GXX" = yes; then
5518	<	# Set up default GNU C++ configuration
5519	<
5520	<	LT_PATH_LD
5521	<
5522	<	# Check if GNU C++ uses GNU ld as the underlying linker, since the
5523	<	# archiving commands below assume that GNU ld is being used.
5524	<	if test "$with_gnu_ld" = yes; then
5525	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
5526	<	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
5527	<
5528	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
5529	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
5530	<
5531	<	# If archive_cmds runs LD, not CC, wlarc should be empty
5532	<	# XXX I think wlarc can be eliminated in ltcf-cxx, but I need to
5533	<	#     investigate it a little bit more. (MM)
5534	<	wlarc='${wl}'
5535	<
5536	<	# ancient GNU ld didn't support --whole-archive et. al.
5537	<	if eval "`$CC -print-prog-name=ld` --help 2>&1" |
5538	<	$GREP 'no-whole-archive' > /dev/null; then
5539	<	_LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
5540	<	else
5541	<	_LT_TAGVAR(whole_archive_flag_spec, $1)=
5542	<	fi
5543	<	else
5544	<	with_gnu_ld=no
5545	<	wlarc=
5546	<
5547	<	# A generic and very simple default shared library creation
5548	<	# command for GNU C++ for the case where it uses the native
5549	<	# linker, instead of GNU ld.  If possible, this setting should
5550	<	# overridden to take advantage of the native linker features on
5551	<	# the platform it is being used on.
5552	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
5553	<	fi
5554	<
5555	<	# Commands to make compiler produce verbose output that lists
5556	<	# what "hidden" libraries, object files and flags are used when
5557	<	# linking a shared library.
5558	<	output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "\-L"'
5559	<
5560	<	else
5561	<	GXX=no
5562	<	with_gnu_ld=no
5563	<	wlarc=
5564	<	fi
5565	<
5566	<	# PORTME: fill in a description of your system's C++ link characteristics
5567	<	AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries])
5568	<	_LT_TAGVAR(ld_shlibs, $1)=yes
5569	<	case $host_os in
5570	<	aix3*)
5571	<	# FIXME: insert proper C++ library support
5572	<	_LT_TAGVAR(ld_shlibs, $1)=no
5573	<	;;
5574	<	aix[[4-9]]*)
5575	<	if test "$host_cpu" = ia64; then
5576	<	# On IA64, the linker does run time linking by default, so we don't
5577	<	# have to do anything special.
5578	<	aix_use_runtimelinking=no
5579	<	exp_sym_flag='-Bexport'
5580	<	no_entry_flag=""
5581	<	else
5582	<	aix_use_runtimelinking=no
5583	<
5584	<	# Test if we are trying to use run time linking or normal
5585	<	# AIX style linking. If -brtl is somewhere in LDFLAGS, we
5586	<	# need to do runtime linking.
5587	<	case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*)
5588	<	for ld_flag in $LDFLAGS; do
5589	<	case $ld_flag in
5590	<	*-brtl*)
5591	<	aix_use_runtimelinking=yes
5592	<	break
5593	<	;;
5594	<	esac
5595	<	done
5596	<	;;
5597	<	esac
5598	<
5599	<	exp_sym_flag='-bexport'
5600	<	no_entry_flag='-bnoentry'
5601	<	fi
5602	<
5603	<	# When large executables or shared objects are built, AIX ld can
5604	<	# have problems creating the table of contents.  If linking a library
5605	<	# or program results in "error TOC overflow" add -mminimal-toc to
5606	<	# CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
5607	<	# enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
5608	<
5609	<	_LT_TAGVAR(archive_cmds, $1)=''
5610	<	_LT_TAGVAR(hardcode_direct, $1)=yes
5611	<	_LT_TAGVAR(hardcode_direct_absolute, $1)=yes
5612	<	_LT_TAGVAR(hardcode_libdir_separator, $1)=':'
5613	<	_LT_TAGVAR(link_all_deplibs, $1)=yes
5614	<	_LT_TAGVAR(file_list_spec, $1)='${wl}-f,'
5615	<
5616	<	if test "$GXX" = yes; then
5617	<	case $host_os in aix4.[[012]]|aix4.[[012]].*)
5618	<	# We only want to do this on AIX 4.2 and lower, the check
5619	<	# below for broken collect2 doesn't work under 4.3+
5620	<	collect2name=`${CC} -print-prog-name=collect2`
5621	<	if test -f "$collect2name" &&
5622	<	strings "$collect2name" | $GREP resolve_lib_name >/dev/null
5623	<	then
5624	<	# We have reworked collect2
5625	<	:
5626	<	else
5627	<	# We have old collect2
5628	<	_LT_TAGVAR(hardcode_direct, $1)=unsupported
5629	<	# It fails to find uninstalled libraries when the uninstalled
5630	<	# path is not listed in the libpath.  Setting hardcode_minus_L
5631	<	# to unsupported forces relinking
5632	<	_LT_TAGVAR(hardcode_minus_L, $1)=yes
5633	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
5634	<	_LT_TAGVAR(hardcode_libdir_separator, $1)=
5635	<	fi
5636	<	esac
5637	<	shared_flag='-shared'
5638	<	if test "$aix_use_runtimelinking" = yes; then
5639	<	shared_flag="$shared_flag "'${wl}-G'
5640	<	fi
5641	<	else
5642	<	# not using gcc
5643	<	if test "$host_cpu" = ia64; then
5644	<	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
5645	<	# chokes on -Wl,-G. The following line is correct:
5646	<	shared_flag='-G'
5647	<	else
5648	<	if test "$aix_use_runtimelinking" = yes; then
5649	<	shared_flag='${wl}-G'
5650	<	else
5651	<	shared_flag='${wl}-bM:SRE'
5652	<	fi
5653	<	fi
5654	<	fi
5655	<
5656	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-bexpall'
5657	<	# It seems that -bexpall does not export symbols beginning with
5658	<	# underscore (_), so it is better to generate a list of symbols to
5659	<	# export.
5660	<	_LT_TAGVAR(always_export_symbols, $1)=yes
5661	<	if test "$aix_use_runtimelinking" = yes; then
5662	<	# Warning - without using the other runtime loading flags (-brtl),
5663	<	# -berok will link without error, but may produce a broken library.
5664	<	_LT_TAGVAR(allow_undefined_flag, $1)='-berok'
5665	<	# Determine the default libpath from the value encoded in an empty
5666	<	# executable.
5667	<	_LT_SYS_MODULE_PATH_AIX
5668	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
5669	<
5670	<	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then $ECHO "X${wl}${allow_undefined_flag}" | $Xsed; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
5671	<	else
5672	<	if test "$host_cpu" = ia64; then
5673	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib'
5674	<	_LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs"
5675	<	_LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
5676	<	else
5677	<	# Determine the default libpath from the value encoded in an
5678	<	# empty executable.
5679	<	_LT_SYS_MODULE_PATH_AIX
5680	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
5681	<	# Warning - without using the other run time loading flags,
5682	<	# -berok will link without error, but may produce a broken library.
5683	<	_LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok'
5684	<	_LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok'
5685	<	# Exported symbols can be pulled into shared objects from archives
5686	<	_LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience'
5687	<	_LT_TAGVAR(archive_cmds_need_lc, $1)=yes
5688	<	# This is similar to how AIX traditionally builds its shared
5689	<	# libraries.
5690	<	_LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
5691	<	fi
5692	<	fi
5693	<	;;
5694	<
5695	<	beos*)
5696	<	if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
5697	<	_LT_TAGVAR(allow_undefined_flag, $1)=unsupported
5698	<	# Joseph Beckenbach <jrb3@best.com> says some releases of gcc
5699	<	# support --undefined.  This deserves some investigation.  FIXME
5700	<	_LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
5701	<	else
5702	<	_LT_TAGVAR(ld_shlibs, $1)=no
5703	<	fi
5704	<	;;
5705	<
5706	<	chorus*)
5707	<	case $cc_basename in
5708	<	*)
5709	<	# FIXME: insert proper C++ library support
5710	<	_LT_TAGVAR(ld_shlibs, $1)=no
5711	<	;;
5712	<	esac
5713	<	;;
5714	<
5715	<	cygwin* | mingw* | pw32* | cegcc*)
5716	<	# _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,
5717	<	# as there is no search path for DLLs.
5718	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
5719	<	_LT_TAGVAR(allow_undefined_flag, $1)=unsupported
5720	<	_LT_TAGVAR(always_export_symbols, $1)=no
5721	<	_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
5722	<
5723	<	if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
5724	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
5725	<	# If the export-symbols file already is a .def file (1st line
5726	<	# is EXPORTS), use it as is; otherwise, prepend...
5727	<	_LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
5728	<	cp $export_symbols $output_objdir/$soname.def;
5729	<	else
5730	<	echo EXPORTS > $output_objdir/$soname.def;
5731	<	cat $export_symbols >> $output_objdir/$soname.def;
5732	<	fi~
5733	<	$CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
5734	<	else
5735	<	_LT_TAGVAR(ld_shlibs, $1)=no
5736	<	fi
5737	<	;;
5738	<	darwin* | rhapsody*)
5739	<	_LT_DARWIN_LINKER_FEATURES($1)
5740	<	;;
5741	<
5742	<	dgux*)
5743	<	case $cc_basename in
5744	<	ec++*)
5745	<	# FIXME: insert proper C++ library support
5746	<	_LT_TAGVAR(ld_shlibs, $1)=no
5747	<	;;
5748	<	ghcx*)
5749	<	# Green Hills C++ Compiler
5750	<	# FIXME: insert proper C++ library support
5751	<	_LT_TAGVAR(ld_shlibs, $1)=no
5752	<	;;
5753	<	*)
5754	<	# FIXME: insert proper C++ library support
5755	<	_LT_TAGVAR(ld_shlibs, $1)=no
5756	<	;;
5757	<	esac
5758	<	;;
5759	<
5760	<	freebsd[[12]]*)
5761	<	# C++ shared libraries reported to be fairly broken before
5762	<	# switch to ELF
5763	<	_LT_TAGVAR(ld_shlibs, $1)=no
5764	<	;;
5765	<
5766	<	freebsd-elf*)
5767	<	_LT_TAGVAR(archive_cmds_need_lc, $1)=no
5768	<	;;
5769	<
5770	<	freebsd* | dragonfly*)
5771	<	# FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF
5772	<	# conventions
5773	<	_LT_TAGVAR(ld_shlibs, $1)=yes
5774	<	;;
5775	<
5776	<	gnu*)
5777	<	;;
5778	<
5779	<	hpux9*)
5780	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
5781	<	_LT_TAGVAR(hardcode_libdir_separator, $1)=:
5782	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
5783	<	_LT_TAGVAR(hardcode_direct, $1)=yes
5784	<	_LT_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,
5785	<	# but as the default
5786	<	# location of the library.
5787	<
5788	<	case $cc_basename in
5789	<	CC*)
5790	<	# FIXME: insert proper C++ library support
5791	<	_LT_TAGVAR(ld_shlibs, $1)=no
5792	<	;;
5793	<	aCC*)
5794	<	_LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
5795	<	# Commands to make compiler produce verbose output that lists
5796	<	# what "hidden" libraries, object files and flags are used when
5797	<	# linking a shared library.
5798	<	#
5799	<	# There doesn't appear to be a way to prevent this compiler from
5800	<	# explicitly linking system object files so we need to strip them
5801	<	# from the output so that they don't get included in the library
5802	<	# dependencies.
5803	<	output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; $ECHO "X$list" | $Xsed'
5804	<	;;
5805	<	*)
5806	<	if test "$GXX" = yes; then
5807	<	_LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared -nostdlib -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
5808	<	else
5809	<	# FIXME: insert proper C++ library support
5810	<	_LT_TAGVAR(ld_shlibs, $1)=no
5811	<	fi
5812	<	;;
5813	<	esac
5814	<	;;
5815	<
5816	<	hpux10*|hpux11*)
5817	<	if test $with_gnu_ld = no; then
5818	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
5819	<	_LT_TAGVAR(hardcode_libdir_separator, $1)=:
5820	<
5821	<	case $host_cpu in
5822	<	hppa*64*|ia64*)
5823	<	;;
5824	<	*)
5825	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
5826	<	;;
5827	<	esac
5828	<	fi
5829	<	case $host_cpu in
5830	<	hppa*64*|ia64*)
5831	<	_LT_TAGVAR(hardcode_direct, $1)=no
5832	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
5833	<	;;
5834	<	*)
5835	<	_LT_TAGVAR(hardcode_direct, $1)=yes
5836	<	_LT_TAGVAR(hardcode_direct_absolute, $1)=yes
5837	<	_LT_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,
5838	<	# but as the default
5839	<	# location of the library.
5840	<	;;
5841	<	esac
5842	<
5843	<	case $cc_basename in
5844	<	CC*)
5845	<	# FIXME: insert proper C++ library support
5846	<	_LT_TAGVAR(ld_shlibs, $1)=no
5847	<	;;
5848	<	aCC*)
5849	<	case $host_cpu in
5850	<	hppa*64*)
5851	<	_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
5852	<	;;
5853	<	ia64*)
5854	<	_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
5855	<	;;
5856	<	*)
5857	<	_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
5858	<	;;
5859	<	esac
5860	<	# Commands to make compiler produce verbose output that lists
5861	<	# what "hidden" libraries, object files and flags are used when
5862	<	# linking a shared library.
5863	<	#
5864	<	# There doesn't appear to be a way to prevent this compiler from
5865	<	# explicitly linking system object files so we need to strip them
5866	<	# from the output so that they don't get included in the library
5867	<	# dependencies.
5868	<	output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; $ECHO "X$list" | $Xsed'
5869	<	;;
5870	<	*)
5871	<	if test "$GXX" = yes; then
5872	<	if test $with_gnu_ld = no; then
5873	<	case $host_cpu in
5874	<	hppa*64*)
5875	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
5876	<	;;
5877	<	ia64*)
5878	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
5879	<	;;
5880	<	*)
5881	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
5882	<	;;
5883	<	esac
5884	<	fi
5885	<	else
5886	<	# FIXME: insert proper C++ library support
5887	<	_LT_TAGVAR(ld_shlibs, $1)=no
5888	<	fi
5889	<	;;
5890	<	esac
5891	<	;;
5892	<
5893	<	interix[[3-9]]*)
5894	<	_LT_TAGVAR(hardcode_direct, $1)=no
5895	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
5896	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
5897	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
5898	<	# Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
5899	<	# Instead, shared libraries are loaded at an image base (0x10000000 by
5900	<	# default) and relocated if they conflict, which is a slow very memory
5901	<	# consuming and fragmenting process.  To avoid this, we pick a random,
5902	<	# 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
5903	<	# time.  Moving up from 0x10000000 also allows more sbrk(2) space.
5904	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
5905	<	_LT_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
5906	<	;;
5907	<	irix5* | irix6*)
5908	<	case $cc_basename in
5909	<	CC*)
5910	<	# SGI C++
5911	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib'
5912	<
5913	<	# Archives containing C++ object files must be created using
5914	<	# "CC -ar", where "CC" is the IRIX C++ compiler.  This is
5915	<	# necessary to make sure instantiated templates are included
5916	<	# in the archive.
5917	<	_LT_TAGVAR(old_archive_cmds, $1)='$CC -ar -WR,-u -o $oldlib $oldobjs'
5918	<	;;
5919	<	*)
5920	<	if test "$GXX" = yes; then
5921	<	if test "$with_gnu_ld" = no; then
5922	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "X${wl}-set_version ${wl}$verstring" | $Xsed` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
5923	<	else
5924	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "X${wl}-set_version ${wl}$verstring" | $Xsed` -o $lib'
5925	<	fi
5926	<	fi
5927	<	_LT_TAGVAR(link_all_deplibs, $1)=yes
5928	<	;;
5929	<	esac
5930	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
5931	<	_LT_TAGVAR(hardcode_libdir_separator, $1)=:
5932	<	_LT_TAGVAR(inherit_rpath, $1)=yes
5933	<	;;
5934	<
5935	<	linux* | k*bsd*-gnu)
5936	<	case $cc_basename in
5937	<	KCC*)
5938	<	# Kuck and Associates, Inc. (KAI) C++ Compiler
5939	<
5940	<	# KCC will only create a shared library if the output file
5941	<	# ends with ".so" (or ".sl" for HP-UX), so rename the library
5942	<	# to its proper name (with version) after linking.
5943	<	_LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
5944	<	_LT_TAGVAR(archive_expsym_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib'
5945	<	# Commands to make compiler produce verbose output that lists
5946	<	# what "hidden" libraries, object files and flags are used when
5947	<	# linking a shared library.
5948	<	#
5949	<	# There doesn't appear to be a way to prevent this compiler from
5950	<	# explicitly linking system object files so we need to strip them
5951	<	# from the output so that they don't get included in the library
5952	<	# dependencies.
5953	<	output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; $ECHO "X$list" | $Xsed'
5954	<
5955	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
5956	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
5957	<
5958	<	# Archives containing C++ object files must be created using
5959	<	# "CC -Bstatic", where "CC" is the KAI C++ compiler.
5960	<	_LT_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs'
5961	<	;;
5962	<	icpc* | ecpc* )
5963	<	# Intel C++
5964	<	with_gnu_ld=yes
5965	<	# version 8.0 and above of icpc choke on multiply defined symbols
5966	<	# if we add $predep_objects and $postdep_objects, however 7.1 and
5967	<	# earlier do not add the objects themselves.
5968	<	case `$CC -V 2>&1` in
5969	<	*"Version 7."*)
5970	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
5971	<	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
5972	<	;;
5973	<	*)  # Version 8.0 or newer
5974	<	tmp_idyn=
5975	<	case $host_cpu in
5976	<	ia64*) tmp_idyn=' -i_dynamic';;
5977	<	esac
5978	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
5979	<	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
5980	<	;;
5981	<	esac
5982	<	_LT_TAGVAR(archive_cmds_need_lc, $1)=no
5983	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
5984	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
5985	<	_LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
5986	<	;;
5987	<	pgCC* | pgcpp*)
5988	<	# Portland Group C++ compiler
5989	<	case `$CC -V` in
5990	<	*pgCC\ [[1-5]]* | *pgcpp\ [[1-5]]*)
5991	<	_LT_TAGVAR(prelink_cmds, $1)='tpldir=Template.dir~
5992	<	rm -rf $tpldir~
5993	<	$CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
5994	<	compile_command="$compile_command `find $tpldir -name \*.o | $NL2SP`"'
5995	<	_LT_TAGVAR(old_archive_cmds, $1)='tpldir=Template.dir~
5996	<	rm -rf $tpldir~
5997	<	$CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
5998	<	$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | $NL2SP`~
5999	<	$RANLIB $oldlib'
6000	<	_LT_TAGVAR(archive_cmds, $1)='tpldir=Template.dir~
6001	<	rm -rf $tpldir~
6002	<	$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
6003	<	$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
6004	<	_LT_TAGVAR(archive_expsym_cmds, $1)='tpldir=Template.dir~
6005	<	rm -rf $tpldir~
6006	<	$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
6007	<	$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
6008	<	;;
6009	<	*) # Version 6 will use weak symbols
6010	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
6011	<	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
6012	<	;;
6013	<	esac
6014	<
6015	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir'
6016	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
6017	<	_LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $ECHO \"$new_convenience\"` ${wl}--no-whole-archive'
6018	<	;;
6019	<	cxx*)
6020	<	# Compaq C++
6021	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
6022	<	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname  -o $lib ${wl}-retain-symbols-file $wl$export_symbols'
6023	<
6024	<	runpath_var=LD_RUN_PATH
6025	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
6026	<	_LT_TAGVAR(hardcode_libdir_separator, $1)=:
6027	<
6028	<	# Commands to make compiler produce verbose output that lists
6029	<	# what "hidden" libraries, object files and flags are used when
6030	<	# linking a shared library.
6031	<	#
6032	<	# There doesn't appear to be a way to prevent this compiler from
6033	<	# explicitly linking system object files so we need to strip them
6034	<	# from the output so that they don't get included in the library
6035	<	# dependencies.
6036	<	output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`$ECHO "X$templist" | $Xsed -e "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; $ECHO "X$list" | $Xsed'
6037	<	;;
6038	<	xl*)
6039	<	# IBM XL 8.0 on PPC, with GNU ld
6040	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
6041	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
6042	<	_LT_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
6043	<	if test "x$supports_anon_versioning" = xyes; then
6044	<	_LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~
6045	<	cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
6046	<	echo "local: *; };" >> $output_objdir/$libname.ver~
6047	<	$CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
6048	<	fi
6049	<	;;
6050	<	*)
6051	<	case `$CC -V 2>&1 | sed 5q` in
6052	<	*Sun\ C*)
6053	<	# Sun C++ 5.9
6054	<	_LT_TAGVAR(no_undefined_flag, $1)=' -zdefs'
6055	<	_LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
6056	<	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file ${wl}$export_symbols'
6057	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
6058	<	_LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; $ECHO \"$new_convenience\"` ${wl}--no-whole-archive'
6059	<	_LT_TAGVAR(compiler_needs_object, $1)=yes
6060	<
6061	<	# Not sure whether something based on
6062	<	# $CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1
6063	<	# would be better.
6064	<	output_verbose_link_cmd='echo'
6065	<
6066	<	# Archives containing C++ object files must be created using
6067	<	# "CC -xar", where "CC" is the Sun C++ compiler.  This is
6068	<	# necessary to make sure instantiated templates are included
6069	<	# in the archive.
6070	<	_LT_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs'
6071	<	;;
6072	<	esac
6073	<	;;
6074	<	esac
6075	<	;;
6076	<
6077	<	lynxos*)
6078	<	# FIXME: insert proper C++ library support
6079	<	_LT_TAGVAR(ld_shlibs, $1)=no
6080	<	;;
6081	<
6082	<	m88k*)
6083	<	# FIXME: insert proper C++ library support
6084	<	_LT_TAGVAR(ld_shlibs, $1)=no
6085	<	;;
6086	<
6087	<	mvs*)
6088	<	case $cc_basename in
6089	<	cxx*)
6090	<	# FIXME: insert proper C++ library support
6091	<	_LT_TAGVAR(ld_shlibs, $1)=no
6092	<	;;
6093	<	*)
6094	<	# FIXME: insert proper C++ library support
6095	<	_LT_TAGVAR(ld_shlibs, $1)=no
6096	<	;;
6097	<	esac
6098	<	;;
6099	<
6100	<	netbsd*)
6101	<	if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
6102	<	_LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable  -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags'
6103	<	wlarc=
6104	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
6105	<	_LT_TAGVAR(hardcode_direct, $1)=yes
6106	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
6107	<	fi
6108	<	# Workaround some broken pre-1.5 toolchains
6109	<	output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"'
6110	<	;;
6111	<
6112	<	*nto* | *qnx*)
6113	<	_LT_TAGVAR(ld_shlibs, $1)=yes
6114	<	;;
6115	<
6116	<	openbsd2*)
6117	<	# C++ shared libraries are fairly broken
6118	<	_LT_TAGVAR(ld_shlibs, $1)=no
6119	<	;;
6120	<
6121	<	openbsd*)
6122	<	if test -f /usr/libexec/ld.so; then
6123	<	_LT_TAGVAR(hardcode_direct, $1)=yes
6124	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
6125	<	_LT_TAGVAR(hardcode_direct_absolute, $1)=yes
6126	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
6127	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
6128	<	if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
6129	<	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file,$export_symbols -o $lib'
6130	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
6131	<	_LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
6132	<	fi
6133	<	output_verbose_link_cmd=echo
6134	<	else
6135	<	_LT_TAGVAR(ld_shlibs, $1)=no
6136	<	fi
6137	<	;;
6138	<
6139	<	osf3* | osf4* | osf5*)
6140	<	case $cc_basename in
6141	<	KCC*)
6142	<	# Kuck and Associates, Inc. (KAI) C++ Compiler
6143	<
6144	<	# KCC will only create a shared library if the output file
6145	<	# ends with ".so" (or ".sl" for HP-UX), so rename the library
6146	<	# to its proper name (with version) after linking.
6147	<	_LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
6148	<
6149	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
6150	<	_LT_TAGVAR(hardcode_libdir_separator, $1)=:
6151	<
6152	<	# Archives containing C++ object files must be created using
6153	<	# the KAI C++ compiler.
6154	<	case $host in
6155	<	osf3*) _LT_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs' ;;
6156	<	*) _LT_TAGVAR(old_archive_cmds, $1)='$CC -o $oldlib $oldobjs' ;;
6157	<	esac
6158	<	;;
6159	<	RCC*)
6160	<	# Rational C++ 2.4.1
6161	<	# FIXME: insert proper C++ library support
6162	<	_LT_TAGVAR(ld_shlibs, $1)=no
6163	<	;;
6164	<	cxx*)
6165	<	case $host in
6166	<	osf3*)
6167	<	_LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
6168	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && $ECHO "X${wl}-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib'
6169	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
6170	<	;;
6171	<	*)
6172	<	_LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
6173	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib'
6174	<	_LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~
6175	<	echo "-hidden">> $lib.exp~
6176	<	$CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname ${wl}-input ${wl}$lib.exp  `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib~
6177	<	$RM $lib.exp'
6178	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
6179	<	;;
6180	<	esac
6181	<
6182	<	_LT_TAGVAR(hardcode_libdir_separator, $1)=:
6183	<
6184	<	# Commands to make compiler produce verbose output that lists
6185	<	# what "hidden" libraries, object files and flags are used when
6186	<	# linking a shared library.
6187	<	#
6188	<	# There doesn't appear to be a way to prevent this compiler from
6189	<	# explicitly linking system object files so we need to strip them
6190	<	# from the output so that they don't get included in the library
6191	<	# dependencies.
6192	<	output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`$ECHO "X$templist" | $Xsed -e "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; $ECHO "X$list" | $Xsed'
6193	<	;;
6194	<	*)
6195	<	if test "$GXX" = yes && test "$with_gnu_ld" = no; then
6196	<	_LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
6197	<	case $host in
6198	<	osf3*)
6199	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "X${wl}-set_version ${wl}$verstring" | $Xsed` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
6200	<	;;
6201	<	*)
6202	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "${wl}-set_version ${wl}$verstring" | $Xsed` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
6203	<	;;
6204	<	esac
6205	<
6206	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
6207	<	_LT_TAGVAR(hardcode_libdir_separator, $1)=:
6208	<
6209	<	# Commands to make compiler produce verbose output that lists
6210	<	# what "hidden" libraries, object files and flags are used when
6211	<	# linking a shared library.
6212	<	output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "\-L"'
6213	<
6214	<	else
6215	<	# FIXME: insert proper C++ library support
6216	<	_LT_TAGVAR(ld_shlibs, $1)=no
6217	<	fi
6218	<	;;
6219	<	esac
6220	<	;;
6221	<
6222	<	psos*)
6223	<	# FIXME: insert proper C++ library support
6224	<	_LT_TAGVAR(ld_shlibs, $1)=no
6225	<	;;
6226	<
6227	<	sunos4*)
6228	<	case $cc_basename in
6229	<	CC*)
6230	<	# Sun C++ 4.x
6231	<	# FIXME: insert proper C++ library support
6232	<	_LT_TAGVAR(ld_shlibs, $1)=no
6233	<	;;
6234	<	lcc*)
6235	<	# Lucid
6236	<	# FIXME: insert proper C++ library support
6237	<	_LT_TAGVAR(ld_shlibs, $1)=no
6238	<	;;
6239	<	*)
6240	<	# FIXME: insert proper C++ library support
6241	<	_LT_TAGVAR(ld_shlibs, $1)=no
6242	<	;;
6243	<	esac
6244	<	;;
6245	<
6246	<	solaris*)
6247	<	case $cc_basename in
6248	<	CC*)
6249	<	# Sun C++ 4.2, 5.x and Centerline C++
6250	<	_LT_TAGVAR(archive_cmds_need_lc,$1)=yes
6251	<	_LT_TAGVAR(no_undefined_flag, $1)=' -zdefs'
6252	<	_LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag}  -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
6253	<	_LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
6254	<	$CC -G${allow_undefined_flag} ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
6255	<
6256	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
6257	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
6258	<	case $host_os in
6259	<	solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
6260	<	*)
6261	<	# The compiler driver will combine and reorder linker options,
6262	<	# but understands `-z linker_flag'.
6263	<	# Supported since Solaris 2.6 (maybe 2.5.1?)
6264	<	_LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract'
6265	<	;;
6266	<	esac
6267	<	_LT_TAGVAR(link_all_deplibs, $1)=yes
6268	<
6269	<	output_verbose_link_cmd='echo'
6270	<
6271	<	# Archives containing C++ object files must be created using
6272	<	# "CC -xar", where "CC" is the Sun C++ compiler.  This is
6273	<	# necessary to make sure instantiated templates are included
6274	<	# in the archive.
6275	<	_LT_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs'
6276	<	;;
6277	<	gcx*)
6278	<	# Green Hills C++ Compiler
6279	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
6280	<
6281	<	# The C++ compiler must be used to create the archive.
6282	<	_LT_TAGVAR(old_archive_cmds, $1)='$CC $LDFLAGS -archive -o $oldlib $oldobjs'
6283	<	;;
6284	<	*)
6285	<	# GNU C++ compiler with Solaris linker
6286	<	if test "$GXX" = yes && test "$with_gnu_ld" = no; then
6287	<	_LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-z ${wl}defs'
6288	<	if $CC --version | $GREP -v '^2\.7' > /dev/null; then
6289	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
6290	<	_LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
6291	<	$CC -shared -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
6292	<
6293	<	# Commands to make compiler produce verbose output that lists
6294	<	# what "hidden" libraries, object files and flags are used when
6295	<	# linking a shared library.
6296	<	output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "\-L"'
6297	<	else
6298	<	# g++ 2.7 appears to require `-G' NOT `-shared' on this
6299	<	# platform.
6300	<	_LT_TAGVAR(archive_cmds, $1)='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
6301	<	_LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
6302	<	$CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
6303	<
6304	<	# Commands to make compiler produce verbose output that lists
6305	<	# what "hidden" libraries, object files and flags are used when
6306	<	# linking a shared library.
6307	<	output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP "\-L"'
6308	<	fi
6309	<
6310	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $wl$libdir'
6311	<	case $host_os in
6312	<	solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
6313	<	*)
6314	<	_LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract'
6315	<	;;
6316	<	esac
6317	<	fi
6318	<	;;
6319	<	esac
6320	<	;;
6321	<
6322	<	sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*)
6323	<	_LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
6324	<	_LT_TAGVAR(archive_cmds_need_lc, $1)=no
6325	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
6326	<	runpath_var='LD_RUN_PATH'
6327	<
6328	<	case $cc_basename in
6329	<	CC*)
6330	<	_LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
6331	<	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
6332	<	;;
6333	<	*)
6334	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
6335	<	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
6336	<	;;
6337	<	esac
6338	<	;;
6339	<
6340	<	sysv5* | sco3.2v5* | sco5v6*)
6341	<	# Note: We can NOT use -z defs as we might desire, because we do not
6342	<	# link with -lc, and that would cause any symbols used from libc to
6343	<	# always be unresolved, which means just about no library would
6344	<	# ever link correctly.  If we're not using GNU ld we use -z text
6345	<	# though, which does catch some bad symbols but isn't as heavy-handed
6346	<	# as -z defs.
6347	<	_LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
6348	<	_LT_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs'
6349	<	_LT_TAGVAR(archive_cmds_need_lc, $1)=no
6350	<	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
6351	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R,$libdir'
6352	<	_LT_TAGVAR(hardcode_libdir_separator, $1)=':'
6353	<	_LT_TAGVAR(link_all_deplibs, $1)=yes
6354	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport'
6355	<	runpath_var='LD_RUN_PATH'
6356	<
6357	<	case $cc_basename in
6358	<	CC*)
6359	<	_LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
6360	<	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
6361	<	;;
6362	<	*)
6363	<	_LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
6364	<	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
6365	<	;;
6366	<	esac
6367	<	;;
6368	<
6369	<	tandem*)
6370	<	case $cc_basename in
6371	<	NCC*)
6372	<	# NonStop-UX NCC 3.20
6373	<	# FIXME: insert proper C++ library support
6374	<	_LT_TAGVAR(ld_shlibs, $1)=no
6375	<	;;
6376	<	*)
6377	<	# FIXME: insert proper C++ library support
6378	<	_LT_TAGVAR(ld_shlibs, $1)=no
6379	<	;;
6380	<	esac
6381	<	;;
6382	<
6383	<	vxworks*)
6384	<	# FIXME: insert proper C++ library support
6385	<	_LT_TAGVAR(ld_shlibs, $1)=no
6386	<	;;
6387	<
6388	<	*)
6389	<	# FIXME: insert proper C++ library support
6390	<	_LT_TAGVAR(ld_shlibs, $1)=no
6391	<	;;
6392	<	esac
6393	<
6394	<	AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)])
6395	<	test "$_LT_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no
6396	<
6397	<	_LT_TAGVAR(GCC, $1)="$GXX"
6398	<	_LT_TAGVAR(LD, $1)="$LD"
6399	<
6400	<	## CAVEAT EMPTOR:
6401	<	## There is no encapsulation within the following macros, do not change
6402	<	## the running order or otherwise move them around unless you know exactly
6403	<	## what you are doing...
6404	<	_LT_SYS_HIDDEN_LIBDEPS($1)
6405	<	_LT_COMPILER_PIC($1)
6406	<	_LT_COMPILER_C_O($1)
6407	<	_LT_COMPILER_FILE_LOCKS($1)
6408	<	_LT_LINKER_SHLIBS($1)
6409	<	_LT_SYS_DYNAMIC_LINKER($1)
6410	<	_LT_LINKER_HARDCODE_LIBPATH($1)
6411	<
6412	<	_LT_CONFIG($1)
6413	<	fi # test -n "$compiler"
6414	<
6415	<	CC=$lt_save_CC
6416	<	LDCXX=$LD
6417	<	LD=$lt_save_LD
6418	<	GCC=$lt_save_GCC
6419	<	with_gnu_ld=$lt_save_with_gnu_ld
6420	<	lt_cv_path_LDCXX=$lt_cv_path_LD
6421	<	lt_cv_path_LD=$lt_save_path_LD
6422	<	lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld
6423	<	lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld
6424	<	fi # test "$_lt_caught_CXX_error" != yes
6425	<
6426	<	AC_LANG_POP
6427	<	])# _LT_LANG_CXX_CONFIG
6428	<
6429	<
6430	<	# _LT_SYS_HIDDEN_LIBDEPS([TAGNAME])
6431	<	# ---------------------------------
6432	<	# Figure out "hidden" library dependencies from verbose
6433	<	# compiler output when linking a shared library.
6434	<	# Parse the compiler output and extract the necessary
6435	<	# objects, libraries and library flags.
6436	<	m4_defun([_LT_SYS_HIDDEN_LIBDEPS],
6437	<	[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
6438	<	# Dependencies to place before and after the object being linked:
6439	<	_LT_TAGVAR(predep_objects, $1)=
6440	<	_LT_TAGVAR(postdep_objects, $1)=
6441	<	_LT_TAGVAR(predeps, $1)=
6442	<	_LT_TAGVAR(postdeps, $1)=
6443	<	_LT_TAGVAR(compiler_lib_search_path, $1)=
6444	<
6445	<	dnl we can't use the lt_simple_compile_test_code here,
6446	<	dnl because it contains code intended for an executable,
6447	<	dnl not a library.  It's possible we should let each
6448	<	dnl tag define a new lt_????_link_test_code variable,
6449	<	dnl but it's only used here...
6450	<	m4_if([$1], [], [cat > conftest.$ac_ext <<_LT_EOF
6451	<	int a;
6452	<	void foo (void) { a = 0; }
6453	<	_LT_EOF
6454	<	], [$1], [CXX], [cat > conftest.$ac_ext <<_LT_EOF
6455	<	class Foo
6456	<	{
6457	<	public:
6458	<	Foo (void) { a = 0; }
6459	<	private:
6460	<	int a;
6461	<	};
6462	<	_LT_EOF
6463	<	], [$1], [F77], [cat > conftest.$ac_ext <<_LT_EOF
6464	<	subroutine foo
6465	<	implicit none
6466	<	integer*4 a
6467	<	a=0
6468	<	return
6469	<	end
6470	<	_LT_EOF
6471	<	], [$1], [FC], [cat > conftest.$ac_ext <<_LT_EOF
6472	<	subroutine foo
6473	<	implicit none
6474	<	integer a
6475	<	a=0
6476	<	return
6477	<	end
6478	<	_LT_EOF
6479	<	], [$1], [GCJ], [cat > conftest.$ac_ext <<_LT_EOF
6480	<	public class foo {
6481	<	private int a;
6482	<	public void bar (void) {
6483	<	a = 0;
6484	<	}
6485	<	};
6486	<	_LT_EOF
6487	<	])
6488	<	dnl Parse the compiler output and extract the necessary
6489	<	dnl objects, libraries and library flags.
6490	<	if AC_TRY_EVAL(ac_compile); then
6491	<	# Parse the compiler output and extract the necessary
6492	<	# objects, libraries and library flags.
6493	<
6494	<	# Sentinel used to keep track of whether or not we are before
6495	<	# the conftest object file.
6496	<	pre_test_object_deps_done=no
6497	<
6498	<	for p in `eval "$output_verbose_link_cmd"`; do
6499	<	case $p in
6500	<
6501	<	-L* | -R* | -l*)
6502	<	# Some compilers place space between "-{L,R}" and the path.
6503	<	# Remove the space.
6504	<	if test $p = "-L" ||
6505	<	test $p = "-R"; then
6506	<	prev=$p
6507	<	continue
6508	<	else
6509	<	prev=
6510	<	fi
6511	<
6512	<	if test "$pre_test_object_deps_done" = no; then
6513	<	case $p in
6514	<	-L* | -R*)
6515	<	# Internal compiler library paths should come after those
6516	<	# provided the user.  The postdeps already come after the
6517	<	# user supplied libs so there is no need to process them.
6518	<	if test -z "$_LT_TAGVAR(compiler_lib_search_path, $1)"; then
6519	<	_LT_TAGVAR(compiler_lib_search_path, $1)="${prev}${p}"
6520	<	else
6521	<	_LT_TAGVAR(compiler_lib_search_path, $1)="${_LT_TAGVAR(compiler_lib_search_path, $1)} ${prev}${p}"
6522	<	fi
6523	<	;;
6524	<	# The "-l" case would never come before the object being
6525	<	# linked, so don't bother handling this case.
6526	<	esac
6527	<	else
6528	<	if test -z "$_LT_TAGVAR(postdeps, $1)"; then
6529	<	_LT_TAGVAR(postdeps, $1)="${prev}${p}"
6530	<	else
6531	<	_LT_TAGVAR(postdeps, $1)="${_LT_TAGVAR(postdeps, $1)} ${prev}${p}"
6532	<	fi
6533	<	fi
6534	<	;;
6535	<
6536	<	*.$objext)
6537	<	# This assumes that the test object file only shows up
6538	<	# once in the compiler output.
6539	<	if test "$p" = "conftest.$objext"; then
6540	<	pre_test_object_deps_done=yes
6541	<	continue
6542	<	fi
6543	<
6544	<	if test "$pre_test_object_deps_done" = no; then
6545	<	if test -z "$_LT_TAGVAR(predep_objects, $1)"; then
6546	<	_LT_TAGVAR(predep_objects, $1)="$p"
6547	<	else
6548	<	_LT_TAGVAR(predep_objects, $1)="$_LT_TAGVAR(predep_objects, $1) $p"
6549	<	fi
6550	<	else
6551	<	if test -z "$_LT_TAGVAR(postdep_objects, $1)"; then
6552	<	_LT_TAGVAR(postdep_objects, $1)="$p"
6553	<	else
6554	<	_LT_TAGVAR(postdep_objects, $1)="$_LT_TAGVAR(postdep_objects, $1) $p"
6555	<	fi
6556	<	fi
6557	<	;;
6558	<
6559	<	*) ;; # Ignore the rest.
6560	<
6561	<	esac
6562	<	done
6563	<
6564	<	# Clean up.
6565	<	rm -f a.out a.exe
6566	<	else
6567	<	echo "libtool.m4: error: problem compiling $1 test program"
6568	<	fi
6569	<
6570	<	$RM -f confest.$objext
6571	<
6572	<	# PORTME: override above test on systems where it is broken
6573	<	m4_if([$1], [CXX],
6574	<	[case $host_os in
6575	<	interix[[3-9]]*)
6576	<	# Interix 3.5 installs completely hosed .la files for C++, so rather than
6577	<	# hack all around it, let's just trust "g++" to DTRT.
6578	<	_LT_TAGVAR(predep_objects,$1)=
6579	<	_LT_TAGVAR(postdep_objects,$1)=
6580	<	_LT_TAGVAR(postdeps,$1)=
6581	<	;;
6582	<
6583	<	linux*)
6584	<	case `$CC -V 2>&1 | sed 5q` in
6585	<	*Sun\ C*)
6586	<	# Sun C++ 5.9
6587	<
6588	<	# The more standards-conforming stlport4 library is
6589	<	# incompatible with the Cstd library. Avoid specifying
6590	<	# it if it's in CXXFLAGS. Ignore libCrun as
6591	<	# -library=stlport4 depends on it.
6592	<	case " $CXX $CXXFLAGS " in
6593	<	*" -library=stlport4 "*)
6594	<	solaris_use_stlport4=yes
6595	<	;;
6596	<	esac
6597	<
6598	<	if test "$solaris_use_stlport4" != yes; then
6599	<	_LT_TAGVAR(postdeps,$1)='-library=Cstd -library=Crun'
6600	<	fi
6601	<	;;
6602	<	esac
6603	<	;;
6604	<
6605	<	solaris*)
6606	<	case $cc_basename in
6607	<	CC*)
6608	<	# The more standards-conforming stlport4 library is
6609	<	# incompatible with the Cstd library. Avoid specifying
6610	<	# it if it's in CXXFLAGS. Ignore libCrun as
6611	<	# -library=stlport4 depends on it.
6612	<	case " $CXX $CXXFLAGS " in
6613	<	*" -library=stlport4 "*)
6614	<	solaris_use_stlport4=yes
6615	<	;;
6616	<	esac
6617	<
6618	<	# Adding this requires a known-good setup of shared libraries for
6619	<	# Sun compiler versions before 5.6, else PIC objects from an old
6620	<	# archive will be linked into the output, leading to subtle bugs.
6621	<	if test "$solaris_use_stlport4" != yes; then
6622	<	_LT_TAGVAR(postdeps,$1)='-library=Cstd -library=Crun'
6623	<	fi
6624	<	;;
6625	<	esac
6626	<	;;
6627	<	esac
6628	<	])
6629	<
6630	<	case " $_LT_TAGVAR(postdeps, $1) " in
6631	<	*" -lc "*) _LT_TAGVAR(archive_cmds_need_lc, $1)=no ;;
6632	<	esac
6633	<	_LT_TAGVAR(compiler_lib_search_dirs, $1)=
6634	<	if test -n "${_LT_TAGVAR(compiler_lib_search_path, $1)}"; then
6635	<	_LT_TAGVAR(compiler_lib_search_dirs, $1)=`echo " ${_LT_TAGVAR(compiler_lib_search_path, $1)}" | ${SED} -e 's! -L! !g' -e 's!^ !!'`
6636	<	fi
6637	<	_LT_TAGDECL([], [compiler_lib_search_dirs], [1],
6638	<	[The directories searched by this compiler when creating a shared library])
6639	<	_LT_TAGDECL([], [predep_objects], [1],
6640	<	[Dependencies to place before and after the objects being linked to
6641	<	create a shared library])
6642	<	_LT_TAGDECL([], [postdep_objects], [1])
6643	<	_LT_TAGDECL([], [predeps], [1])
6644	<	_LT_TAGDECL([], [postdeps], [1])
6645	<	_LT_TAGDECL([], [compiler_lib_search_path], [1],
6646	<	[The library search path used internally by the compiler when linking
6647	<	a shared library])
6648	<	])# _LT_SYS_HIDDEN_LIBDEPS
6649	<
6650	<
6651	<	# _LT_PROG_F77
6652	<	# ------------
6653	<	# Since AC_PROG_F77 is broken, in that it returns the empty string
6654	<	# if there is no fortran compiler, we have our own version here.
6655	<	m4_defun([_LT_PROG_F77],
6656	<	[
6657	<	pushdef([AC_MSG_ERROR], [_lt_disable_F77=yes])
6658	<	AC_PROG_F77
6659	<	if test -z "$F77" || test "X$F77" = "Xno"; then
6660	<	_lt_disable_F77=yes
6661	<	fi
6662	<	popdef([AC_MSG_ERROR])
6663	<	])# _LT_PROG_F77
6664	<
6665	<	dnl aclocal-1.4 backwards compatibility:
6666	<	dnl AC_DEFUN([_LT_PROG_F77], [])
6667	<
6668	<
6669	<	# _LT_LANG_F77_CONFIG([TAG])
6670	<	# --------------------------
6671	<	# Ensure that the configuration variables for a Fortran 77 compiler are
6672	<	# suitably defined.  These variables are subsequently used by _LT_CONFIG
6673	<	# to write the compiler configuration to `libtool'.
6674	<	m4_defun([_LT_LANG_F77_CONFIG],
6675	<	[AC_REQUIRE([_LT_PROG_F77])dnl
6676	<	AC_LANG_PUSH(Fortran 77)
6677	<
6678	<	_LT_TAGVAR(archive_cmds_need_lc, $1)=no
6679	<	_LT_TAGVAR(allow_undefined_flag, $1)=
6680	<	_LT_TAGVAR(always_export_symbols, $1)=no
6681	<	_LT_TAGVAR(archive_expsym_cmds, $1)=
6682	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)=
6683	<	_LT_TAGVAR(hardcode_direct, $1)=no
6684	<	_LT_TAGVAR(hardcode_direct_absolute, $1)=no
6685	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
6686	<	_LT_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=
6687	<	_LT_TAGVAR(hardcode_libdir_separator, $1)=
6688	<	_LT_TAGVAR(hardcode_minus_L, $1)=no
6689	<	_LT_TAGVAR(hardcode_automatic, $1)=no
6690	<	_LT_TAGVAR(inherit_rpath, $1)=no
6691	<	_LT_TAGVAR(module_cmds, $1)=
6692	<	_LT_TAGVAR(module_expsym_cmds, $1)=
6693	<	_LT_TAGVAR(link_all_deplibs, $1)=unknown
6694	<	_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
6695	<	_LT_TAGVAR(no_undefined_flag, $1)=
6696	<	_LT_TAGVAR(whole_archive_flag_spec, $1)=
6697	<	_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no
6698	<
6699	<	# Source file extension for f77 test sources.
6700	<	ac_ext=f
6701	<
6702	<	# Object file extension for compiled f77 test sources.
6703	<	objext=o
6704	<	_LT_TAGVAR(objext, $1)=$objext
6705	<
6706	<	# No sense in running all these tests if we already determined that
6707	<	# the F77 compiler isn't working.  Some variables (like enable_shared)
6708	<	# are currently assumed to apply to all compilers on this platform,
6709	<	# and will be corrupted by setting them based on a non-working compiler.
6710	<	if test "$_lt_disable_F77" != yes; then
6711	<	# Code to be used in simple compile tests
6712	<	lt_simple_compile_test_code="\
6713	<	subroutine t
6714	<	return
6715	<	end
6716	<	"
6717	<
6718	<	# Code to be used in simple link tests
6719	<	lt_simple_link_test_code="\
6720	<	program t
6721	<	end
6722	<	"
6723	<
6724	<	# ltmain only uses $CC for tagged configurations so make sure $CC is set.
6725	<	_LT_TAG_COMPILER
6726	<
6727	<	# save warnings/boilerplate of simple test code
6728	<	_LT_COMPILER_BOILERPLATE
6729	<	_LT_LINKER_BOILERPLATE
6730	<
6731	<	# Allow CC to be a program name with arguments.
6732	<	lt_save_CC="$CC"
6733	<	lt_save_GCC=$GCC
6734	<	CC=${F77-"f77"}
6735	<	compiler=$CC
6736	<	_LT_TAGVAR(compiler, $1)=$CC
6737	<	_LT_CC_BASENAME([$compiler])
6738	<	GCC=$G77
6739	<	if test -n "$compiler"; then
6740	<	AC_MSG_CHECKING([if libtool supports shared libraries])
6741	<	AC_MSG_RESULT([$can_build_shared])
6742	<
6743	<	AC_MSG_CHECKING([whether to build shared libraries])
6744	<	test "$can_build_shared" = "no" && enable_shared=no
6745	<
6746	<	# On AIX, shared libraries and static libraries use the same namespace, and
6747	<	# are all built from PIC.
6748	<	case $host_os in
6749	<	aix3*)
6750	<	test "$enable_shared" = yes && enable_static=no
6751	<	if test -n "$RANLIB"; then
6752	<	archive_cmds="$archive_cmds~\$RANLIB \$lib"
6753	<	postinstall_cmds='$RANLIB $lib'
6754	<	fi
6755	<	;;
6756	<	aix[[4-9]]*)
6757	<	if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
6758	<	test "$enable_shared" = yes && enable_static=no
6759	<	fi
6760	<	;;
6761	<	esac
6762	<	AC_MSG_RESULT([$enable_shared])
6763	<
6764	<	AC_MSG_CHECKING([whether to build static libraries])
6765	<	# Make sure either enable_shared or enable_static is yes.
6766	<	test "$enable_shared" = yes || enable_static=yes
6767	<	AC_MSG_RESULT([$enable_static])
6768	<
6769	<	_LT_TAGVAR(GCC, $1)="$G77"
6770	<	_LT_TAGVAR(LD, $1)="$LD"
6771	<
6772	<	## CAVEAT EMPTOR:
6773	<	## There is no encapsulation within the following macros, do not change
6774	<	## the running order or otherwise move them around unless you know exactly
6775	<	## what you are doing...
6776	<	_LT_COMPILER_PIC($1)
6777	<	_LT_COMPILER_C_O($1)
6778	<	_LT_COMPILER_FILE_LOCKS($1)
6779	<	_LT_LINKER_SHLIBS($1)
6780	<	_LT_SYS_DYNAMIC_LINKER($1)
6781	<	_LT_LINKER_HARDCODE_LIBPATH($1)
6782	<
6783	<	_LT_CONFIG($1)
6784	<	fi # test -n "$compiler"
6785	<
6786	<	GCC=$lt_save_GCC
6787	<	CC="$lt_save_CC"
6788	<	fi # test "$_lt_disable_F77" != yes
6789	<
6790	<	AC_LANG_POP
6791	<	])# _LT_LANG_F77_CONFIG
6792	<
6793	<
6794	<	# _LT_PROG_FC
6795	<	# -----------
6796	<	# Since AC_PROG_FC is broken, in that it returns the empty string
6797	<	# if there is no fortran compiler, we have our own version here.
6798	<	m4_defun([_LT_PROG_FC],
6799	<	[
6800	<	pushdef([AC_MSG_ERROR], [_lt_disable_FC=yes])
6801	<	AC_PROG_FC
6802	<	if test -z "$FC" || test "X$FC" = "Xno"; then
6803	<	_lt_disable_FC=yes
6804	<	fi
6805	<	popdef([AC_MSG_ERROR])
6806	<	])# _LT_PROG_FC
6807	<
6808	<	dnl aclocal-1.4 backwards compatibility:
6809	<	dnl AC_DEFUN([_LT_PROG_FC], [])
6810	<
6811	<
6812	<	# _LT_LANG_FC_CONFIG([TAG])
6813	<	# -------------------------
6814	<	# Ensure that the configuration variables for a Fortran compiler are
6815	<	# suitably defined.  These variables are subsequently used by _LT_CONFIG
6816	<	# to write the compiler configuration to `libtool'.
6817	<	m4_defun([_LT_LANG_FC_CONFIG],
6818	<	[AC_REQUIRE([_LT_PROG_FC])dnl
6819	<	AC_LANG_PUSH(Fortran)
6820	<
6821	<	_LT_TAGVAR(archive_cmds_need_lc, $1)=no
6822	<	_LT_TAGVAR(allow_undefined_flag, $1)=
6823	<	_LT_TAGVAR(always_export_symbols, $1)=no
6824	<	_LT_TAGVAR(archive_expsym_cmds, $1)=
6825	<	_LT_TAGVAR(export_dynamic_flag_spec, $1)=
6826	<	_LT_TAGVAR(hardcode_direct, $1)=no
6827	<	_LT_TAGVAR(hardcode_direct_absolute, $1)=no
6828	<	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
6829	<	_LT_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=
6830	<	_LT_TAGVAR(hardcode_libdir_separator, $1)=
6831	<	_LT_TAGVAR(hardcode_minus_L, $1)=no
6832	<	_LT_TAGVAR(hardcode_automatic, $1)=no
6833	<	_LT_TAGVAR(inherit_rpath, $1)=no
6834	<	_LT_TAGVAR(module_cmds, $1)=
6835	<	_LT_TAGVAR(module_expsym_cmds, $1)=
6836	<	_LT_TAGVAR(link_all_deplibs, $1)=unknown
6837	<	_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
6838	<	_LT_TAGVAR(no_undefined_flag, $1)=
6839	<	_LT_TAGVAR(whole_archive_flag_spec, $1)=
6840	<	_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no
6841	<
6842	<	# Source file extension for fc test sources.
6843	<	ac_ext=${ac_fc_srcext-f}
6844	<
6845	<	# Object file extension for compiled fc test sources.
6846	<	objext=o
6847	<	_LT_TAGVAR(objext, $1)=$objext
6848	<
6849	<	# No sense in running all these tests if we already determined that
6850	<	# the FC compiler isn't working.  Some variables (like enable_shared)
6851	<	# are currently assumed to apply to all compilers on this platform,
6852	<	# and will be corrupted by setting them based on a non-working compiler.
6853	<	if test "$_lt_disable_FC" != yes; then
6854	<	# Code to be used in simple compile tests
6855	<	lt_simple_compile_test_code="\
6856	<	subroutine t
6857	<	return
6858	<	end
6859	<	"
6860	<
6861	<	# Code to be used in simple link tests
6862	<	lt_simple_link_test_code="\
6863	<	program t
6864	<	end
6865	<	"
6866	<
6867	<	# ltmain only uses $CC for tagged configurations so make sure $CC is set.
6868	<	_LT_TAG_COMPILER
6869	<
6870	<	# save warnings/boilerplate of simple test code
6871	<	_LT_COMPILER_BOILERPLATE
6872	<	_LT_LINKER_BOILERPLATE
6873	<
6874	<	# Allow CC to be a program name with arguments.
6875	<	lt_save_CC="$CC"
6876	<	lt_save_GCC=$GCC
6877	<	CC=${FC-"f95"}
6878	<	compiler=$CC
6879	<	GCC=$ac_cv_fc_compiler_gnu
6880	<
6881	<	_LT_TAGVAR(compiler, $1)=$CC
6882	<	_LT_CC_BASENAME([$compiler])
6883	<
6884	<	if test -n "$compiler"; then
6885	<	AC_MSG_CHECKING([if libtool supports shared libraries])
6886	<	AC_MSG_RESULT([$can_build_shared])
6887	<
6888	<	AC_MSG_CHECKING([whether to build shared libraries])
6889	<	test "$can_build_shared" = "no" && enable_shared=no
6890	<
6891	<	# On AIX, shared libraries and static libraries use the same namespace, and
6892	<	# are all built from PIC.
6893	<	case $host_os in
6894	<	aix3*)
6895	<	test "$enable_shared" = yes && enable_static=no
6896	<	if test -n "$RANLIB"; then
6897	<	archive_cmds="$archive_cmds~\$RANLIB \$lib"
6898	<	postinstall_cmds='$RANLIB $lib'
6899	<	fi
6900	<	;;
6901	<	aix[[4-9]]*)
6902	<	if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
6903	<	test "$enable_shared" = yes && enable_static=no
6904	<	fi
6905	<	;;
6906	<	esac
6907	<	AC_MSG_RESULT([$enable_shared])
6908	<
6909	<	AC_MSG_CHECKING([whether to build static libraries])
6910	<	# Make sure either enable_shared or enable_static is yes.
6911	<	test "$enable_shared" = yes || enable_static=yes
6912	<	AC_MSG_RESULT([$enable_static])
6913	<
6914	<	_LT_TAGVAR(GCC, $1)="$ac_cv_fc_compiler_gnu"
6915	<	_LT_TAGVAR(LD, $1)="$LD"
6916	<
6917	<	## CAVEAT EMPTOR:
6918	<	## There is no encapsulation within the following macros, do not change
6919	<	## the running order or otherwise move them around unless you know exactly
6920	<	## what you are doing...
6921	<	_LT_SYS_HIDDEN_LIBDEPS($1)
6922	<	_LT_COMPILER_PIC($1)
6923	<	_LT_COMPILER_C_O($1)
6924	<	_LT_COMPILER_FILE_LOCKS($1)
6925	<	_LT_LINKER_SHLIBS($1)
6926	<	_LT_SYS_DYNAMIC_LINKER($1)
6927	<	_LT_LINKER_HARDCODE_LIBPATH($1)
6928	<
6929	<	_LT_CONFIG($1)
6930	<	fi # test -n "$compiler"
6931	<
6932	<	GCC=$lt_save_GCC
6933	<	CC="$lt_save_CC"
6934	<	fi # test "$_lt_disable_FC" != yes
6935	<
6936	<	AC_LANG_POP
6937	<	])# _LT_LANG_FC_CONFIG
6938	<
6939	<
6940	<	# _LT_LANG_GCJ_CONFIG([TAG])
6941	<	# --------------------------
6942	<	# Ensure that the configuration variables for the GNU Java Compiler compiler
6943	<	# are suitably defined.  These variables are subsequently used by _LT_CONFIG
6944	<	# to write the compiler configuration to `libtool'.
6945	<	m4_defun([_LT_LANG_GCJ_CONFIG],
6946	<	[AC_REQUIRE([LT_PROG_GCJ])dnl
6947	<	AC_LANG_SAVE
6948	<
6949	<	# Source file extension for Java test sources.
6950	<	ac_ext=java
6951	<
6952	<	# Object file extension for compiled Java test sources.
6953	<	objext=o
6954	<	_LT_TAGVAR(objext, $1)=$objext
6955	<
6956	<	# Code to be used in simple compile tests
6957	<	lt_simple_compile_test_code="class foo {}"
6958	<
6959	<	# Code to be used in simple link tests
6960	<	lt_simple_link_test_code='public class conftest { public static void main(String[[]] argv) {}; }'
6961	<
6962	<	# ltmain only uses $CC for tagged configurations so make sure $CC is set.
6963	<	_LT_TAG_COMPILER
6964	<
6965	<	# save warnings/boilerplate of simple test code
6966	<	_LT_COMPILER_BOILERPLATE
6967	<	_LT_LINKER_BOILERPLATE
6968	<
6969	<	# Allow CC to be a program name with arguments.
6970	<	lt_save_CC="$CC"
6971	<	lt_save_GCC=$GCC
6972	<	GCC=yes
6973	<	CC=${GCJ-"gcj"}
6974	<	compiler=$CC
6975	<	_LT_TAGVAR(compiler, $1)=$CC
6976	<	_LT_TAGVAR(LD, $1)="$LD"
6977	<	_LT_CC_BASENAME([$compiler])
6978	<
6979	<	# GCJ did not exist at the time GCC didn't implicitly link libc in.
6980	<	_LT_TAGVAR(archive_cmds_need_lc, $1)=no
6981	<
6982	<	_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
6983	<
6984	<	if test -n "$compiler"; then
6985	<	_LT_COMPILER_NO_RTTI($1)
6986	<	_LT_COMPILER_PIC($1)
6987	<	_LT_COMPILER_C_O($1)
6988	<	_LT_COMPILER_FILE_LOCKS($1)
6989	<	_LT_LINKER_SHLIBS($1)
6990	<	_LT_LINKER_HARDCODE_LIBPATH($1)
6991	<
6992	<	_LT_CONFIG($1)
6993	<	fi
6994	<
6995	<	AC_LANG_RESTORE
6996	<
6997	<	GCC=$lt_save_GCC
6998	<	CC="$lt_save_CC"
6999	<	])# _LT_LANG_GCJ_CONFIG
7000	<
7001	<
7002	<	# _LT_LANG_RC_CONFIG([TAG])
7003	<	# -------------------------
7004	<	# Ensure that the configuration variables for the Windows resource compiler
7005	<	# are suitably defined.  These variables are subsequently used by _LT_CONFIG
7006	<	# to write the compiler configuration to `libtool'.
7007	<	m4_defun([_LT_LANG_RC_CONFIG],
7008	<	[AC_REQUIRE([LT_PROG_RC])dnl
7009	<	AC_LANG_SAVE
7010	<
7011	<	# Source file extension for RC test sources.
7012	<	ac_ext=rc
7013	<
7014	<	# Object file extension for compiled RC test sources.
7015	<	objext=o
7016	<	_LT_TAGVAR(objext, $1)=$objext
7017	<
7018	<	# Code to be used in simple compile tests
7019	<	lt_simple_compile_test_code='sample MENU { MENUITEM "&Soup", 100, CHECKED }'
7020	<
7021	<	# Code to be used in simple link tests
7022	<	lt_simple_link_test_code="$lt_simple_compile_test_code"
7023	<
7024	<	# ltmain only uses $CC for tagged configurations so make sure $CC is set.
7025	<	_LT_TAG_COMPILER
7026	<
7027	<	# save warnings/boilerplate of simple test code
7028	<	_LT_COMPILER_BOILERPLATE
7029	<	_LT_LINKER_BOILERPLATE
7030	<
7031	<	# Allow CC to be a program name with arguments.
7032	<	lt_save_CC="$CC"
7033	<	lt_save_GCC=$GCC
7034	<	GCC=
7035	<	CC=${RC-"windres"}
7036	<	compiler=$CC
7037	<	_LT_TAGVAR(compiler, $1)=$CC
7038	<	_LT_CC_BASENAME([$compiler])
7039	<	_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes
7040	<
7041	<	if test -n "$compiler"; then
7042	<	:
7043	<	_LT_CONFIG($1)
7044	<	fi
7045	<
7046	<	GCC=$lt_save_GCC
7047	<	AC_LANG_RESTORE
7048	<	CC="$lt_save_CC"
7049	<	])# _LT_LANG_RC_CONFIG
7050	<
7051	<
7052	<	# LT_PROG_GCJ
7053	<	# -----------
7054	<	AC_DEFUN([LT_PROG_GCJ],
7055	<	[m4_ifdef([AC_PROG_GCJ], [AC_PROG_GCJ],
7056	<	[m4_ifdef([A][M_PROG_GCJ], [A][M_PROG_GCJ],
7057	<	[AC_CHECK_TOOL(GCJ, gcj,)
7058	<	test "x${GCJFLAGS+set}" = xset || GCJFLAGS="-g -O2"
7059	<	AC_SUBST(GCJFLAGS)])])[]dnl
7060	<	])
7061	<
7062	<	# Old name:
7063	<	AU_ALIAS([LT_AC_PROG_GCJ], [LT_PROG_GCJ])
7064	<	dnl aclocal-1.4 backwards compatibility:
7065	<	dnl AC_DEFUN([LT_AC_PROG_GCJ], [])
7066	<
7067	<
7068	<	# LT_PROG_RC
7069	<	# ----------
7070	<	AC_DEFUN([LT_PROG_RC],
7071	<	[AC_CHECK_TOOL(RC, windres,)
7072	<	])
7073	<
7074	<	# Old name:
7075	<	AU_ALIAS([LT_AC_PROG_RC], [LT_PROG_RC])
7076	<	dnl aclocal-1.4 backwards compatibility:
7077	<	dnl AC_DEFUN([LT_AC_PROG_RC], [])
7078	<
7079	<
7080	<	# _LT_DECL_EGREP
7081	<	# --------------
7082	<	# If we don't have a new enough Autoconf to choose the best grep
7083	<	# available, choose the one first in the user's PATH.
7084	<	m4_defun([_LT_DECL_EGREP],
7085	<	[AC_REQUIRE([AC_PROG_EGREP])dnl
7086	<	AC_REQUIRE([AC_PROG_FGREP])dnl
7087	<	test -z "$GREP" && GREP=grep
7088	<	_LT_DECL([], [GREP], [1], [A grep program that handles long lines])
7089	<	_LT_DECL([], [EGREP], [1], [An ERE matcher])
7090	<	_LT_DECL([], [FGREP], [1], [A literal string matcher])
7091	<	dnl Non-bleeding-edge autoconf doesn't subst GREP, so do it here too
7092	<	AC_SUBST([GREP])
7093	<	])
7094	<
7095	<
7096	<	# _LT_DECL_OBJDUMP
7097	<	# --------------
7098	<	# If we don't have a new enough Autoconf to choose the best objdump
7099	<	# available, choose the one first in the user's PATH.
7100	<	m4_defun([_LT_DECL_OBJDUMP],
7101	<	[AC_CHECK_TOOL(OBJDUMP, objdump, false)
7102	<	test -z "$OBJDUMP" && OBJDUMP=objdump
7103	<	_LT_DECL([], [OBJDUMP], [1], [An object symbol dumper])
7104	<	AC_SUBST([OBJDUMP])
7105	<	])
7106	<
7107	<
7108	<	# _LT_DECL_SED
7109	<	# ------------
7110	<	# Check for a fully-functional sed program, that truncates
7111	<	# as few characters as possible.  Prefer GNU sed if found.
7112	<	m4_defun([_LT_DECL_SED],
7113	<	[AC_PROG_SED
7114	<	test -z "$SED" && SED=sed
7115	<	Xsed="$SED -e 1s/^X//"
7116	<	_LT_DECL([], [SED], [1], [A sed program that does not truncate output])
7117	<	_LT_DECL([], [Xsed], ["\$SED -e 1s/^X//"],
7118	<	[Sed that helps us avoid accidentally triggering echo(1) options like -n])
7119	<	])# _LT_DECL_SED
7120	<
7121	<	m4_ifndef([AC_PROG_SED], [
7122	<	# NOTE: This macro has been submitted for inclusion into   #
7123	<	#  GNU Autoconf as AC_PROG_SED.  When it is available in   #
7124	<	#  a released version of Autoconf we should remove this    #
7125	<	#  macro and use it instead.                               #
7126	<
7127	<	m4_defun([AC_PROG_SED],
7128	<	[AC_MSG_CHECKING([for a sed that does not truncate output])
7129	<	AC_CACHE_VAL(lt_cv_path_SED,
7130	<	[# Loop through the user's path and test for sed and gsed.
7131	<	# Then use that list of sed's as ones to test for truncation.
7132	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7133	<	for as_dir in $PATH
7134	<	do
7135	<	IFS=$as_save_IFS
7136	<	test -z "$as_dir" && as_dir=.
7137	<	for lt_ac_prog in sed gsed; do
7138	<	for ac_exec_ext in '' $ac_executable_extensions; do
7139	<	if $as_executable_p "$as_dir/$lt_ac_prog$ac_exec_ext"; then
7140	<	lt_ac_sed_list="$lt_ac_sed_list $as_dir/$lt_ac_prog$ac_exec_ext"
7141	<	fi
7142	<	done
7143	<	done
7144	<	done
7145	<	IFS=$as_save_IFS
7146	<	lt_ac_max=0
7147	<	lt_ac_count=0
7148	<	# Add /usr/xpg4/bin/sed as it is typically found on Solaris
7149	<	# along with /bin/sed that truncates output.
7150	<	for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do
7151	<	test ! -f $lt_ac_sed && continue
7152	<	cat /dev/null > conftest.in
7153	<	lt_ac_count=0
7154	<	echo $ECHO_N "0123456789$ECHO_C" >conftest.in
7155	<	# Check for GNU sed and select it if it is found.
7156	<	if "$lt_ac_sed" --version 2>&1 < /dev/null | grep 'GNU' > /dev/null; then
7157	<	lt_cv_path_SED=$lt_ac_sed
7158	<	break
7159	<	fi
7160	<	while true; do
7161	<	cat conftest.in conftest.in >conftest.tmp
7162	<	mv conftest.tmp conftest.in
7163	<	cp conftest.in conftest.nl
7164	<	echo >>conftest.nl
7165	<	$lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break
7166	<	cmp -s conftest.out conftest.nl || break
7167	<	# 10000 chars as input seems more than enough
7168	<	test $lt_ac_count -gt 10 && break
7169	<	lt_ac_count=`expr $lt_ac_count + 1`
7170	<	if test $lt_ac_count -gt $lt_ac_max; then
7171	<	lt_ac_max=$lt_ac_count
7172	<	lt_cv_path_SED=$lt_ac_sed
7173	<	fi
7174	<	done
7175	<	done
7176	<	])
7177	<	SED=$lt_cv_path_SED
7178	<	AC_SUBST([SED])
7179	<	AC_MSG_RESULT([$SED])
7180	<	])#AC_PROG_SED
7181	<	])#m4_ifndef
7182	<
7183	<	# Old name:
7184	<	AU_ALIAS([LT_AC_PROG_SED], [AC_PROG_SED])
7185	<	dnl aclocal-1.4 backwards compatibility:
7186	<	dnl AC_DEFUN([LT_AC_PROG_SED], [])
7187	<
7188	<
7189	<	# _LT_CHECK_SHELL_FEATURES
7190	<	# ------------------------
7191	<	# Find out whether the shell is Bourne or XSI compatible,
7192	<	# or has some other useful features.
7193	<	m4_defun([_LT_CHECK_SHELL_FEATURES],
7194	<	[AC_MSG_CHECKING([whether the shell understands some XSI constructs])
7195	<	# Try some XSI features
7196	<	xsi_shell=no
7197	<	( _lt_dummy="a/b/c"
7198	<	test "${_lt_dummy##*/},${_lt_dummy%/*},"${_lt_dummy%"$_lt_dummy"}, \
7199	<	= c,a/b,, \
7200	<	&& eval 'test $(( 1 + 1 )) -eq 2 \
7201	<	&& test "${#_lt_dummy}" -eq 5' ) >/dev/null 2>&1 \
7202	<	&& xsi_shell=yes
7203	<	AC_MSG_RESULT([$xsi_shell])
7204	<	_LT_CONFIG_LIBTOOL_INIT([xsi_shell='$xsi_shell'])
7205	<
7206	<	AC_MSG_CHECKING([whether the shell understands "+="])
7207	<	lt_shell_append=no
7208	<	( foo=bar; set foo baz; eval "$[1]+=\$[2]" && test "$foo" = barbaz ) \
7209	<	>/dev/null 2>&1 \
7210	<	&& lt_shell_append=yes
7211	<	AC_MSG_RESULT([$lt_shell_append])
7212	<	_LT_CONFIG_LIBTOOL_INIT([lt_shell_append='$lt_shell_append'])
7213	<
7214	<	if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
7215	<	lt_unset=unset
7216	<	else
7217	<	lt_unset=false
7218	<	fi
7219	<	_LT_DECL([], [lt_unset], [0], [whether the shell understands "unset"])dnl
7220	<
7221	<	# test EBCDIC or ASCII
7222	<	case `echo X|tr X '\101'` in
7223	<	A) # ASCII based system
7224	<	# \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
7225	<	lt_SP2NL='tr \040 \012'
7226	<	lt_NL2SP='tr \015\012 \040\040'
7227	<	;;
7228	<	*) # EBCDIC based system
7229	<	lt_SP2NL='tr \100 \n'
7230	<	lt_NL2SP='tr \r\n \100\100'
7231	<	;;
7232	<	esac
7233	<	_LT_DECL([SP2NL], [lt_SP2NL], [1], [turn spaces into newlines])dnl
7234	<	_LT_DECL([NL2SP], [lt_NL2SP], [1], [turn newlines into spaces])dnl
7235	<	])# _LT_CHECK_SHELL_FEATURES
7236	<
7237	<
7238	<	# _LT_PROG_XSI_SHELLFNS
7239	<	# ---------------------
7240	<	# Bourne and XSI compatible variants of some useful shell functions.
7241	<	m4_defun([_LT_PROG_XSI_SHELLFNS],
7242	<	[case $xsi_shell in
7243	<	yes)
7244	<	cat << \_LT_EOF >> "$cfgfile"
7245	<
7246	<	# func_dirname file append nondir_replacement
7247	<	# Compute the dirname of FILE.  If nonempty, add APPEND to the result,
7248	<	# otherwise set result to NONDIR_REPLACEMENT.
7249	<	func_dirname ()
7250	<	{
7251	<	case ${1} in
7252	<	*/*) func_dirname_result="${1%/*}${2}" ;;
7253	<	*  ) func_dirname_result="${3}" ;;
7254	<	esac
7255	<	}
7256	<
7257	<	# func_basename file
7258	<	func_basename ()
7259	<	{
7260	<	func_basename_result="${1##*/}"
7261	<	}
7262	<
7263	<	# func_dirname_and_basename file append nondir_replacement
7264	<	# perform func_basename and func_dirname in a single function
7265	<	# call:
7266	<	#   dirname:  Compute the dirname of FILE.  If nonempty,
7267	<	#             add APPEND to the result, otherwise set result
7268	<	#             to NONDIR_REPLACEMENT.
7269	<	#             value returned in "$func_dirname_result"
7270	<	#   basename: Compute filename of FILE.
7271	<	#             value retuned in "$func_basename_result"
7272	<	# Implementation must be kept synchronized with func_dirname
7273	<	# and func_basename. For efficiency, we do not delegate to
7274	<	# those functions but instead duplicate the functionality here.
7275	<	func_dirname_and_basename ()
7276	<	{
7277	<	case ${1} in
7278	<	*/*) func_dirname_result="${1%/*}${2}" ;;
7279	<	*  ) func_dirname_result="${3}" ;;
7280	<	esac
7281	<	func_basename_result="${1##*/}"
7282	<	}
7283	<
7284	<	# func_stripname prefix suffix name
7285	<	# strip PREFIX and SUFFIX off of NAME.
7286	<	# PREFIX and SUFFIX must not contain globbing or regex special
7287	<	# characters, hashes, percent signs, but SUFFIX may contain a leading
7288	<	# dot (in which case that matches only a dot).
7289	<	func_stripname ()
7290	<	{
7291	<	# pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are
7292	<	# positional parameters, so assign one to ordinary parameter first.
7293	<	func_stripname_result=${3}
7294	<	func_stripname_result=${func_stripname_result#"${1}"}
7295	<	func_stripname_result=${func_stripname_result%"${2}"}
7296	<	}
7297	<
7298	<	# func_opt_split
7299	<	func_opt_split ()
7300	<	{
7301	<	func_opt_split_opt=${1%%=*}
7302	<	func_opt_split_arg=${1#*=}
7303	<	}
7304	<
7305	<	# func_lo2o object
7306	<	func_lo2o ()
7307	<	{
7308	<	case ${1} in
7309	<	*.lo) func_lo2o_result=${1%.lo}.${objext} ;;
7310	<	*)    func_lo2o_result=${1} ;;
7311	<	esac
7312	<	}
7313	<
7314	<	# func_xform libobj-or-source
7315	<	func_xform ()
7316	<	{
7317	<	func_xform_result=${1%.*}.lo
7318	<	}
7319	<
7320	<	# func_arith arithmetic-term...
7321	<	func_arith ()
7322	<	{
7323	<	func_arith_result=$(( $[*] ))
7324	<	}
7325	<
7326	<	# func_len string
7327	<	# STRING may not start with a hyphen.
7328	<	func_len ()
7329	<	{
7330	<	func_len_result=${#1}
7331	<	}
7332	<
7333	<	_LT_EOF
7334	<	;;
7335	<	*) # Bourne compatible functions.
7336	<	cat << \_LT_EOF >> "$cfgfile"
7337	<
7338	<	# func_dirname file append nondir_replacement
7339	<	# Compute the dirname of FILE.  If nonempty, add APPEND to the result,
7340	<	# otherwise set result to NONDIR_REPLACEMENT.
7341	<	func_dirname ()
7342	<	{
7343	<	# Extract subdirectory from the argument.
7344	<	func_dirname_result=`$ECHO "X${1}" | $Xsed -e "$dirname"`
7345	<	if test "X$func_dirname_result" = "X${1}"; then
7346	<	func_dirname_result="${3}"
7347	<	else
7348	<	func_dirname_result="$func_dirname_result${2}"
7349	<	fi
7350	<	}
7351	<
7352	<	# func_basename file
7353	<	func_basename ()
7354	<	{
7355	<	func_basename_result=`$ECHO "X${1}" | $Xsed -e "$basename"`
7356	<	}
7357	<
7358	<	dnl func_dirname_and_basename
7359	<	dnl A portable version of this function is already defined in general.m4sh
7360	<	dnl so there is no need for it here.
7361	<
7362	<	# func_stripname prefix suffix name
7363	<	# strip PREFIX and SUFFIX off of NAME.
7364	<	# PREFIX and SUFFIX must not contain globbing or regex special
7365	<	# characters, hashes, percent signs, but SUFFIX may contain a leading
7366	<	# dot (in which case that matches only a dot).
7367	<	# func_strip_suffix prefix name
7368	<	func_stripname ()
7369	<	{
7370	<	case ${2} in
7371	<	.*) func_stripname_result=`$ECHO "X${3}" \
7372	<	| $Xsed -e "s%^${1}%%" -e "s%\\\\${2}\$%%"`;;
7373	<	*)  func_stripname_result=`$ECHO "X${3}" \
7374	<	| $Xsed -e "s%^${1}%%" -e "s%${2}\$%%"`;;
7375	<	esac
7376	<	}
7377	<
7378	<	# sed scripts:
7379	<	my_sed_long_opt='1s/^\(-[[^=]]*\)=.*/\1/;q'
7380	<	my_sed_long_arg='1s/^-[[^=]]*=//'
7381	<
7382	<	# func_opt_split
7383	<	func_opt_split ()
7384	<	{
7385	<	func_opt_split_opt=`$ECHO "X${1}" | $Xsed -e "$my_sed_long_opt"`
7386	<	func_opt_split_arg=`$ECHO "X${1}" | $Xsed -e "$my_sed_long_arg"`
7387	<	}
21	>	To do so, use the procedure documented by the package, typically 'autoreconf'.])])
22
23	<	# func_lo2o object
7390	<	func_lo2o ()
7391	<	{
7392	<	func_lo2o_result=`$ECHO "X${1}" | $Xsed -e "$lo2o"`
7393	<	}
7394	<
7395	<	# func_xform libobj-or-source
7396	<	func_xform ()
7397	<	{
7398	<	func_xform_result=`$ECHO "X${1}" | $Xsed -e 's/\.[[^.]]*$/.lo/'`
7399	<	}
7400	<
7401	<	# func_arith arithmetic-term...
7402	<	func_arith ()
7403	<	{
7404	<	func_arith_result=`expr "$[@]"`
7405	<	}
7406	<
7407	<	# func_len string
7408	<	# STRING may not start with a hyphen.
7409	<	func_len ()
7410	<	{
7411	<	func_len_result=`expr "$[1]" : ".*" 2>/dev/null || echo $max_cmd_len`
7412	<	}
7413	<
7414	<	_LT_EOF
7415	<	esac
7416	<
7417	<	case $lt_shell_append in
7418	<	yes)
7419	<	cat << \_LT_EOF >> "$cfgfile"
7420	<
7421	<	# func_append var value
7422	<	# Append VALUE to the end of shell variable VAR.
7423	<	func_append ()
7424	<	{
7425	<	eval "$[1]+=\$[2]"
7426	<	}
7427	<	_LT_EOF
7428	<	;;
7429	<	*)
7430	<	cat << \_LT_EOF >> "$cfgfile"
7431	<
7432	<	# func_append var value
7433	<	# Append VALUE to the end of shell variable VAR.
7434	<	func_append ()
7435	<	{
7436	<	eval "$[1]=\$$[1]\$[2]"
7437	<	}
7438	<
7439	<	_LT_EOF
7440	<	;;
7441	<	esac
7442	<	])
7443	<
7444	<	# ltdl.m4 - Configure ltdl for the target system. -*-Autoconf-*-
7445	<	#
7446	<	#   Copyright (C) 1999-2006, 2007, 2008 Free Software Foundation, Inc.
7447	<	#   Written by Thomas Tanner, 1999
7448	<	#
7449	<	# This file is free software; the Free Software Foundation gives
7450	<	# unlimited permission to copy and/or distribute it, with or without
7451	<	# modifications, as long as this notice is preserved.
7452	<
7453	<	# serial 17 LTDL_INIT
7454	<
7455	<	# LT_CONFIG_LTDL_DIR(DIRECTORY, [LTDL-MODE])
7456	<	# ------------------------------------------
7457	<	# DIRECTORY contains the libltdl sources.  It is okay to call this
7458	<	# function multiple times, as long as the same DIRECTORY is always given.
7459	<	AC_DEFUN([LT_CONFIG_LTDL_DIR],
7460	<	[AC_BEFORE([$0], [LTDL_INIT])
7461	<	_$0($*)
7462	<	])# LT_CONFIG_LTDL_DIR
7463	<
7464	<	# We break this out into a separate macro, so that we can call it safely
7465	<	# internally without being caught accidentally by the sed scan in libtoolize.
7466	<	m4_defun([_LT_CONFIG_LTDL_DIR],
7467	<	[dnl remove trailing slashes
7468	<	m4_pushdef([_ARG_DIR], m4_bpatsubst([$1], [/*$]))
7469	<	m4_case(_LTDL_DIR,
7470	<	[], [dnl only set lt_ltdl_dir if _ARG_DIR is not simply `.'
7471	<	m4_if(_ARG_DIR, [.],
7472	<	[],
7473	<	[m4_define([_LTDL_DIR], _ARG_DIR)
7474	<	_LT_SHELL_INIT([lt_ltdl_dir=']_ARG_DIR['])])],
7475	<	[m4_if(_ARG_DIR, _LTDL_DIR,
7476	<	[],
7477	<	[m4_fatal([multiple libltdl directories: `]_LTDL_DIR[', `]_ARG_DIR['])])])
7478	<	m4_popdef([_ARG_DIR])
7479	<	])# _LT_CONFIG_LTDL_DIR
7480	<
7481	<	# Initialise:
7482	<	m4_define([_LTDL_DIR], [])
7483	<
7484	<
7485	<	# _LT_BUILD_PREFIX
7486	<	# ----------------
7487	<	# If Autoconf is new enough, expand to `${top_build_prefix}', otherwise
7488	<	# to `${top_builddir}/'.
7489	<	m4_define([_LT_BUILD_PREFIX],
7490	<	[m4_ifdef([AC_AUTOCONF_VERSION],
7491	<	[m4_if(m4_version_compare(m4_defn([AC_AUTOCONF_VERSION]), [2.62]),
7492	<	[-1], [m4_ifdef([_AC_HAVE_TOP_BUILD_PREFIX],
7493	<	[${top_build_prefix}],
7494	<	[${top_builddir}/])],
7495	<	[${top_build_prefix}])],
7496	<	[${top_builddir}/])[]dnl
7497	<	])
7498	<
7499	<
7500	<	# LTDL_CONVENIENCE
7501	<	# ----------------
7502	<	# sets LIBLTDL to the link flags for the libltdl convenience library and
7503	<	# LTDLINCL to the include flags for the libltdl header and adds
7504	<	# --enable-ltdl-convenience to the configure arguments.  Note that
7505	<	# AC_CONFIG_SUBDIRS is not called here.  LIBLTDL will be prefixed with
7506	<	# '${top_build_prefix}' if available, otherwise with '${top_builddir}/',
7507	<	# and LTDLINCL will be prefixed with '${top_srcdir}/' (note the single
7508	<	# quotes!).  If your package is not flat and you're not using automake,
7509	<	# define top_build_prefix, top_builddir, and top_srcdir appropriately
7510	<	# in your Makefiles.
7511	<	AC_DEFUN([LTDL_CONVENIENCE],
7512	<	[AC_BEFORE([$0], [LTDL_INIT])dnl
7513	<	dnl Although the argument is deprecated and no longer documented,
7514	<	dnl LTDL_CONVENIENCE used to take a DIRECTORY orgument, if we have one
7515	<	dnl here make sure it is the same as any other declaration of libltdl's
7516	<	dnl location!  This also ensures lt_ltdl_dir is set when configure.ac is
7517	<	dnl not yet using an explicit LT_CONFIG_LTDL_DIR.
7518	<	m4_ifval([$1], [_LT_CONFIG_LTDL_DIR([$1])])dnl
7519	<	_$0()
7520	<	])# LTDL_CONVENIENCE
7521	<
7522	<	# AC_LIBLTDL_CONVENIENCE accepted a directory argument in older libtools,
7523	<	# now we have LT_CONFIG_LTDL_DIR:
7524	<	AU_DEFUN([AC_LIBLTDL_CONVENIENCE],
7525	<	[_LT_CONFIG_LTDL_DIR([m4_default([$1], [libltdl])])
7526	<	_LTDL_CONVENIENCE])
7527	<
7528	<	dnl aclocal-1.4 backwards compatibility:
7529	<	dnl AC_DEFUN([AC_LIBLTDL_CONVENIENCE], [])
7530	<
7531	<
7532	<	# _LTDL_CONVENIENCE
7533	<	# -----------------
7534	<	# Code shared by LTDL_CONVENIENCE and LTDL_INIT([convenience]).
7535	<	m4_defun([_LTDL_CONVENIENCE],
7536	<	[case $enable_ltdl_convenience in
7537	<	no) AC_MSG_ERROR([this package needs a convenience libltdl]) ;;
7538	<	"") enable_ltdl_convenience=yes
7539	<	ac_configure_args="$ac_configure_args --enable-ltdl-convenience" ;;
7540	<	esac
7541	<	LIBLTDL='_LT_BUILD_PREFIX'"${lt_ltdl_dir+$lt_ltdl_dir/}libltdlc.la"
7542	<	LTDLDEPS=$LIBLTDL
7543	<	LTDLINCL='-I${top_srcdir}'"${lt_ltdl_dir+/$lt_ltdl_dir}"
7544	<
7545	<	AC_SUBST([LIBLTDL])
7546	<	AC_SUBST([LTDLDEPS])
7547	<	AC_SUBST([LTDLINCL])
7548	<
7549	<	# For backwards non-gettext consistent compatibility...
7550	<	INCLTDL="$LTDLINCL"
7551	<	AC_SUBST([INCLTDL])
7552	<	])# _LTDL_CONVENIENCE
7553	<
7554	<
7555	<	# LTDL_INSTALLABLE
7556	<	# ----------------
7557	<	# sets LIBLTDL to the link flags for the libltdl installable library
7558	<	# and LTDLINCL to the include flags for the libltdl header and adds
7559	<	# --enable-ltdl-install to the configure arguments.  Note that
7560	<	# AC_CONFIG_SUBDIRS is not called from here.  If an installed libltdl
7561	<	# is not found, LIBLTDL will be prefixed with '${top_build_prefix}' if
7562	<	# available, otherwise with '${top_builddir}/', and LTDLINCL will be
7563	<	# prefixed with '${top_srcdir}/' (note the single quotes!).  If your
7564	<	# package is not flat and you're not using automake, define top_build_prefix,
7565	<	# top_builddir, and top_srcdir appropriately in your Makefiles.
7566	<	# In the future, this macro may have to be called after LT_INIT.
7567	<	AC_DEFUN([LTDL_INSTALLABLE],
7568	<	[AC_BEFORE([$0], [LTDL_INIT])dnl
7569	<	dnl Although the argument is deprecated and no longer documented,
7570	<	dnl LTDL_INSTALLABLE used to take a DIRECTORY orgument, if we have one
7571	<	dnl here make sure it is the same as any other declaration of libltdl's
7572	<	dnl location!  This also ensures lt_ltdl_dir is set when configure.ac is
7573	<	dnl not yet using an explicit LT_CONFIG_LTDL_DIR.
7574	<	m4_ifval([$1], [_LT_CONFIG_LTDL_DIR([$1])])dnl
7575	<	_$0()
7576	<	])# LTDL_INSTALLABLE
7577	<
7578	<	# AC_LIBLTDL_INSTALLABLE accepted a directory argument in older libtools,
7579	<	# now we have LT_CONFIG_LTDL_DIR:
7580	<	AU_DEFUN([AC_LIBLTDL_INSTALLABLE],
7581	<	[_LT_CONFIG_LTDL_DIR([m4_default([$1], [libltdl])])
7582	<	_LTDL_INSTALLABLE])
7583	<
7584	<	dnl aclocal-1.4 backwards compatibility:
7585	<	dnl AC_DEFUN([AC_LIBLTDL_INSTALLABLE], [])
7586	<
7587	<
7588	<	# _LTDL_INSTALLABLE
7589	<	# -----------------
7590	<	# Code shared by LTDL_INSTALLABLE and LTDL_INIT([installable]).
7591	<	m4_defun([_LTDL_INSTALLABLE],
7592	<	[if test -f $prefix/lib/libltdl.la; then
7593	<	lt_save_LDFLAGS="$LDFLAGS"
7594	<	LDFLAGS="-L$prefix/lib $LDFLAGS"
7595	<	AC_CHECK_LIB([ltdl], [lt_dlinit], [lt_lib_ltdl=yes])
7596	<	LDFLAGS="$lt_save_LDFLAGS"
7597	<	if test x"${lt_lib_ltdl-no}" = xyes; then
7598	<	if test x"$enable_ltdl_install" != xyes; then
7599	<	# Don't overwrite $prefix/lib/libltdl.la without --enable-ltdl-install
7600	<	AC_MSG_WARN([not overwriting libltdl at $prefix, force with `--enable-ltdl-install'])
7601	<	enable_ltdl_install=no
7602	<	fi
7603	<	elif test x"$enable_ltdl_install" = xno; then
7604	<	AC_MSG_WARN([libltdl not installed, but installation disabled])
7605	<	fi
7606	<	fi
7607	<
7608	<	# If configure.ac declared an installable ltdl, and the user didn't override
7609	<	# with --disable-ltdl-install, we will install the shipped libltdl.
7610	<	case $enable_ltdl_install in
7611	<	no) ac_configure_args="$ac_configure_args --enable-ltdl-install=no"
7612	<	LIBLTDL="-lltdl"
7613	<	LTDLDEPS=
7614	<	LTDLINCL=
7615	<	;;
7616	<	*)  enable_ltdl_install=yes
7617	<	ac_configure_args="$ac_configure_args --enable-ltdl-install"
7618	<	LIBLTDL='_LT_BUILD_PREFIX'"${lt_ltdl_dir+$lt_ltdl_dir/}libltdl.la"
7619	<	LTDLDEPS=$LIBLTDL
7620	<	LTDLINCL='-I${top_srcdir}'"${lt_ltdl_dir+/$lt_ltdl_dir}"
7621	<	;;
7622	<	esac
7623	<
7624	<	AC_SUBST([LIBLTDL])
7625	<	AC_SUBST([LTDLDEPS])
7626	<	AC_SUBST([LTDLINCL])
7627	<
7628	<	# For backwards non-gettext consistent compatibility...
7629	<	INCLTDL="$LTDLINCL"
7630	<	AC_SUBST([INCLTDL])
7631	<	])# LTDL_INSTALLABLE
7632	<
7633	<
7634	<	# _LTDL_MODE_DISPATCH
7635	<	# -------------------
7636	<	m4_define([_LTDL_MODE_DISPATCH],
7637	<	[dnl If _LTDL_DIR is `.', then we are configuring libltdl itself:
7638	<	m4_if(_LTDL_DIR, [],
7639	<	[],
7640	<	dnl if _LTDL_MODE was not set already, the default value is `subproject':
7641	<	[m4_case(m4_default(_LTDL_MODE, [subproject]),
7642	<	[subproject], [AC_CONFIG_SUBDIRS(_LTDL_DIR)
7643	<	_LT_SHELL_INIT([lt_dlopen_dir="$lt_ltdl_dir"])],
7644	<	[nonrecursive], [_LT_SHELL_INIT([lt_dlopen_dir="$lt_ltdl_dir"; lt_libobj_prefix="$lt_ltdl_dir/"])],
7645	<	[recursive], [],
7646	<	[m4_fatal([unknown libltdl mode: ]_LTDL_MODE)])])dnl
7647	<	dnl Be careful not to expand twice:
7648	<	m4_define([$0], [])
7649	<	])# _LTDL_MODE_DISPATCH
7650	<
7651	<
7652	<	# _LT_LIBOBJ(MODULE_NAME)
7653	<	# -----------------------
7654	<	# Like AC_LIBOBJ, except that MODULE_NAME goes into _LT_LIBOBJS instead
7655	<	# of into LIBOBJS.
7656	<	AC_DEFUN([_LT_LIBOBJ], [
7657	<	m4_pattern_allow([^_LT_LIBOBJS$])
7658	<	_LT_LIBOBJS="$_LT_LIBOBJS $1.$ac_objext"
7659	<	])# _LT_LIBOBJS
7660	<
7661	<
7662	<	# LTDL_INIT([OPTIONS])
7663	<	# --------------------
7664	<	# Clients of libltdl can use this macro to allow the installer to
7665	<	# choose between a shipped copy of the ltdl sources or a preinstalled
7666	<	# version of the library.  If the shipped ltdl sources are not in a
7667	<	# subdirectory named libltdl, the directory name must be given by
7668	<	# LT_CONFIG_LTDL_DIR.
7669	<	AC_DEFUN([LTDL_INIT],
7670	<	[dnl Parse OPTIONS
7671	<	_LT_SET_OPTIONS([$0], [$1])
7672	<
7673	<	dnl We need to keep our own list of libobjs separate from our parent project,
7674	<	dnl and the easiest way to do that is redefine the AC_LIBOBJs macro while
7675	<	dnl we look for our own LIBOBJs.
7676	<	m4_pushdef([AC_LIBOBJ], m4_defn([_LT_LIBOBJ]))
7677	<	m4_pushdef([AC_LIBSOURCES])
7678	<
7679	<	dnl If not otherwise defined, default to the 1.5.x compatible subproject mode:
7680	<	m4_if(_LTDL_MODE, [],
7681	<	[m4_define([_LTDL_MODE], m4_default([$2], [subproject]))
7682	<	m4_if([-1], [m4_bregexp(_LTDL_MODE, [\(subproject\|\(non\)?recursive\)])],
7683	<	[m4_fatal([unknown libltdl mode: ]_LTDL_MODE)])])
7684	<
7685	<	AC_ARG_WITH([included_ltdl],
7686	<	[AS_HELP_STRING([--with-included-ltdl],
7687	<	[use the GNU ltdl sources included here])])
7688	<
7689	<	if test "x$with_included_ltdl" != xyes; then
7690	<	# We are not being forced to use the included libltdl sources, so
7691	<	# decide whether there is a useful installed version we can use.
7692	<	AC_CHECK_HEADER([ltdl.h],
7693	<	[AC_CHECK_DECL([lt_dlinterface_register],
7694	<	[AC_CHECK_LIB([ltdl], [lt_dladvise_preload],
7695	<	[with_included_ltdl=no],
7696	<	[with_included_ltdl=yes])],
7697	<	[with_included_ltdl=yes],
7698	<	[AC_INCLUDES_DEFAULT
7699	<	#include <ltdl.h>])],
7700	<	[with_included_ltdl=yes],
7701	<	[AC_INCLUDES_DEFAULT]
7702	<	)
7703	<	fi
7704	<
7705	<	dnl If neither LT_CONFIG_LTDL_DIR, LTDL_CONVENIENCE nor LTDL_INSTALLABLE
7706	<	dnl was called yet, then for old times' sake, we assume libltdl is in an
7707	<	dnl eponymous directory:
7708	<	AC_PROVIDE_IFELSE([LT_CONFIG_LTDL_DIR], [], [_LT_CONFIG_LTDL_DIR([libltdl])])
7709	<
7710	<	AC_ARG_WITH([ltdl_include],
7711	<	[AS_HELP_STRING([--with-ltdl-include=DIR],
7712	<	[use the ltdl headers installed in DIR])])
7713	<
7714	<	if test -n "$with_ltdl_include"; then
7715	<	if test -f "$with_ltdl_include/ltdl.h"; then :
7716	<	else
7717	<	AC_MSG_ERROR([invalid ltdl include directory: `$with_ltdl_include'])
7718	<	fi
7719	<	else
7720	<	with_ltdl_include=no
7721	<	fi
7722	<
7723	<	AC_ARG_WITH([ltdl_lib],
7724	<	[AS_HELP_STRING([--with-ltdl-lib=DIR],
7725	<	[use the libltdl.la installed in DIR])])
7726	<
7727	<	if test -n "$with_ltdl_lib"; then
7728	<	if test -f "$with_ltdl_lib/libltdl.la"; then :
7729	<	else
7730	<	AC_MSG_ERROR([invalid ltdl library directory: `$with_ltdl_lib'])
7731	<	fi
7732	<	else
7733	<	with_ltdl_lib=no
7734	<	fi
7735	<
7736	<	case ,$with_included_ltdl,$with_ltdl_include,$with_ltdl_lib, in
7737	<	,yes,no,no,)
7738	<	m4_case(m4_default(_LTDL_TYPE, [convenience]),
7739	<	[convenience], [_LTDL_CONVENIENCE],
7740	<	[installable], [_LTDL_INSTALLABLE],
7741	<	[m4_fatal([unknown libltdl build type: ]_LTDL_TYPE)])
7742	<	;;
7743	<	,no,no,no,)
7744	<	# If the included ltdl is not to be used, then use the
7745	<	# preinstalled libltdl we found.
7746	<	AC_DEFINE([HAVE_LTDL], [1],
7747	<	[Define this if a modern libltdl is already installed])
7748	<	LIBLTDL=-lltdl
7749	<	LTDLDEPS=
7750	<	LTDLINCL=
7751	<	;;
7752	<	,no*,no,*)
7753	<	AC_MSG_ERROR([`--with-ltdl-include' and `--with-ltdl-lib' options must be used together])
7754	<	;;
7755	<	*)    with_included_ltdl=no
7756	<	LIBLTDL="-L$with_ltdl_lib -lltdl"
7757	<	LTDLDEPS=
7758	<	LTDLINCL="-I$with_ltdl_include"
7759	<	;;
7760	<	esac
7761	<	INCLTDL="$LTDLINCL"
7762	<
7763	<	# Report our decision...
7764	<	AC_MSG_CHECKING([where to find libltdl headers])
7765	<	AC_MSG_RESULT([$LTDLINCL])
7766	<	AC_MSG_CHECKING([where to find libltdl library])
7767	<	AC_MSG_RESULT([$LIBLTDL])
7768	<
7769	<	_LTDL_SETUP
7770	<
7771	<	dnl restore autoconf definition.
7772	<	m4_popdef([AC_LIBOBJ])
7773	<	m4_popdef([AC_LIBSOURCES])
7774	<
7775	<	AC_CONFIG_COMMANDS_PRE([
7776	<	_ltdl_libobjs=
7777	<	_ltdl_ltlibobjs=
7778	<	if test -n "$_LT_LIBOBJS"; then
7779	<	# Remove the extension.
7780	<	_lt_sed_drop_objext='s/\.o$//;s/\.obj$//'
7781	<	for i in `for i in $_LT_LIBOBJS; do echo "$i"; done | sed "$_lt_sed_drop_objext" | sort -u`; do
7782	<	_ltdl_libobjs="$_ltdl_libobjs $lt_libobj_prefix$i.$ac_objext"
7783	<	_ltdl_ltlibobjs="$_ltdl_ltlibobjs $lt_libobj_prefix$i.lo"
7784	<	done
7785	<	fi
7786	<	AC_SUBST([ltdl_LIBOBJS], [$_ltdl_libobjs])
7787	<	AC_SUBST([ltdl_LTLIBOBJS], [$_ltdl_ltlibobjs])
7788	<	])
7789	<
7790	<	# Only expand once:
7791	<	m4_define([LTDL_INIT])
7792	<	])# LTDL_INIT
7793	<
7794	<	# Old names:
7795	<	AU_DEFUN([AC_LIB_LTDL], [LTDL_INIT($@)])
7796	<	AU_DEFUN([AC_WITH_LTDL], [LTDL_INIT($@)])
7797	<	AU_DEFUN([LT_WITH_LTDL], [LTDL_INIT($@)])
7798	<	dnl aclocal-1.4 backwards compatibility:
7799	<	dnl AC_DEFUN([AC_LIB_LTDL], [])
7800	<	dnl AC_DEFUN([AC_WITH_LTDL], [])
7801	<	dnl AC_DEFUN([LT_WITH_LTDL], [])
7802	<
7803	<
7804	<	# _LTDL_SETUP
7805	<	# -----------
7806	<	# Perform all the checks necessary for compilation of the ltdl objects
7807	<	#  -- including compiler checks and header checks.  This is a public
7808	<	# interface  mainly for the benefit of libltdl's own configure.ac, most
7809	<	# other users should call LTDL_INIT instead.
7810	<	AC_DEFUN([_LTDL_SETUP],
7811	<	[AC_REQUIRE([AC_PROG_CC])dnl
7812	<	AC_REQUIRE([LT_SYS_MODULE_EXT])dnl
7813	<	AC_REQUIRE([LT_SYS_MODULE_PATH])dnl
7814	<	AC_REQUIRE([LT_SYS_DLSEARCH_PATH])dnl
7815	<	AC_REQUIRE([LT_LIB_DLLOAD])dnl
7816	<	AC_REQUIRE([LT_SYS_SYMBOL_USCORE])dnl
7817	<	AC_REQUIRE([LT_FUNC_DLSYM_USCORE])dnl
7818	<	AC_REQUIRE([LT_SYS_DLOPEN_DEPLIBS])dnl
7819	<	AC_REQUIRE([gl_FUNC_ARGZ])dnl
7820	<
7821	<	m4_require([_LT_CHECK_OBJDIR])dnl
7822	<	m4_require([_LT_HEADER_DLFCN])dnl
7823	<	m4_require([_LT_CHECK_DLPREOPEN])dnl
7824	<	m4_require([_LT_DECL_SED])dnl
7825	<
7826	<	dnl Don't require this, or it will be expanded earlier than the code
7827	<	dnl that sets the variables it relies on:
7828	<	_LT_ENABLE_INSTALL
7829	<
7830	<	dnl _LTDL_MODE specific code must be called at least once:
7831	<	_LTDL_MODE_DISPATCH
7832	<
7833	<	# In order that ltdl.c can compile, find out the first AC_CONFIG_HEADERS
7834	<	# the user used.  This is so that ltdl.h can pick up the parent projects
7835	<	# config.h file, The first file in AC_CONFIG_HEADERS must contain the
7836	<	# definitions required by ltdl.c.
7837	<	# FIXME: Remove use of undocumented AC_LIST_HEADERS (2.59 compatibility).
7838	<	AC_CONFIG_COMMANDS_PRE([dnl
7839	<	m4_pattern_allow([^LT_CONFIG_H$])dnl
7840	<	m4_ifset([AH_HEADER],
7841	<	[LT_CONFIG_H=AH_HEADER],
7842	<	[m4_ifset([AC_LIST_HEADERS],
7843	<	[LT_CONFIG_H=`echo "AC_LIST_HEADERS" | $SED 's,^[[      ]]*,,;s,[[ :]].*$,,'`],
7844	<	[])])])
7845	<	AC_SUBST([LT_CONFIG_H])
7846	<
7847	<	AC_CHECK_HEADERS([unistd.h dl.h sys/dl.h dld.h mach-o/dyld.h dirent.h],
7848	<	[], [], [AC_INCLUDES_DEFAULT])
7849	<
7850	<	AC_CHECK_FUNCS([closedir opendir readdir], [], [AC_LIBOBJ([lt__dirent])])
7851	<	AC_CHECK_FUNCS([strlcat strlcpy], [], [AC_LIBOBJ([lt__strl])])
7852	<
7853	<	AC_DEFINE_UNQUOTED([LT_LIBEXT],["$libext"],[The archive extension])
7854	<
7855	<	name=ltdl
7856	<	LTDLOPEN=`eval "\\$ECHO \"$libname_spec\""`
7857	<	AC_SUBST([LTDLOPEN])
7858	<	])# _LTDL_SETUP
7859	<
7860	<
7861	<	# _LT_ENABLE_INSTALL
7862	<	# ------------------
7863	<	m4_define([_LT_ENABLE_INSTALL],
7864	<	[AC_ARG_ENABLE([ltdl-install],
7865	<	[AS_HELP_STRING([--enable-ltdl-install], [install libltdl])])
7866	<
7867	<	case ,${enable_ltdl_install},${enable_ltdl_convenience} in
7868	<	*yes*) ;;
7869	<	*) enable_ltdl_convenience=yes ;;
7870	<	esac
7871	<
7872	<	m4_ifdef([AM_CONDITIONAL],
7873	<	[AM_CONDITIONAL(INSTALL_LTDL, test x"${enable_ltdl_install-no}" != xno)
7874	<	AM_CONDITIONAL(CONVENIENCE_LTDL, test x"${enable_ltdl_convenience-no}" != xno)])
7875	<	])# _LT_ENABLE_INSTALL
7876	<
7877	<
7878	<	# LT_SYS_DLOPEN_DEPLIBS
7879	<	# ---------------------
7880	<	AC_DEFUN([LT_SYS_DLOPEN_DEPLIBS],
7881	<	[AC_REQUIRE([AC_CANONICAL_HOST])dnl
7882	<	AC_CACHE_CHECK([whether deplibs are loaded by dlopen],
7883	<	[lt_cv_sys_dlopen_deplibs],
7884	<	[# PORTME does your system automatically load deplibs for dlopen?
7885	<	# or its logical equivalent (e.g. shl_load for HP-UX < 11)
7886	<	# For now, we just catch OSes we know something about -- in the
7887	<	# future, we'll try test this programmatically.
7888	<	lt_cv_sys_dlopen_deplibs=unknown
7889	<	case $host_os in
7890	<	aix3*|aix4.1.*|aix4.2.*)
7891	<	# Unknown whether this is true for these versions of AIX, but
7892	<	# we want this `case' here to explicitly catch those versions.
7893	<	lt_cv_sys_dlopen_deplibs=unknown
7894	<	;;
7895	<	aix[[4-9]]*)
7896	<	lt_cv_sys_dlopen_deplibs=yes
7897	<	;;
7898	<	amigaos*)
7899	<	case $host_cpu in
7900	<	powerpc)
7901	<	lt_cv_sys_dlopen_deplibs=no
7902	<	;;
7903	<	esac
7904	<	;;
7905	<	darwin*)
7906	<	# Assuming the user has installed a libdl from somewhere, this is true
7907	<	# If you are looking for one http://www.opendarwin.org/projects/dlcompat
7908	<	lt_cv_sys_dlopen_deplibs=yes
7909	<	;;
7910	<	freebsd* | dragonfly*)
7911	<	lt_cv_sys_dlopen_deplibs=yes
7912	<	;;
7913	<	gnu* | linux* | k*bsd*-gnu)
7914	<	# GNU and its variants, using gnu ld.so (Glibc)
7915	<	lt_cv_sys_dlopen_deplibs=yes
7916	<	;;
7917	<	hpux10*|hpux11*)
7918	<	lt_cv_sys_dlopen_deplibs=yes
7919	<	;;
7920	<	interix*)
7921	<	lt_cv_sys_dlopen_deplibs=yes
7922	<	;;
7923	<	irix[[12345]]*|irix6.[[01]]*)
7924	<	# Catch all versions of IRIX before 6.2, and indicate that we don't
7925	<	# know how it worked for any of those versions.
7926	<	lt_cv_sys_dlopen_deplibs=unknown
7927	<	;;
7928	<	irix*)
7929	<	# The case above catches anything before 6.2, and it's known that
7930	<	# at 6.2 and later dlopen does load deplibs.
7931	<	lt_cv_sys_dlopen_deplibs=yes
7932	<	;;
7933	<	netbsd*)
7934	<	lt_cv_sys_dlopen_deplibs=yes
7935	<	;;
7936	<	openbsd*)
7937	<	lt_cv_sys_dlopen_deplibs=yes
7938	<	;;
7939	<	osf[[1234]]*)
7940	<	# dlopen did load deplibs (at least at 4.x), but until the 5.x series,
7941	<	# it did *not* use an RPATH in a shared library to find objects the
7942	<	# library depends on, so we explicitly say `no'.
7943	<	lt_cv_sys_dlopen_deplibs=no
7944	<	;;
7945	<	osf5.0|osf5.0a|osf5.1)
7946	<	# dlopen *does* load deplibs and with the right loader patch applied
7947	<	# it even uses RPATH in a shared library to search for shared objects
7948	<	# that the library depends on, but there's no easy way to know if that
7949	<	# patch is installed.  Since this is the case, all we can really
7950	<	# say is unknown -- it depends on the patch being installed.  If
7951	<	# it is, this changes to `yes'.  Without it, it would be `no'.
7952	<	lt_cv_sys_dlopen_deplibs=unknown
7953	<	;;
7954	<	osf*)
7955	<	# the two cases above should catch all versions of osf <= 5.1.  Read
7956	<	# the comments above for what we know about them.
7957	<	# At > 5.1, deplibs are loaded *and* any RPATH in a shared library
7958	<	# is used to find them so we can finally say `yes'.
7959	<	lt_cv_sys_dlopen_deplibs=yes
7960	<	;;
7961	<	qnx*)
7962	<	lt_cv_sys_dlopen_deplibs=yes
7963	<	;;
7964	<	solaris*)
7965	<	lt_cv_sys_dlopen_deplibs=yes
7966	<	;;
7967	<	sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
7968	<	libltdl_cv_sys_dlopen_deplibs=yes
7969	<	;;
7970	<	esac
7971	<	])
7972	<	if test "$lt_cv_sys_dlopen_deplibs" != yes; then
7973	<	AC_DEFINE([LTDL_DLOPEN_DEPLIBS], [1],
7974	<	[Define if the OS needs help to load dependent libraries for dlopen().])
7975	<	fi
7976	<	])# LT_SYS_DLOPEN_DEPLIBS
7977	<
7978	<	# Old name:
7979	<	AU_ALIAS([AC_LTDL_SYS_DLOPEN_DEPLIBS], [LT_SYS_DLOPEN_DEPLIBS])
7980	<	dnl aclocal-1.4 backwards compatibility:
7981	<	dnl AC_DEFUN([AC_LTDL_SYS_DLOPEN_DEPLIBS], [])
7982	<
7983	<
7984	<	# LT_SYS_MODULE_EXT
7985	<	# -----------------
7986	<	AC_DEFUN([LT_SYS_MODULE_EXT],
7987	<	[m4_require([_LT_SYS_DYNAMIC_LINKER])dnl
7988	<	AC_CACHE_CHECK([which extension is used for runtime loadable modules],
7989	<	[libltdl_cv_shlibext],
7990	<	[
7991	<	module=yes
7992	<	eval libltdl_cv_shlibext=$shrext_cmds
7993	<	])
7994	<	if test -n "$libltdl_cv_shlibext"; then
7995	<	m4_pattern_allow([LT_MODULE_EXT])dnl
7996	<	AC_DEFINE_UNQUOTED([LT_MODULE_EXT], ["$libltdl_cv_shlibext"],
7997	<	[Define to the extension used for runtime loadable modules, say, ".so".])
7998	<	fi
7999	<	])# LT_SYS_MODULE_EXT
8000	<
8001	<	# Old name:
8002	<	AU_ALIAS([AC_LTDL_SHLIBEXT], [LT_SYS_MODULE_EXT])
8003	<	dnl aclocal-1.4 backwards compatibility:
8004	<	dnl AC_DEFUN([AC_LTDL_SHLIBEXT], [])
8005	<
8006	<
8007	<	# LT_SYS_MODULE_PATH
8008	<	# ------------------
8009	<	AC_DEFUN([LT_SYS_MODULE_PATH],
8010	<	[m4_require([_LT_SYS_DYNAMIC_LINKER])dnl
8011	<	AC_CACHE_CHECK([which variable specifies run-time module search path],
8012	<	[lt_cv_module_path_var], [lt_cv_module_path_var="$shlibpath_var"])
8013	<	if test -n "$lt_cv_module_path_var"; then
8014	<	m4_pattern_allow([LT_MODULE_PATH_VAR])dnl
8015	<	AC_DEFINE_UNQUOTED([LT_MODULE_PATH_VAR], ["$lt_cv_module_path_var"],
8016	<	[Define to the name of the environment variable that determines the run-time module search path.])
8017	<	fi
8018	<	])# LT_SYS_MODULE_PATH
8019	<
8020	<	# Old name:
8021	<	AU_ALIAS([AC_LTDL_SHLIBPATH], [LT_SYS_MODULE_PATH])
8022	<	dnl aclocal-1.4 backwards compatibility:
8023	<	dnl AC_DEFUN([AC_LTDL_SHLIBPATH], [])
8024	<
8025	<
8026	<	# LT_SYS_DLSEARCH_PATH
8027	<	# --------------------
8028	<	AC_DEFUN([LT_SYS_DLSEARCH_PATH],
8029	<	[m4_require([_LT_SYS_DYNAMIC_LINKER])dnl
8030	<	AC_CACHE_CHECK([for the default library search path],
8031	<	[lt_cv_sys_dlsearch_path],
8032	<	[lt_cv_sys_dlsearch_path="$sys_lib_dlsearch_path_spec"])
8033	<	if test -n "$lt_cv_sys_dlsearch_path"; then
8034	<	sys_dlsearch_path=
8035	<	for dir in $lt_cv_sys_dlsearch_path; do
8036	<	if test -z "$sys_dlsearch_path"; then
8037	<	sys_dlsearch_path="$dir"
8038	<	else
8039	<	sys_dlsearch_path="$sys_dlsearch_path$PATH_SEPARATOR$dir"
8040	<	fi
8041	<	done
8042	<	m4_pattern_allow([LT_DLSEARCH_PATH])dnl
8043	<	AC_DEFINE_UNQUOTED([LT_DLSEARCH_PATH], ["$sys_dlsearch_path"],
8044	<	[Define to the system default library search path.])
8045	<	fi
8046	<	])# LT_SYS_DLSEARCH_PATH
8047	<
8048	<	# Old name:
8049	<	AU_ALIAS([AC_LTDL_SYSSEARCHPATH], [LT_SYS_DLSEARCH_PATH])
8050	<	dnl aclocal-1.4 backwards compatibility:
8051	<	dnl AC_DEFUN([AC_LTDL_SYSSEARCHPATH], [])
8052	<
8053	<
8054	<	# _LT_CHECK_DLPREOPEN
8055	<	# -------------------
8056	<	m4_defun([_LT_CHECK_DLPREOPEN],
8057	<	[m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl
8058	<	AC_CACHE_CHECK([whether libtool supports -dlopen/-dlpreopen],
8059	<	[libltdl_cv_preloaded_symbols],
8060	<	[if test -n "$lt_cv_sys_global_symbol_pipe"; then
8061	<	libltdl_cv_preloaded_symbols=yes
8062	<	else
8063	<	libltdl_cv_preloaded_symbols=no
8064	<	fi
8065	<	])
8066	<	if test x"$libltdl_cv_preloaded_symbols" = xyes; then
8067	<	AC_DEFINE([HAVE_PRELOADED_SYMBOLS], [1],
8068	<	[Define if libtool can extract symbol lists from object files.])
8069	<	fi
8070	<	])# _LT_CHECK_DLPREOPEN
8071	<
8072	<
8073	<	# LT_LIB_DLLOAD
8074	<	# -------------
8075	<	AC_DEFUN([LT_LIB_DLLOAD],
8076	<	[m4_pattern_allow([^LT_DLLOADERS$])
8077	<	LT_DLLOADERS=
8078	<	AC_SUBST([LT_DLLOADERS])
8079	<
8080	<	AC_LANG_PUSH([C])
8081	<
8082	<	LIBADD_DLOPEN=
8083	<	AC_SEARCH_LIBS([dlopen], [dl],
8084	<	[AC_DEFINE([HAVE_LIBDL], [1],
8085	<	[Define if you have the libdl library or equivalent.])
8086	<	if test "$ac_cv_search_dlopen" != "none required" ; then
8087	<	LIBADD_DLOPEN="-ldl"
8088	<	fi
8089	<	libltdl_cv_lib_dl_dlopen="yes"
8090	<	LT_DLLOADERS="$LT_DLLOADERS ${lt_dlopen_dir+$lt_dlopen_dir/}dlopen.la"],
8091	<	[AC_LINK_IFELSE([AC_LANG_PROGRAM([[#if HAVE_DLFCN_H
8092	<	#  include <dlfcn.h>
8093	<	#endif
8094	<	]], [[dlopen(0, 0);]])],
8095	<	[AC_DEFINE([HAVE_LIBDL], [1],
8096	<	[Define if you have the libdl library or equivalent.])
8097	<	libltdl_cv_func_dlopen="yes"
8098	<	LT_DLLOADERS="$LT_DLLOADERS ${lt_dlopen_dir+$lt_dlopen_dir/}dlopen.la"],
8099	<	[AC_CHECK_LIB([svld], [dlopen],
8100	<	[AC_DEFINE([HAVE_LIBDL], [1],
8101	<	[Define if you have the libdl library or equivalent.])
8102	<	LIBADD_DLOPEN="-lsvld" libltdl_cv_func_dlopen="yes"
8103	<	LT_DLLOADERS="$LT_DLLOADERS ${lt_dlopen_dir+$lt_dlopen_dir/}dlopen.la"])])])
8104	<	if test x"$libltdl_cv_func_dlopen" = xyes || test x"$libltdl_cv_lib_dl_dlopen" = xyes
8105	<	then
8106	<	lt_save_LIBS="$LIBS"
8107	<	LIBS="$LIBS $LIBADD_DLOPEN"
8108	<	AC_CHECK_FUNCS([dlerror])
8109	<	LIBS="$lt_save_LIBS"
8110	<	fi
8111	<	AC_SUBST([LIBADD_DLOPEN])
8112	<
8113	<	LIBADD_SHL_LOAD=
8114	<	AC_CHECK_FUNC([shl_load],
8115	<	[AC_DEFINE([HAVE_SHL_LOAD], [1],
8116	<	[Define if you have the shl_load function.])
8117	<	LT_DLLOADERS="$LT_DLLOADERS ${lt_dlopen_dir+$lt_dlopen_dir/}shl_load.la"],
8118	<	[AC_CHECK_LIB([dld], [shl_load],
8119	<	[AC_DEFINE([HAVE_SHL_LOAD], [1],
8120	<	[Define if you have the shl_load function.])
8121	<	LT_DLLOADERS="$LT_DLLOADERS ${lt_dlopen_dir+$lt_dlopen_dir/}shl_load.la"
8122	<	LIBADD_SHL_LOAD="-ldld"])])
8123	<	AC_SUBST([LIBADD_SHL_LOAD])
8124	<
8125	<	case $host_os in
8126	<	darwin[[1567]].*)
8127	<	# We only want this for pre-Mac OS X 10.4.
8128	<	AC_CHECK_FUNC([_dyld_func_lookup],
8129	<	[AC_DEFINE([HAVE_DYLD], [1],
8130	<	[Define if you have the _dyld_func_lookup function.])
8131	<	LT_DLLOADERS="$LT_DLLOADERS ${lt_dlopen_dir+$lt_dlopen_dir/}dyld.la"])
8132	<	;;
8133	<	beos*)
8134	<	LT_DLLOADERS="$LT_DLLOADERS ${lt_dlopen_dir+$lt_dlopen_dir/}load_add_on.la"
8135	<	;;
8136	<	cygwin* | mingw* | os2* | pw32*)
8137	<	AC_CHECK_DECLS([cygwin_conv_path], [], [], [[#include <sys/cygwin.h>]])
8138	<	LT_DLLOADERS="$LT_DLLOADERS ${lt_dlopen_dir+$lt_dlopen_dir/}loadlibrary.la"
8139	<	;;
8140	<	esac
8141	<
8142	<	AC_CHECK_LIB([dld], [dld_link],
8143	<	[AC_DEFINE([HAVE_DLD], [1],
8144	<	[Define if you have the GNU dld library.])
8145	<	LT_DLLOADERS="$LT_DLLOADERS ${lt_dlopen_dir+$lt_dlopen_dir/}dld_link.la"])
8146	<	AC_SUBST([LIBADD_DLD_LINK])
8147	<
8148	<	m4_pattern_allow([^LT_DLPREOPEN$])
8149	<	LT_DLPREOPEN=
8150	<	if test -n "$LT_DLLOADERS"
8151	<	then
8152	<	for lt_loader in $LT_DLLOADERS; do
8153	<	LT_DLPREOPEN="$LT_DLPREOPEN-dlpreopen $lt_loader "
8154	<	done
8155	<	AC_DEFINE([HAVE_LIBDLLOADER], [1],
8156	<	[Define if libdlloader will be built on this platform])
8157	<	fi
8158	<	AC_SUBST([LT_DLPREOPEN])
8159	<
8160	<	dnl This isn't used anymore, but set it for backwards compatibility
8161	<	LIBADD_DL="$LIBADD_DLOPEN $LIBADD_SHL_LOAD"
8162	<	AC_SUBST([LIBADD_DL])
8163	<
8164	<	AC_LANG_POP
8165	<	])# LT_LIB_DLLOAD
8166	<
8167	<	# Old name:
8168	<	AU_ALIAS([AC_LTDL_DLLIB], [LT_LIB_DLLOAD])
8169	<	dnl aclocal-1.4 backwards compatibility:
8170	<	dnl AC_DEFUN([AC_LTDL_DLLIB], [])
8171	<
8172	<
8173	<	# LT_SYS_SYMBOL_USCORE
8174	<	# --------------------
8175	<	# does the compiler prefix global symbols with an underscore?
8176	<	AC_DEFUN([LT_SYS_SYMBOL_USCORE],
8177	<	[m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl
8178	<	AC_CACHE_CHECK([for _ prefix in compiled symbols],
8179	<	[lt_cv_sys_symbol_underscore],
8180	<	[lt_cv_sys_symbol_underscore=no
8181	<	cat > conftest.$ac_ext <<_LT_EOF
8182	<	void nm_test_func(){}
8183	<	int main(){nm_test_func;return 0;}
8184	<	_LT_EOF
8185	<	if AC_TRY_EVAL(ac_compile); then
8186	<	# Now try to grab the symbols.
8187	<	ac_nlist=conftest.nm
8188	<	if AC_TRY_EVAL(NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $ac_nlist) && test -s "$ac_nlist"; then
8189	<	# See whether the symbols have a leading underscore.
8190	<	if grep '^. _nm_test_func' "$ac_nlist" >/dev/null; then
8191	<	lt_cv_sys_symbol_underscore=yes
8192	<	else
8193	<	if grep '^. nm_test_func ' "$ac_nlist" >/dev/null; then
8194	<	:
8195	<	else
8196	<	echo "configure: cannot find nm_test_func in $ac_nlist" >&AS_MESSAGE_LOG_FD
8197	<	fi
8198	<	fi
8199	<	else
8200	<	echo "configure: cannot run $lt_cv_sys_global_symbol_pipe" >&AS_MESSAGE_LOG_FD
8201	<	fi
8202	<	else
8203	<	echo "configure: failed program was:" >&AS_MESSAGE_LOG_FD
8204	<	cat conftest.c >&AS_MESSAGE_LOG_FD
8205	<	fi
8206	<	rm -rf conftest*
8207	<	])
8208	<	sys_symbol_underscore=$lt_cv_sys_symbol_underscore
8209	<	AC_SUBST([sys_symbol_underscore])
8210	<	])# LT_SYS_SYMBOL_USCORE
8211	<
8212	<	# Old name:
8213	<	AU_ALIAS([AC_LTDL_SYMBOL_USCORE], [LT_SYS_SYMBOL_USCORE])
8214	<	dnl aclocal-1.4 backwards compatibility:
8215	<	dnl AC_DEFUN([AC_LTDL_SYMBOL_USCORE], [])
8216	<
8217	<
8218	<	# LT_FUNC_DLSYM_USCORE
8219	<	# --------------------
8220	<	AC_DEFUN([LT_FUNC_DLSYM_USCORE],
8221	<	[AC_REQUIRE([LT_SYS_SYMBOL_USCORE])dnl
8222	<	if test x"$lt_cv_sys_symbol_underscore" = xyes; then
8223	<	if test x"$libltdl_cv_func_dlopen" = xyes ||
8224	<	test x"$libltdl_cv_lib_dl_dlopen" = xyes ; then
8225	<	AC_CACHE_CHECK([whether we have to add an underscore for dlsym],
8226	<	[libltdl_cv_need_uscore],
8227	<	[libltdl_cv_need_uscore=unknown
8228	<	save_LIBS="$LIBS"
8229	<	LIBS="$LIBS $LIBADD_DLOPEN"
8230	<	_LT_TRY_DLOPEN_SELF(
8231	<	[libltdl_cv_need_uscore=no], [libltdl_cv_need_uscore=yes],
8232	<	[],                          [libltdl_cv_need_uscore=cross])
8233	<	LIBS="$save_LIBS"
8234	<	])
8235	<	fi
8236	<	fi
8237	<
8238	<	if test x"$libltdl_cv_need_uscore" = xyes; then
8239	<	AC_DEFINE([NEED_USCORE], [1],
8240	<	[Define if dlsym() requires a leading underscore in symbol names.])
8241	<	fi
8242	<	])# LT_FUNC_DLSYM_USCORE
8243	<
8244	<	# Old name:
8245	<	AU_ALIAS([AC_LTDL_DLSYM_USCORE], [LT_FUNC_DLSYM_USCORE])
8246	<	dnl aclocal-1.4 backwards compatibility:
8247	<	dnl AC_DEFUN([AC_LTDL_DLSYM_USCORE], [])
8248	<
8249	<	# Helper functions for option handling.                    -*- Autoconf -*-
8250	<	#
8251	<	#   Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
8252	<	#   Written by Gary V. Vaughan, 2004
8253	<	#
8254	<	# This file is free software; the Free Software Foundation gives
8255	<	# unlimited permission to copy and/or distribute it, with or without
8256	<	# modifications, as long as this notice is preserved.
8257	<
8258	<	# serial 6 ltoptions.m4
8259	<
8260	<	# This is to help aclocal find these macros, as it can't see m4_define.
8261	<	AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])])
8262	<
8263	<
8264	<	# _LT_MANGLE_OPTION(MACRO-NAME, OPTION-NAME)
8265	<	# ------------------------------------------
8266	<	m4_define([_LT_MANGLE_OPTION],
8267	<	[[_LT_OPTION_]m4_bpatsubst($1__$2, [[^a-zA-Z0-9_]], [_])])
8268	<
8269	<
8270	<	# _LT_SET_OPTION(MACRO-NAME, OPTION-NAME)
8271	<	# ---------------------------------------
8272	<	# Set option OPTION-NAME for macro MACRO-NAME, and if there is a
8273	<	# matching handler defined, dispatch to it.  Other OPTION-NAMEs are
8274	<	# saved as a flag.
8275	<	m4_define([_LT_SET_OPTION],
8276	<	[m4_define(_LT_MANGLE_OPTION([$1], [$2]))dnl
8277	<	m4_ifdef(_LT_MANGLE_DEFUN([$1], [$2]),
8278	<	_LT_MANGLE_DEFUN([$1], [$2]),
8279	<	[m4_warning([Unknown $1 option `$2'])])[]dnl
8280	<	])
8281	<
8282	<
8283	<	# _LT_IF_OPTION(MACRO-NAME, OPTION-NAME, IF-SET, [IF-NOT-SET])
8284	<	# ------------------------------------------------------------
8285	<	# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
8286	<	m4_define([_LT_IF_OPTION],
8287	<	[m4_ifdef(_LT_MANGLE_OPTION([$1], [$2]), [$3], [$4])])
8288	<
8289	<
8290	<	# _LT_UNLESS_OPTIONS(MACRO-NAME, OPTION-LIST, IF-NOT-SET)
8291	<	# -------------------------------------------------------
8292	<	# Execute IF-NOT-SET unless all options in OPTION-LIST for MACRO-NAME
8293	<	# are set.
8294	<	m4_define([_LT_UNLESS_OPTIONS],
8295	<	[m4_foreach([_LT_Option], m4_split(m4_normalize([$2])),
8296	<	[m4_ifdef(_LT_MANGLE_OPTION([$1], _LT_Option),
8297	<	[m4_define([$0_found])])])[]dnl
8298	<	m4_ifdef([$0_found], [m4_undefine([$0_found])], [$3
8299	<	])[]dnl
8300	<	])
8301	<
8302	<
8303	<	# _LT_SET_OPTIONS(MACRO-NAME, OPTION-LIST)
8304	<	# ----------------------------------------
8305	<	# OPTION-LIST is a space-separated list of Libtool options associated
8306	<	# with MACRO-NAME.  If any OPTION has a matching handler declared with
8307	<	# LT_OPTION_DEFINE, dispatch to that macro; otherwise complain about
8308	<	# the unknown option and exit.
8309	<	m4_defun([_LT_SET_OPTIONS],
8310	<	[# Set options
8311	<	m4_foreach([_LT_Option], m4_split(m4_normalize([$2])),
8312	<	[_LT_SET_OPTION([$1], _LT_Option)])
8313	<
8314	<	m4_if([$1],[LT_INIT],[
8315	<	dnl
8316	<	dnl Simply set some default values (i.e off) if boolean options were not
8317	<	dnl specified:
8318	<	_LT_UNLESS_OPTIONS([LT_INIT], [dlopen], [enable_dlopen=no
8319	<	])
8320	<	_LT_UNLESS_OPTIONS([LT_INIT], [win32-dll], [enable_win32_dll=no
8321	<	])
8322	<	dnl
8323	<	dnl If no reference was made to various pairs of opposing options, then
8324	<	dnl we run the default mode handler for the pair.  For example, if neither
8325	<	dnl `shared' nor `disable-shared' was passed, we enable building of shared
8326	<	dnl archives by default:
8327	<	_LT_UNLESS_OPTIONS([LT_INIT], [shared disable-shared], [_LT_ENABLE_SHARED])
8328	<	_LT_UNLESS_OPTIONS([LT_INIT], [static disable-static], [_LT_ENABLE_STATIC])
8329	<	_LT_UNLESS_OPTIONS([LT_INIT], [pic-only no-pic], [_LT_WITH_PIC])
8330	<	_LT_UNLESS_OPTIONS([LT_INIT], [fast-install disable-fast-install],
8331	<	[_LT_ENABLE_FAST_INSTALL])
8332	<	])
8333	<	])# _LT_SET_OPTIONS
8334	<
8335	<
8336	<
8337	<	# _LT_MANGLE_DEFUN(MACRO-NAME, OPTION-NAME)
8338	<	# -----------------------------------------
8339	<	m4_define([_LT_MANGLE_DEFUN],
8340	<	[[_LT_OPTION_DEFUN_]m4_bpatsubst(m4_toupper([$1__$2]), [[^A-Z0-9_]], [_])])
8341	<
8342	<
8343	<	# LT_OPTION_DEFINE(MACRO-NAME, OPTION-NAME, CODE)
8344	<	# -----------------------------------------------
8345	<	m4_define([LT_OPTION_DEFINE],
8346	<	[m4_define(_LT_MANGLE_DEFUN([$1], [$2]), [$3])[]dnl
8347	<	])# LT_OPTION_DEFINE
8348	<
8349	<
8350	<	# dlopen
8351	<	# ------
8352	<	LT_OPTION_DEFINE([LT_INIT], [dlopen], [enable_dlopen=yes
8353	<	])
8354	<
8355	<	AU_DEFUN([AC_LIBTOOL_DLOPEN],
8356	<	[_LT_SET_OPTION([LT_INIT], [dlopen])
8357	<	AC_DIAGNOSE([obsolete],
8358	<	[$0: Remove this warning and the call to _LT_SET_OPTION when you
8359	<	put the `dlopen' option into LT_INIT's first parameter.])
8360	<	])
8361	<
8362	<	dnl aclocal-1.4 backwards compatibility:
8363	<	dnl AC_DEFUN([AC_LIBTOOL_DLOPEN], [])
8364	<
8365	<
8366	<	# win32-dll
8367	<	# ---------
8368	<	# Declare package support for building win32 dll's.
8369	<	LT_OPTION_DEFINE([LT_INIT], [win32-dll],
8370	<	[enable_win32_dll=yes
8371	<
8372	<	case $host in
8373	<	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-cegcc*)
8374	<	AC_CHECK_TOOL(AS, as, false)
8375	<	AC_CHECK_TOOL(DLLTOOL, dlltool, false)
8376	<	AC_CHECK_TOOL(OBJDUMP, objdump, false)
8377	<	;;
8378	<	esac
8379	<
8380	<	test -z "$AS" && AS=as
8381	<	_LT_DECL([], [AS],      [0], [Assembler program])dnl
8382	<
8383	<	test -z "$DLLTOOL" && DLLTOOL=dlltool
8384	<	_LT_DECL([], [DLLTOOL], [0], [DLL creation program])dnl
8385	<
8386	<	test -z "$OBJDUMP" && OBJDUMP=objdump
8387	<	_LT_DECL([], [OBJDUMP], [0], [Object dumper program])dnl
8388	<	])# win32-dll
8389	<
8390	<	AU_DEFUN([AC_LIBTOOL_WIN32_DLL],
8391	<	[AC_REQUIRE([AC_CANONICAL_HOST])dnl
8392	<	_LT_SET_OPTION([LT_INIT], [win32-dll])
8393	<	AC_DIAGNOSE([obsolete],
8394	<	[$0: Remove this warning and the call to _LT_SET_OPTION when you
8395	<	put the `win32-dll' option into LT_INIT's first parameter.])
8396	<	])
8397	<
8398	<	dnl aclocal-1.4 backwards compatibility:
8399	<	dnl AC_DEFUN([AC_LIBTOOL_WIN32_DLL], [])
8400	<
8401	<
8402	<	# _LT_ENABLE_SHARED([DEFAULT])
8403	<	# ----------------------------
8404	<	# implement the --enable-shared flag, and supports the `shared' and
8405	<	# `disable-shared' LT_INIT options.
8406	<	# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
8407	<	m4_define([_LT_ENABLE_SHARED],
8408	<	[m4_define([_LT_ENABLE_SHARED_DEFAULT], [m4_if($1, no, no, yes)])dnl
8409	<	AC_ARG_ENABLE([shared],
8410	<	[AS_HELP_STRING([--enable-shared@<:@=PKGS@:>@],
8411	<	[build shared libraries @<:@default=]_LT_ENABLE_SHARED_DEFAULT[@:>@])],
8412	<	[p=${PACKAGE-default}
8413	<	case $enableval in
8414	<	yes) enable_shared=yes ;;
8415	<	no) enable_shared=no ;;
8416	<	*)
8417	<	enable_shared=no
8418	<	# Look at the argument we got.  We use all the common list separators.
8419	<	lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
8420	<	for pkg in $enableval; do
8421	<	IFS="$lt_save_ifs"
8422	<	if test "X$pkg" = "X$p"; then
8423	<	enable_shared=yes
8424	<	fi
8425	<	done
8426	<	IFS="$lt_save_ifs"
8427	<	;;
8428	<	esac],
8429	<	[enable_shared=]_LT_ENABLE_SHARED_DEFAULT)
8430	<
8431	<	_LT_DECL([build_libtool_libs], [enable_shared], [0],
8432	<	[Whether or not to build shared libraries])
8433	<	])# _LT_ENABLE_SHARED
8434	<
8435	<	LT_OPTION_DEFINE([LT_INIT], [shared], [_LT_ENABLE_SHARED([yes])])
8436	<	LT_OPTION_DEFINE([LT_INIT], [disable-shared], [_LT_ENABLE_SHARED([no])])
8437	<
8438	<	# Old names:
8439	<	AC_DEFUN([AC_ENABLE_SHARED],
8440	<	[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[shared])
8441	<	])
8442	<
8443	<	AC_DEFUN([AC_DISABLE_SHARED],
8444	<	[_LT_SET_OPTION([LT_INIT], [disable-shared])
8445	<	])
8446	<
8447	<	AU_DEFUN([AM_ENABLE_SHARED], [AC_ENABLE_SHARED($@)])
8448	<	AU_DEFUN([AM_DISABLE_SHARED], [AC_DISABLE_SHARED($@)])
8449	<
8450	<	dnl aclocal-1.4 backwards compatibility:
8451	<	dnl AC_DEFUN([AM_ENABLE_SHARED], [])
8452	<	dnl AC_DEFUN([AM_DISABLE_SHARED], [])
8453	<
8454	<
8455	<
8456	<	# _LT_ENABLE_STATIC([DEFAULT])
8457	<	# ----------------------------
8458	<	# implement the --enable-static flag, and support the `static' and
8459	<	# `disable-static' LT_INIT options.
8460	<	# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
8461	<	m4_define([_LT_ENABLE_STATIC],
8462	<	[m4_define([_LT_ENABLE_STATIC_DEFAULT], [m4_if($1, no, no, yes)])dnl
8463	<	AC_ARG_ENABLE([static],
8464	<	[AS_HELP_STRING([--enable-static@<:@=PKGS@:>@],
8465	<	[build static libraries @<:@default=]_LT_ENABLE_STATIC_DEFAULT[@:>@])],
8466	<	[p=${PACKAGE-default}
8467	<	case $enableval in
8468	<	yes) enable_static=yes ;;
8469	<	no) enable_static=no ;;
8470	<	*)
8471	<	enable_static=no
8472	<	# Look at the argument we got.  We use all the common list separators.
8473	<	lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
8474	<	for pkg in $enableval; do
8475	<	IFS="$lt_save_ifs"
8476	<	if test "X$pkg" = "X$p"; then
8477	<	enable_static=yes
8478	<	fi
8479	<	done
8480	<	IFS="$lt_save_ifs"
8481	<	;;
8482	<	esac],
8483	<	[enable_static=]_LT_ENABLE_STATIC_DEFAULT)
8484	<
8485	<	_LT_DECL([build_old_libs], [enable_static], [0],
8486	<	[Whether or not to build static libraries])
8487	<	])# _LT_ENABLE_STATIC
8488	<
8489	<	LT_OPTION_DEFINE([LT_INIT], [static], [_LT_ENABLE_STATIC([yes])])
8490	<	LT_OPTION_DEFINE([LT_INIT], [disable-static], [_LT_ENABLE_STATIC([no])])
8491	<
8492	<	# Old names:
8493	<	AC_DEFUN([AC_ENABLE_STATIC],
8494	<	[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[static])
8495	<	])
8496	<
8497	<	AC_DEFUN([AC_DISABLE_STATIC],
8498	<	[_LT_SET_OPTION([LT_INIT], [disable-static])
8499	<	])
8500	<
8501	<	AU_DEFUN([AM_ENABLE_STATIC], [AC_ENABLE_STATIC($@)])
8502	<	AU_DEFUN([AM_DISABLE_STATIC], [AC_DISABLE_STATIC($@)])
8503	<
8504	<	dnl aclocal-1.4 backwards compatibility:
8505	<	dnl AC_DEFUN([AM_ENABLE_STATIC], [])
8506	<	dnl AC_DEFUN([AM_DISABLE_STATIC], [])
8507	<
8508	<
8509	<
8510	<	# _LT_ENABLE_FAST_INSTALL([DEFAULT])
8511	<	# ----------------------------------
8512	<	# implement the --enable-fast-install flag, and support the `fast-install'
8513	<	# and `disable-fast-install' LT_INIT options.
8514	<	# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
8515	<	m4_define([_LT_ENABLE_FAST_INSTALL],
8516	<	[m4_define([_LT_ENABLE_FAST_INSTALL_DEFAULT], [m4_if($1, no, no, yes)])dnl
8517	<	AC_ARG_ENABLE([fast-install],
8518	<	[AS_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@],
8519	<	[optimize for fast installation @<:@default=]_LT_ENABLE_FAST_INSTALL_DEFAULT[@:>@])],
8520	<	[p=${PACKAGE-default}
8521	<	case $enableval in
8522	<	yes) enable_fast_install=yes ;;
8523	<	no) enable_fast_install=no ;;
8524	<	*)
8525	<	enable_fast_install=no
8526	<	# Look at the argument we got.  We use all the common list separators.
8527	<	lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
8528	<	for pkg in $enableval; do
8529	<	IFS="$lt_save_ifs"
8530	<	if test "X$pkg" = "X$p"; then
8531	<	enable_fast_install=yes
8532	<	fi
8533	<	done
8534	<	IFS="$lt_save_ifs"
8535	<	;;
8536	<	esac],
8537	<	[enable_fast_install=]_LT_ENABLE_FAST_INSTALL_DEFAULT)
8538	<
8539	<	_LT_DECL([fast_install], [enable_fast_install], [0],
8540	<	[Whether or not to optimize for fast installation])dnl
8541	<	])# _LT_ENABLE_FAST_INSTALL
8542	<
8543	<	LT_OPTION_DEFINE([LT_INIT], [fast-install], [_LT_ENABLE_FAST_INSTALL([yes])])
8544	<	LT_OPTION_DEFINE([LT_INIT], [disable-fast-install], [_LT_ENABLE_FAST_INSTALL([no])])
8545	<
8546	<	# Old names:
8547	<	AU_DEFUN([AC_ENABLE_FAST_INSTALL],
8548	<	[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[fast-install])
8549	<	AC_DIAGNOSE([obsolete],
8550	<	[$0: Remove this warning and the call to _LT_SET_OPTION when you put
8551	<	the `fast-install' option into LT_INIT's first parameter.])
8552	<	])
8553	<
8554	<	AU_DEFUN([AC_DISABLE_FAST_INSTALL],
8555	<	[_LT_SET_OPTION([LT_INIT], [disable-fast-install])
8556	<	AC_DIAGNOSE([obsolete],
8557	<	[$0: Remove this warning and the call to _LT_SET_OPTION when you put
8558	<	the `disable-fast-install' option into LT_INIT's first parameter.])
8559	<	])
8560	<
8561	<	dnl aclocal-1.4 backwards compatibility:
8562	<	dnl AC_DEFUN([AC_ENABLE_FAST_INSTALL], [])
8563	<	dnl AC_DEFUN([AM_DISABLE_FAST_INSTALL], [])
8564	<
8565	<
8566	<	# _LT_WITH_PIC([MODE])
8567	<	# --------------------
8568	<	# implement the --with-pic flag, and support the `pic-only' and `no-pic'
8569	<	# LT_INIT options.
8570	<	# MODE is either `yes' or `no'.  If omitted, it defaults to `both'.
8571	<	m4_define([_LT_WITH_PIC],
8572	<	[AC_ARG_WITH([pic],
8573	<	[AS_HELP_STRING([--with-pic],
8574	<	[try to use only PIC/non-PIC objects @<:@default=use both@:>@])],
8575	<	[pic_mode="$withval"],
8576	<	[pic_mode=default])
8577	<
8578	<	test -z "$pic_mode" && pic_mode=m4_default([$1], [default])
8579	<
8580	<	_LT_DECL([], [pic_mode], [0], [What type of objects to build])dnl
8581	<	])# _LT_WITH_PIC
8582	<
8583	<	LT_OPTION_DEFINE([LT_INIT], [pic-only], [_LT_WITH_PIC([yes])])
8584	<	LT_OPTION_DEFINE([LT_INIT], [no-pic], [_LT_WITH_PIC([no])])
8585	<
8586	<	# Old name:
8587	<	AU_DEFUN([AC_LIBTOOL_PICMODE],
8588	<	[_LT_SET_OPTION([LT_INIT], [pic-only])
8589	<	AC_DIAGNOSE([obsolete],
8590	<	[$0: Remove this warning and the call to _LT_SET_OPTION when you
8591	<	put the `pic-only' option into LT_INIT's first parameter.])
8592	<	])
8593	<
8594	<	dnl aclocal-1.4 backwards compatibility:
8595	<	dnl AC_DEFUN([AC_LIBTOOL_PICMODE], [])
8596	<
8597	<
8598	<	m4_define([_LTDL_MODE], [])
8599	<	LT_OPTION_DEFINE([LTDL_INIT], [nonrecursive],
8600	<	[m4_define([_LTDL_MODE], [nonrecursive])])
8601	<	LT_OPTION_DEFINE([LTDL_INIT], [recursive],
8602	<	[m4_define([_LTDL_MODE], [recursive])])
8603	<	LT_OPTION_DEFINE([LTDL_INIT], [subproject],
8604	<	[m4_define([_LTDL_MODE], [subproject])])
8605	<
8606	<	m4_define([_LTDL_TYPE], [])
8607	<	LT_OPTION_DEFINE([LTDL_INIT], [installable],
8608	<	[m4_define([_LTDL_TYPE], [installable])])
8609	<	LT_OPTION_DEFINE([LTDL_INIT], [convenience],
8610	<	[m4_define([_LTDL_TYPE], [convenience])])
8611	<
8612	<	# ltsugar.m4 -- libtool m4 base layer.                         -*-Autoconf-*-
8613	<	#
8614	<	# Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
8615	<	# Written by Gary V. Vaughan, 2004
8616	<	#
8617	<	# This file is free software; the Free Software Foundation gives
8618	<	# unlimited permission to copy and/or distribute it, with or without
8619	<	# modifications, as long as this notice is preserved.
8620	<
8621	<	# serial 6 ltsugar.m4
8622	<
8623	<	# This is to help aclocal find these macros, as it can't see m4_define.
8624	<	AC_DEFUN([LTSUGAR_VERSION], [m4_if([0.1])])
8625	<
8626	<
8627	<	# lt_join(SEP, ARG1, [ARG2...])
8628	<	# -----------------------------
8629	<	# Produce ARG1SEPARG2...SEPARGn, omitting [] arguments and their
8630	<	# associated separator.
8631	<	# Needed until we can rely on m4_join from Autoconf 2.62, since all earlier
8632	<	# versions in m4sugar had bugs.
8633	<	m4_define([lt_join],
8634	<	[m4_if([$#], [1], [],
8635	<	[$#], [2], [[$2]],
8636	<	[m4_if([$2], [], [], [[$2]_])$0([$1], m4_shift(m4_shift($@)))])])
8637	<	m4_define([_lt_join],
8638	<	[m4_if([$#$2], [2], [],
8639	<	[m4_if([$2], [], [], [[$1$2]])$0([$1], m4_shift(m4_shift($@)))])])
8640	<
8641	<
8642	<	# lt_car(LIST)
8643	<	# lt_cdr(LIST)
8644	<	# ------------
8645	<	# Manipulate m4 lists.
8646	<	# These macros are necessary as long as will still need to support
8647	<	# Autoconf-2.59 which quotes differently.
8648	<	m4_define([lt_car], [[$1]])
8649	<	m4_define([lt_cdr],
8650	<	[m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])],
8651	<	[$#], 1, [],
8652	<	[m4_dquote(m4_shift($@))])])
8653	<	m4_define([lt_unquote], $1)
8654	<
8655	<
8656	<	# lt_append(MACRO-NAME, STRING, [SEPARATOR])
8657	<	# ------------------------------------------
8658	<	# Redefine MACRO-NAME to hold its former content plus `SEPARATOR'`STRING'.
8659	<	# Note that neither SEPARATOR nor STRING are expanded; they are appended
8660	<	# to MACRO-NAME as is (leaving the expansion for when MACRO-NAME is invoked).
8661	<	# No SEPARATOR is output if MACRO-NAME was previously undefined (different
8662	<	# than defined and empty).
8663	<	#
8664	<	# This macro is needed until we can rely on Autoconf 2.62, since earlier
8665	<	# versions of m4sugar mistakenly expanded SEPARATOR but not STRING.
8666	<	m4_define([lt_append],
8667	<	[m4_define([$1],
8668	<	m4_ifdef([$1], [m4_defn([$1])[$3]])[$2])])
8669	<
8670	<
8671	<
8672	<	# lt_combine(SEP, PREFIX-LIST, INFIX, SUFFIX1, [SUFFIX2...])
8673	<	# ----------------------------------------------------------
8674	<	# Produce a SEP delimited list of all paired combinations of elements of
8675	<	# PREFIX-LIST with SUFFIX1 through SUFFIXn.  Each element of the list
8676	<	# has the form PREFIXmINFIXSUFFIXn.
8677	<	# Needed until we can rely on m4_combine added in Autoconf 2.62.
8678	<	m4_define([lt_combine],
8679	<	[m4_if(m4_eval([$# > 3]), [1],
8680	<	[m4_pushdef([_Lt_sep], [m4_define([_Lt_sep], m4_defn([lt_car]))])]]dnl
8681	<	[[m4_foreach([_Lt_prefix], [$2],
8682	<	[m4_foreach([_Lt_suffix],
8683	<	]m4_dquote(m4_dquote(m4_shift(m4_shift(m4_shift($@)))))[,
8684	<	[_Lt_sep([$1])[]m4_defn([_Lt_prefix])[$3]m4_defn([_Lt_suffix])])])])])
8685	<
8686	<
8687	<	# lt_if_append_uniq(MACRO-NAME, VARNAME, [SEPARATOR], [UNIQ], [NOT-UNIQ])
8688	<	# -----------------------------------------------------------------------
8689	<	# Iff MACRO-NAME does not yet contain VARNAME, then append it (delimited
8690	<	# by SEPARATOR if supplied) and expand UNIQ, else NOT-UNIQ.
8691	<	m4_define([lt_if_append_uniq],
8692	<	[m4_ifdef([$1],
8693	<	[m4_if(m4_index([$3]m4_defn([$1])[$3], [$3$2$3]), [-1],
8694	<	[lt_append([$1], [$2], [$3])$4],
8695	<	[$5])],
8696	<	[lt_append([$1], [$2], [$3])$4])])
8697	<
8698	<
8699	<	# lt_dict_add(DICT, KEY, VALUE)
8700	<	# -----------------------------
8701	<	m4_define([lt_dict_add],
8702	<	[m4_define([$1($2)], [$3])])
8703	<
8704	<
8705	<	# lt_dict_add_subkey(DICT, KEY, SUBKEY, VALUE)
8706	<	# --------------------------------------------
8707	<	m4_define([lt_dict_add_subkey],
8708	<	[m4_define([$1($2:$3)], [$4])])
8709	<
8710	<
8711	<	# lt_dict_fetch(DICT, KEY, [SUBKEY])
8712	<	# ----------------------------------
8713	<	m4_define([lt_dict_fetch],
8714	<	[m4_ifval([$3],
8715	<	m4_ifdef([$1($2:$3)], [m4_defn([$1($2:$3)])]),
8716	<	m4_ifdef([$1($2)], [m4_defn([$1($2)])]))])
8717	<
8718	<
8719	<	# lt_if_dict_fetch(DICT, KEY, [SUBKEY], VALUE, IF-TRUE, [IF-FALSE])
8720	<	# -----------------------------------------------------------------
8721	<	m4_define([lt_if_dict_fetch],
8722	<	[m4_if(lt_dict_fetch([$1], [$2], [$3]), [$4],
8723	<	[$5],
8724	<	[$6])])
8725	<
8726	<
8727	<	# lt_dict_filter(DICT, [SUBKEY], VALUE, [SEPARATOR], KEY, [...])
8728	<	# --------------------------------------------------------------
8729	<	m4_define([lt_dict_filter],
8730	<	[m4_if([$5], [], [],
8731	<	[lt_join(m4_quote(m4_default([$4], [[, ]])),
8732	<	lt_unquote(m4_split(m4_normalize(m4_foreach(_Lt_key, lt_car([m4_shiftn(4, $@)]),
8733	<	[lt_if_dict_fetch([$1], _Lt_key, [$2], [$3], [_Lt_key ])])))))])[]dnl
8734	<	])
8735	<
8736	<	# ltversion.m4 -- version numbers                       -*- Autoconf -*-
8737	<	#
8738	<	#   Copyright (C) 2004 Free Software Foundation, Inc.
8739	<	#   Written by Scott James Remnant, 2004
8740	<	#
8741	<	# This file is free software; the Free Software Foundation gives
8742	<	# unlimited permission to copy and/or distribute it, with or without
8743	<	# modifications, as long as this notice is preserved.
8744	<
8745	<	# Generated from ltversion.in.
8746	<
8747	<	# serial 3017 ltversion.m4
8748	<	# This file is part of GNU Libtool
8749	<
8750	<	m4_define([LT_PACKAGE_VERSION], [2.2.6b])
8751	<	m4_define([LT_PACKAGE_REVISION], [1.3017])
8752	<
8753	<	AC_DEFUN([LTVERSION_VERSION],
8754	<	[macro_version='2.2.6b'
8755	<	macro_revision='1.3017'
8756	<	_LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?])
8757	<	_LT_DECL(, macro_revision, 0)
8758	<	])
8759	<
8760	<	# lt~obsolete.m4 -- aclocal satisfying obsolete definitions.    -*-Autoconf-*-
8761	<	#
8762	<	#   Copyright (C) 2004, 2005, 2007 Free Software Foundation, Inc.
8763	<	#   Written by Scott James Remnant, 2004.
8764	<	#
8765	<	# This file is free software; the Free Software Foundation gives
8766	<	# unlimited permission to copy and/or distribute it, with or without
8767	<	# modifications, as long as this notice is preserved.
8768	<
8769	<	# serial 4 lt~obsolete.m4
8770	<
8771	<	# These exist entirely to fool aclocal when bootstrapping libtool.
8772	<	#
8773	<	# In the past libtool.m4 has provided macros via AC_DEFUN (or AU_DEFUN)
8774	<	# which have later been changed to m4_define as they aren't part of the
8775	<	# exported API, or moved to Autoconf or Automake where they belong.
8776	<	#
8777	<	# The trouble is, aclocal is a bit thick.  It'll see the old AC_DEFUN
8778	<	# in /usr/share/aclocal/libtool.m4 and remember it, then when it sees us
8779	<	# using a macro with the same name in our local m4/libtool.m4 it'll
8780	<	# pull the old libtool.m4 in (it doesn't see our shiny new m4_define
8781	<	# and doesn't know about Autoconf macros at all.)
8782	<	#
8783	<	# So we provide this file, which has a silly filename so it's always
8784	<	# included after everything else.  This provides aclocal with the
8785	<	# AC_DEFUNs it wants, but when m4 processes it, it doesn't do anything
8786	<	# because those macros already exist, or will be overwritten later.
8787	<	# We use AC_DEFUN over AU_DEFUN for compatibility with aclocal-1.6.
8788	<	#
8789	<	# Anytime we withdraw an AC_DEFUN or AU_DEFUN, remember to add it here.
8790	<	# Yes, that means every name once taken will need to remain here until
8791	<	# we give up compatibility with versions before 1.7, at which point
8792	<	# we need to keep only those names which we still refer to.
8793	<
8794	<	# This is to help aclocal find these macros, as it can't see m4_define.
8795	<	AC_DEFUN([LTOBSOLETE_VERSION], [m4_if([1])])
8796	<
8797	<	m4_ifndef([AC_LIBTOOL_LINKER_OPTION],   [AC_DEFUN([AC_LIBTOOL_LINKER_OPTION])])
8798	<	m4_ifndef([AC_PROG_EGREP],              [AC_DEFUN([AC_PROG_EGREP])])
8799	<	m4_ifndef([_LT_AC_PROG_ECHO_BACKSLASH], [AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH])])
8800	<	m4_ifndef([_LT_AC_SHELL_INIT],          [AC_DEFUN([_LT_AC_SHELL_INIT])])
8801	<	m4_ifndef([_LT_AC_SYS_LIBPATH_AIX],     [AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX])])
8802	<	m4_ifndef([_LT_PROG_LTMAIN],            [AC_DEFUN([_LT_PROG_LTMAIN])])
8803	<	m4_ifndef([_LT_AC_TAGVAR],              [AC_DEFUN([_LT_AC_TAGVAR])])
8804	<	m4_ifndef([AC_LTDL_ENABLE_INSTALL],     [AC_DEFUN([AC_LTDL_ENABLE_INSTALL])])
8805	<	m4_ifndef([AC_LTDL_PREOPEN],            [AC_DEFUN([AC_LTDL_PREOPEN])])
8806	<	m4_ifndef([_LT_AC_SYS_COMPILER],        [AC_DEFUN([_LT_AC_SYS_COMPILER])])
8807	<	m4_ifndef([_LT_AC_LOCK],                [AC_DEFUN([_LT_AC_LOCK])])
8808	<	m4_ifndef([AC_LIBTOOL_SYS_OLD_ARCHIVE], [AC_DEFUN([AC_LIBTOOL_SYS_OLD_ARCHIVE])])
8809	<	m4_ifndef([_LT_AC_TRY_DLOPEN_SELF],     [AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF])])
8810	<	m4_ifndef([AC_LIBTOOL_PROG_CC_C_O],     [AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O])])
8811	<	m4_ifndef([AC_LIBTOOL_SYS_HARD_LINK_LOCKS], [AC_DEFUN([AC_LIBTOOL_SYS_HARD_LINK_LOCKS])])
8812	<	m4_ifndef([AC_LIBTOOL_OBJDIR],          [AC_DEFUN([AC_LIBTOOL_OBJDIR])])
8813	<	m4_ifndef([AC_LTDL_OBJDIR],             [AC_DEFUN([AC_LTDL_OBJDIR])])
8814	<	m4_ifndef([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH], [AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH])])
8815	<	m4_ifndef([AC_LIBTOOL_SYS_LIB_STRIP],   [AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP])])
8816	<	m4_ifndef([AC_PATH_MAGIC],              [AC_DEFUN([AC_PATH_MAGIC])])
8817	<	m4_ifndef([AC_PROG_LD_GNU],             [AC_DEFUN([AC_PROG_LD_GNU])])
8818	<	m4_ifndef([AC_PROG_LD_RELOAD_FLAG],     [AC_DEFUN([AC_PROG_LD_RELOAD_FLAG])])
8819	<	m4_ifndef([AC_DEPLIBS_CHECK_METHOD],    [AC_DEFUN([AC_DEPLIBS_CHECK_METHOD])])
8820	<	m4_ifndef([AC_LIBTOOL_PROG_COMPILER_NO_RTTI], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_NO_RTTI])])
8821	<	m4_ifndef([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE], [AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE])])
8822	<	m4_ifndef([AC_LIBTOOL_PROG_COMPILER_PIC], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_PIC])])
8823	<	m4_ifndef([AC_LIBTOOL_PROG_LD_SHLIBS],  [AC_DEFUN([AC_LIBTOOL_PROG_LD_SHLIBS])])
8824	<	m4_ifndef([AC_LIBTOOL_POSTDEP_PREDEP],  [AC_DEFUN([AC_LIBTOOL_POSTDEP_PREDEP])])
8825	<	m4_ifndef([LT_AC_PROG_EGREP],           [AC_DEFUN([LT_AC_PROG_EGREP])])
8826	<	m4_ifndef([LT_AC_PROG_SED],             [AC_DEFUN([LT_AC_PROG_SED])])
8827	<	m4_ifndef([_LT_CC_BASENAME],            [AC_DEFUN([_LT_CC_BASENAME])])
8828	<	m4_ifndef([_LT_COMPILER_BOILERPLATE],   [AC_DEFUN([_LT_COMPILER_BOILERPLATE])])
8829	<	m4_ifndef([_LT_LINKER_BOILERPLATE],     [AC_DEFUN([_LT_LINKER_BOILERPLATE])])
8830	<	m4_ifndef([_AC_PROG_LIBTOOL],           [AC_DEFUN([_AC_PROG_LIBTOOL])])
8831	<	m4_ifndef([AC_LIBTOOL_SETUP],           [AC_DEFUN([AC_LIBTOOL_SETUP])])
8832	<	m4_ifndef([_LT_AC_CHECK_DLFCN],         [AC_DEFUN([_LT_AC_CHECK_DLFCN])])
8833	<	m4_ifndef([AC_LIBTOOL_SYS_DYNAMIC_LINKER],      [AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER])])
8834	<	m4_ifndef([_LT_AC_TAGCONFIG],           [AC_DEFUN([_LT_AC_TAGCONFIG])])
8835	<	m4_ifndef([AC_DISABLE_FAST_INSTALL],    [AC_DEFUN([AC_DISABLE_FAST_INSTALL])])
8836	<	m4_ifndef([_LT_AC_LANG_CXX],            [AC_DEFUN([_LT_AC_LANG_CXX])])
8837	<	m4_ifndef([_LT_AC_LANG_F77],            [AC_DEFUN([_LT_AC_LANG_F77])])
8838	<	m4_ifndef([_LT_AC_LANG_GCJ],            [AC_DEFUN([_LT_AC_LANG_GCJ])])
8839	<	m4_ifndef([AC_LIBTOOL_RC],              [AC_DEFUN([AC_LIBTOOL_RC])])
8840	<	m4_ifndef([AC_LIBTOOL_LANG_C_CONFIG],   [AC_DEFUN([AC_LIBTOOL_LANG_C_CONFIG])])
8841	<	m4_ifndef([_LT_AC_LANG_C_CONFIG],       [AC_DEFUN([_LT_AC_LANG_C_CONFIG])])
8842	<	m4_ifndef([AC_LIBTOOL_LANG_CXX_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_CXX_CONFIG])])
8843	<	m4_ifndef([_LT_AC_LANG_CXX_CONFIG],     [AC_DEFUN([_LT_AC_LANG_CXX_CONFIG])])
8844	<	m4_ifndef([AC_LIBTOOL_LANG_F77_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_F77_CONFIG])])
8845	<	m4_ifndef([_LT_AC_LANG_F77_CONFIG],     [AC_DEFUN([_LT_AC_LANG_F77_CONFIG])])
8846	<	m4_ifndef([AC_LIBTOOL_LANG_GCJ_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_GCJ_CONFIG])])
8847	<	m4_ifndef([_LT_AC_LANG_GCJ_CONFIG],     [AC_DEFUN([_LT_AC_LANG_GCJ_CONFIG])])
8848	<	m4_ifndef([AC_LIBTOOL_LANG_RC_CONFIG],  [AC_DEFUN([AC_LIBTOOL_LANG_RC_CONFIG])])
8849	<	m4_ifndef([_LT_AC_LANG_RC_CONFIG],      [AC_DEFUN([_LT_AC_LANG_RC_CONFIG])])
8850	<	m4_ifndef([AC_LIBTOOL_CONFIG],          [AC_DEFUN([AC_LIBTOOL_CONFIG])])
8851	<	m4_ifndef([_LT_AC_FILE_LTDLL_C],        [AC_DEFUN([_LT_AC_FILE_LTDLL_C])])
8852	<
8853	<	# Copyright (C) 2002, 2003, 2005, 2006, 2007, 2008  Free Software Foundation, Inc.
23	>	# Copyright (C) 2002-2014 Free Software Foundation, Inc.
24		#
25		# This file is free software; the Free Software Foundation
26		# gives unlimited permission to copy and/or distribute it,
#	Line 8862 | Line 32 | m4_ifndef([_LT_AC_FILE_LTDLL_C],       [AC_DEF
32		# generated from the m4 files accompanying Automake X.Y.
33		# (This private macro should not be called outside this file.)
34		AC_DEFUN([AM_AUTOMAKE_VERSION],
35	<	[am__api_version='1.11'
35	>	[am__api_version='1.15'
36		dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to
37		dnl require some minimum version.  Point them to the right macro.
38	<	m4_if([$1], [1.11.1], [],
38	>	m4_if([$1], [1.15], [],
39		[AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl
40		])
41
#	Line 8881 | Line 51 | m4_define([_AM_AUTOCONF_VERSION], [])
51		# Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced.
52		# This function is AC_REQUIREd by AM_INIT_AUTOMAKE.
53		AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],
54	<	[AM_AUTOMAKE_VERSION([1.11.1])dnl
54	>	[AM_AUTOMAKE_VERSION([1.15])dnl
55		m4_ifndef([AC_AUTOCONF_VERSION],
56		[m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
57		_AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))])
58
59		# AM_AUX_DIR_EXPAND                                         -*- Autoconf -*-
60
61	<	# Copyright (C) 2001, 2003, 2005  Free Software Foundation, Inc.
61	>	# Copyright (C) 2001-2014 Free Software Foundation, Inc.
62		#
63		# This file is free software; the Free Software Foundation
64		# gives unlimited permission to copy and/or distribute it,
65		# with or without modifications, as long as this notice is preserved.
66
67		# For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets
68	<	# $ac_aux_dir to `$srcdir/foo'.  In other projects, it is set to
69	<	# `$srcdir', `$srcdir/..', or `$srcdir/../..'.
68	>	# $ac_aux_dir to '$srcdir/foo'.  In other projects, it is set to
69	>	# '$srcdir', '$srcdir/..', or '$srcdir/../..'.
70		#
71		# Of course, Automake must honor this variable whenever it calls a
72		# tool from the auxiliary directory.  The problem is that $srcdir (and
#	Line 8915 | Line 85 | _AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCON
85		#
86		# The reason of the latter failure is that $top_srcdir and $ac_aux_dir
87		# are both prefixed by $srcdir.  In an in-source build this is usually
88	<	# harmless because $srcdir is `.', but things will broke when you
88	>	# harmless because $srcdir is '.', but things will broke when you
89		# start a VPATH build or use an absolute $srcdir.
90		#
91		# So we could use something similar to $top_srcdir/$ac_aux_dir/missing,
#	Line 8933 | Line 103 | _AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCON
103		# configured tree to be moved without reconfiguration.
104
105		AC_DEFUN([AM_AUX_DIR_EXPAND],
106	<	[dnl Rely on autoconf to set up CDPATH properly.
107	<	AC_PREREQ([2.50])dnl
108	<	# expand $ac_aux_dir to an absolute path
8939	<	am_aux_dir=`cd $ac_aux_dir && pwd`
106	>	[AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
107	>	# Expand $ac_aux_dir to an absolute path.
108	>	am_aux_dir=`cd "$ac_aux_dir" && pwd`
109		])
110
111		# AM_CONDITIONAL                                            -*- Autoconf -*-
112
113	<	# Copyright (C) 1997, 2000, 2001, 2003, 2004, 2005, 2006, 2008
8945	<	# Free Software Foundation, Inc.
113	>	# Copyright (C) 1997-2014 Free Software Foundation, Inc.
114		#
115		# This file is free software; the Free Software Foundation
116		# gives unlimited permission to copy and/or distribute it,
117		# with or without modifications, as long as this notice is preserved.
118
8951	–	# serial 9
8952	–
119		# AM_CONDITIONAL(NAME, SHELL-CONDITION)
120		# -------------------------------------
121		# Define a conditional.
122		AC_DEFUN([AM_CONDITIONAL],
123	<	[AC_PREREQ(2.52)dnl
124	<	ifelse([$1], [TRUE],  [AC_FATAL([$0: invalid condition: $1])],
125	<	[$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl
123	>	[AC_PREREQ([2.52])dnl
124	>	m4_if([$1], [TRUE],  [AC_FATAL([$0: invalid condition: $1])],
125	>	[$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl
126		AC_SUBST([$1_TRUE])dnl
127		AC_SUBST([$1_FALSE])dnl
128		_AM_SUBST_NOTMAKE([$1_TRUE])dnl
#	Line 8975 | Line 141 | AC_CONFIG_COMMANDS_PRE(
141		Usually this means the macro was only invoked conditionally.]])
142		fi])])
143
144	<	# Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2009
8979	<	# Free Software Foundation, Inc.
144	>	# Copyright (C) 1999-2014 Free Software Foundation, Inc.
145		#
146		# This file is free software; the Free Software Foundation
147		# gives unlimited permission to copy and/or distribute it,
148		# with or without modifications, as long as this notice is preserved.
149
8985	–	# serial 10
150
151	<	# There are a few dirty hacks below to avoid letting `AC_PROG_CC' be
151	>	# There are a few dirty hacks below to avoid letting 'AC_PROG_CC' be
152		# written in clear, in which case automake, when reading aclocal.m4,
153		# will think it sees a *use*, and therefore will trigger all it's
154		# C support machinery.  Also note that it means that autoscan, seeing
#	Line 8994 | Line 158 | fi])])
158		# _AM_DEPENDENCIES(NAME)
159		# ----------------------
160		# See how the compiler implements dependency checking.
161	<	# NAME is "CC", "CXX", "GCJ", or "OBJC".
161	>	# NAME is "CC", "CXX", "OBJC", "OBJCXX", "UPC", or "GJC".
162		# We try a few techniques and use that to set a single cache variable.
163		#
164		# We don't AC_REQUIRE the corresponding AC_PROG_CC since the latter was
#	Line 9007 | Line 171 | AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMAND
171		AC_REQUIRE([AM_MAKE_INCLUDE])dnl
172		AC_REQUIRE([AM_DEP_TRACK])dnl
173
174	<	ifelse([$1], CC,   [depcc="$CC"   am_compiler_list=],
175	<	[$1], CXX,  [depcc="$CXX"  am_compiler_list=],
176	<	[$1], OBJC, [depcc="$OBJC" am_compiler_list='gcc3 gcc'],
177	<	[$1], UPC,  [depcc="$UPC"  am_compiler_list=],
178	<	[$1], GCJ,  [depcc="$GCJ"  am_compiler_list='gcc3 gcc'],
179	<	[depcc="$$1"   am_compiler_list=])
174	>	m4_if([$1], [CC],   [depcc="$CC"   am_compiler_list=],
175	>	[$1], [CXX],  [depcc="$CXX"  am_compiler_list=],
176	>	[$1], [OBJC], [depcc="$OBJC" am_compiler_list='gcc3 gcc'],
177	>	[$1], [OBJCXX], [depcc="$OBJCXX" am_compiler_list='gcc3 gcc'],
178	>	[$1], [UPC],  [depcc="$UPC"  am_compiler_list=],
179	>	[$1], [GCJ],  [depcc="$GCJ"  am_compiler_list='gcc3 gcc'],
180	>	[depcc="$$1"   am_compiler_list=])
181
182		AC_CACHE_CHECK([dependency style of $depcc],
183		[am_cv_$1_dependencies_compiler_type],
#	Line 9020 | Line 185 | AC_CACHE_CHECK([dependency style of $dep
185		# We make a subdir and do the tests there.  Otherwise we can end up
186		# making bogus files that we don't know about and never remove.  For
187		# instance it was reported that on HP-UX the gcc test will end up
188	<	# making a dummy file named `D' -- because `-MD' means `put the output
189	<	# in D'.
188	>	# making a dummy file named 'D' -- because '-MD' means "put the output
189	>	# in D".
190	>	rm -rf conftest.dir
191		mkdir conftest.dir
192		# Copy depcomp to subdir because otherwise we won't find it if we're
193		# using a relative directory.
#	Line 9060 | Line 226 | AC_CACHE_CHECK([dependency style of $dep
226		: > sub/conftest.c
227		for i in 1 2 3 4 5 6; do
228		echo '#include "conftst'$i'.h"' >> sub/conftest.c
229	<	# Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
230	<	# Solaris 8's {/usr,}/bin/sh.
231	<	touch sub/conftst$i.h
229	>	# Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
230	>	# Solaris 10 /bin/sh.
231	>	echo '/* dummy */' > sub/conftst$i.h
232		done
233		echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
234
235	<	# We check with `-c' and `-o' for the sake of the "dashmstdout"
235	>	# We check with '-c' and '-o' for the sake of the "dashmstdout"
236		# mode.  It turns out that the SunPro C++ compiler does not properly
237	<	# handle `-M -o', and we need to detect this.  Also, some Intel
238	<	# versions had trouble with output in subdirs
237	>	# handle '-M -o', and we need to detect this.  Also, some Intel
238	>	# versions had trouble with output in subdirs.
239		am__obj=sub/conftest.${OBJEXT-o}
240		am__minus_obj="-o $am__obj"
241		case $depmode in
#	Line 9078 | Line 244 | AC_CACHE_CHECK([dependency style of $dep
244		test "$am__universal" = false || continue
245		;;
246		nosideeffect)
247	<	# after this tag, mechanisms are not by side-effect, so they'll
248	<	# only be used when explicitly requested
247	>	# After this tag, mechanisms are not by side-effect, so they'll
248	>	# only be used when explicitly requested.
249		if test "x$enable_dependency_tracking" = xyes; then
250		continue
251		else
252		break
253		fi
254		;;
255	<	msvisualcpp | msvcmsys)
256	<	# This compiler won't grok `-c -o', but also, the minuso test has
255	>	msvc7 | msvc7msys | msvisualcpp | msvcmsys)
256	>	# This compiler won't grok '-c -o', but also, the minuso test has
257		# not run yet.  These depmodes are late enough in the game, and
258		# so weak that their functioning should not be impacted.
259		am__obj=conftest.${OBJEXT-o}
#	Line 9135 | Line 301 | AM_CONDITIONAL([am__fastdep$1], [
301		# AM_SET_DEPDIR
302		# -------------
303		# Choose a directory name for dependency files.
304	<	# This macro is AC_REQUIREd in _AM_DEPENDENCIES
304	>	# This macro is AC_REQUIREd in _AM_DEPENDENCIES.
305		AC_DEFUN([AM_SET_DEPDIR],
306		[AC_REQUIRE([AM_SET_LEADING_DOT])dnl
307		AC_SUBST([DEPDIR], ["${am__leading_dot}deps"])dnl
#	Line 9145 | Line 311 | AC_SUBST([DEPDIR], ["${am__leading_dot}d
311		# AM_DEP_TRACK
312		# ------------
313		AC_DEFUN([AM_DEP_TRACK],
314	<	[AC_ARG_ENABLE(dependency-tracking,
315	<	[  --disable-dependency-tracking  speeds up one-time build
316	<	--enable-dependency-tracking   do not reject slow dependency extractors])
314	>	[AC_ARG_ENABLE([dependency-tracking], [dnl
315	>	AS_HELP_STRING(
316	>	[--enable-dependency-tracking],
317	>	[do not reject slow dependency extractors])
318	>	AS_HELP_STRING(
319	>	[--disable-dependency-tracking],
320	>	[speeds up one-time build])])
321		if test "x$enable_dependency_tracking" != xno; then
322		am_depcomp="$ac_aux_dir/depcomp"
323		AMDEPBACKSLASH='\'
324	+	am__nodep='_no'
325		fi
326		AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno])
327		AC_SUBST([AMDEPBACKSLASH])dnl
328		_AM_SUBST_NOTMAKE([AMDEPBACKSLASH])dnl
329	+	AC_SUBST([am__nodep])dnl
330	+	_AM_SUBST_NOTMAKE([am__nodep])dnl
331		])
332
333		# Generate code to set up dependency tracking.              -*- Autoconf -*-
334
335	<	# Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2008
9163	<	# Free Software Foundation, Inc.
335	>	# Copyright (C) 1999-2014 Free Software Foundation, Inc.
336		#
337		# This file is free software; the Free Software Foundation
338		# gives unlimited permission to copy and/or distribute it,
339		# with or without modifications, as long as this notice is preserved.
340
9169	–	#serial 5
341
342		# _AM_OUTPUT_DEPENDENCY_COMMANDS
343		# ------------------------------
344		AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS],
345		[{
346	<	# Autoconf 2.62 quotes --file arguments for eval, but not when files
346	>	# Older Autoconf quotes --file arguments for eval, but not when files
347		# are listed without --file.  Let's play safe and only enable the eval
348		# if we detect the quoting.
349		case $CONFIG_FILES in
#	Line 9185 | Line 356 | AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS
356		# Strip MF so we end up with the name of the file.
357		mf=`echo "$mf" | sed -e 's/:.*$//'`
358		# Check whether this is an Automake generated Makefile or not.
359	<	# We used to match only the files named `Makefile.in', but
359	>	# We used to match only the files named 'Makefile.in', but
360		# some people rename them; so instead we look at the file content.
361		# Grep'ing the first line is not enough: some people post-process
362		# each Makefile.in and add a new line on top of each file to say so.
#	Line 9197 | Line 368 | AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS
368		continue
369		fi
370		# Extract the definition of DEPDIR, am__include, and am__quote
371	<	# from the Makefile without running `make'.
371	>	# from the Makefile without running 'make'.
372		DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
373		test -z "$DEPDIR" && continue
374		am__include=`sed -n 's/^am__include = //p' < "$mf"`
375	<	test -z "am__include" && continue
375	>	test -z "$am__include" && continue
376		am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
9206	–	# When using ansi2knr, U may be empty or an underscore; expand it
9207	–	U=`sed -n 's/^U = //p' < "$mf"`
377		# Find all dependency output files, they are included files with
378		# $(DEPDIR) in their names.  We invoke sed twice because it is the
379		# simplest approach to changing $(DEPDIR) to its actual value in the
380		# expansion.
381		for file in `sed -n "
382		s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
383	<	sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do
383	>	sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do
384		# Make sure the directory exists.
385		test -f "$dirpart/$file" && continue
386		fdir=`AS_DIRNAME(["$file"])`
#	Line 9229 | Line 398 | AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS
398		# This macro should only be invoked once -- use via AC_REQUIRE.
399		#
400		# This code is only required when automatic dependency tracking
401	<	# is enabled.  FIXME.  This creates each `.P' file that we will
401	>	# is enabled.  FIXME.  This creates each '.P' file that we will
402		# need in order to bootstrap the dependency handling code.
403		AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS],
404		[AC_CONFIG_COMMANDS([depfiles],
#	Line 9239 | Line 408 | AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS]
408
409		# Do all the work for Automake.                             -*- Autoconf -*-
410
411	<	# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
9243	<	# 2005, 2006, 2008, 2009 Free Software Foundation, Inc.
411	>	# Copyright (C) 1996-2014 Free Software Foundation, Inc.
412		#
413		# This file is free software; the Free Software Foundation
414		# gives unlimited permission to copy and/or distribute it,
415		# with or without modifications, as long as this notice is preserved.
416
9249	–	# serial 16
9250	–
417		# This macro actually does too much.  Some checks are only needed if
418		# your package does certain things.  But this isn't really a big deal.
419
420	+	dnl Redefine AC_PROG_CC to automatically invoke _AM_PROG_CC_C_O.
421	+	m4_define([AC_PROG_CC],
422	+	m4_defn([AC_PROG_CC])
423	+	[_AM_PROG_CC_C_O
424	+	])
425	+
426		# AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE])
427		# AM_INIT_AUTOMAKE([OPTIONS])
428		# -----------------------------------------------
#	Line 9263 | Line 435 | AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS]
435		# arguments mandatory, and then we can depend on a new Autoconf
436		# release and drop the old call support.
437		AC_DEFUN([AM_INIT_AUTOMAKE],
438	<	[AC_PREREQ([2.62])dnl
438	>	[AC_PREREQ([2.65])dnl
439		dnl Autoconf wants to disallow AM_ names.  We explicitly allow
440		dnl the ones we care about.
441		m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl
#	Line 9292 | Line 464 | AC_SUBST([CYGPATH_W])
464		# Define the identity of the package.
465		dnl Distinguish between old-style and new-style calls.
466		m4_ifval([$2],
467	<	[m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl
467	>	[AC_DIAGNOSE([obsolete],
468	>	[$0: two- and three-arguments forms are deprecated.])
469	>	m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl
470		AC_SUBST([PACKAGE], [$1])dnl
471		AC_SUBST([VERSION], [$2])],
472		[_AM_SET_OPTIONS([$1])dnl
473		dnl Diagnose old-style AC_INIT with new-style AM_AUTOMAKE_INIT.
474	<	m4_if(m4_ifdef([AC_PACKAGE_NAME], 1)m4_ifdef([AC_PACKAGE_VERSION], 1), 11,,
474	>	m4_if(
475	>	m4_ifdef([AC_PACKAGE_NAME], [ok]):m4_ifdef([AC_PACKAGE_VERSION], [ok]),
476	>	[ok:ok],,
477		[m4_fatal([AC_INIT should be called with package and version arguments])])dnl
478		AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl
479		AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl
480
481		_AM_IF_OPTION([no-define],,
482	<	[AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of package])
483	<	AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version number of package])])dnl
482	>	[AC_DEFINE_UNQUOTED([PACKAGE], ["$PACKAGE"], [Name of package])
483	>	AC_DEFINE_UNQUOTED([VERSION], ["$VERSION"], [Version number of package])])dnl
484
485		# Some tools Automake needs.
486		AC_REQUIRE([AM_SANITY_CHECK])dnl
487		AC_REQUIRE([AC_ARG_PROGRAM])dnl
488	<	AM_MISSING_PROG(ACLOCAL, aclocal-${am__api_version})
489	<	AM_MISSING_PROG(AUTOCONF, autoconf)
490	<	AM_MISSING_PROG(AUTOMAKE, automake-${am__api_version})
491	<	AM_MISSING_PROG(AUTOHEADER, autoheader)
492	<	AM_MISSING_PROG(MAKEINFO, makeinfo)
488	>	AM_MISSING_PROG([ACLOCAL], [aclocal-${am__api_version}])
489	>	AM_MISSING_PROG([AUTOCONF], [autoconf])
490	>	AM_MISSING_PROG([AUTOMAKE], [automake-${am__api_version}])
491	>	AM_MISSING_PROG([AUTOHEADER], [autoheader])
492	>	AM_MISSING_PROG([MAKEINFO], [makeinfo])
493		AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
494		AC_REQUIRE([AM_PROG_INSTALL_STRIP])dnl
495	<	AC_REQUIRE([AM_PROG_MKDIR_P])dnl
496	<	# We need awk for the "check" target.  The system "awk" is bad on
497	<	# some platforms.
495	>	AC_REQUIRE([AC_PROG_MKDIR_P])dnl
496	>	# For better backward compatibility.  To be removed once Automake 1.9.x
497	>	# dies out for good.  For more background, see:
498	>	# <http://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
499	>	# <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
500	>	AC_SUBST([mkdir_p], ['$(MKDIR_P)'])
501	>	# We need awk for the "check" target (and possibly the TAP driver).  The
502	>	# system "awk" is bad on some platforms.
503		AC_REQUIRE([AC_PROG_AWK])dnl
504		AC_REQUIRE([AC_PROG_MAKE_SET])dnl
505		AC_REQUIRE([AM_SET_LEADING_DOT])dnl
#	Line 9327 | Line 508 | _AM_IF_OPTION([tar-ustar], [_AM_PROG_TAR
508		[_AM_PROG_TAR([v7])])])
509		_AM_IF_OPTION([no-dependencies],,
510		[AC_PROVIDE_IFELSE([AC_PROG_CC],
511	<	[_AM_DEPENDENCIES(CC)],
512	<	[define([AC_PROG_CC],
513	<	defn([AC_PROG_CC])[_AM_DEPENDENCIES(CC)])])dnl
511	>	[_AM_DEPENDENCIES([CC])],
512	>	[m4_define([AC_PROG_CC],
513	>	m4_defn([AC_PROG_CC])[_AM_DEPENDENCIES([CC])])])dnl
514		AC_PROVIDE_IFELSE([AC_PROG_CXX],
515	<	[_AM_DEPENDENCIES(CXX)],
516	<	[define([AC_PROG_CXX],
517	<	defn([AC_PROG_CXX])[_AM_DEPENDENCIES(CXX)])])dnl
515	>	[_AM_DEPENDENCIES([CXX])],
516	>	[m4_define([AC_PROG_CXX],
517	>	m4_defn([AC_PROG_CXX])[_AM_DEPENDENCIES([CXX])])])dnl
518		AC_PROVIDE_IFELSE([AC_PROG_OBJC],
519	<	[_AM_DEPENDENCIES(OBJC)],
520	<	[define([AC_PROG_OBJC],
521	<	defn([AC_PROG_OBJC])[_AM_DEPENDENCIES(OBJC)])])dnl
522	<	])
523	<	_AM_IF_OPTION([silent-rules], [AC_REQUIRE([AM_SILENT_RULES])])dnl
524	<	dnl The `parallel-tests' driver may need to know about EXEEXT, so add the
525	<	dnl `am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen.  This macro
526	<	dnl is hooked onto _AC_COMPILER_EXEEXT early, see below.
519	>	[_AM_DEPENDENCIES([OBJC])],
520	>	[m4_define([AC_PROG_OBJC],
521	>	m4_defn([AC_PROG_OBJC])[_AM_DEPENDENCIES([OBJC])])])dnl
522	>	AC_PROVIDE_IFELSE([AC_PROG_OBJCXX],
523	>	[_AM_DEPENDENCIES([OBJCXX])],
524	>	[m4_define([AC_PROG_OBJCXX],
525	>	m4_defn([AC_PROG_OBJCXX])[_AM_DEPENDENCIES([OBJCXX])])])dnl
526	>	])
527	>	AC_REQUIRE([AM_SILENT_RULES])dnl
528	>	dnl The testsuite driver may need to know about EXEEXT, so add the
529	>	dnl 'am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen.  This
530	>	dnl macro is hooked onto _AC_COMPILER_EXEEXT early, see below.
531		AC_CONFIG_COMMANDS_PRE(dnl
532		[m4_provide_if([_AM_COMPILER_EXEEXT],
533		[AM_CONDITIONAL([am__EXEEXT], [test -n "$EXEEXT"])])])dnl
534	+
535	+	# POSIX will say in a future version that running "rm -f" with no argument
536	+	# is OK; and we want to be able to make that assumption in our Makefile
537	+	# recipes.  So use an aggressive probe to check that the usage we want is
538	+	# actually supported "in the wild" to an acceptable degree.
539	+	# See automake bug#10828.
540	+	# To make any issue more visible, cause the running configure to be aborted
541	+	# by default if the 'rm' program in use doesn't match our expectations; the
542	+	# user can still override this though.
543	+	if rm -f && rm -fr && rm -rf; then : OK; else
544	+	cat >&2 <<'END'
545	+	Oops!
546	+
547	+	Your 'rm' program seems unable to run without file operands specified
548	+	on the command line, even when the '-f' option is present.  This is contrary
549	+	to the behaviour of most rm programs out there, and not conforming with
550	+	the upcoming POSIX standard: <http://austingroupbugs.net/view.php?id=542>
551	+
552	+	Please tell bug-automake@gnu.org about your system, including the value
553	+	of your $PATH and any error possibly output before this message.  This
554	+	can help us improve future automake versions.
555	+
556	+	END
557	+	if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then
558	+	echo 'Configuration will proceed anyway, since you have set the' >&2
559	+	echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2
560	+	echo >&2
561	+	else
562	+	cat >&2 <<'END'
563	+	Aborting the configuration process, to ensure you take notice of the issue.
564	+
565	+	You can download and install GNU coreutils to get an 'rm' implementation
566	+	that behaves properly: <http://www.gnu.org/software/coreutils/>.
567	+
568	+	If you want to complete the configuration process using your problematic
569	+	'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
570	+	to "yes", and re-run configure.
571	+
572	+	END
573	+	AC_MSG_ERROR([Your 'rm' program is bad, sorry.])
574	+	fi
575	+	fi
576	+	dnl The trailing newline in this macro's definition is deliberate, for
577	+	dnl backward compatibility and to allow trailing 'dnl'-style comments
578	+	dnl after the AM_INIT_AUTOMAKE invocation. See automake bug#16841.
579		])
580
581	<	dnl Hook into `_AC_COMPILER_EXEEXT' early to learn its expansion.  Do not
581	>	dnl Hook into '_AC_COMPILER_EXEEXT' early to learn its expansion.  Do not
582		dnl add the conditional right here, as _AC_COMPILER_EXEEXT may be further
583		dnl mangled by Autoconf and run in a shell conditional statement.
584		m4_define([_AC_COMPILER_EXEEXT],
585		m4_defn([_AC_COMPILER_EXEEXT])[m4_provide([_AM_COMPILER_EXEEXT])])
586
9357	–
587		# When config.status generates a header, we must update the stamp-h file.
588		# This file resides in the same directory as the config header
589		# that is generated.  The stamp files are numbered to have different names.
#	Line 9376 | Line 605 | for _am_header in $config_headers :; do
605		done
606		echo "timestamp for $_am_arg" >`AS_DIRNAME(["$_am_arg"])`/stamp-h[]$_am_stamp_count])
607
608	<	# Copyright (C) 2001, 2003, 2005, 2008  Free Software Foundation, Inc.
608	>	# Copyright (C) 2001-2014 Free Software Foundation, Inc.
609		#
610		# This file is free software; the Free Software Foundation
611		# gives unlimited permission to copy and/or distribute it,
#	Line 9387 | Line 616 | echo "timestamp for $_am_arg" >`AS_DIRNA
616		# Define $install_sh.
617		AC_DEFUN([AM_PROG_INSTALL_SH],
618		[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
619	<	if test x"${install_sh}" != xset; then
619	>	if test x"${install_sh+set}" != xset; then
620		case $am_aux_dir in
621		*\ * | *\     *)
622		install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
#	Line 9395 | Line 624 | if test x"${install_sh}" != xset; then
624		install_sh="\${SHELL} $am_aux_dir/install-sh"
625		esac
626		fi
627	<	AC_SUBST(install_sh)])
627	>	AC_SUBST([install_sh])])
628
629	<	# Copyright (C) 2003, 2005  Free Software Foundation, Inc.
629	>	# Copyright (C) 2003-2014 Free Software Foundation, Inc.
630		#
631		# This file is free software; the Free Software Foundation
632		# gives unlimited permission to copy and/or distribute it,
633		# with or without modifications, as long as this notice is preserved.
634
9406	–	# serial 2
9407	–
635		# Check whether the underlying file-system supports filenames
636		# with a leading dot.  For instance MS-DOS doesn't.
637		AC_DEFUN([AM_SET_LEADING_DOT],
#	Line 9418 | Line 645 | fi
645		rmdir .tst 2>/dev/null
646		AC_SUBST([am__leading_dot])])
647
648	<	# Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2005
9422	<	# Free Software Foundation, Inc.
648	>	# Copyright (C) 1998-2014 Free Software Foundation, Inc.
649		#
650		# This file is free software; the Free Software Foundation
651		# gives unlimited permission to copy and/or distribute it,
652		# with or without modifications, as long as this notice is preserved.
653
9428	–	# serial 5
9429	–
654		# AM_PROG_LEX
655		# -----------
656		# Autoconf leaves LEX=: if lex or flex can't be found.  Change that to a
657		# "missing" invocation, for better error output.
658		AC_DEFUN([AM_PROG_LEX],
659	<	[AC_PREREQ(2.50)dnl
659	>	[AC_PREREQ([2.50])dnl
660		AC_REQUIRE([AM_MISSING_HAS_RUN])dnl
661		AC_REQUIRE([AC_PROG_LEX])dnl
662		if test "$LEX" = :; then
#	Line 9442 | Line 666 | fi])
666		# Add --enable-maintainer-mode option to configure.         -*- Autoconf -*-
667		# From Jim Meyering
668
669	<	# Copyright (C) 1996, 1998, 2000, 2001, 2002, 2003, 2004, 2005, 2008
9446	<	# Free Software Foundation, Inc.
669	>	# Copyright (C) 1996-2014 Free Software Foundation, Inc.
670		#
671		# This file is free software; the Free Software Foundation
672		# gives unlimited permission to copy and/or distribute it,
673		# with or without modifications, as long as this notice is preserved.
674
9452	–	# serial 5
9453	–
675		# AM_MAINTAINER_MODE([DEFAULT-MODE])
676		# ----------------------------------
677		# Control maintainer-specific portions of Makefiles.
678	<	# Default is to disable them, unless `enable' is passed literally.
679	<	# For symmetry, `disable' may be passed as well.  Anyway, the user
678	>	# Default is to disable them, unless 'enable' is passed literally.
679	>	# For symmetry, 'disable' may be passed as well.  Anyway, the user
680		# can override the default with the --enable/--disable switch.
681		AC_DEFUN([AM_MAINTAINER_MODE],
682		[m4_case(m4_default([$1], [disable]),
#	Line 9463 | Line 684 | AC_DEFUN([AM_MAINTAINER_MODE],
684		[disable], [m4_define([am_maintainer_other], [enable])],
685		[m4_define([am_maintainer_other], [enable])
686		m4_warn([syntax], [unexpected argument to AM@&t@_MAINTAINER_MODE: $1])])
687	<	AC_MSG_CHECKING([whether to am_maintainer_other maintainer-specific portions of Makefiles])
687	>	AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
688		dnl maintainer-mode's default is 'disable' unless 'enable' is passed
689		AC_ARG_ENABLE([maintainer-mode],
690	<	[  --][am_maintainer_other][-maintainer-mode  am_maintainer_other make rules and dependencies not useful
691	<	(and sometimes confusing) to the casual installer],
692	<	[USE_MAINTAINER_MODE=$enableval],
693	<	[USE_MAINTAINER_MODE=]m4_if(am_maintainer_other, [enable], [no], [yes]))
690	>	[AS_HELP_STRING([--]am_maintainer_other[-maintainer-mode],
691	>	am_maintainer_other[ make rules and dependencies not useful
692	>	(and sometimes confusing) to the casual installer])],
693	>	[USE_MAINTAINER_MODE=$enableval],
694	>	[USE_MAINTAINER_MODE=]m4_if(am_maintainer_other, [enable], [no], [yes]))
695		AC_MSG_RESULT([$USE_MAINTAINER_MODE])
696		AM_CONDITIONAL([MAINTAINER_MODE], [test $USE_MAINTAINER_MODE = yes])
697		MAINT=$MAINTAINER_MODE_TRUE
#	Line 9477 | Line 699 | AC_MSG_CHECKING([whether to am_maintaine
699		]
700		)
701
9480	–	AU_DEFUN([jm_MAINTAINER_MODE], [AM_MAINTAINER_MODE])
9481	–
702		# Check to see how 'make' treats includes.                  -*- Autoconf -*-
703
704	<	# Copyright (C) 2001, 2002, 2003, 2005, 2009  Free Software Foundation, Inc.
704	>	# Copyright (C) 2001-2014 Free Software Foundation, Inc.
705		#
706		# This file is free software; the Free Software Foundation
707		# gives unlimited permission to copy and/or distribute it,
708		# with or without modifications, as long as this notice is preserved.
709
9490	–	# serial 4
9491	–
710		# AM_MAKE_INCLUDE()
711		# -----------------
712		# Check to see how make treats includes.
#	Line 9506 | Line 724 | am__quote=
724		_am_result=none
725		# First try GNU make style include.
726		echo "include confinc" > confmf
727	<	# Ignore all kinds of additional output from `make'.
727	>	# Ignore all kinds of additional output from 'make'.
728		case `$am_make -s -f confmf 2> /dev/null` in #(
729		*the\ am__doit\ target*)
730		am__include=include
#	Line 9533 | Line 751 | rm -f confinc confmf
751
752		# Fake the existence of programs that GNU maintainers use.  -*- Autoconf -*-
753
754	<	# Copyright (C) 1997, 1999, 2000, 2001, 2003, 2004, 2005, 2008
9537	<	# Free Software Foundation, Inc.
754	>	# Copyright (C) 1997-2014 Free Software Foundation, Inc.
755		#
756		# This file is free software; the Free Software Foundation
757		# gives unlimited permission to copy and/or distribute it,
758		# with or without modifications, as long as this notice is preserved.
759
9543	–	# serial 6
9544	–
760		# AM_MISSING_PROG(NAME, PROGRAM)
761		# ------------------------------
762		AC_DEFUN([AM_MISSING_PROG],
#	Line 9549 | Line 764 | AC_DEFUN([AM_MISSING_PROG],
764		$1=${$1-"${am_missing_run}$2"}
765		AC_SUBST($1)])
766
9552	–
767		# AM_MISSING_HAS_RUN
768		# ------------------
769	<	# Define MISSING if not defined so far and test if it supports --run.
770	<	# If it does, set am_missing_run to use it, otherwise, to nothing.
769	>	# Define MISSING if not defined so far and test if it is modern enough.
770	>	# If it is, set am_missing_run to use it, otherwise, to nothing.
771		AC_DEFUN([AM_MISSING_HAS_RUN],
772		[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
773		AC_REQUIRE_AUX_FILE([missing])dnl
#	Line 9566 | Line 780 | if test x"${MISSING+set}" != xset; then
780		esac
781		fi
782		# Use eval to expand $SHELL
783	<	if eval "$MISSING --run true"; then
784	<	am_missing_run="$MISSING --run "
783	>	if eval "$MISSING --is-lightweight"; then
784	>	am_missing_run="$MISSING "
785		else
786		am_missing_run=
787	<	AC_MSG_WARN([`missing' script is too old or missing])
787	>	AC_MSG_WARN(['missing' script is too old or missing])
788		fi
789		])
790
9577	–	# Copyright (C) 2003, 2004, 2005, 2006  Free Software Foundation, Inc.
9578	–	#
9579	–	# This file is free software; the Free Software Foundation
9580	–	# gives unlimited permission to copy and/or distribute it,
9581	–	# with or without modifications, as long as this notice is preserved.
9582	–
9583	–	# AM_PROG_MKDIR_P
9584	–	# ---------------
9585	–	# Check for `mkdir -p'.
9586	–	AC_DEFUN([AM_PROG_MKDIR_P],
9587	–	[AC_PREREQ([2.60])dnl
9588	–	AC_REQUIRE([AC_PROG_MKDIR_P])dnl
9589	–	dnl Automake 1.8 to 1.9.6 used to define mkdir_p.  We now use MKDIR_P,
9590	–	dnl while keeping a definition of mkdir_p for backward compatibility.
9591	–	dnl @MKDIR_P@ is magic: AC_OUTPUT adjusts its value for each Makefile.
9592	–	dnl However we cannot define mkdir_p as $(MKDIR_P) for the sake of
9593	–	dnl Makefile.ins that do not define MKDIR_P, so we do our own
9594	–	dnl adjustment using top_builddir (which is defined more often than
9595	–	dnl MKDIR_P).
9596	–	AC_SUBST([mkdir_p], ["$MKDIR_P"])dnl
9597	–	case $mkdir_p in
9598	–	[[\\/$]]* | ?:[[\\/]]*) ;;
9599	–	*/*) mkdir_p="\$(top_builddir)/$mkdir_p" ;;
9600	–	esac
9601	–	])
9602	–
791		# Helper functions for option handling.                     -*- Autoconf -*-
792
793	<	# Copyright (C) 2001, 2002, 2003, 2005, 2008  Free Software Foundation, Inc.
793	>	# Copyright (C) 2001-2014 Free Software Foundation, Inc.
794		#
795		# This file is free software; the Free Software Foundation
796		# gives unlimited permission to copy and/or distribute it,
797		# with or without modifications, as long as this notice is preserved.
798
9611	–	# serial 4
9612	–
799		# _AM_MANGLE_OPTION(NAME)
800		# -----------------------
801		AC_DEFUN([_AM_MANGLE_OPTION],
802		[[_AM_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])])
803
804		# _AM_SET_OPTION(NAME)
805	<	# ------------------------------
805	>	# --------------------
806		# Set option NAME.  Presently that only means defining a flag for this option.
807		AC_DEFUN([_AM_SET_OPTION],
808	<	[m4_define(_AM_MANGLE_OPTION([$1]), 1)])
808	>	[m4_define(_AM_MANGLE_OPTION([$1]), [1])])
809
810		# _AM_SET_OPTIONS(OPTIONS)
811	<	# ----------------------------------
811	>	# ------------------------
812		# OPTIONS is a space-separated list of Automake options.
813		AC_DEFUN([_AM_SET_OPTIONS],
814		[m4_foreach_w([_AM_Option], [$1], [_AM_SET_OPTION(_AM_Option)])])
#	Line 9633 | Line 819 | AC_DEFUN([_AM_SET_OPTIONS],
819		AC_DEFUN([_AM_IF_OPTION],
820		[m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])])
821
822	<	# Check to make sure that the build environment is sane.    -*- Autoconf -*-
822	>	# Copyright (C) 1999-2014 Free Software Foundation, Inc.
823	>	#
824	>	# This file is free software; the Free Software Foundation
825	>	# gives unlimited permission to copy and/or distribute it,
826	>	# with or without modifications, as long as this notice is preserved.
827	>
828	>	# _AM_PROG_CC_C_O
829	>	# ---------------
830	>	# Like AC_PROG_CC_C_O, but changed for automake.  We rewrite AC_PROG_CC
831	>	# to automatically call this.
832	>	AC_DEFUN([_AM_PROG_CC_C_O],
833	>	[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
834	>	AC_REQUIRE_AUX_FILE([compile])dnl
835	>	AC_LANG_PUSH([C])dnl
836	>	AC_CACHE_CHECK(
837	>	[whether $CC understands -c and -o together],
838	>	[am_cv_prog_cc_c_o],
839	>	[AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
840	>	# Make sure it works both with $CC and with simple cc.
841	>	# Following AC_PROG_CC_C_O, we do the test twice because some
842	>	# compilers refuse to overwrite an existing .o file with -o,
843	>	# though they will create one.
844	>	am_cv_prog_cc_c_o=yes
845	>	for am_i in 1 2; do
846	>	if AM_RUN_LOG([$CC -c conftest.$ac_ext -o conftest2.$ac_objext]) \
847	>	&& test -f conftest2.$ac_objext; then
848	>	: OK
849	>	else
850	>	am_cv_prog_cc_c_o=no
851	>	break
852	>	fi
853	>	done
854	>	rm -f core conftest*
855	>	unset am_i])
856	>	if test "$am_cv_prog_cc_c_o" != yes; then
857	>	# Losing compiler, so override with the script.
858	>	# FIXME: It is wrong to rewrite CC.
859	>	# But if we don't then we get into trouble of one sort or another.
860	>	# A longer-term fix would be to have automake use am__CC in this case,
861	>	# and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
862	>	CC="$am_aux_dir/compile $CC"
863	>	fi
864	>	AC_LANG_POP([C])])
865	>
866	>	# For backward compatibility.
867	>	AC_DEFUN_ONCE([AM_PROG_CC_C_O], [AC_REQUIRE([AC_PROG_CC])])
868
869	<	# Copyright (C) 1996, 1997, 2000, 2001, 2003, 2005, 2008
9639	<	# Free Software Foundation, Inc.
869	>	# Copyright (C) 2001-2014 Free Software Foundation, Inc.
870		#
871		# This file is free software; the Free Software Foundation
872		# gives unlimited permission to copy and/or distribute it,
873		# with or without modifications, as long as this notice is preserved.
874
875	<	# serial 5
875	>	# AM_RUN_LOG(COMMAND)
876	>	# -------------------
877	>	# Run COMMAND, save the exit status in ac_status, and log it.
878	>	# (This has been adapted from Autoconf's _AC_RUN_LOG macro.)
879	>	AC_DEFUN([AM_RUN_LOG],
880	>	[{ echo "$as_me:$LINENO: $1" >&AS_MESSAGE_LOG_FD
881	>	($1) >&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD
882	>	ac_status=$?
883	>	echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
884	>	(exit $ac_status); }])
885	>
886	>	# Check to make sure that the build environment is sane.    -*- Autoconf -*-
887	>
888	>	# Copyright (C) 1996-2014 Free Software Foundation, Inc.
889	>	#
890	>	# This file is free software; the Free Software Foundation
891	>	# gives unlimited permission to copy and/or distribute it,
892	>	# with or without modifications, as long as this notice is preserved.
893
894		# AM_SANITY_CHECK
895		# ---------------
896		AC_DEFUN([AM_SANITY_CHECK],
897		[AC_MSG_CHECKING([whether build environment is sane])
9651	–	# Just in case
9652	–	sleep 1
9653	–	echo timestamp > conftest.file
898		# Reject unsafe characters in $srcdir or the absolute working directory
899		# name.  Accept space and tab only in the latter.
900		am_lf='
#	Line 9661 | Line 905 | case `pwd` in
905		esac
906		case $srcdir in
907		*[[\\\"\#\$\&\'\`$am_lf\ \    ]]*)
908	<	AC_MSG_ERROR([unsafe srcdir value: `$srcdir']);;
908	>	AC_MSG_ERROR([unsafe srcdir value: '$srcdir']);;
909		esac
910
911	<	# Do `set' in a subshell so we don't clobber the current shell's
911	>	# Do 'set' in a subshell so we don't clobber the current shell's
912		# arguments.  Must try -L first in case configure is actually a
913		# symlink; some systems play weird games with the mod time of symlinks
914		# (eg FreeBSD returns the mod time of the symlink's containing
915		# directory).
916		if (
917	<	set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
918	<	if test "$[*]" = "X"; then
919	<	# -L didn't work.
920	<	set X `ls -t "$srcdir/configure" conftest.file`
921	<	fi
922	<	rm -f conftest.file
923	<	if test "$[*]" != "X $srcdir/configure conftest.file" \
924	<	&& test "$[*]" != "X conftest.file $srcdir/configure"; then
925	<
926	<	# If neither matched, then we have a broken ls.  This can happen
9683	<	# if, for instance, CONFIG_SHELL is bash and it inherits a
9684	<	# broken ls alias from the environment.  This has actually
9685	<	# happened.  Such a system could not be considered "sane".
9686	<	AC_MSG_ERROR([ls -t appears to fail.  Make sure there is not a broken
9687	<	alias in your environment])
9688	<	fi
917	>	am_has_slept=no
918	>	for am_try in 1 2; do
919	>	echo "timestamp, slept: $am_has_slept" > conftest.file
920	>	set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
921	>	if test "$[*]" = "X"; then
922	>	# -L didn't work.
923	>	set X `ls -t "$srcdir/configure" conftest.file`
924	>	fi
925	>	if test "$[*]" != "X $srcdir/configure conftest.file" \
926	>	&& test "$[*]" != "X conftest.file $srcdir/configure"; then
927
928	+	# If neither matched, then we have a broken ls.  This can happen
929	+	# if, for instance, CONFIG_SHELL is bash and it inherits a
930	+	# broken ls alias from the environment.  This has actually
931	+	# happened.  Such a system could not be considered "sane".
932	+	AC_MSG_ERROR([ls -t appears to fail.  Make sure there is not a broken
933	+	alias in your environment])
934	+	fi
935	+	if test "$[2]" = conftest.file || test $am_try -eq 2; then
936	+	break
937	+	fi
938	+	# Just in case.
939	+	sleep 1
940	+	am_has_slept=yes
941	+	done
942		test "$[2]" = conftest.file
943		)
944		then
#	Line 9696 | Line 948 | else
948		AC_MSG_ERROR([newly created file is older than distributed files!
949		Check your system clock])
950		fi
951	<	AC_MSG_RESULT(yes)])
951	>	AC_MSG_RESULT([yes])
952	>	# If we didn't sleep, we still need to ensure time stamps of config.status and
953	>	# generated files are strictly newer.
954	>	am_sleep_pid=
955	>	if grep 'slept: no' conftest.file >/dev/null 2>&1; then
956	>	( sleep 1 ) &
957	>	am_sleep_pid=$!
958	>	fi
959	>	AC_CONFIG_COMMANDS_PRE(
960	>	[AC_MSG_CHECKING([that generated files are newer than configure])
961	>	if test -n "$am_sleep_pid"; then
962	>	# Hide warnings about reused PIDs.
963	>	wait $am_sleep_pid 2>/dev/null
964	>	fi
965	>	AC_MSG_RESULT([done])])
966	>	rm -f conftest.file
967	>	])
968	>
969	>	# Copyright (C) 2009-2014 Free Software Foundation, Inc.
970	>	#
971	>	# This file is free software; the Free Software Foundation
972	>	# gives unlimited permission to copy and/or distribute it,
973	>	# with or without modifications, as long as this notice is preserved.
974	>
975	>	# AM_SILENT_RULES([DEFAULT])
976	>	# --------------------------
977	>	# Enable less verbose build rules; with the default set to DEFAULT
978	>	# ("yes" being less verbose, "no" or empty being verbose).
979	>	AC_DEFUN([AM_SILENT_RULES],
980	>	[AC_ARG_ENABLE([silent-rules], [dnl
981	>	AS_HELP_STRING(
982	>	[--enable-silent-rules],
983	>	[less verbose build output (undo: "make V=1")])
984	>	AS_HELP_STRING(
985	>	[--disable-silent-rules],
986	>	[verbose build output (undo: "make V=0")])dnl
987	>	])
988	>	case $enable_silent_rules in @%:@ (((
989	>	yes) AM_DEFAULT_VERBOSITY=0;;
990	>	no) AM_DEFAULT_VERBOSITY=1;;
991	>	*) AM_DEFAULT_VERBOSITY=m4_if([$1], [yes], [0], [1]);;
992	>	esac
993	>	dnl
994	>	dnl A few 'make' implementations (e.g., NonStop OS and NextStep)
995	>	dnl do not support nested variable expansions.
996	>	dnl See automake bug#9928 and bug#10237.
997	>	am_make=${MAKE-make}
998	>	AC_CACHE_CHECK([whether $am_make supports nested variables],
999	>	[am_cv_make_support_nested_variables],
1000	>	[if AS_ECHO([['TRUE=$(BAR$(V))
1001	>	BAR0=false
1002	>	BAR1=true
1003	>	V=1
1004	>	am__doit:
1005	>	@$(TRUE)
1006	>	.PHONY: am__doit']]) | $am_make -f - >/dev/null 2>&1; then
1007	>	am_cv_make_support_nested_variables=yes
1008	>	else
1009	>	am_cv_make_support_nested_variables=no
1010	>	fi])
1011	>	if test $am_cv_make_support_nested_variables = yes; then
1012	>	dnl Using '$V' instead of '$(V)' breaks IRIX make.
1013	>	AM_V='$(V)'
1014	>	AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
1015	>	else
1016	>	AM_V=$AM_DEFAULT_VERBOSITY
1017	>	AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
1018	>	fi
1019	>	AC_SUBST([AM_V])dnl
1020	>	AM_SUBST_NOTMAKE([AM_V])dnl
1021	>	AC_SUBST([AM_DEFAULT_V])dnl
1022	>	AM_SUBST_NOTMAKE([AM_DEFAULT_V])dnl
1023	>	AC_SUBST([AM_DEFAULT_VERBOSITY])dnl
1024	>	AM_BACKSLASH='\'
1025	>	AC_SUBST([AM_BACKSLASH])dnl
1026	>	_AM_SUBST_NOTMAKE([AM_BACKSLASH])dnl
1027	>	])
1028
1029	<	# Copyright (C) 2001, 2003, 2005  Free Software Foundation, Inc.
1029	>	# Copyright (C) 2001-2014 Free Software Foundation, Inc.
1030		#
1031		# This file is free software; the Free Software Foundation
1032		# gives unlimited permission to copy and/or distribute it,
#	Line 9706 | Line 1034 | AC_MSG_RESULT(yes)])
1034
1035		# AM_PROG_INSTALL_STRIP
1036		# ---------------------
1037	<	# One issue with vendor `install' (even GNU) is that you can't
1037	>	# One issue with vendor 'install' (even GNU) is that you can't
1038		# specify the program used to strip binaries.  This is especially
1039		# annoying in cross-compiling environments, where the build's strip
1040		# is unlikely to handle the host's binaries.
1041		# Fortunately install-sh will honor a STRIPPROG variable, so we
1042	<	# always use install-sh in `make install-strip', and initialize
1042	>	# always use install-sh in "make install-strip", and initialize
1043		# STRIPPROG with the value of the STRIP variable (set by the user).
1044		AC_DEFUN([AM_PROG_INSTALL_STRIP],
1045		[AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
1046	<	# Installed binaries are usually stripped using `strip' when the user
1047	<	# run `make install-strip'.  However `strip' might not be the right
1046	>	# Installed binaries are usually stripped using 'strip' when the user
1047	>	# run "make install-strip".  However 'strip' might not be the right
1048		# tool to use in cross-compilation environments, therefore Automake
1049	<	# will honor the `STRIP' environment variable to overrule this program.
1050	<	dnl Don't test for $cross_compiling = yes, because it might be `maybe'.
1049	>	# will honor the 'STRIP' environment variable to overrule this program.
1050	>	dnl Don't test for $cross_compiling = yes, because it might be 'maybe'.
1051		if test "$cross_compiling" != no; then
1052		AC_CHECK_TOOL([STRIP], [strip], :)
1053		fi
1054		INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
1055		AC_SUBST([INSTALL_STRIP_PROGRAM])])
1056
1057	<	# Copyright (C) 2006, 2008  Free Software Foundation, Inc.
1057	>	# Copyright (C) 2006-2014 Free Software Foundation, Inc.
1058		#
1059		# This file is free software; the Free Software Foundation
1060		# gives unlimited permission to copy and/or distribute it,
1061		# with or without modifications, as long as this notice is preserved.
1062
9735	–	# serial 2
9736	–
1063		# _AM_SUBST_NOTMAKE(VARIABLE)
1064		# ---------------------------
1065		# Prevent Automake from outputting VARIABLE = @VARIABLE@ in Makefile.in.
#	Line 9741 | Line 1067 | AC_SUBST([INSTALL_STRIP_PROGRAM])])
1067		AC_DEFUN([_AM_SUBST_NOTMAKE])
1068
1069		# AM_SUBST_NOTMAKE(VARIABLE)
1070	<	# ---------------------------
1070	>	# --------------------------
1071		# Public sister of _AM_SUBST_NOTMAKE.
1072		AC_DEFUN([AM_SUBST_NOTMAKE], [_AM_SUBST_NOTMAKE($@)])
1073
1074		# Check how to create a tarball.                            -*- Autoconf -*-
1075
1076	<	# Copyright (C) 2004, 2005  Free Software Foundation, Inc.
1076	>	# Copyright (C) 2004-2014 Free Software Foundation, Inc.
1077		#
1078		# This file is free software; the Free Software Foundation
1079		# gives unlimited permission to copy and/or distribute it,
1080		# with or without modifications, as long as this notice is preserved.
1081
9756	–	# serial 2
9757	–
1082		# _AM_PROG_TAR(FORMAT)
1083		# --------------------
1084		# Check how to create a tarball in format FORMAT.
1085	<	# FORMAT should be one of `v7', `ustar', or `pax'.
1085	>	# FORMAT should be one of 'v7', 'ustar', or 'pax'.
1086		#
1087		# Substitute a variable $(am__tar) that is a command
1088		# writing to stdout a FORMAT-tarball containing the directory
#	Line 9768 | Line 1092 | AC_DEFUN([AM_SUBST_NOTMAKE], [_AM_SUBST_
1092		# Substitute a variable $(am__untar) that extract such
1093		# a tarball read from stdin.
1094		#     $(am__untar) < result.tar
1095	+	#
1096		AC_DEFUN([_AM_PROG_TAR],
1097	<	[# Always define AMTAR for backward compatibility.
1098	<	AM_MISSING_PROG([AMTAR], [tar])
1099	<	m4_if([$1], [v7],
1100	<	[am__tar='${AMTAR} chof - "$$tardir"'; am__untar='${AMTAR} xf -'],
1101	<	[m4_case([$1], [ustar],, [pax],,
9777	<	[m4_fatal([Unknown tar format])])
9778	<	AC_MSG_CHECKING([how to create a $1 tar archive])
9779	<	# Loop over all known methods to create a tar archive until one works.
1097	>	[# Always define AMTAR for backward compatibility.  Yes, it's still used
1098	>	# in the wild :-(  We should find a proper way to deprecate it ...
1099	>	AC_SUBST([AMTAR], ['$${TAR-tar}'])
1100	>
1101	>	# We'll loop over all known methods to create a tar archive until one works.
1102		_am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none'
9781	–	_am_tools=${am_cv_prog_tar_$1-$_am_tools}
9782	–	# Do not fold the above two line into one, because Tru64 sh and
9783	–	# Solaris sh will not grok spaces in the rhs of `-'.
9784	–	for _am_tool in $_am_tools
9785	–	do
9786	–	case $_am_tool in
9787	–	gnutar)
9788	–	for _am_tar in tar gnutar gtar;
9789	–	do
9790	–	AM_RUN_LOG([$_am_tar --version]) && break
9791	–	done
9792	–	am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"'
9793	–	am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"'
9794	–	am__untar="$_am_tar -xf -"
9795	–	;;
9796	–	plaintar)
9797	–	# Must skip GNU tar: if it does not support --format= it doesn't create
9798	–	# ustar tarball either.
9799	–	(tar --version) >/dev/null 2>&1 && continue
9800	–	am__tar='tar chf - "$$tardir"'
9801	–	am__tar_='tar chf - "$tardir"'
9802	–	am__untar='tar xf -'
9803	–	;;
9804	–	pax)
9805	–	am__tar='pax -L -x $1 -w "$$tardir"'
9806	–	am__tar_='pax -L -x $1 -w "$tardir"'
9807	–	am__untar='pax -r'
9808	–	;;
9809	–	cpio)
9810	–	am__tar='find "$$tardir" -print | cpio -o -H $1 -L'
9811	–	am__tar_='find "$tardir" -print | cpio -o -H $1 -L'
9812	–	am__untar='cpio -i -H $1 -d'
9813	–	;;
9814	–	none)
9815	–	am__tar=false
9816	–	am__tar_=false
9817	–	am__untar=false
9818	–	;;
9819	–	esac
1103
1104	<	# If the value was cached, stop now.  We just wanted to have am__tar
1105	<	# and am__untar set.
1106	<	test -n "${am_cv_prog_tar_$1}" && break
1104	>	m4_if([$1], [v7],
1105	>	[am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'],
1106	>
1107	>	[m4_case([$1],
1108	>	[ustar],
1109	>	[# The POSIX 1988 'ustar' format is defined with fixed-size fields.
1110	>	# There is notably a 21 bits limit for the UID and the GID.  In fact,
1111	>	# the 'pax' utility can hang on bigger UID/GID (see automake bug#8343
1112	>	# and bug#13588).
1113	>	am_max_uid=2097151 # 2^21 - 1
1114	>	am_max_gid=$am_max_uid
1115	>	# The $UID and $GID variables are not portable, so we need to resort
1116	>	# to the POSIX-mandated id(1) utility.  Errors in the 'id' calls
1117	>	# below are definitely unexpected, so allow the users to see them
1118	>	# (that is, avoid stderr redirection).
1119	>	am_uid=`id -u || echo unknown`
1120	>	am_gid=`id -g || echo unknown`
1121	>	AC_MSG_CHECKING([whether UID '$am_uid' is supported by ustar format])
1122	>	if test $am_uid -le $am_max_uid; then
1123	>	AC_MSG_RESULT([yes])
1124	>	else
1125	>	AC_MSG_RESULT([no])
1126	>	_am_tools=none
1127	>	fi
1128	>	AC_MSG_CHECKING([whether GID '$am_gid' is supported by ustar format])
1129	>	if test $am_gid -le $am_max_gid; then
1130	>	AC_MSG_RESULT([yes])
1131	>	else
1132	>	AC_MSG_RESULT([no])
1133	>	_am_tools=none
1134	>	fi],
1135	>
1136	>	[pax],
1137	>	[],
1138	>
1139	>	[m4_fatal([Unknown tar format])])
1140	>
1141	>	AC_MSG_CHECKING([how to create a $1 tar archive])
1142	>
1143	>	# Go ahead even if we have the value already cached.  We do so because we
1144	>	# need to set the values for the 'am__tar' and 'am__untar' variables.
1145	>	_am_tools=${am_cv_prog_tar_$1-$_am_tools}
1146	>
1147	>	for _am_tool in $_am_tools; do
1148	>	case $_am_tool in
1149	>	gnutar)
1150	>	for _am_tar in tar gnutar gtar; do
1151	>	AM_RUN_LOG([$_am_tar --version]) && break
1152	>	done
1153	>	am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"'
1154	>	am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"'
1155	>	am__untar="$_am_tar -xf -"
1156	>	;;
1157	>	plaintar)
1158	>	# Must skip GNU tar: if it does not support --format= it doesn't create
1159	>	# ustar tarball either.
1160	>	(tar --version) >/dev/null 2>&1 && continue
1161	>	am__tar='tar chf - "$$tardir"'
1162	>	am__tar_='tar chf - "$tardir"'
1163	>	am__untar='tar xf -'
1164	>	;;
1165	>	pax)
1166	>	am__tar='pax -L -x $1 -w "$$tardir"'
1167	>	am__tar_='pax -L -x $1 -w "$tardir"'
1168	>	am__untar='pax -r'
1169	>	;;
1170	>	cpio)
1171	>	am__tar='find "$$tardir" -print | cpio -o -H $1 -L'
1172	>	am__tar_='find "$tardir" -print | cpio -o -H $1 -L'
1173	>	am__untar='cpio -i -H $1 -d'
1174	>	;;
1175	>	none)
1176	>	am__tar=false
1177	>	am__tar_=false
1178	>	am__untar=false
1179	>	;;
1180	>	esac
1181
1182	<	# tar/untar a dummy directory, and stop if the command works
1183	<	rm -rf conftest.dir
1184	<	mkdir conftest.dir
1185	<	echo GrepMe > conftest.dir/file
1186	<	AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar])
1182	>	# If the value was cached, stop now.  We just wanted to have am__tar
1183	>	# and am__untar set.
1184	>	test -n "${am_cv_prog_tar_$1}" && break
1185	>
1186	>	# tar/untar a dummy directory, and stop if the command works.
1187	>	rm -rf conftest.dir
1188	>	mkdir conftest.dir
1189	>	echo GrepMe > conftest.dir/file
1190	>	AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar])
1191	>	rm -rf conftest.dir
1192	>	if test -s conftest.tar; then
1193	>	AM_RUN_LOG([$am__untar <conftest.tar])
1194	>	AM_RUN_LOG([cat conftest.dir/file])
1195	>	grep GrepMe conftest.dir/file >/dev/null 2>&1 && break
1196	>	fi
1197	>	done
1198		rm -rf conftest.dir
9831	–	if test -s conftest.tar; then
9832	–	AM_RUN_LOG([$am__untar <conftest.tar])
9833	–	grep GrepMe conftest.dir/file >/dev/null 2>&1 && break
9834	–	fi
9835	–	done
9836	–	rm -rf conftest.dir
1199
1200	<	AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool])
1201	<	AC_MSG_RESULT([$am_cv_prog_tar_$1])])
1200	>	AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool])
1201	>	AC_MSG_RESULT([$am_cv_prog_tar_$1])])
1202	>
1203		AC_SUBST([am__tar])
1204		AC_SUBST([am__untar])
1205		]) # _AM_PROG_TAR
1206
1207	<	m4_include([acinclude.m4])
1207	>	m4_include([m4/ac_define_dir.m4])
1208	>	m4_include([m4/ax_append_compile_flags.m4])
1209	>	m4_include([m4/ax_append_flag.m4])
1210	>	m4_include([m4/ax_arg_enable_assert.m4])
1211	>	m4_include([m4/ax_arg_enable_debugging.m4])
1212	>	m4_include([m4/ax_arg_enable_warnings.m4])
1213	>	m4_include([m4/ax_arg_gnutls.m4])
1214	>	m4_include([m4/ax_arg_ioloop_mechanism.m4])
1215	>	m4_include([m4/ax_arg_libgeoip.m4])
1216	>	m4_include([m4/ax_arg_openssl.m4])
1217	>	m4_include([m4/ax_check_compile_flag.m4])
1218	>	m4_include([m4/ax_library_net.m4])
1219	>	m4_include([m4/ax_mempool_chunksizes.m4])
1220	>	m4_include([m4/ax_require_defined.m4])
1221	>	m4_include([m4/gcc_stack_protect.m4])
1222	>	m4_include([m4/libtool.m4])
1223	>	m4_include([m4/ltargz.m4])
1224	>	m4_include([m4/ltdl.m4])
1225	>	m4_include([m4/ltoptions.m4])
1226	>	m4_include([m4/ltsugar.m4])
1227	>	m4_include([m4/ltversion.m4])
1228	>	m4_include([m4/lt~obsolete.m4])

Comparing:
ircd-hybrid-7.3/aclocal.m4 (property svn:eol-style), Revision 1084 by michael, Sat Mar 13 23:24:10 2010 UTC vs.
ircd-hybrid/branches/8.2.x/aclocal.m4 (property svn:eol-style), Revision 7107 by michael, Sat Jan 23 20:17:49 2016 UTC

#	Line 0 | Line 1
1	+	native

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)