source: web/old/remctl-2.14/libtool @ f6f3e91

web
Last change on this file since f6f3e91 was f6f3e91, checked in by Jessica B. Hamrick <jhamrick@…>, 15 years ago

Preserve directory hierarchy (not sure what happened to it)

  • Property mode set to 100755
File size: 252.0 KB
Line 
1#! /bin/sh
2
3# libtool - Provide generalized library-building support services.
4# Generated automatically by config.status (remctl) 2.14
5# Libtool was configured on host cats-whiskers.mit.edu:
6# NOTE: Changes made to this file will be lost: look at ltmain.sh.
7#
8#   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,
9#                 2006, 2007, 2008 Free Software Foundation, Inc.
10#   Written by Gordon Matzigkeit, 1996
11#
12#   This file is part of GNU Libtool.
13#
14# GNU Libtool is free software; you can redistribute it and/or
15# modify it under the terms of the GNU General Public License as
16# published by the Free Software Foundation; either version 2 of
17# the License, or (at your option) any later version.
18#
19# As a special exception to the GNU General Public License,
20# if you distribute this file as part of a program or library that
21# is built using GNU Libtool, you may include this file under the
22# same distribution terms that you use for the rest of that program.
23#
24# GNU Libtool is distributed in the hope that it will be useful,
25# but WITHOUT ANY WARRANTY; without even the implied warranty of
26# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
27# GNU General Public License for more details.
28#
29# You should have received a copy of the GNU General Public License
30# along with GNU Libtool; see the file COPYING.  If not, a copy
31# can be downloaded from http://www.gnu.org/licenses/gpl.html, or
32# obtained by writing to the Free Software Foundation, Inc.,
33# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
34
35
36# The names of the tagged configurations supported by this script.
37available_tags=""
38
39# ### BEGIN LIBTOOL CONFIG
40
41# Which release of libtool.m4 was used?
42macro_version=2.2.6
43macro_revision=1.3012
44
45# Whether or not to build shared libraries.
46build_libtool_libs=yes
47
48# Whether or not to build static libraries.
49build_old_libs=yes
50
51# What type of objects to build.
52pic_mode=default
53
54# Whether or not to optimize for fast installation.
55fast_install=yes
56
57# The host system.
58host_alias=
59host=x86_64-unknown-linux-gnu
60host_os=linux-gnu
61
62# The build system.
63build_alias=
64build=x86_64-unknown-linux-gnu
65build_os=linux-gnu
66
67# A sed program that does not truncate output.
68SED="/bin/sed"
69
70# Sed that helps us avoid accidentally triggering echo(1) options like -n.
71Xsed="$SED -e 1s/^X//"
72
73# A grep program that handles long lines.
74GREP="/bin/grep"
75
76# An ERE matcher.
77EGREP="/bin/grep -E"
78
79# A literal string matcher.
80FGREP="/bin/grep -F"
81
82# A BSD- or MS-compatible name lister.
83NM="/usr/bin/nm -B"
84
85# Whether we need soft or hard links.
86LN_S="ln -s"
87
88# What is the maximum length of a command?
89max_cmd_len=1966080
90
91# Object file suffix (normally "o").
92objext=o
93
94# Executable file suffix (normally "").
95exeext=
96
97# whether the shell understands "unset".
98lt_unset=unset
99
100# turn spaces into newlines.
101SP2NL="tr \\040 \\012"
102
103# turn newlines into spaces.
104NL2SP="tr \\015\\012 \\040\\040"
105
106# How to create reloadable object files.
107reload_flag=" -r"
108reload_cmds="\$LD\$reload_flag -o \$output\$reload_objs"
109
110# An object symbol dumper.
111OBJDUMP="objdump"
112
113# Method to check whether dependent libraries are shared objects.
114deplibs_check_method="pass_all"
115
116# Command to use when deplibs_check_method == "file_magic".
117file_magic_cmd="\$MAGIC_CMD"
118
119# The archiver.
120AR="ar"
121AR_FLAGS="cru"
122
123# A symbol stripping program.
124STRIP="strip"
125
126# Commands used to install an old-style archive.
127RANLIB="ranlib"
128old_postinstall_cmds="chmod 644 \$oldlib~\$RANLIB \$oldlib"
129old_postuninstall_cmds=""
130
131# A C compiler.
132LTCC="gcc"
133
134# LTCC compiler flags.
135LTCFLAGS="-g -O2"
136
137# Take the output of nm and produce a listing of raw symbols and C names.
138global_symbol_pipe="sed -n -e 's/^.*[    ]\\([ABCDGIRSTW][ABCDGIRSTW]*\\)[       ][      ]*\\([_A-Za-z][_A-Za-z0-9]*\\)\$/\\1 \\2 \\2/p'"
139
140# Transform the output of nm in a proper C declaration.
141global_symbol_to_cdecl="sed -n -e 's/^T .* \\(.*\\)\$/extern int \\1();/p' -e 's/^[ABCDGIRSTW]* .* \\(.*\\)\$/extern char \\1;/p'"
142
143# Transform the output of nm in a C name address pair.
144global_symbol_to_c_name_address="sed -n -e 's/^: \\([^ ]*\\) \$/  {\\\"\\1\\\", (void *) 0},/p' -e 's/^[ABCDGIRSTW]* \\([^ ]*\\) \\([^ ]*\\)\$/  {\"\\2\", (void *) \\&\\2},/p'"
145
146# Transform the output of nm in a C name address pair when lib prefix is needed.
147global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \\([^ ]*\\) \$/  {\\\"\\1\\\", (void *) 0},/p' -e 's/^[ABCDGIRSTW]* \\([^ ]*\\) \\(lib[^ ]*\\)\$/  {\"\\2\", (void *) \\&\\2},/p' -e 's/^[ABCDGIRSTW]* \\([^ ]*\\) \\([^ ]*\\)\$/  {\"lib\\2\", (void *) \\&\\2},/p'"
148
149# The name of the directory that contains temporary libtool files.
150objdir=.libs
151
152# Shell to use when invoking shell scripts.
153SHELL="/bin/sh"
154
155# An echo program that does not interpret backslashes.
156ECHO="echo"
157
158# Used to examine libraries when file_magic_cmd begins with "file".
159MAGIC_CMD=file
160
161# Must we lock files when doing compilation?
162need_locks="no"
163
164# Tool to manipulate archived DWARF debug symbol files on Mac OS X.
165DSYMUTIL=""
166
167# Tool to change global to local symbols on Mac OS X.
168NMEDIT=""
169
170# Tool to manipulate fat objects and archives on Mac OS X.
171LIPO=""
172
173# ldd/readelf like tool for Mach-O binaries on Mac OS X.
174OTOOL=""
175
176# ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4.
177OTOOL64=""
178
179# Old archive suffix (normally "a").
180libext=a
181
182# Shared library suffix (normally ".so").
183shrext_cmds=".so"
184
185# The commands to extract the exported symbol list from a shared archive.
186extract_expsyms_cmds=""
187
188# Variables whose values should be saved in libtool wrapper scripts and
189# restored at link time.
190variables_saved_for_relink="PATH LD_LIBRARY_PATH LD_RUN_PATH GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
191
192# Do we need the "lib" prefix for modules?
193need_lib_prefix=no
194
195# Do we need a version for libraries?
196need_version=no
197
198# Library versioning type.
199version_type=linux
200
201# Shared library runtime path variable.
202runpath_var=LD_RUN_PATH
203
204# Shared library path variable.
205shlibpath_var=LD_LIBRARY_PATH
206
207# Is shlibpath searched before the hard-coded library search path?
208shlibpath_overrides_runpath=no
209
210# Format of library name prefix.
211libname_spec="lib\$name"
212
213# List of archive names.  First name is the real one, the rest are links.
214# The last name is the one that the linker finds with -lNAME
215library_names_spec="\${libname}\${release}\${shared_ext}\$versuffix \${libname}\${release}\${shared_ext}\$major \$libname\${shared_ext}"
216
217# The coded name of the library, if different from the real name.
218soname_spec="\${libname}\${release}\${shared_ext}\$major"
219
220# Command to use after installation of a shared archive.
221postinstall_cmds=""
222
223# Command to use after uninstallation of a shared archive.
224postuninstall_cmds=""
225
226# Commands used to finish a libtool library installation in a directory.
227finish_cmds="PATH=\\\"\\\$PATH:/sbin\\\" ldconfig -n \$libdir"
228
229# As "finish_cmds", except a single script fragment to be evaled but
230# not shown.
231finish_eval=""
232
233# Whether we should hardcode library paths into libraries.
234hardcode_into_libs=yes
235
236# Compile-time system search path for libraries.
237sys_lib_search_path_spec="/usr/lib/gcc/x86_64-redhat-linux/4.4.1 /usr/lib64 /lib64"
238
239# Run-time system search path for libraries.
240sys_lib_dlsearch_path_spec="/lib /usr/lib /usr/lib64/atlas /usr/lib64/mysql /usr/lib64/octave-3.0.5 /usr/lib64/qt-3.3/lib /usr/lib64/tcl8.5 /usr/lib64/xulrunner-1.9.1 "
241
242# Whether dlopen is supported.
243dlopen_support=unknown
244
245# Whether dlopen of programs is supported.
246dlopen_self=unknown
247
248# Whether dlopen of statically linked programs is supported.
249dlopen_self_static=unknown
250
251# Commands to strip libraries.
252old_striplib="strip --strip-debug"
253striplib="strip --strip-unneeded"
254
255
256# The linker used to build libraries.
257LD="/usr/bin/ld -m elf_x86_64"
258
259# Commands used to build an old-style archive.
260old_archive_cmds="\$AR \$AR_FLAGS \$oldlib\$oldobjs~\$RANLIB \$oldlib"
261
262# A language specific compiler.
263CC="gcc"
264
265# Is the compiler the GNU compiler?
266with_gcc=yes
267
268# Compiler flag to turn off builtin functions.
269no_builtin_flag=" -fno-builtin"
270
271# How to pass a linker flag through the compiler.
272wl="-Wl,"
273
274# Additional compiler flags for building library objects.
275pic_flag=" -fPIC -DPIC"
276
277# Compiler flag to prevent dynamic linking.
278link_static_flag=""
279
280# Does compiler simultaneously support -c and -o options?
281compiler_c_o="yes"
282
283# Whether or not to add -lc for building shared libraries.
284build_libtool_need_lc=no
285
286# Whether or not to disallow shared libs when runtime libs are static.
287allow_libtool_libs_with_static_runtimes=no
288
289# Compiler flag to allow reflexive dlopens.
290export_dynamic_flag_spec="\${wl}--export-dynamic"
291
292# Compiler flag to generate shared objects directly from archives.
293whole_archive_flag_spec="\${wl}--whole-archive\$convenience \${wl}--no-whole-archive"
294
295# Whether the compiler copes with passing no objects directly.
296compiler_needs_object="no"
297
298# Create an old-style archive from a shared archive.
299old_archive_from_new_cmds=""
300
301# Create a temporary old-style archive to link instead of a shared archive.
302old_archive_from_expsyms_cmds=""
303
304# Commands used to build a shared archive.
305archive_cmds="\$CC -shared \$libobjs \$deplibs \$compiler_flags \${wl}-soname \$wl\$soname -o \$lib"
306archive_expsym_cmds="echo \\\"{ global:\\\" > \$output_objdir/\$libname.ver~
307            cat \$export_symbols | sed -e \\\"s/\\\\(.*\\\\)/\\\\1;/\\\" >> \$output_objdir/\$libname.ver~
308            echo \\\"local: *; };\\\" >> \$output_objdir/\$libname.ver~
309            \$CC -shared \$libobjs \$deplibs \$compiler_flags \${wl}-soname \$wl\$soname \${wl}-version-script \${wl}\$output_objdir/\$libname.ver -o \$lib"
310
311# Commands used to build a loadable module if different from building
312# a shared archive.
313module_cmds=""
314module_expsym_cmds=""
315
316# Whether we are building with GNU ld or not.
317with_gnu_ld="yes"
318
319# Flag that allows shared libraries with undefined symbols to be built.
320allow_undefined_flag=""
321
322# Flag that enforces no undefined symbols.
323no_undefined_flag=""
324
325# Flag to hardcode $libdir into a binary during linking.
326# This must work even if $libdir does not exist
327hardcode_libdir_flag_spec="\${wl}-rpath \${wl}\$libdir"
328
329# If ld is used when linking, flag to hardcode $libdir into a binary
330# during linking.  This must work even if $libdir does not exist.
331hardcode_libdir_flag_spec_ld=""
332
333# Whether we need a single "-rpath" flag with a separated argument.
334hardcode_libdir_separator=""
335
336# Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes
337# DIR into the resulting binary.
338hardcode_direct=no
339
340# Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes
341# DIR into the resulting binary and the resulting library dependency is
342# "absolute",i.e impossible to change by setting ${shlibpath_var} if the
343# library is relocated.
344hardcode_direct_absolute=no
345
346# Set to "yes" if using the -LDIR flag during linking hardcodes DIR
347# into the resulting binary.
348hardcode_minus_L=no
349
350# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
351# into the resulting binary.
352hardcode_shlibpath_var=unsupported
353
354# Set to "yes" if building a shared library automatically hardcodes DIR
355# into the library and all subsequent libraries and executables linked
356# against it.
357hardcode_automatic=no
358
359# Set to yes if linker adds runtime paths of dependent libraries
360# to runtime path list.
361inherit_rpath=no
362
363# Whether libtool must link a program against all its dependency libraries.
364link_all_deplibs=no
365
366# Fix the shell variable $srcfile for the compiler.
367fix_srcfile_path=""
368
369# Set to "yes" if exported symbols are required.
370always_export_symbols=no
371
372# The commands to list exported symbols.
373export_symbols_cmds="\$NM \$libobjs \$convenience | \$global_symbol_pipe | \$SED 's/.* //' | sort | uniq > \$export_symbols"
374
375# Symbols that should not be listed in the preloaded symbols.
376exclude_expsyms="_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*"
377
378# Symbols that must always be exported.
379include_expsyms=""
380
381# Commands necessary for linking programs (against libraries) with templates.
382prelink_cmds=""
383
384# Specify filename containing input files.
385file_list_spec=""
386
387# How to hardcode a shared library path into an executable.
388hardcode_action=immediate
389
390# ### END LIBTOOL CONFIG
391
392# Generated from ltmain.m4sh.
393
394# ltmain.sh (GNU libtool) 2.2.6
395# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
396
397# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007 2008 Free Software Foundation, Inc.
398# This is free software; see the source for copying conditions.  There is NO
399# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
400
401# GNU Libtool is free software; you can redistribute it and/or modify
402# it under the terms of the GNU General Public License as published by
403# the Free Software Foundation; either version 2 of the License, or
404# (at your option) any later version.
405#
406# As a special exception to the GNU General Public License,
407# if you distribute this file as part of a program or library that
408# is built using GNU Libtool, you may include this file under the
409# same distribution terms that you use for the rest of that program.
410#
411# GNU Libtool is distributed in the hope that it will be useful, but
412# WITHOUT ANY WARRANTY; without even the implied warranty of
413# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
414# General Public License for more details.
415#
416# You should have received a copy of the GNU General Public License
417# along with GNU Libtool; see the file COPYING.  If not, a copy
418# can be downloaded from http://www.gnu.org/licenses/gpl.html,
419# or obtained by writing to the Free Software Foundation, Inc.,
420# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
421
422# Usage: $progname [OPTION]... [MODE-ARG]...
423#
424# Provide generalized library-building support services.
425#
426#     --config             show all configuration variables
427#     --debug              enable verbose shell tracing
428# -n, --dry-run            display commands without modifying any files
429#     --features           display basic configuration information and exit
430#     --mode=MODE          use operation mode MODE
431#     --preserve-dup-deps  don't remove duplicate dependency libraries
432#     --quiet, --silent    don't print informational messages
433#     --tag=TAG            use configuration variables from tag TAG
434# -v, --verbose            print informational messages (default)
435#     --version            print version information
436# -h, --help               print short or long help message
437#
438# MODE must be one of the following:
439#
440#       clean              remove files from the build directory
441#       compile            compile a source file into a libtool object
442#       execute            automatically set library path, then run a program
443#       finish             complete the installation of libtool libraries
444#       install            install libraries or executables
445#       link               create a library or an executable
446#       uninstall          remove libraries from an installed directory
447#
448# MODE-ARGS vary depending on the MODE.
449# Try `$progname --help --mode=MODE' for a more detailed description of MODE.
450#
451# When reporting a bug, please describe a test case to reproduce it and
452# include the following information:
453#
454#       host-triplet:   $host
455#       shell:          $SHELL
456#       compiler:               $LTCC
457#       compiler flags:         $LTCFLAGS
458#       linker:         $LD (gnu? $with_gnu_ld)
459#       $progname:              (GNU libtool) 2.2.6 Debian-2.2.6a-4
460#       automake:               $automake_version
461#       autoconf:               $autoconf_version
462#
463# Report bugs to <bug-libtool@gnu.org>.
464
465PROGRAM=ltmain.sh
466PACKAGE=libtool
467VERSION="2.2.6 Debian-2.2.6a-4"
468TIMESTAMP=""
469package_revision=1.3012
470
471# Be Bourne compatible
472if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
473  emulate sh
474  NULLCMD=:
475  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
476  # is contrary to our usage.  Disable this feature.
477  alias -g '${1+"$@"}'='"$@"'
478  setopt NO_GLOB_SUBST
479else
480  case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
481fi
482BIN_SH=xpg4; export BIN_SH # for Tru64
483DUALCASE=1; export DUALCASE # for MKS sh
484
485# NLS nuisances: We save the old values to restore during execute mode.
486# Only set LANG and LC_ALL to C if already set.
487# These must not be set unconditionally because not all systems understand
488# e.g. LANG=C (notably SCO).
489lt_user_locale=
490lt_safe_locale=
491for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
492do
493  eval "if test \"\${$lt_var+set}\" = set; then
494          save_$lt_var=\$$lt_var
495          $lt_var=C
496          export $lt_var
497          lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
498          lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
499        fi"
500done
501
502$lt_unset CDPATH
503
504
505
506
507
508: ${CP="cp -f"}
509: ${ECHO="echo"}
510: ${EGREP="/bin/grep -E"}
511: ${FGREP="/bin/grep -F"}
512: ${GREP="/bin/grep"}
513: ${LN_S="ln -s"}
514: ${MAKE="make"}
515: ${MKDIR="mkdir"}
516: ${MV="mv -f"}
517: ${RM="rm -f"}
518: ${SED="/bin/sed"}
519: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
520: ${Xsed="$SED -e 1s/^X//"}
521
522# Global variables:
523EXIT_SUCCESS=0
524EXIT_FAILURE=1
525EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.
526EXIT_SKIP=77      # $? = 77 is used to indicate a skipped test to automake.
527
528exit_status=$EXIT_SUCCESS
529
530# Make sure IFS has a sensible default
531lt_nl='
532'
533IFS="   $lt_nl"
534
535dirname="s,/[^/]*$,,"
536basename="s,^.*/,,"
537
538# func_dirname_and_basename file append nondir_replacement
539# perform func_basename and func_dirname in a single function
540# call:
541#   dirname:  Compute the dirname of FILE.  If nonempty,
542#             add APPEND to the result, otherwise set result
543#             to NONDIR_REPLACEMENT.
544#             value returned in "$func_dirname_result"
545#   basename: Compute filename of FILE.
546#             value retuned in "$func_basename_result"
547# Implementation must be kept synchronized with func_dirname
548# and func_basename. For efficiency, we do not delegate to
549# those functions but instead duplicate the functionality here.
550func_dirname_and_basename ()
551{
552  # Extract subdirectory from the argument.
553  func_dirname_result=`$ECHO "X${1}" | $Xsed -e "$dirname"`
554  if test "X$func_dirname_result" = "X${1}"; then
555    func_dirname_result="${3}"
556  else
557    func_dirname_result="$func_dirname_result${2}"
558  fi
559  func_basename_result=`$ECHO "X${1}" | $Xsed -e "$basename"`
560}
561
562# Generated shell functions inserted here.
563
564# func_dirname file append nondir_replacement
565# Compute the dirname of FILE.  If nonempty, add APPEND to the result,
566# otherwise set result to NONDIR_REPLACEMENT.
567func_dirname ()
568{
569  case ${1} in
570    */*) func_dirname_result="${1%/*}${2}" ;;
571    *  ) func_dirname_result="${3}" ;;
572  esac
573}
574
575# func_basename file
576func_basename ()
577{
578  func_basename_result="${1##*/}"
579}
580
581# func_dirname_and_basename file append nondir_replacement
582# perform func_basename and func_dirname in a single function
583# call:
584#   dirname:  Compute the dirname of FILE.  If nonempty,
585#             add APPEND to the result, otherwise set result
586#             to NONDIR_REPLACEMENT.
587#             value returned in "$func_dirname_result"
588#   basename: Compute filename of FILE.
589#             value retuned in "$func_basename_result"
590# Implementation must be kept synchronized with func_dirname
591# and func_basename. For efficiency, we do not delegate to
592# those functions but instead duplicate the functionality here.
593func_dirname_and_basename ()
594{
595  case ${1} in
596    */*) func_dirname_result="${1%/*}${2}" ;;
597    *  ) func_dirname_result="${3}" ;;
598  esac
599  func_basename_result="${1##*/}"
600}
601
602# func_stripname prefix suffix name
603# strip PREFIX and SUFFIX off of NAME.
604# PREFIX and SUFFIX must not contain globbing or regex special
605# characters, hashes, percent signs, but SUFFIX may contain a leading
606# dot (in which case that matches only a dot).
607func_stripname ()
608{
609  # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are
610  # positional parameters, so assign one to ordinary parameter first.
611  func_stripname_result=${3}
612  func_stripname_result=${func_stripname_result#"${1}"}
613  func_stripname_result=${func_stripname_result%"${2}"}
614}
615
616# func_opt_split
617func_opt_split ()
618{
619  func_opt_split_opt=${1%%=*}
620  func_opt_split_arg=${1#*=}
621}
622
623# func_lo2o object
624func_lo2o ()
625{
626  case ${1} in
627    *.lo) func_lo2o_result=${1%.lo}.${objext} ;;
628    *)    func_lo2o_result=${1} ;;
629  esac
630}
631
632# func_xform libobj-or-source
633func_xform ()
634{
635  func_xform_result=${1%.*}.lo
636}
637
638# func_arith arithmetic-term...
639func_arith ()
640{
641  func_arith_result=$(( $* ))
642}
643
644# func_len string
645# STRING may not start with a hyphen.
646func_len ()
647{
648  func_len_result=${#1}
649}
650
651
652# func_append var value
653# Append VALUE to the end of shell variable VAR.
654func_append ()
655{
656  eval "$1+=\$2"
657}
658# Generated shell functions inserted here.
659
660# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
661# is ksh but when the shell is invoked as "sh" and the current value of
662# the _XPG environment variable is not equal to 1 (one), the special
663# positional parameter $0, within a function call, is the name of the
664# function.
665progpath="$0"
666
667# The name of this program:
668# In the unlikely event $progname began with a '-', it would play havoc with
669# func_echo (imagine progname=-n), so we prepend ./ in that case:
670func_dirname_and_basename "$progpath"
671progname=$func_basename_result
672case $progname in
673  -*) progname=./$progname ;;
674esac
675
676# Make sure we have an absolute path for reexecution:
677case $progpath in
678  [\\/]*|[A-Za-z]:\\*) ;;
679  *[\\/]*)
680     progdir=$func_dirname_result
681     progdir=`cd "$progdir" && pwd`
682     progpath="$progdir/$progname"
683     ;;
684  *)
685     save_IFS="$IFS"
686     IFS=:
687     for progdir in $PATH; do
688       IFS="$save_IFS"
689       test -x "$progdir/$progname" && break
690     done
691     IFS="$save_IFS"
692     test -n "$progdir" || progdir=`pwd`
693     progpath="$progdir/$progname"
694     ;;
695esac
696
697# Sed substitution that helps us do robust quoting.  It backslashifies
698# metacharacters that are still active within double-quoted strings.
699Xsed="${SED}"' -e 1s/^X//'
700sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
701
702# Same as above, but do not quote variable references.
703double_quote_subst='s/\(["`\\]\)/\\\1/g'
704
705# Re-`\' parameter expansions in output of double_quote_subst that were
706# `\'-ed in input to the same.  If an odd number of `\' preceded a '$'
707# in input to double_quote_subst, that '$' was protected from expansion.
708# Since each input `\' is now two `\'s, look for any number of runs of
709# four `\'s followed by two `\'s and then a '$'.  `\' that '$'.
710bs='\\'
711bs2='\\\\'
712bs4='\\\\\\\\'
713dollar='\$'
714sed_double_backslash="\
715  s/$bs4/&\\
716/g
717  s/^$bs2$dollar/$bs&/
718  s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
719  s/\n//g"
720
721# Standard options:
722opt_dry_run=false
723opt_help=false
724opt_quiet=false
725opt_verbose=false
726opt_warning=:
727
728# func_echo arg...
729# Echo program name prefixed message, along with the current mode
730# name if it has been set yet.
731func_echo ()
732{
733    $ECHO "$progname${mode+: }$mode: $*"
734}
735
736# func_verbose arg...
737# Echo program name prefixed message in verbose mode only.
738func_verbose ()
739{
740    $opt_verbose && func_echo ${1+"$@"}
741
742    # A bug in bash halts the script if the last line of a function
743    # fails when set -e is in force, so we need another command to
744    # work around that:
745    :
746}
747
748# func_error arg...
749# Echo program name prefixed message to standard error.
750func_error ()
751{
752    $ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
753}
754
755# func_warning arg...
756# Echo program name prefixed warning message to standard error.
757func_warning ()
758{
759    $opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
760
761    # bash bug again:
762    :
763}
764
765# func_fatal_error arg...
766# Echo program name prefixed message to standard error, and exit.
767func_fatal_error ()
768{
769    func_error ${1+"$@"}
770    exit $EXIT_FAILURE
771}
772
773# func_fatal_help arg...
774# Echo program name prefixed message to standard error, followed by
775# a help hint, and exit.
776func_fatal_help ()
777{
778    func_error ${1+"$@"}
779    func_fatal_error "$help"
780}
781help="Try \`$progname --help' for more information."  ## default
782
783
784# func_grep expression filename
785# Check whether EXPRESSION matches any line of FILENAME, without output.
786func_grep ()
787{
788    $GREP "$1" "$2" >/dev/null 2>&1
789}
790
791
792# func_mkdir_p directory-path
793# Make sure the entire path to DIRECTORY-PATH is available.
794func_mkdir_p ()
795{
796    my_directory_path="$1"
797    my_dir_list=
798
799    if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
800
801      # Protect directory names starting with `-'
802      case $my_directory_path in
803        -*) my_directory_path="./$my_directory_path" ;;
804      esac
805
806      # While some portion of DIR does not yet exist...
807      while test ! -d "$my_directory_path"; do
808        # ...make a list in topmost first order.  Use a colon delimited
809        # list incase some portion of path contains whitespace.
810        my_dir_list="$my_directory_path:$my_dir_list"
811
812        # If the last portion added has no slash in it, the list is done
813        case $my_directory_path in */*) ;; *) break ;; esac
814
815        # ...otherwise throw away the child directory and loop
816        my_directory_path=`$ECHO "X$my_directory_path" | $Xsed -e "$dirname"`
817      done
818      my_dir_list=`$ECHO "X$my_dir_list" | $Xsed -e 's,:*$,,'`
819
820      save_mkdir_p_IFS="$IFS"; IFS=':'
821      for my_dir in $my_dir_list; do
822        IFS="$save_mkdir_p_IFS"
823        # mkdir can fail with a `File exist' error if two processes
824        # try to create one of the directories concurrently.  Don't
825        # stop in that case!
826        $MKDIR "$my_dir" 2>/dev/null || :
827      done
828      IFS="$save_mkdir_p_IFS"
829
830      # Bail out if we (or some other process) failed to create a directory.
831      test -d "$my_directory_path" || \
832        func_fatal_error "Failed to create \`$1'"
833    fi
834}
835
836
837# func_mktempdir [string]
838# Make a temporary directory that won't clash with other running
839# libtool processes, and avoids race conditions if possible.  If
840# given, STRING is the basename for that directory.
841func_mktempdir ()
842{
843    my_template="${TMPDIR-/tmp}/${1-$progname}"
844
845    if test "$opt_dry_run" = ":"; then
846      # Return a directory name, but don't create it in dry-run mode
847      my_tmpdir="${my_template}-$$"
848    else
849
850      # If mktemp works, use that first and foremost
851      my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
852
853      if test ! -d "$my_tmpdir"; then
854        # Failing that, at least try and use $RANDOM to avoid a race
855        my_tmpdir="${my_template}-${RANDOM-0}$$"
856
857        save_mktempdir_umask=`umask`
858        umask 0077
859        $MKDIR "$my_tmpdir"
860        umask $save_mktempdir_umask
861      fi
862
863      # If we're not in dry-run mode, bomb out on failure
864      test -d "$my_tmpdir" || \
865        func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
866    fi
867
868    $ECHO "X$my_tmpdir" | $Xsed
869}
870
871
872# func_quote_for_eval arg
873# Aesthetically quote ARG to be evaled later.
874# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
875# is double-quoted, suitable for a subsequent eval, whereas
876# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
877# which are still active within double quotes backslashified.
878func_quote_for_eval ()
879{
880    case $1 in
881      *[\\\`\"\$]*)
882        func_quote_for_eval_unquoted_result=`$ECHO "X$1" | $Xsed -e "$sed_quote_subst"` ;;
883      *)
884        func_quote_for_eval_unquoted_result="$1" ;;
885    esac
886
887    case $func_quote_for_eval_unquoted_result in
888      # Double-quote args containing shell metacharacters to delay
889      # word splitting, command substitution and and variable
890      # expansion for a subsequent eval.
891      # Many Bourne shells cannot handle close brackets correctly
892      # in scan sets, so we specify it separately.
893      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
894        func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
895        ;;
896      *)
897        func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
898    esac
899}
900
901
902# func_quote_for_expand arg
903# Aesthetically quote ARG to be evaled later; same as above,
904# but do not quote variable references.
905func_quote_for_expand ()
906{
907    case $1 in
908      *[\\\`\"]*)
909        my_arg=`$ECHO "X$1" | $Xsed \
910            -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
911      *)
912        my_arg="$1" ;;
913    esac
914
915    case $my_arg in
916      # Double-quote args containing shell metacharacters to delay
917      # word splitting and command substitution for a subsequent eval.
918      # Many Bourne shells cannot handle close brackets correctly
919      # in scan sets, so we specify it separately.
920      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
921        my_arg="\"$my_arg\""
922        ;;
923    esac
924
925    func_quote_for_expand_result="$my_arg"
926}
927
928
929# func_show_eval cmd [fail_exp]
930# Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
931# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
932# is given, then evaluate it.
933func_show_eval ()
934{
935    my_cmd="$1"
936    my_fail_exp="${2-:}"
937
938    ${opt_silent-false} || {
939      func_quote_for_expand "$my_cmd"
940      eval "func_echo $func_quote_for_expand_result"
941    }
942
943    if ${opt_dry_run-false}; then :; else
944      eval "$my_cmd"
945      my_status=$?
946      if test "$my_status" -eq 0; then :; else
947        eval "(exit $my_status); $my_fail_exp"
948      fi
949    fi
950}
951
952
953# func_show_eval_locale cmd [fail_exp]
954# Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
955# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
956# is given, then evaluate it.  Use the saved locale for evaluation.
957func_show_eval_locale ()
958{
959    my_cmd="$1"
960    my_fail_exp="${2-:}"
961
962    ${opt_silent-false} || {
963      func_quote_for_expand "$my_cmd"
964      eval "func_echo $func_quote_for_expand_result"
965    }
966
967    if ${opt_dry_run-false}; then :; else
968      eval "$lt_user_locale
969            $my_cmd"
970      my_status=$?
971      eval "$lt_safe_locale"
972      if test "$my_status" -eq 0; then :; else
973        eval "(exit $my_status); $my_fail_exp"
974      fi
975    fi
976}
977
978
979
980
981
982# func_version
983# Echo version message to standard output and exit.
984func_version ()
985{
986    $SED -n '/^# '$PROGRAM' (GNU /,/# warranty; / {
987        s/^# //
988        s/^# *$//
989        s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
990        p
991     }' < "$progpath"
992     exit $?
993}
994
995# func_usage
996# Echo short help message to standard output and exit.
997func_usage ()
998{
999    $SED -n '/^# Usage:/,/# -h/ {
1000        s/^# //
1001        s/^# *$//
1002        s/\$progname/'$progname'/
1003        p
1004    }' < "$progpath"
1005    $ECHO
1006    $ECHO "run \`$progname --help | more' for full usage"
1007    exit $?
1008}
1009
1010# func_help
1011# Echo long help message to standard output and exit.
1012func_help ()
1013{
1014    $SED -n '/^# Usage:/,/# Report bugs to/ {
1015        s/^# //
1016        s/^# *$//
1017        s*\$progname*'$progname'*
1018        s*\$host*'"$host"'*
1019        s*\$SHELL*'"$SHELL"'*
1020        s*\$LTCC*'"$LTCC"'*
1021        s*\$LTCFLAGS*'"$LTCFLAGS"'*
1022        s*\$LD*'"$LD"'*
1023        s/\$with_gnu_ld/'"$with_gnu_ld"'/
1024        s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
1025        s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
1026        p
1027     }' < "$progpath"
1028    exit $?
1029}
1030
1031# func_missing_arg argname
1032# Echo program name prefixed message to standard error and set global
1033# exit_cmd.
1034func_missing_arg ()
1035{
1036    func_error "missing argument for $1"
1037    exit_cmd=exit
1038}
1039
1040exit_cmd=:
1041
1042
1043
1044
1045
1046# Check that we have a working $ECHO.
1047if test "X$1" = X--no-reexec; then
1048  # Discard the --no-reexec flag, and continue.
1049  shift
1050elif test "X$1" = X--fallback-echo; then
1051  # Avoid inline document here, it may be left over
1052  :
1053elif test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t'; then
1054  # Yippee, $ECHO works!
1055  :
1056else
1057  # Restart under the correct shell, and then maybe $ECHO will work.
1058  exec $SHELL "$progpath" --no-reexec ${1+"$@"}
1059fi
1060
1061if test "X$1" = X--fallback-echo; then
1062  # used as fallback echo
1063  shift
1064  cat <<EOF
1065$*
1066EOF
1067  exit $EXIT_SUCCESS
1068fi
1069
1070magic="%%%MAGIC variable%%%"
1071magic_exe="%%%MAGIC EXE variable%%%"
1072
1073# Global variables.
1074# $mode is unset
1075nonopt=
1076execute_dlfiles=
1077preserve_args=
1078lo2o="s/\\.lo\$/.${objext}/"
1079o2lo="s/\\.${objext}\$/.lo/"
1080extracted_archives=
1081extracted_serial=0
1082
1083opt_dry_run=false
1084opt_duplicate_deps=false
1085opt_silent=false
1086opt_debug=:
1087
1088# If this variable is set in any of the actions, the command in it
1089# will be execed at the end.  This prevents here-documents from being
1090# left over by shells.
1091exec_cmd=
1092
1093# func_fatal_configuration arg...
1094# Echo program name prefixed message to standard error, followed by
1095# a configuration failure hint, and exit.
1096func_fatal_configuration ()
1097{
1098    func_error ${1+"$@"}
1099    func_error "See the $PACKAGE documentation for more information."
1100    func_fatal_error "Fatal configuration error."
1101}
1102
1103
1104# func_config
1105# Display the configuration for all the tags in this script.
1106func_config ()
1107{
1108    re_begincf='^# ### BEGIN LIBTOOL'
1109    re_endcf='^# ### END LIBTOOL'
1110
1111    # Default configuration.
1112    $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
1113
1114    # Now print the configurations for the tags.
1115    for tagname in $taglist; do
1116      $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
1117    done
1118
1119    exit $?
1120}
1121
1122# func_features
1123# Display the features supported by this script.
1124func_features ()
1125{
1126    $ECHO "host: $host"
1127    if test "$build_libtool_libs" = yes; then
1128      $ECHO "enable shared libraries"
1129    else
1130      $ECHO "disable shared libraries"
1131    fi
1132    if test "$build_old_libs" = yes; then
1133      $ECHO "enable static libraries"
1134    else
1135      $ECHO "disable static libraries"
1136    fi
1137
1138    exit $?
1139}
1140
1141# func_enable_tag tagname
1142# Verify that TAGNAME is valid, and either flag an error and exit, or
1143# enable the TAGNAME tag.  We also add TAGNAME to the global $taglist
1144# variable here.
1145func_enable_tag ()
1146{
1147  # Global variable:
1148  tagname="$1"
1149
1150  re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
1151  re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
1152  sed_extractcf="/$re_begincf/,/$re_endcf/p"
1153
1154  # Validate tagname.
1155  case $tagname in
1156    *[!-_A-Za-z0-9,/]*)
1157      func_fatal_error "invalid tag name: $tagname"
1158      ;;
1159  esac
1160
1161  # Don't test for the "default" C tag, as we know it's
1162  # there but not specially marked.
1163  case $tagname in
1164    CC) ;;
1165    *)
1166      if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
1167        taglist="$taglist $tagname"
1168
1169        # Evaluate the configuration.  Be careful to quote the path
1170        # and the sed script, to avoid splitting on whitespace, but
1171        # also don't use non-portable quotes within backquotes within
1172        # quotes we have to do it in 2 steps:
1173        extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
1174        eval "$extractedcf"
1175      else
1176        func_error "ignoring unknown tag $tagname"
1177      fi
1178      ;;
1179  esac
1180}
1181
1182# Parse options once, thoroughly.  This comes as soon as possible in
1183# the script to make things like `libtool --version' happen quickly.
1184{
1185
1186  # Shorthand for --mode=foo, only valid as the first argument
1187  case $1 in
1188  clean|clea|cle|cl)
1189    shift; set dummy --mode clean ${1+"$@"}; shift
1190    ;;
1191  compile|compil|compi|comp|com|co|c)
1192    shift; set dummy --mode compile ${1+"$@"}; shift
1193    ;;
1194  execute|execut|execu|exec|exe|ex|e)
1195    shift; set dummy --mode execute ${1+"$@"}; shift
1196    ;;
1197  finish|finis|fini|fin|fi|f)
1198    shift; set dummy --mode finish ${1+"$@"}; shift
1199    ;;
1200  install|instal|insta|inst|ins|in|i)
1201    shift; set dummy --mode install ${1+"$@"}; shift
1202    ;;
1203  link|lin|li|l)
1204    shift; set dummy --mode link ${1+"$@"}; shift
1205    ;;
1206  uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
1207    shift; set dummy --mode uninstall ${1+"$@"}; shift
1208    ;;
1209  esac
1210
1211  # Parse non-mode specific arguments:
1212  while test "$#" -gt 0; do
1213    opt="$1"
1214    shift
1215
1216    case $opt in
1217      --config)         func_config                                     ;;
1218
1219      --debug)          preserve_args="$preserve_args $opt"
1220                        func_echo "enabling shell trace mode"
1221                        opt_debug='set -x'
1222                        $opt_debug
1223                        ;;
1224
1225      -dlopen)          test "$#" -eq 0 && func_missing_arg "$opt" && break
1226                        execute_dlfiles="$execute_dlfiles $1"
1227                        shift
1228                        ;;
1229
1230      --dry-run | -n)   opt_dry_run=:                                   ;;
1231      --features)       func_features                                   ;;
1232      --finish)         mode="finish"                                   ;;
1233
1234      --mode)           test "$#" -eq 0 && func_missing_arg "$opt" && break
1235                        case $1 in
1236                          # Valid mode arguments:
1237                          clean)        ;;
1238                          compile)      ;;
1239                          execute)      ;;
1240                          finish)       ;;
1241                          install)      ;;
1242                          link)         ;;
1243                          relink)       ;;
1244                          uninstall)    ;;
1245
1246                          # Catch anything else as an error
1247                          *) func_error "invalid argument for $opt"
1248                             exit_cmd=exit
1249                             break
1250                             ;;
1251                        esac
1252
1253                        mode="$1"
1254                        shift
1255                        ;;
1256
1257      --preserve-dup-deps)
1258                        opt_duplicate_deps=:                            ;;
1259
1260      --quiet|--silent) preserve_args="$preserve_args $opt"
1261                        opt_silent=:
1262                        ;;
1263
1264      --verbose| -v)    preserve_args="$preserve_args $opt"
1265                        opt_silent=false
1266                        ;;
1267
1268      --tag)            test "$#" -eq 0 && func_missing_arg "$opt" && break
1269                        preserve_args="$preserve_args $opt $1"
1270                        func_enable_tag "$1"    # tagname is set here
1271                        shift
1272                        ;;
1273
1274      # Separate optargs to long options:
1275      -dlopen=*|--mode=*|--tag=*)
1276                        func_opt_split "$opt"
1277                        set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}
1278                        shift
1279                        ;;
1280
1281      -\?|-h)           func_usage                                      ;;
1282      --help)           opt_help=:                                      ;;
1283      --version)        func_version                                    ;;
1284
1285      -*)               func_fatal_help "unrecognized option \`$opt'"   ;;
1286
1287      *)                nonopt="$opt"
1288                        break
1289                        ;;
1290    esac
1291  done
1292
1293
1294  case $host in
1295    *cygwin* | *mingw* | *pw32* | *cegcc*)
1296      # don't eliminate duplications in $postdeps and $predeps
1297      opt_duplicate_compiler_generated_deps=:
1298      ;;
1299    *)
1300      opt_duplicate_compiler_generated_deps=$opt_duplicate_deps
1301      ;;
1302  esac
1303
1304  # Having warned about all mis-specified options, bail out if
1305  # anything was wrong.
1306  $exit_cmd $EXIT_FAILURE
1307}
1308
1309# func_check_version_match
1310# Ensure that we are using m4 macros, and libtool script from the same
1311# release of libtool.
1312func_check_version_match ()
1313{
1314  if test "$package_revision" != "$macro_revision"; then
1315    if test "$VERSION" != "$macro_version"; then
1316      if test -z "$macro_version"; then
1317        cat >&2 <<_LT_EOF
1318$progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
1319$progname: definition of this LT_INIT comes from an older release.
1320$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
1321$progname: and run autoconf again.
1322_LT_EOF
1323      else
1324        cat >&2 <<_LT_EOF
1325$progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
1326$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
1327$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
1328$progname: and run autoconf again.
1329_LT_EOF
1330      fi
1331    else
1332      cat >&2 <<_LT_EOF
1333$progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,
1334$progname: but the definition of this LT_INIT comes from revision $macro_revision.
1335$progname: You should recreate aclocal.m4 with macros from revision $package_revision
1336$progname: of $PACKAGE $VERSION and run autoconf again.
1337_LT_EOF
1338    fi
1339
1340    exit $EXIT_MISMATCH
1341  fi
1342}
1343
1344
1345## ----------- ##
1346##    Main.    ##
1347## ----------- ##
1348
1349$opt_help || {
1350  # Sanity checks first:
1351  func_check_version_match
1352
1353  if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
1354    func_fatal_configuration "not configured to build any kind of library"
1355  fi
1356
1357  test -z "$mode" && func_fatal_error "error: you must specify a MODE."
1358
1359
1360  # Darwin sucks
1361  eval std_shrext=\"$shrext_cmds\"
1362
1363
1364  # Only execute mode is allowed to have -dlopen flags.
1365  if test -n "$execute_dlfiles" && test "$mode" != execute; then
1366    func_error "unrecognized option \`-dlopen'"
1367    $ECHO "$help" 1>&2
1368    exit $EXIT_FAILURE
1369  fi
1370
1371  # Change the help message to a mode-specific one.
1372  generic_help="$help"
1373  help="Try \`$progname --help --mode=$mode' for more information."
1374}
1375
1376
1377# func_lalib_p file
1378# True iff FILE is a libtool `.la' library or `.lo' object file.
1379# This function is only a basic sanity check; it will hardly flush out
1380# determined imposters.
1381func_lalib_p ()
1382{
1383    test -f "$1" &&
1384      $SED -e 4q "$1" 2>/dev/null \
1385        | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
1386}
1387
1388# func_lalib_unsafe_p file
1389# True iff FILE is a libtool `.la' library or `.lo' object file.
1390# This function implements the same check as func_lalib_p without
1391# resorting to external programs.  To this end, it redirects stdin and
1392# closes it afterwards, without saving the original file descriptor.
1393# As a safety measure, use it only where a negative result would be
1394# fatal anyway.  Works if `file' does not exist.
1395func_lalib_unsafe_p ()
1396{
1397    lalib_p=no
1398    if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
1399        for lalib_p_l in 1 2 3 4
1400        do
1401            read lalib_p_line
1402            case "$lalib_p_line" in
1403                \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
1404            esac
1405        done
1406        exec 0<&5 5<&-
1407    fi
1408    test "$lalib_p" = yes
1409}
1410
1411# func_ltwrapper_script_p file
1412# True iff FILE is a libtool wrapper script
1413# This function is only a basic sanity check; it will hardly flush out
1414# determined imposters.
1415func_ltwrapper_script_p ()
1416{
1417    func_lalib_p "$1"
1418}
1419
1420# func_ltwrapper_executable_p file
1421# True iff FILE is a libtool wrapper executable
1422# This function is only a basic sanity check; it will hardly flush out
1423# determined imposters.
1424func_ltwrapper_executable_p ()
1425{
1426    func_ltwrapper_exec_suffix=
1427    case $1 in
1428    *.exe) ;;
1429    *) func_ltwrapper_exec_suffix=.exe ;;
1430    esac
1431    $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
1432}
1433
1434# func_ltwrapper_scriptname file
1435# Assumes file is an ltwrapper_executable
1436# uses $file to determine the appropriate filename for a
1437# temporary ltwrapper_script.
1438func_ltwrapper_scriptname ()
1439{
1440    func_ltwrapper_scriptname_result=""
1441    if func_ltwrapper_executable_p "$1"; then
1442        func_dirname_and_basename "$1" "" "."
1443        func_stripname '' '.exe' "$func_basename_result"
1444        func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
1445    fi
1446}
1447
1448# func_ltwrapper_p file
1449# True iff FILE is a libtool wrapper script or wrapper executable
1450# This function is only a basic sanity check; it will hardly flush out
1451# determined imposters.
1452func_ltwrapper_p ()
1453{
1454    func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
1455}
1456
1457
1458# func_execute_cmds commands fail_cmd
1459# Execute tilde-delimited COMMANDS.
1460# If FAIL_CMD is given, eval that upon failure.
1461# FAIL_CMD may read-access the current command in variable CMD!
1462func_execute_cmds ()
1463{
1464    $opt_debug
1465    save_ifs=$IFS; IFS='~'
1466    for cmd in $1; do
1467      IFS=$save_ifs
1468      eval cmd=\"$cmd\"
1469      func_show_eval "$cmd" "${2-:}"
1470    done
1471    IFS=$save_ifs
1472}
1473
1474
1475# func_source file
1476# Source FILE, adding directory component if necessary.
1477# Note that it is not necessary on cygwin/mingw to append a dot to
1478# FILE even if both FILE and FILE.exe exist: automatic-append-.exe
1479# behavior happens only for exec(3), not for open(2)!  Also, sourcing
1480# `FILE.' does not work on cygwin managed mounts.
1481func_source ()
1482{
1483    $opt_debug
1484    case $1 in
1485    */* | *\\*) . "$1" ;;
1486    *)          . "./$1" ;;
1487    esac
1488}
1489
1490
1491# func_infer_tag arg
1492# Infer tagged configuration to use if any are available and
1493# if one wasn't chosen via the "--tag" command line option.
1494# Only attempt this if the compiler in the base compile
1495# command doesn't match the default compiler.
1496# arg is usually of the form 'gcc ...'
1497func_infer_tag ()
1498{
1499    $opt_debug
1500    if test -n "$available_tags" && test -z "$tagname"; then
1501      CC_quoted=
1502      for arg in $CC; do
1503        func_quote_for_eval "$arg"
1504        CC_quoted="$CC_quoted $func_quote_for_eval_result"
1505      done
1506      case $@ in
1507      # Blanks in the command may have been stripped by the calling shell,
1508      # but not from the CC environment variable when configure was run.
1509      " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*) ;;
1510      # Blanks at the start of $base_compile will cause this to fail
1511      # if we don't check for them as well.
1512      *)
1513        for z in $available_tags; do
1514          if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1515            # Evaluate the configuration.
1516            eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1517            CC_quoted=
1518            for arg in $CC; do
1519              # Double-quote args containing other shell metacharacters.
1520              func_quote_for_eval "$arg"
1521              CC_quoted="$CC_quoted $func_quote_for_eval_result"
1522            done
1523            case "$@ " in
1524              " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*)
1525              # The compiler in the base compile command matches
1526              # the one in the tagged configuration.
1527              # Assume this is the tagged configuration we want.
1528              tagname=$z
1529              break
1530              ;;
1531            esac
1532          fi
1533        done
1534        # If $tagname still isn't set, then no tagged configuration
1535        # was found and let the user know that the "--tag" command
1536        # line option must be used.
1537        if test -z "$tagname"; then
1538          func_echo "unable to infer tagged configuration"
1539          func_fatal_error "specify a tag with \`--tag'"
1540#       else
1541#         func_verbose "using $tagname tagged configuration"
1542        fi
1543        ;;
1544      esac
1545    fi
1546}
1547
1548
1549
1550# func_write_libtool_object output_name pic_name nonpic_name
1551# Create a libtool object file (analogous to a ".la" file),
1552# but don't create it if we're doing a dry run.
1553func_write_libtool_object ()
1554{
1555    write_libobj=${1}
1556    if test "$build_libtool_libs" = yes; then
1557      write_lobj=\'${2}\'
1558    else
1559      write_lobj=none
1560    fi
1561
1562    if test "$build_old_libs" = yes; then
1563      write_oldobj=\'${3}\'
1564    else
1565      write_oldobj=none
1566    fi
1567
1568    $opt_dry_run || {
1569      cat >${write_libobj}T <<EOF
1570# $write_libobj - a libtool object file
1571# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1572#
1573# Please DO NOT delete this file!
1574# It is necessary for linking the library.
1575
1576# Name of the PIC object.
1577pic_object=$write_lobj
1578
1579# Name of the non-PIC object
1580non_pic_object=$write_oldobj
1581
1582EOF
1583      $MV "${write_libobj}T" "${write_libobj}"
1584    }
1585}
1586
1587# func_mode_compile arg...
1588func_mode_compile ()
1589{
1590    $opt_debug
1591    # Get the compilation command and the source file.
1592    base_compile=
1593    srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
1594    suppress_opt=yes
1595    suppress_output=
1596    arg_mode=normal
1597    libobj=
1598    later=
1599    pie_flag=
1600
1601    for arg
1602    do
1603      case $arg_mode in
1604      arg  )
1605        # do not "continue".  Instead, add this to base_compile
1606        lastarg="$arg"
1607        arg_mode=normal
1608        ;;
1609
1610      target )
1611        libobj="$arg"
1612        arg_mode=normal
1613        continue
1614        ;;
1615
1616      normal )
1617        # Accept any command-line options.
1618        case $arg in
1619        -o)
1620          test -n "$libobj" && \
1621            func_fatal_error "you cannot specify \`-o' more than once"
1622          arg_mode=target
1623          continue
1624          ;;
1625
1626        -pie | -fpie | -fPIE)
1627          pie_flag="$pie_flag $arg"
1628          continue
1629          ;;
1630
1631        -shared | -static | -prefer-pic | -prefer-non-pic)
1632          later="$later $arg"
1633          continue
1634          ;;
1635
1636        -no-suppress)
1637          suppress_opt=no
1638          continue
1639          ;;
1640
1641        -Xcompiler)
1642          arg_mode=arg  #  the next one goes into the "base_compile" arg list
1643          continue      #  The current "srcfile" will either be retained or
1644          ;;            #  replaced later.  I would guess that would be a bug.
1645
1646        -Wc,*)
1647          func_stripname '-Wc,' '' "$arg"
1648          args=$func_stripname_result
1649          lastarg=
1650          save_ifs="$IFS"; IFS=','
1651          for arg in $args; do
1652            IFS="$save_ifs"
1653            func_quote_for_eval "$arg"
1654            lastarg="$lastarg $func_quote_for_eval_result"
1655          done
1656          IFS="$save_ifs"
1657          func_stripname ' ' '' "$lastarg"
1658          lastarg=$func_stripname_result
1659
1660          # Add the arguments to base_compile.
1661          base_compile="$base_compile $lastarg"
1662          continue
1663          ;;
1664
1665        *)
1666          # Accept the current argument as the source file.
1667          # The previous "srcfile" becomes the current argument.
1668          #
1669          lastarg="$srcfile"
1670          srcfile="$arg"
1671          ;;
1672        esac  #  case $arg
1673        ;;
1674      esac    #  case $arg_mode
1675
1676      # Aesthetically quote the previous argument.
1677      func_quote_for_eval "$lastarg"
1678      base_compile="$base_compile $func_quote_for_eval_result"
1679    done # for arg
1680
1681    case $arg_mode in
1682    arg)
1683      func_fatal_error "you must specify an argument for -Xcompile"
1684      ;;
1685    target)
1686      func_fatal_error "you must specify a target with \`-o'"
1687      ;;
1688    *)
1689      # Get the name of the library object.
1690      test -z "$libobj" && {
1691        func_basename "$srcfile"
1692        libobj="$func_basename_result"
1693      }
1694      ;;
1695    esac
1696
1697    # Recognize several different file suffixes.
1698    # If the user specifies -o file.o, it is replaced with file.lo
1699    case $libobj in
1700    *.[cCFSifmso] | \
1701    *.ada | *.adb | *.ads | *.asm | \
1702    *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
1703    *.[fF][09]? | *.for | *.java | *.obj | *.sx)
1704      func_xform "$libobj"
1705      libobj=$func_xform_result
1706      ;;
1707    esac
1708
1709    case $libobj in
1710    *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
1711    *)
1712      func_fatal_error "cannot determine name of library object from \`$libobj'"
1713      ;;
1714    esac
1715
1716    func_infer_tag $base_compile
1717
1718    for arg in $later; do
1719      case $arg in
1720      -shared)
1721        test "$build_libtool_libs" != yes && \
1722          func_fatal_configuration "can not build a shared library"
1723        build_old_libs=no
1724        continue
1725        ;;
1726
1727      -static)
1728        build_libtool_libs=no
1729        build_old_libs=yes
1730        continue
1731        ;;
1732
1733      -prefer-pic)
1734        pic_mode=yes
1735        continue
1736        ;;
1737
1738      -prefer-non-pic)
1739        pic_mode=no
1740        continue
1741        ;;
1742      esac
1743    done
1744
1745    func_quote_for_eval "$libobj"
1746    test "X$libobj" != "X$func_quote_for_eval_result" \
1747      && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'    &()|`$[]' \
1748      && func_warning "libobj name \`$libobj' may not contain shell special characters."
1749    func_dirname_and_basename "$obj" "/" ""
1750    objname="$func_basename_result"
1751    xdir="$func_dirname_result"
1752    lobj=${xdir}$objdir/$objname
1753
1754    test -z "$base_compile" && \
1755      func_fatal_help "you must specify a compilation command"
1756
1757    # Delete any leftover library objects.
1758    if test "$build_old_libs" = yes; then
1759      removelist="$obj $lobj $libobj ${libobj}T"
1760    else
1761      removelist="$lobj $libobj ${libobj}T"
1762    fi
1763
1764    # On Cygwin there's no "real" PIC flag so we must build both object types
1765    case $host_os in
1766    cygwin* | mingw* | pw32* | os2* | cegcc*)
1767      pic_mode=default
1768      ;;
1769    esac
1770    if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
1771      # non-PIC code in shared libraries is not supported
1772      pic_mode=default
1773    fi
1774
1775    # Calculate the filename of the output object if compiler does
1776    # not support -o with -c
1777    if test "$compiler_c_o" = no; then
1778      output_obj=`$ECHO "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
1779      lockfile="$output_obj.lock"
1780    else
1781      output_obj=
1782      need_locks=no
1783      lockfile=
1784    fi
1785
1786    # Lock this critical section if it is needed
1787    # We use this script file to make the link, it avoids creating a new file
1788    if test "$need_locks" = yes; then
1789      until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
1790        func_echo "Waiting for $lockfile to be removed"
1791        sleep 2
1792      done
1793    elif test "$need_locks" = warn; then
1794      if test -f "$lockfile"; then
1795        $ECHO "\
1796*** ERROR, $lockfile exists and contains:
1797`cat $lockfile 2>/dev/null`
1798
1799This indicates that another process is trying to use the same
1800temporary object file, and libtool could not work around it because
1801your compiler does not support \`-c' and \`-o' together.  If you
1802repeat this compilation, it may succeed, by chance, but you had better
1803avoid parallel builds (make -j) in this platform, or get a better
1804compiler."
1805
1806        $opt_dry_run || $RM $removelist
1807        exit $EXIT_FAILURE
1808      fi
1809      removelist="$removelist $output_obj"
1810      $ECHO "$srcfile" > "$lockfile"
1811    fi
1812
1813    $opt_dry_run || $RM $removelist
1814    removelist="$removelist $lockfile"
1815    trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
1816
1817    if test -n "$fix_srcfile_path"; then
1818      eval srcfile=\"$fix_srcfile_path\"
1819    fi
1820    func_quote_for_eval "$srcfile"
1821    qsrcfile=$func_quote_for_eval_result
1822
1823    # Only build a PIC object if we are building libtool libraries.
1824    if test "$build_libtool_libs" = yes; then
1825      # Without this assignment, base_compile gets emptied.
1826      fbsd_hideous_sh_bug=$base_compile
1827
1828      if test "$pic_mode" != no; then
1829        command="$base_compile $qsrcfile $pic_flag"
1830      else
1831        # Don't build PIC code
1832        command="$base_compile $qsrcfile"
1833      fi
1834
1835      func_mkdir_p "$xdir$objdir"
1836
1837      if test -z "$output_obj"; then
1838        # Place PIC objects in $objdir
1839        command="$command -o $lobj"
1840      fi
1841
1842      func_show_eval_locale "$command"  \
1843          'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
1844
1845      if test "$need_locks" = warn &&
1846         test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1847        $ECHO "\
1848*** ERROR, $lockfile contains:
1849`cat $lockfile 2>/dev/null`
1850
1851but it should contain:
1852$srcfile
1853
1854This indicates that another process is trying to use the same
1855temporary object file, and libtool could not work around it because
1856your compiler does not support \`-c' and \`-o' together.  If you
1857repeat this compilation, it may succeed, by chance, but you had better
1858avoid parallel builds (make -j) in this platform, or get a better
1859compiler."
1860
1861        $opt_dry_run || $RM $removelist
1862        exit $EXIT_FAILURE
1863      fi
1864
1865      # Just move the object if needed, then go on to compile the next one
1866      if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
1867        func_show_eval '$MV "$output_obj" "$lobj"' \
1868          'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1869      fi
1870
1871      # Allow error messages only from the first compilation.
1872      if test "$suppress_opt" = yes; then
1873        suppress_output=' >/dev/null 2>&1'
1874      fi
1875    fi
1876
1877    # Only build a position-dependent object if we build old libraries.
1878    if test "$build_old_libs" = yes; then
1879      if test "$pic_mode" != yes; then
1880        # Don't build PIC code
1881        command="$base_compile $qsrcfile$pie_flag"
1882      else
1883        command="$base_compile $qsrcfile $pic_flag"
1884      fi
1885      if test "$compiler_c_o" = yes; then
1886        command="$command -o $obj"
1887      fi
1888
1889      # Suppress compiler output if we already did a PIC compilation.
1890      command="$command$suppress_output"
1891      func_show_eval_locale "$command" \
1892        '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
1893
1894      if test "$need_locks" = warn &&
1895         test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1896        $ECHO "\
1897*** ERROR, $lockfile contains:
1898`cat $lockfile 2>/dev/null`
1899
1900but it should contain:
1901$srcfile
1902
1903This indicates that another process is trying to use the same
1904temporary object file, and libtool could not work around it because
1905your compiler does not support \`-c' and \`-o' together.  If you
1906repeat this compilation, it may succeed, by chance, but you had better
1907avoid parallel builds (make -j) in this platform, or get a better
1908compiler."
1909
1910        $opt_dry_run || $RM $removelist
1911        exit $EXIT_FAILURE
1912      fi
1913
1914      # Just move the object if needed
1915      if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
1916        func_show_eval '$MV "$output_obj" "$obj"' \
1917          'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1918      fi
1919    fi
1920
1921    $opt_dry_run || {
1922      func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
1923
1924      # Unlock the critical section if it was locked
1925      if test "$need_locks" != no; then
1926        removelist=$lockfile
1927        $RM "$lockfile"
1928      fi
1929    }
1930
1931    exit $EXIT_SUCCESS
1932}
1933
1934$opt_help || {
1935test "$mode" = compile && func_mode_compile ${1+"$@"}
1936}
1937
1938func_mode_help ()
1939{
1940    # We need to display help for each of the modes.
1941    case $mode in
1942      "")
1943        # Generic help is extracted from the usage comments
1944        # at the start of this file.
1945        func_help
1946        ;;
1947
1948      clean)
1949        $ECHO \
1950"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
1951
1952Remove files from the build directory.
1953
1954RM is the name of the program to use to delete files associated with each FILE
1955(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
1956to RM.
1957
1958If FILE is a libtool library, object or program, all the files associated
1959with it are deleted. Otherwise, only FILE itself is deleted using RM."
1960        ;;
1961
1962      compile)
1963      $ECHO \
1964"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
1965
1966Compile a source file into a libtool library object.
1967
1968This mode accepts the following additional options:
1969
1970  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
1971  -no-suppress      do not suppress compiler output for multiple passes
1972  -prefer-pic       try to building PIC objects only
1973  -prefer-non-pic   try to building non-PIC objects only
1974  -shared           do not build a \`.o' file suitable for static linking
1975  -static           only build a \`.o' file suitable for static linking
1976
1977COMPILE-COMMAND is a command to be used in creating a \`standard' object file
1978from the given SOURCEFILE.
1979
1980The output file name is determined by removing the directory component from
1981SOURCEFILE, then substituting the C source code suffix \`.c' with the
1982library object suffix, \`.lo'."
1983        ;;
1984
1985      execute)
1986        $ECHO \
1987"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
1988
1989Automatically set library path, then run a program.
1990
1991This mode accepts the following additional options:
1992
1993  -dlopen FILE      add the directory containing FILE to the library path
1994
1995This mode sets the library path environment variable according to \`-dlopen'
1996flags.
1997
1998If any of the ARGS are libtool executable wrappers, then they are translated
1999into their corresponding uninstalled binary, and any of their required library
2000directories are added to the library path.
2001
2002Then, COMMAND is executed, with ARGS as arguments."
2003        ;;
2004
2005      finish)
2006        $ECHO \
2007"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
2008
2009Complete the installation of libtool libraries.
2010
2011Each LIBDIR is a directory that contains libtool libraries.
2012
2013The commands that this mode executes may require superuser privileges.  Use
2014the \`--dry-run' option if you just want to see what would be executed."
2015        ;;
2016
2017      install)
2018        $ECHO \
2019"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
2020
2021Install executables or libraries.
2022
2023INSTALL-COMMAND is the installation command.  The first component should be
2024either the \`install' or \`cp' program.
2025
2026The following components of INSTALL-COMMAND are treated specially:
2027
2028  -inst-prefix PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
2029
2030The rest of the components are interpreted as arguments to that command (only
2031BSD-compatible install options are recognized)."
2032        ;;
2033
2034      link)
2035        $ECHO \
2036"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
2037
2038Link object files or libraries together to form another library, or to
2039create an executable program.
2040
2041LINK-COMMAND is a command using the C compiler that you would use to create
2042a program from several object files.
2043
2044The following components of LINK-COMMAND are treated specially:
2045
2046  -all-static       do not do any dynamic linking at all
2047  -avoid-version    do not add a version suffix if possible
2048  -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
2049  -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
2050  -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
2051  -export-symbols SYMFILE
2052                    try to export only the symbols listed in SYMFILE
2053  -export-symbols-regex REGEX
2054                    try to export only the symbols matching REGEX
2055  -LLIBDIR          search LIBDIR for required installed libraries
2056  -lNAME            OUTPUT-FILE requires the installed library libNAME
2057  -module           build a library that can dlopened
2058  -no-fast-install  disable the fast-install mode
2059  -no-install       link a not-installable executable
2060  -no-undefined     declare that a library does not refer to external symbols
2061  -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
2062  -objectlist FILE  Use a list of object files found in FILE to specify objects
2063  -precious-files-regex REGEX
2064                    don't remove output files matching REGEX
2065  -release RELEASE  specify package release information
2066  -rpath LIBDIR     the created library will eventually be installed in LIBDIR
2067  -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
2068  -shared           only do dynamic linking of libtool libraries
2069  -shrext SUFFIX    override the standard shared library file extension
2070  -static           do not do any dynamic linking of uninstalled libtool libraries
2071  -static-libtool-libs
2072                    do not do any dynamic linking of libtool libraries
2073  -version-info CURRENT[:REVISION[:AGE]]
2074                    specify library version info [each variable defaults to 0]
2075  -weak LIBNAME     declare that the target provides the LIBNAME interface
2076
2077All other options (arguments beginning with \`-') are ignored.
2078
2079Every other argument is treated as a filename.  Files ending in \`.la' are
2080treated as uninstalled libtool libraries, other files are standard or library
2081object files.
2082
2083If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
2084only library objects (\`.lo' files) may be specified, and \`-rpath' is
2085required, except when creating a convenience library.
2086
2087If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
2088using \`ar' and \`ranlib', or on Windows using \`lib'.
2089
2090If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
2091is created, otherwise an executable program is created."
2092        ;;
2093
2094      uninstall)
2095        $ECHO \
2096"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
2097
2098Remove libraries from an installation directory.
2099
2100RM is the name of the program to use to delete files associated with each FILE
2101(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
2102to RM.
2103
2104If FILE is a libtool library, all the files associated with it are deleted.
2105Otherwise, only FILE itself is deleted using RM."
2106        ;;
2107
2108      *)
2109        func_fatal_help "invalid operation mode \`$mode'"
2110        ;;
2111    esac
2112
2113    $ECHO
2114    $ECHO "Try \`$progname --help' for more information about other modes."
2115
2116    exit $?
2117}
2118
2119  # Now that we've collected a possible --mode arg, show help if necessary
2120  $opt_help && func_mode_help
2121
2122
2123# func_mode_execute arg...
2124func_mode_execute ()
2125{
2126    $opt_debug
2127    # The first argument is the command name.
2128    cmd="$nonopt"
2129    test -z "$cmd" && \
2130      func_fatal_help "you must specify a COMMAND"
2131
2132    # Handle -dlopen flags immediately.
2133    for file in $execute_dlfiles; do
2134      test -f "$file" \
2135        || func_fatal_help "\`$file' is not a file"
2136
2137      dir=
2138      case $file in
2139      *.la)
2140        # Check to see that this really is a libtool archive.
2141        func_lalib_unsafe_p "$file" \
2142          || func_fatal_help "\`$lib' is not a valid libtool archive"
2143
2144        # Read the libtool library.
2145        dlname=
2146        library_names=
2147        func_source "$file"
2148
2149        # Skip this library if it cannot be dlopened.
2150        if test -z "$dlname"; then
2151          # Warn if it was a shared library.
2152          test -n "$library_names" && \
2153            func_warning "\`$file' was not linked with \`-export-dynamic'"
2154          continue
2155        fi
2156
2157        func_dirname "$file" "" "."
2158        dir="$func_dirname_result"
2159
2160        if test -f "$dir/$objdir/$dlname"; then
2161          dir="$dir/$objdir"
2162        else
2163          if test ! -f "$dir/$dlname"; then
2164            func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
2165          fi
2166        fi
2167        ;;
2168
2169      *.lo)
2170        # Just add the directory containing the .lo file.
2171        func_dirname "$file" "" "."
2172        dir="$func_dirname_result"
2173        ;;
2174
2175      *)
2176        func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
2177        continue
2178        ;;
2179      esac
2180
2181      # Get the absolute pathname.
2182      absdir=`cd "$dir" && pwd`
2183      test -n "$absdir" && dir="$absdir"
2184
2185      # Now add the directory to shlibpath_var.
2186      if eval "test -z \"\$$shlibpath_var\""; then
2187        eval "$shlibpath_var=\"\$dir\""
2188      else
2189        eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
2190      fi
2191    done
2192
2193    # This variable tells wrapper scripts just to set shlibpath_var
2194    # rather than running their programs.
2195    libtool_execute_magic="$magic"
2196
2197    # Check if any of the arguments is a wrapper script.
2198    args=
2199    for file
2200    do
2201      case $file in
2202      -*) ;;
2203      *)
2204        # Do a test to see if this is really a libtool program.
2205        if func_ltwrapper_script_p "$file"; then
2206          func_source "$file"
2207          # Transform arg to wrapped name.
2208          file="$progdir/$program"
2209        elif func_ltwrapper_executable_p "$file"; then
2210          func_ltwrapper_scriptname "$file"
2211          func_source "$func_ltwrapper_scriptname_result"
2212          # Transform arg to wrapped name.
2213          file="$progdir/$program"
2214        fi
2215        ;;
2216      esac
2217      # Quote arguments (to preserve shell metacharacters).
2218      func_quote_for_eval "$file"
2219      args="$args $func_quote_for_eval_result"
2220    done
2221
2222    if test "X$opt_dry_run" = Xfalse; then
2223      if test -n "$shlibpath_var"; then
2224        # Export the shlibpath_var.
2225        eval "export $shlibpath_var"
2226      fi
2227
2228      # Restore saved environment variables
2229      for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
2230      do
2231        eval "if test \"\${save_$lt_var+set}\" = set; then
2232                $lt_var=\$save_$lt_var; export $lt_var
2233              else
2234                $lt_unset $lt_var
2235              fi"
2236      done
2237
2238      # Now prepare to actually exec the command.
2239      exec_cmd="\$cmd$args"
2240    else
2241      # Display what would be done.
2242      if test -n "$shlibpath_var"; then
2243        eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
2244        $ECHO "export $shlibpath_var"
2245      fi
2246      $ECHO "$cmd$args"
2247      exit $EXIT_SUCCESS
2248    fi
2249}
2250
2251test "$mode" = execute && func_mode_execute ${1+"$@"}
2252
2253
2254# func_mode_finish arg...
2255func_mode_finish ()
2256{
2257    $opt_debug
2258    libdirs="$nonopt"
2259    admincmds=
2260
2261    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2262      for dir
2263      do
2264        libdirs="$libdirs $dir"
2265      done
2266
2267      for libdir in $libdirs; do
2268        if test -n "$finish_cmds"; then
2269          # Do each command in the finish commands.
2270          func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
2271'"$cmd"'"'
2272        fi
2273        if test -n "$finish_eval"; then
2274          # Do the single finish_eval.
2275          eval cmds=\"$finish_eval\"
2276          $opt_dry_run || eval "$cmds" || admincmds="$admincmds
2277       $cmds"
2278        fi
2279      done
2280    fi
2281
2282    # Exit here if they wanted silent mode.
2283    $opt_silent && exit $EXIT_SUCCESS
2284
2285    $ECHO "X----------------------------------------------------------------------" | $Xsed
2286    $ECHO "Libraries have been installed in:"
2287    for libdir in $libdirs; do
2288      $ECHO "   $libdir"
2289    done
2290    $ECHO
2291    $ECHO "If you ever happen to want to link against installed libraries"
2292    $ECHO "in a given directory, LIBDIR, you must either use libtool, and"
2293    $ECHO "specify the full pathname of the library, or use the \`-LLIBDIR'"
2294    $ECHO "flag during linking and do at least one of the following:"
2295    if test -n "$shlibpath_var"; then
2296      $ECHO "   - add LIBDIR to the \`$shlibpath_var' environment variable"
2297      $ECHO "     during execution"
2298    fi
2299    if test -n "$runpath_var"; then
2300      $ECHO "   - add LIBDIR to the \`$runpath_var' environment variable"
2301      $ECHO "     during linking"
2302    fi
2303    if test -n "$hardcode_libdir_flag_spec"; then
2304      libdir=LIBDIR
2305      eval flag=\"$hardcode_libdir_flag_spec\"
2306
2307      $ECHO "   - use the \`$flag' linker flag"
2308    fi
2309    if test -n "$admincmds"; then
2310      $ECHO "   - have your system administrator run these commands:$admincmds"
2311    fi
2312    if test -f /etc/ld.so.conf; then
2313      $ECHO "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
2314    fi
2315    $ECHO
2316
2317    $ECHO "See any operating system documentation about shared libraries for"
2318    case $host in
2319      solaris2.[6789]|solaris2.1[0-9])
2320        $ECHO "more information, such as the ld(1), crle(1) and ld.so(8) manual"
2321        $ECHO "pages."
2322        ;;
2323      *)
2324        $ECHO "more information, such as the ld(1) and ld.so(8) manual pages."
2325        ;;
2326    esac
2327    $ECHO "X----------------------------------------------------------------------" | $Xsed
2328    exit $EXIT_SUCCESS
2329}
2330
2331test "$mode" = finish && func_mode_finish ${1+"$@"}
2332
2333
2334# func_mode_install arg...
2335func_mode_install ()
2336{
2337    $opt_debug
2338    # There may be an optional sh(1) argument at the beginning of
2339    # install_prog (especially on Windows NT).
2340    if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
2341       # Allow the use of GNU shtool's install command.
2342       $ECHO "X$nonopt" | $GREP shtool >/dev/null; then
2343      # Aesthetically quote it.
2344      func_quote_for_eval "$nonopt"
2345      install_prog="$func_quote_for_eval_result "
2346      arg=$1
2347      shift
2348    else
2349      install_prog=
2350      arg=$nonopt
2351    fi
2352
2353    # The real first argument should be the name of the installation program.
2354    # Aesthetically quote it.
2355    func_quote_for_eval "$arg"
2356    install_prog="$install_prog$func_quote_for_eval_result"
2357
2358    # We need to accept at least all the BSD install flags.
2359    dest=
2360    files=
2361    opts=
2362    prev=
2363    install_type=
2364    isdir=no
2365    stripme=
2366    for arg
2367    do
2368      if test -n "$dest"; then
2369        files="$files $dest"
2370        dest=$arg
2371        continue
2372      fi
2373
2374      case $arg in
2375      -d) isdir=yes ;;
2376      -f)
2377        case " $install_prog " in
2378        *[\\\ /]cp\ *) ;;
2379        *) prev=$arg ;;
2380        esac
2381        ;;
2382      -g | -m | -o)
2383        prev=$arg
2384        ;;
2385      -s)
2386        stripme=" -s"
2387        continue
2388        ;;
2389      -*)
2390        ;;
2391      *)
2392        # If the previous option needed an argument, then skip it.
2393        if test -n "$prev"; then
2394          prev=
2395        else
2396          dest=$arg
2397          continue
2398        fi
2399        ;;
2400      esac
2401
2402      # Aesthetically quote the argument.
2403      func_quote_for_eval "$arg"
2404      install_prog="$install_prog $func_quote_for_eval_result"
2405    done
2406
2407    test -z "$install_prog" && \
2408      func_fatal_help "you must specify an install program"
2409
2410    test -n "$prev" && \
2411      func_fatal_help "the \`$prev' option requires an argument"
2412
2413    if test -z "$files"; then
2414      if test -z "$dest"; then
2415        func_fatal_help "no file or destination specified"
2416      else
2417        func_fatal_help "you must specify a destination"
2418      fi
2419    fi
2420
2421    # Strip any trailing slash from the destination.
2422    func_stripname '' '/' "$dest"
2423    dest=$func_stripname_result
2424
2425    # Check to see that the destination is a directory.
2426    test -d "$dest" && isdir=yes
2427    if test "$isdir" = yes; then
2428      destdir="$dest"
2429      destname=
2430    else
2431      func_dirname_and_basename "$dest" "" "."
2432      destdir="$func_dirname_result"
2433      destname="$func_basename_result"
2434
2435      # Not a directory, so check to see that there is only one file specified.
2436      set dummy $files; shift
2437      test "$#" -gt 1 && \
2438        func_fatal_help "\`$dest' is not a directory"
2439    fi
2440    case $destdir in
2441    [\\/]* | [A-Za-z]:[\\/]*) ;;
2442    *)
2443      for file in $files; do
2444        case $file in
2445        *.lo) ;;
2446        *)
2447          func_fatal_help "\`$destdir' must be an absolute directory name"
2448          ;;
2449        esac
2450      done
2451      ;;
2452    esac
2453
2454    # This variable tells wrapper scripts just to set variables rather
2455    # than running their programs.
2456    libtool_install_magic="$magic"
2457
2458    staticlibs=
2459    future_libdirs=
2460    current_libdirs=
2461    for file in $files; do
2462
2463      # Do each installation.
2464      case $file in
2465      *.$libext)
2466        # Do the static libraries later.
2467        staticlibs="$staticlibs $file"
2468        ;;
2469
2470      *.la)
2471        # Check to see that this really is a libtool archive.
2472        func_lalib_unsafe_p "$file" \
2473          || func_fatal_help "\`$file' is not a valid libtool archive"
2474
2475        library_names=
2476        old_library=
2477        relink_command=
2478        func_source "$file"
2479
2480        # Add the libdir to current_libdirs if it is the destination.
2481        if test "X$destdir" = "X$libdir"; then
2482          case "$current_libdirs " in
2483          *" $libdir "*) ;;
2484          *) current_libdirs="$current_libdirs $libdir" ;;
2485          esac
2486        else
2487          # Note the libdir as a future libdir.
2488          case "$future_libdirs " in
2489          *" $libdir "*) ;;
2490          *) future_libdirs="$future_libdirs $libdir" ;;
2491          esac
2492        fi
2493
2494        func_dirname "$file" "/" ""
2495        dir="$func_dirname_result"
2496        dir="$dir$objdir"
2497
2498        if test -n "$relink_command"; then
2499          # Determine the prefix the user has applied to our future dir.
2500          inst_prefix_dir=`$ECHO "X$destdir" | $Xsed -e "s%$libdir\$%%"`
2501
2502          # Don't allow the user to place us outside of our expected
2503          # location b/c this prevents finding dependent libraries that
2504          # are installed to the same prefix.
2505          # At present, this check doesn't affect windows .dll's that
2506          # are installed into $libdir/../bin (currently, that works fine)
2507          # but it's something to keep an eye on.
2508          test "$inst_prefix_dir" = "$destdir" && \
2509            func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2510
2511          if test -n "$inst_prefix_dir"; then
2512            # Stick the inst_prefix_dir data into the link command.
2513            relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2514          else
2515            relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%%"`
2516          fi
2517
2518          func_warning "relinking \`$file'"
2519          func_show_eval "$relink_command" \
2520            'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2521        fi
2522
2523        # See the names of the shared library.
2524        set dummy $library_names; shift
2525        if test -n "$1"; then
2526          realname="$1"
2527          shift
2528
2529          srcname="$realname"
2530          test -n "$relink_command" && srcname="$realname"T
2531
2532          # Install the shared library and build the symlinks.
2533          func_show_eval "$install_prog $dir/$srcname $destdir/$realname" \
2534              'exit $?'
2535          tstripme="$stripme"
2536          case $host_os in
2537          cygwin* | mingw* | pw32* | cegcc*)
2538            case $realname in
2539            *.dll.a)
2540              tstripme=""
2541              ;;
2542            esac
2543            ;;
2544          esac
2545          if test -n "$tstripme" && test -n "$striplib"; then
2546            func_show_eval "$striplib $destdir/$realname" 'exit $?'
2547          fi
2548
2549          if test "$#" -gt 0; then
2550            # Delete the old symlinks, and create new ones.
2551            # Try `ln -sf' first, because the `ln' binary might depend on
2552            # the symlink we replace!  Solaris /bin/ln does not understand -f,
2553            # so we also need to try rm && ln -s.
2554            for linkname
2555            do
2556              test "$linkname" != "$realname" \
2557                && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
2558            done
2559          fi
2560
2561          # Do each command in the postinstall commands.
2562          lib="$destdir/$realname"
2563          func_execute_cmds "$postinstall_cmds" 'exit $?'
2564        fi
2565
2566        # Install the pseudo-library for information purposes.
2567        func_basename "$file"
2568        name="$func_basename_result"
2569        instname="$dir/$name"i
2570        func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
2571
2572        # Maybe install the static library, too.
2573        test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
2574        ;;
2575
2576      *.lo)
2577        # Install (i.e. copy) a libtool object.
2578
2579        # Figure out destination file name, if it wasn't already specified.
2580        if test -n "$destname"; then
2581          destfile="$destdir/$destname"
2582        else
2583          func_basename "$file"
2584          destfile="$func_basename_result"
2585          destfile="$destdir/$destfile"
2586        fi
2587
2588        # Deduce the name of the destination old-style object file.
2589        case $destfile in
2590        *.lo)
2591          func_lo2o "$destfile"
2592          staticdest=$func_lo2o_result
2593          ;;
2594        *.$objext)
2595          staticdest="$destfile"
2596          destfile=
2597          ;;
2598        *)
2599          func_fatal_help "cannot copy a libtool object to \`$destfile'"
2600          ;;
2601        esac
2602
2603        # Install the libtool object if requested.
2604        test -n "$destfile" && \
2605          func_show_eval "$install_prog $file $destfile" 'exit $?'
2606
2607        # Install the old object if enabled.
2608        if test "$build_old_libs" = yes; then
2609          # Deduce the name of the old-style object file.
2610          func_lo2o "$file"
2611          staticobj=$func_lo2o_result
2612          func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
2613        fi
2614        exit $EXIT_SUCCESS
2615        ;;
2616
2617      *)
2618        # Figure out destination file name, if it wasn't already specified.
2619        if test -n "$destname"; then
2620          destfile="$destdir/$destname"
2621        else
2622          func_basename "$file"
2623          destfile="$func_basename_result"
2624          destfile="$destdir/$destfile"
2625        fi
2626
2627        # If the file is missing, and there is a .exe on the end, strip it
2628        # because it is most likely a libtool script we actually want to
2629        # install
2630        stripped_ext=""
2631        case $file in
2632          *.exe)
2633            if test ! -f "$file"; then
2634              func_stripname '' '.exe' "$file"
2635              file=$func_stripname_result
2636              stripped_ext=".exe"
2637            fi
2638            ;;
2639        esac
2640
2641        # Do a test to see if this is really a libtool program.
2642        case $host in
2643        *cygwin* | *mingw*)
2644            if func_ltwrapper_executable_p "$file"; then
2645              func_ltwrapper_scriptname "$file"
2646              wrapper=$func_ltwrapper_scriptname_result
2647            else
2648              func_stripname '' '.exe' "$file"
2649              wrapper=$func_stripname_result
2650            fi
2651            ;;
2652        *)
2653            wrapper=$file
2654            ;;
2655        esac
2656        if func_ltwrapper_script_p "$wrapper"; then
2657          notinst_deplibs=
2658          relink_command=
2659
2660          func_source "$wrapper"
2661
2662          # Check the variables that should have been set.
2663          test -z "$generated_by_libtool_version" && \
2664            func_fatal_error "invalid libtool wrapper script \`$wrapper'"
2665
2666          finalize=yes
2667          for lib in $notinst_deplibs; do
2668            # Check to see that each library is installed.
2669            libdir=
2670            if test -f "$lib"; then
2671              func_source "$lib"
2672            fi
2673            libfile="$libdir/"`$ECHO "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
2674            if test -n "$libdir" && test ! -f "$libfile"; then
2675              func_warning "\`$lib' has not been installed in \`$libdir'"
2676              finalize=no
2677            fi
2678          done
2679
2680          relink_command=
2681          func_source "$wrapper"
2682
2683          outputname=
2684          if test "$fast_install" = no && test -n "$relink_command"; then
2685            $opt_dry_run || {
2686              if test "$finalize" = yes; then
2687                tmpdir=`func_mktempdir`
2688                func_basename "$file$stripped_ext"
2689                file="$func_basename_result"
2690                outputname="$tmpdir/$file"
2691                # Replace the output file specification.
2692                relink_command=`$ECHO "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
2693
2694                $opt_silent || {
2695                  func_quote_for_expand "$relink_command"
2696                  eval "func_echo $func_quote_for_expand_result"
2697                }
2698                if eval "$relink_command"; then :
2699                  else
2700                  func_error "error: relink \`$file' with the above command before installing it"
2701                  $opt_dry_run || ${RM}r "$tmpdir"
2702                  continue
2703                fi
2704                file="$outputname"
2705              else
2706                func_warning "cannot relink \`$file'"
2707              fi
2708            }
2709          else
2710            # Install the binary that we compiled earlier.
2711            file=`$ECHO "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
2712          fi
2713        fi
2714
2715        # remove .exe since cygwin /usr/bin/install will append another
2716        # one anyway
2717        case $install_prog,$host in
2718        */usr/bin/install*,*cygwin*)
2719          case $file:$destfile in
2720          *.exe:*.exe)
2721            # this is ok
2722            ;;
2723          *.exe:*)
2724            destfile=$destfile.exe
2725            ;;
2726          *:*.exe)
2727            func_stripname '' '.exe' "$destfile"
2728            destfile=$func_stripname_result
2729            ;;
2730          esac
2731          ;;
2732        esac
2733        func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
2734        $opt_dry_run || if test -n "$outputname"; then
2735          ${RM}r "$tmpdir"
2736        fi
2737        ;;
2738      esac
2739    done
2740
2741    for file in $staticlibs; do
2742      func_basename "$file"
2743      name="$func_basename_result"
2744
2745      # Set up the ranlib parameters.
2746      oldlib="$destdir/$name"
2747
2748      func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
2749
2750      if test -n "$stripme" && test -n "$old_striplib"; then
2751        func_show_eval "$old_striplib $oldlib" 'exit $?'
2752      fi
2753
2754      # Do each command in the postinstall commands.
2755      func_execute_cmds "$old_postinstall_cmds" 'exit $?'
2756    done
2757
2758    test -n "$future_libdirs" && \
2759      func_warning "remember to run \`$progname --finish$future_libdirs'"
2760
2761    if test -n "$current_libdirs"; then
2762      # Maybe just do a dry run.
2763      $opt_dry_run && current_libdirs=" -n$current_libdirs"
2764      exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
2765    else
2766      exit $EXIT_SUCCESS
2767    fi
2768}
2769
2770test "$mode" = install && func_mode_install ${1+"$@"}
2771
2772
2773# func_generate_dlsyms outputname originator pic_p
2774# Extract symbols from dlprefiles and create ${outputname}S.o with
2775# a dlpreopen symbol table.
2776func_generate_dlsyms ()
2777{
2778    $opt_debug
2779    my_outputname="$1"
2780    my_originator="$2"
2781    my_pic_p="${3-no}"
2782    my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
2783    my_dlsyms=
2784
2785    if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2786      if test -n "$NM" && test -n "$global_symbol_pipe"; then
2787        my_dlsyms="${my_outputname}S.c"
2788      else
2789        func_error "not configured to extract global symbols from dlpreopened files"
2790      fi
2791    fi
2792
2793    if test -n "$my_dlsyms"; then
2794      case $my_dlsyms in
2795      "") ;;
2796      *.c)
2797        # Discover the nlist of each of the dlfiles.
2798        nlist="$output_objdir/${my_outputname}.nm"
2799
2800        func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
2801
2802        # Parse the name list into a source file.
2803        func_verbose "creating $output_objdir/$my_dlsyms"
2804
2805        $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
2806/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
2807/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
2808
2809#ifdef __cplusplus
2810extern \"C\" {
2811#endif
2812
2813/* External symbol declarations for the compiler. */\
2814"
2815
2816        if test "$dlself" = yes; then
2817          func_verbose "generating symbol list for \`$output'"
2818
2819          $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
2820
2821          # Add our own program objects to the symbol list.
2822          progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
2823          for progfile in $progfiles; do
2824            func_verbose "extracting global C symbols from \`$progfile'"
2825            $opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
2826          done
2827
2828          if test -n "$exclude_expsyms"; then
2829            $opt_dry_run || {
2830              eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
2831              eval '$MV "$nlist"T "$nlist"'
2832            }
2833          fi
2834
2835          if test -n "$export_symbols_regex"; then
2836            $opt_dry_run || {
2837              eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
2838              eval '$MV "$nlist"T "$nlist"'
2839            }
2840          fi
2841
2842          # Prepare the list of exported symbols
2843          if test -z "$export_symbols"; then
2844            export_symbols="$output_objdir/$outputname.exp"
2845            $opt_dry_run || {
2846              $RM $export_symbols
2847              eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
2848              case $host in
2849              *cygwin* | *mingw* | *cegcc* )
2850                eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2851                eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
2852                ;;
2853              esac
2854            }
2855          else
2856            $opt_dry_run || {
2857              eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
2858              eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
2859              eval '$MV "$nlist"T "$nlist"'
2860              case $host in
2861                *cygwin | *mingw* | *cegcc* )
2862                  eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2863                  eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
2864                  ;;
2865              esac
2866            }
2867          fi
2868        fi
2869
2870        for dlprefile in $dlprefiles; do
2871          func_verbose "extracting global C symbols from \`$dlprefile'"
2872          func_basename "$dlprefile"
2873          name="$func_basename_result"
2874          $opt_dry_run || {
2875            eval '$ECHO ": $name " >> "$nlist"'
2876            eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
2877          }
2878        done
2879
2880        $opt_dry_run || {
2881          # Make sure we have at least an empty file.
2882          test -f "$nlist" || : > "$nlist"
2883
2884          if test -n "$exclude_expsyms"; then
2885            $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
2886            $MV "$nlist"T "$nlist"
2887          fi
2888
2889          # Try sorting and uniquifying the output.
2890          if $GREP -v "^: " < "$nlist" |
2891              if sort -k 3 </dev/null >/dev/null 2>&1; then
2892                sort -k 3
2893              else
2894                sort +2
2895              fi |
2896              uniq > "$nlist"S; then
2897            :
2898          else
2899            $GREP -v "^: " < "$nlist" > "$nlist"S
2900          fi
2901
2902          if test -f "$nlist"S; then
2903            eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
2904          else
2905            $ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms"
2906          fi
2907
2908          $ECHO >> "$output_objdir/$my_dlsyms" "\
2909
2910/* The mapping between symbol names and symbols.  */
2911typedef struct {
2912  const char *name;
2913  void *address;
2914} lt_dlsymlist;
2915"
2916          case $host in
2917          *cygwin* | *mingw* | *cegcc* )
2918            $ECHO >> "$output_objdir/$my_dlsyms" "\
2919/* DATA imports from DLLs on WIN32 con't be const, because
2920   runtime relocations are performed -- see ld's documentation
2921   on pseudo-relocs.  */"
2922            lt_dlsym_const= ;;
2923          *osf5*)
2924            echo >> "$output_objdir/$my_dlsyms" "\
2925/* This system does not cope well with relocations in const data */"
2926            lt_dlsym_const= ;;
2927          *)
2928            lt_dlsym_const=const ;;
2929          esac
2930
2931          $ECHO >> "$output_objdir/$my_dlsyms" "\
2932extern $lt_dlsym_const lt_dlsymlist
2933lt_${my_prefix}_LTX_preloaded_symbols[];
2934$lt_dlsym_const lt_dlsymlist
2935lt_${my_prefix}_LTX_preloaded_symbols[] =
2936{\
2937  { \"$my_originator\", (void *) 0 },"
2938
2939          case $need_lib_prefix in
2940          no)
2941            eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
2942            ;;
2943          *)
2944            eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
2945            ;;
2946          esac
2947          $ECHO >> "$output_objdir/$my_dlsyms" "\
2948  {0, (void *) 0}
2949};
2950
2951/* This works around a problem in FreeBSD linker */
2952#ifdef FREEBSD_WORKAROUND
2953static const void *lt_preloaded_setup() {
2954  return lt_${my_prefix}_LTX_preloaded_symbols;
2955}
2956#endif
2957
2958#ifdef __cplusplus
2959}
2960#endif\
2961"
2962        } # !$opt_dry_run
2963
2964        pic_flag_for_symtable=
2965        case "$compile_command " in
2966        *" -static "*) ;;
2967        *)
2968          case $host in
2969          # compiling the symbol table file with pic_flag works around
2970          # a FreeBSD bug that causes programs to crash when -lm is
2971          # linked before any other PIC object.  But we must not use
2972          # pic_flag when linking with -static.  The problem exists in
2973          # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
2974          *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
2975            pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
2976          *-*-hpux*)
2977            pic_flag_for_symtable=" $pic_flag"  ;;
2978          *)
2979            if test "X$my_pic_p" != Xno; then
2980              pic_flag_for_symtable=" $pic_flag"
2981            fi
2982            ;;
2983          esac
2984          ;;
2985        esac
2986        symtab_cflags=
2987        for arg in $LTCFLAGS; do
2988          case $arg in
2989          -pie | -fpie | -fPIE) ;;
2990          *) symtab_cflags="$symtab_cflags $arg" ;;
2991          esac
2992        done
2993
2994        # Now compile the dynamic symbol file.
2995        func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
2996
2997        # Clean up the generated files.
2998        func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
2999
3000        # Transform the symbol file into the correct name.
3001        symfileobj="$output_objdir/${my_outputname}S.$objext"
3002        case $host in
3003        *cygwin* | *mingw* | *cegcc* )
3004          if test -f "$output_objdir/$my_outputname.def"; then
3005            compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3006            finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3007          else
3008            compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
3009            finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
3010          fi
3011          ;;
3012        *)
3013          compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
3014          finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
3015          ;;
3016        esac
3017        ;;
3018      *)
3019        func_fatal_error "unknown suffix for \`$my_dlsyms'"
3020        ;;
3021      esac
3022    else
3023      # We keep going just in case the user didn't refer to
3024      # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
3025      # really was required.
3026
3027      # Nullify the symbol file.
3028      compile_command=`$ECHO "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
3029      finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
3030    fi
3031}
3032
3033# func_win32_libid arg
3034# return the library type of file 'arg'
3035#
3036# Need a lot of goo to handle *both* DLLs and import libs
3037# Has to be a shell function in order to 'eat' the argument
3038# that is supplied when $file_magic_command is called.
3039func_win32_libid ()
3040{
3041  $opt_debug
3042  win32_libid_type="unknown"
3043  win32_fileres=`file -L $1 2>/dev/null`
3044  case $win32_fileres in
3045  *ar\ archive\ import\ library*) # definitely import
3046    win32_libid_type="x86 archive import"
3047    ;;
3048  *ar\ archive*) # could be an import, or static
3049    if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
3050       $EGREP 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
3051      win32_nmres=`eval $NM -f posix -A $1 |
3052        $SED -n -e '
3053            1,100{
3054                / I /{
3055                    s,.*,import,
3056                    p
3057                    q
3058                }
3059            }'`
3060      case $win32_nmres in
3061      import*)  win32_libid_type="x86 archive import";;
3062      *)        win32_libid_type="x86 archive static";;
3063      esac
3064    fi
3065    ;;
3066  *DLL*)
3067    win32_libid_type="x86 DLL"
3068    ;;
3069  *executable*) # but shell scripts are "executable" too...
3070    case $win32_fileres in
3071    *MS\ Windows\ PE\ Intel*)
3072      win32_libid_type="x86 DLL"
3073      ;;
3074    esac
3075    ;;
3076  esac
3077  $ECHO "$win32_libid_type"
3078}
3079
3080
3081
3082# func_extract_an_archive dir oldlib
3083func_extract_an_archive ()
3084{
3085    $opt_debug
3086    f_ex_an_ar_dir="$1"; shift
3087    f_ex_an_ar_oldlib="$1"
3088    func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" 'exit $?'
3089    if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
3090     :
3091    else
3092      func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
3093    fi
3094}
3095
3096
3097# func_extract_archives gentop oldlib ...
3098func_extract_archives ()
3099{
3100    $opt_debug
3101    my_gentop="$1"; shift
3102    my_oldlibs=${1+"$@"}
3103    my_oldobjs=""
3104    my_xlib=""
3105    my_xabs=""
3106    my_xdir=""
3107
3108    for my_xlib in $my_oldlibs; do
3109      # Extract the objects.
3110      case $my_xlib in
3111        [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
3112        *) my_xabs=`pwd`"/$my_xlib" ;;
3113      esac
3114      func_basename "$my_xlib"
3115      my_xlib="$func_basename_result"
3116      my_xlib_u=$my_xlib
3117      while :; do
3118        case " $extracted_archives " in
3119        *" $my_xlib_u "*)
3120          func_arith $extracted_serial + 1
3121          extracted_serial=$func_arith_result
3122          my_xlib_u=lt$extracted_serial-$my_xlib ;;
3123        *) break ;;
3124        esac
3125      done
3126      extracted_archives="$extracted_archives $my_xlib_u"
3127      my_xdir="$my_gentop/$my_xlib_u"
3128
3129      func_mkdir_p "$my_xdir"
3130
3131      case $host in
3132      *-darwin*)
3133        func_verbose "Extracting $my_xabs"
3134        # Do not bother doing anything if just a dry run
3135        $opt_dry_run || {
3136          darwin_orig_dir=`pwd`
3137          cd $my_xdir || exit $?
3138          darwin_archive=$my_xabs
3139          darwin_curdir=`pwd`
3140          darwin_base_archive=`basename "$darwin_archive"`
3141          darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
3142          if test -n "$darwin_arches"; then
3143            darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
3144            darwin_arch=
3145            func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
3146            for darwin_arch in  $darwin_arches ; do
3147              func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3148              $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
3149              cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3150              func_extract_an_archive "`pwd`" "${darwin_base_archive}"
3151              cd "$darwin_curdir"
3152              $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
3153            done # $darwin_arches
3154            ## Okay now we've a bunch of thin objects, gotta fatten them up :)
3155            darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
3156            darwin_file=
3157            darwin_files=
3158            for darwin_file in $darwin_filelist; do
3159              darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
3160              $LIPO -create -output "$darwin_file" $darwin_files
3161            done # $darwin_filelist
3162            $RM -rf unfat-$$
3163            cd "$darwin_orig_dir"
3164          else
3165            cd $darwin_orig_dir
3166            func_extract_an_archive "$my_xdir" "$my_xabs"
3167          fi # $darwin_arches
3168        } # !$opt_dry_run
3169        ;;
3170      *)
3171        func_extract_an_archive "$my_xdir" "$my_xabs"
3172        ;;
3173      esac
3174      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
3175    done
3176
3177    func_extract_archives_result="$my_oldobjs"
3178}
3179
3180
3181
3182# func_emit_wrapper_part1 [arg=no]
3183#
3184# Emit the first part of a libtool wrapper script on stdout.
3185# For more information, see the description associated with
3186# func_emit_wrapper(), below.
3187func_emit_wrapper_part1 ()
3188{
3189        func_emit_wrapper_part1_arg1=no
3190        if test -n "$1" ; then
3191          func_emit_wrapper_part1_arg1=$1
3192        fi
3193
3194        $ECHO "\
3195#! $SHELL
3196
3197# $output - temporary wrapper script for $objdir/$outputname
3198# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3199#
3200# The $output program cannot be directly executed until all the libtool
3201# libraries that it depends on are installed.
3202#
3203# This wrapper script should never be moved out of the build directory.
3204# If it is, it will not operate correctly.
3205
3206# Sed substitution that helps us do robust quoting.  It backslashifies
3207# metacharacters that are still active within double-quoted strings.
3208Xsed='${SED} -e 1s/^X//'
3209sed_quote_subst='$sed_quote_subst'
3210
3211# Be Bourne compatible
3212if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
3213  emulate sh
3214  NULLCMD=:
3215  # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
3216  # is contrary to our usage.  Disable this feature.
3217  alias -g '\${1+\"\$@\"}'='\"\$@\"'
3218  setopt NO_GLOB_SUBST
3219else
3220  case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
3221fi
3222BIN_SH=xpg4; export BIN_SH # for Tru64
3223DUALCASE=1; export DUALCASE # for MKS sh
3224
3225# The HP-UX ksh and POSIX shell print the target directory to stdout
3226# if CDPATH is set.
3227(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
3228
3229relink_command=\"$relink_command\"
3230
3231# This environment variable determines our operation mode.
3232if test \"\$libtool_install_magic\" = \"$magic\"; then
3233  # install mode needs the following variables:
3234  generated_by_libtool_version='$macro_version'
3235  notinst_deplibs='$notinst_deplibs'
3236else
3237  # When we are sourced in execute mode, \$file and \$ECHO are already set.
3238  if test \"\$libtool_execute_magic\" != \"$magic\"; then
3239    ECHO=\"$qecho\"
3240    file=\"\$0\"
3241    # Make sure echo works.
3242    if test \"X\$1\" = X--no-reexec; then
3243      # Discard the --no-reexec flag, and continue.
3244      shift
3245    elif test \"X\`{ \$ECHO '\t'; } 2>/dev/null\`\" = 'X\t'; then
3246      # Yippee, \$ECHO works!
3247      :
3248    else
3249      # Restart under the correct shell, and then maybe \$ECHO will work.
3250      exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
3251    fi
3252  fi\
3253"
3254        $ECHO "\
3255
3256  # Find the directory that this script lives in.
3257  thisdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
3258  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
3259
3260  # Follow symbolic links until we get to the real thisdir.
3261  file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
3262  while test -n \"\$file\"; do
3263    destdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
3264
3265    # If there was a directory component, then change thisdir.
3266    if test \"x\$destdir\" != \"x\$file\"; then
3267      case \"\$destdir\" in
3268      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
3269      *) thisdir=\"\$thisdir/\$destdir\" ;;
3270      esac
3271    fi
3272
3273    file=\`\$ECHO \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
3274    file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
3275  done
3276"
3277}
3278# end: func_emit_wrapper_part1
3279
3280# func_emit_wrapper_part2 [arg=no]
3281#
3282# Emit the second part of a libtool wrapper script on stdout.
3283# For more information, see the description associated with
3284# func_emit_wrapper(), below.
3285func_emit_wrapper_part2 ()
3286{
3287        func_emit_wrapper_part2_arg1=no
3288        if test -n "$1" ; then
3289          func_emit_wrapper_part2_arg1=$1
3290        fi
3291
3292        $ECHO "\
3293
3294  # Usually 'no', except on cygwin/mingw when embedded into
3295  # the cwrapper.
3296  WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_part2_arg1
3297  if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
3298    # special case for '.'
3299    if test \"\$thisdir\" = \".\"; then
3300      thisdir=\`pwd\`
3301    fi
3302    # remove .libs from thisdir
3303    case \"\$thisdir\" in
3304    *[\\\\/]$objdir ) thisdir=\`\$ECHO \"X\$thisdir\" | \$Xsed -e 's%[\\\\/][^\\\\/]*$%%'\` ;;
3305    $objdir )   thisdir=. ;;
3306    esac
3307  fi
3308
3309  # Try to get the absolute directory name.
3310  absdir=\`cd \"\$thisdir\" && pwd\`
3311  test -n \"\$absdir\" && thisdir=\"\$absdir\"
3312"
3313
3314        if test "$fast_install" = yes; then
3315          $ECHO "\
3316  program=lt-'$outputname'$exeext
3317  progdir=\"\$thisdir/$objdir\"
3318
3319  if test ! -f \"\$progdir/\$program\" ||
3320     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
3321       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
3322
3323    file=\"\$\$-\$program\"
3324
3325    if test ! -d \"\$progdir\"; then
3326      $MKDIR \"\$progdir\"
3327    else
3328      $RM \"\$progdir/\$file\"
3329    fi"
3330
3331          $ECHO "\
3332
3333    # relink executable if necessary
3334    if test -n \"\$relink_command\"; then
3335      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
3336      else
3337        $ECHO \"\$relink_command_output\" >&2
3338        $RM \"\$progdir/\$file\"
3339        exit 1
3340      fi
3341    fi
3342
3343    $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
3344    { $RM \"\$progdir/\$program\";
3345      $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
3346    $RM \"\$progdir/\$file\"
3347  fi"
3348        else
3349          $ECHO "\
3350  program='$outputname'
3351  progdir=\"\$thisdir/$objdir\"
3352"
3353        fi
3354
3355        $ECHO "\
3356
3357  if test -f \"\$progdir/\$program\"; then"
3358
3359        # Export our shlibpath_var if we have one.
3360        if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3361          $ECHO "\
3362    # Add our own library path to $shlibpath_var
3363    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
3364
3365    # Some systems cannot cope with colon-terminated $shlibpath_var
3366    # The second colon is a workaround for a bug in BeOS R4 sed
3367    $shlibpath_var=\`\$ECHO \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
3368
3369    export $shlibpath_var
3370"
3371        fi
3372
3373        # fixup the dll searchpath if we need to.
3374        if test -n "$dllsearchpath"; then
3375          $ECHO "\
3376    # Add the dll search path components to the executable PATH
3377    PATH=$dllsearchpath:\$PATH
3378"
3379        fi
3380
3381        $ECHO "\
3382    if test \"\$libtool_execute_magic\" != \"$magic\"; then
3383      # Run the actual program with our arguments.
3384"
3385        case $host in
3386        # Backslashes separate directories on plain windows
3387        *-*-mingw | *-*-os2* | *-cegcc*)
3388          $ECHO "\
3389      exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
3390"
3391          ;;
3392
3393        *)
3394          $ECHO "\
3395      exec \"\$progdir/\$program\" \${1+\"\$@\"}
3396"
3397          ;;
3398        esac
3399        $ECHO "\
3400      \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
3401      exit 1
3402    fi
3403  else
3404    # The program doesn't exist.
3405    \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
3406    \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
3407    $ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
3408    exit 1
3409  fi
3410fi\
3411"
3412}
3413# end: func_emit_wrapper_part2
3414
3415
3416# func_emit_wrapper [arg=no]
3417#
3418# Emit a libtool wrapper script on stdout.
3419# Don't directly open a file because we may want to
3420# incorporate the script contents within a cygwin/mingw
3421# wrapper executable.  Must ONLY be called from within
3422# func_mode_link because it depends on a number of variables
3423# set therein.
3424#
3425# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
3426# variable will take.  If 'yes', then the emitted script
3427# will assume that the directory in which it is stored is
3428# the $objdir directory.  This is a cygwin/mingw-specific
3429# behavior.
3430func_emit_wrapper ()
3431{
3432        func_emit_wrapper_arg1=no
3433        if test -n "$1" ; then
3434          func_emit_wrapper_arg1=$1
3435        fi
3436
3437        # split this up so that func_emit_cwrapperexe_src
3438        # can call each part independently.
3439        func_emit_wrapper_part1 "${func_emit_wrapper_arg1}"
3440        func_emit_wrapper_part2 "${func_emit_wrapper_arg1}"
3441}
3442
3443
3444# func_to_host_path arg
3445#
3446# Convert paths to host format when used with build tools.
3447# Intended for use with "native" mingw (where libtool itself
3448# is running under the msys shell), or in the following cross-
3449# build environments:
3450#    $build          $host
3451#    mingw (msys)    mingw  [e.g. native]
3452#    cygwin          mingw
3453#    *nix + wine     mingw
3454# where wine is equipped with the `winepath' executable.
3455# In the native mingw case, the (msys) shell automatically
3456# converts paths for any non-msys applications it launches,
3457# but that facility isn't available from inside the cwrapper.
3458# Similar accommodations are necessary for $host mingw and
3459# $build cygwin.  Calling this function does no harm for other
3460# $host/$build combinations not listed above.
3461#
3462# ARG is the path (on $build) that should be converted to
3463# the proper representation for $host. The result is stored
3464# in $func_to_host_path_result.
3465func_to_host_path ()
3466{
3467  func_to_host_path_result="$1"
3468  if test -n "$1" ; then
3469    case $host in
3470      *mingw* )
3471        lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
3472        case $build in
3473          *mingw* ) # actually, msys
3474            # awkward: cmd appends spaces to result
3475            lt_sed_strip_trailing_spaces="s/[ ]*\$//"
3476            func_to_host_path_tmp1=`( cmd //c echo "$1" |\
3477              $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
3478            func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
3479              $SED -e "$lt_sed_naive_backslashify"`
3480            ;;
3481          *cygwin* )
3482            func_to_host_path_tmp1=`cygpath -w "$1"`
3483            func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
3484              $SED -e "$lt_sed_naive_backslashify"`
3485            ;;
3486          * )
3487            # Unfortunately, winepath does not exit with a non-zero
3488            # error code, so we are forced to check the contents of
3489            # stdout. On the other hand, if the command is not
3490            # found, the shell will set an exit code of 127 and print
3491            # *an error message* to stdout. So we must check for both
3492            # error code of zero AND non-empty stdout, which explains
3493            # the odd construction:
3494            func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null`
3495            if test "$?" -eq 0 && test -n "${func_to_host_path_tmp1}"; then
3496              func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
3497                $SED -e "$lt_sed_naive_backslashify"`
3498            else
3499              # Allow warning below.
3500              func_to_host_path_result=""
3501            fi
3502            ;;
3503        esac
3504        if test -z "$func_to_host_path_result" ; then
3505          func_error "Could not determine host path corresponding to"
3506          func_error "  '$1'"
3507          func_error "Continuing, but uninstalled executables may not work."
3508          # Fallback:
3509          func_to_host_path_result="$1"
3510        fi
3511        ;;
3512    esac
3513  fi
3514}
3515# end: func_to_host_path
3516
3517# func_to_host_pathlist arg
3518#
3519# Convert pathlists to host format when used with build tools.
3520# See func_to_host_path(), above. This function supports the
3521# following $build/$host combinations (but does no harm for
3522# combinations not listed here):
3523#    $build          $host
3524#    mingw (msys)    mingw  [e.g. native]
3525#    cygwin          mingw
3526#    *nix + wine     mingw
3527#
3528# Path separators are also converted from $build format to
3529# $host format. If ARG begins or ends with a path separator
3530# character, it is preserved (but converted to $host format)
3531# on output.
3532#
3533# ARG is a pathlist (on $build) that should be converted to
3534# the proper representation on $host. The result is stored
3535# in $func_to_host_pathlist_result.
3536func_to_host_pathlist ()
3537{
3538  func_to_host_pathlist_result="$1"
3539  if test -n "$1" ; then
3540    case $host in
3541      *mingw* )
3542        lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
3543        # Remove leading and trailing path separator characters from
3544        # ARG. msys behavior is inconsistent here, cygpath turns them
3545        # into '.;' and ';.', and winepath ignores them completely.
3546        func_to_host_pathlist_tmp2="$1"
3547        # Once set for this call, this variable should not be
3548        # reassigned. It is used in tha fallback case.
3549        func_to_host_pathlist_tmp1=`echo "$func_to_host_pathlist_tmp2" |\
3550          $SED -e 's|^:*||' -e 's|:*$||'`
3551        case $build in
3552          *mingw* ) # Actually, msys.
3553            # Awkward: cmd appends spaces to result.
3554            lt_sed_strip_trailing_spaces="s/[ ]*\$//"
3555            func_to_host_pathlist_tmp2=`( cmd //c echo "$func_to_host_pathlist_tmp1" |\
3556              $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
3557            func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
3558              $SED -e "$lt_sed_naive_backslashify"`
3559            ;;
3560          *cygwin* )
3561            func_to_host_pathlist_tmp2=`cygpath -w -p "$func_to_host_pathlist_tmp1"`
3562            func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
3563              $SED -e "$lt_sed_naive_backslashify"`
3564            ;;
3565          * )
3566            # unfortunately, winepath doesn't convert pathlists
3567            func_to_host_pathlist_result=""
3568            func_to_host_pathlist_oldIFS=$IFS
3569            IFS=:
3570            for func_to_host_pathlist_f in $func_to_host_pathlist_tmp1 ; do
3571              IFS=$func_to_host_pathlist_oldIFS
3572              if test -n "$func_to_host_pathlist_f" ; then
3573                func_to_host_path "$func_to_host_pathlist_f"
3574                if test -n "$func_to_host_path_result" ; then
3575                  if test -z "$func_to_host_pathlist_result" ; then
3576                    func_to_host_pathlist_result="$func_to_host_path_result"
3577                  else
3578                    func_to_host_pathlist_result="$func_to_host_pathlist_result;$func_to_host_path_result"
3579                  fi
3580                fi
3581              fi
3582              IFS=:
3583            done
3584            IFS=$func_to_host_pathlist_oldIFS
3585            ;;
3586        esac
3587        if test -z "$func_to_host_pathlist_result" ; then
3588          func_error "Could not determine the host path(s) corresponding to"
3589          func_error "  '$1'"
3590          func_error "Continuing, but uninstalled executables may not work."
3591          # Fallback. This may break if $1 contains DOS-style drive
3592          # specifications. The fix is not to complicate the expression
3593          # below, but for the user to provide a working wine installation
3594          # with winepath so that path translation in the cross-to-mingw
3595          # case works properly.
3596          lt_replace_pathsep_nix_to_dos="s|:|;|g"
3597          func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp1" |\
3598            $SED -e "$lt_replace_pathsep_nix_to_dos"`
3599        fi
3600        # Now, add the leading and trailing path separators back
3601        case "$1" in
3602          :* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result"
3603            ;;
3604        esac
3605        case "$1" in
3606          *: ) func_to_host_pathlist_result="$func_to_host_pathlist_result;"
3607            ;;
3608        esac
3609        ;;
3610    esac
3611  fi
3612}
3613# end: func_to_host_pathlist
3614
3615# func_emit_cwrapperexe_src
3616# emit the source code for a wrapper executable on stdout
3617# Must ONLY be called from within func_mode_link because
3618# it depends on a number of variable set therein.
3619func_emit_cwrapperexe_src ()
3620{
3621        cat <<EOF
3622
3623/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
3624   Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3625
3626   The $output program cannot be directly executed until all the libtool
3627   libraries that it depends on are installed.
3628
3629   This wrapper executable should never be moved out of the build directory.
3630   If it is, it will not operate correctly.
3631
3632   Currently, it simply execs the wrapper *script* "$SHELL $output",
3633   but could eventually absorb all of the scripts functionality and
3634   exec $objdir/$outputname directly.
3635*/
3636EOF
3637            cat <<"EOF"
3638#include <stdio.h>
3639#include <stdlib.h>
3640#ifdef _MSC_VER
3641# include <direct.h>
3642# include <process.h>
3643# include <io.h>
3644# define setmode _setmode
3645#else
3646# include <unistd.h>
3647# include <stdint.h>
3648# ifdef __CYGWIN__
3649#  include <io.h>
3650#  define HAVE_SETENV
3651#  ifdef __STRICT_ANSI__
3652char *realpath (const char *, char *);
3653int putenv (char *);
3654int setenv (const char *, const char *, int);
3655#  endif
3656# endif
3657#endif
3658#include <malloc.h>
3659#include <stdarg.h>
3660#include <assert.h>
3661#include <string.h>
3662#include <ctype.h>
3663#include <errno.h>
3664#include <fcntl.h>
3665#include <sys/stat.h>
3666
3667#if defined(PATH_MAX)
3668# define LT_PATHMAX PATH_MAX
3669#elif defined(MAXPATHLEN)
3670# define LT_PATHMAX MAXPATHLEN
3671#else
3672# define LT_PATHMAX 1024
3673#endif
3674
3675#ifndef S_IXOTH
3676# define S_IXOTH 0
3677#endif
3678#ifndef S_IXGRP
3679# define S_IXGRP 0
3680#endif
3681
3682#ifdef _MSC_VER
3683# define S_IXUSR _S_IEXEC
3684# define stat _stat
3685# ifndef _INTPTR_T_DEFINED
3686#  define intptr_t int
3687# endif
3688#endif
3689
3690#ifndef DIR_SEPARATOR
3691# define DIR_SEPARATOR '/'
3692# define PATH_SEPARATOR ':'
3693#endif
3694
3695#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
3696  defined (__OS2__)
3697# define HAVE_DOS_BASED_FILE_SYSTEM
3698# define FOPEN_WB "wb"
3699# ifndef DIR_SEPARATOR_2
3700#  define DIR_SEPARATOR_2 '\\'
3701# endif
3702# ifndef PATH_SEPARATOR_2
3703#  define PATH_SEPARATOR_2 ';'
3704# endif
3705#endif
3706
3707#ifndef DIR_SEPARATOR_2
3708# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
3709#else /* DIR_SEPARATOR_2 */
3710# define IS_DIR_SEPARATOR(ch) \
3711        (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
3712#endif /* DIR_SEPARATOR_2 */
3713
3714#ifndef PATH_SEPARATOR_2
3715# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
3716#else /* PATH_SEPARATOR_2 */
3717# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
3718#endif /* PATH_SEPARATOR_2 */
3719
3720#ifdef __CYGWIN__
3721# define FOPEN_WB "wb"
3722#endif
3723
3724#ifndef FOPEN_WB
3725# define FOPEN_WB "w"
3726#endif
3727#ifndef _O_BINARY
3728# define _O_BINARY 0
3729#endif
3730
3731#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
3732#define XFREE(stale) do { \
3733  if (stale) { free ((void *) stale); stale = 0; } \
3734} while (0)
3735
3736#undef LTWRAPPER_DEBUGPRINTF
3737#if defined DEBUGWRAPPER
3738# define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args
3739static void
3740ltwrapper_debugprintf (const char *fmt, ...)
3741{
3742    va_list args;
3743    va_start (args, fmt);
3744    (void) vfprintf (stderr, fmt, args);
3745    va_end (args);
3746}
3747#else
3748# define LTWRAPPER_DEBUGPRINTF(args)
3749#endif
3750
3751const char *program_name = NULL;
3752
3753void *xmalloc (size_t num);
3754char *xstrdup (const char *string);
3755const char *base_name (const char *name);
3756char *find_executable (const char *wrapper);
3757char *chase_symlinks (const char *pathspec);
3758int make_executable (const char *path);
3759int check_executable (const char *path);
3760char *strendzap (char *str, const char *pat);
3761void lt_fatal (const char *message, ...);
3762void lt_setenv (const char *name, const char *value);
3763char *lt_extend_str (const char *orig_value, const char *add, int to_end);
3764void lt_opt_process_env_set (const char *arg);
3765void lt_opt_process_env_prepend (const char *arg);
3766void lt_opt_process_env_append (const char *arg);
3767int lt_split_name_value (const char *arg, char** name, char** value);
3768void lt_update_exe_path (const char *name, const char *value);
3769void lt_update_lib_path (const char *name, const char *value);
3770
3771static const char *script_text_part1 =
3772EOF
3773
3774            func_emit_wrapper_part1 yes |
3775                $SED -e 's/\([\\"]\)/\\\1/g' \
3776                     -e 's/^/  "/' -e 's/$/\\n"/'
3777            echo ";"
3778            cat <<EOF
3779
3780static const char *script_text_part2 =
3781EOF
3782            func_emit_wrapper_part2 yes |
3783                $SED -e 's/\([\\"]\)/\\\1/g' \
3784                     -e 's/^/  "/' -e 's/$/\\n"/'
3785            echo ";"
3786
3787            cat <<EOF
3788const char * MAGIC_EXE = "$magic_exe";
3789const char * LIB_PATH_VARNAME = "$shlibpath_var";
3790EOF
3791
3792            if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3793              func_to_host_pathlist "$temp_rpath"
3794              cat <<EOF
3795const char * LIB_PATH_VALUE   = "$func_to_host_pathlist_result";
3796EOF
3797            else
3798              cat <<"EOF"
3799const char * LIB_PATH_VALUE   = "";
3800EOF
3801            fi
3802
3803            if test -n "$dllsearchpath"; then
3804              func_to_host_pathlist "$dllsearchpath:"
3805              cat <<EOF
3806const char * EXE_PATH_VARNAME = "PATH";
3807const char * EXE_PATH_VALUE   = "$func_to_host_pathlist_result";
3808EOF
3809            else
3810              cat <<"EOF"
3811const char * EXE_PATH_VARNAME = "";
3812const char * EXE_PATH_VALUE   = "";
3813EOF
3814            fi
3815
3816            if test "$fast_install" = yes; then
3817              cat <<EOF
3818const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
3819EOF
3820            else
3821              cat <<EOF
3822const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
3823EOF
3824            fi
3825
3826
3827            cat <<"EOF"
3828
3829#define LTWRAPPER_OPTION_PREFIX         "--lt-"
3830#define LTWRAPPER_OPTION_PREFIX_LENGTH  5
3831
3832static const size_t opt_prefix_len         = LTWRAPPER_OPTION_PREFIX_LENGTH;
3833static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
3834
3835static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
3836
3837static const size_t env_set_opt_len     = LTWRAPPER_OPTION_PREFIX_LENGTH + 7;
3838static const char *env_set_opt          = LTWRAPPER_OPTION_PREFIX "env-set";
3839  /* argument is putenv-style "foo=bar", value of foo is set to bar */
3840
3841static const size_t env_prepend_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 11;
3842static const char *env_prepend_opt      = LTWRAPPER_OPTION_PREFIX "env-prepend";
3843  /* argument is putenv-style "foo=bar", new value of foo is bar${foo} */
3844
3845static const size_t env_append_opt_len  = LTWRAPPER_OPTION_PREFIX_LENGTH + 10;
3846static const char *env_append_opt       = LTWRAPPER_OPTION_PREFIX "env-append";
3847  /* argument is putenv-style "foo=bar", new value of foo is ${foo}bar */
3848
3849int
3850main (int argc, char *argv[])
3851{
3852  char **newargz;
3853  int  newargc;
3854  char *tmp_pathspec;
3855  char *actual_cwrapper_path;
3856  char *actual_cwrapper_name;
3857  char *target_name;
3858  char *lt_argv_zero;
3859  intptr_t rval = 127;
3860
3861  int i;
3862
3863  program_name = (char *) xstrdup (base_name (argv[0]));
3864  LTWRAPPER_DEBUGPRINTF (("(main) argv[0]      : %s\n", argv[0]));
3865  LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name));
3866
3867  /* very simple arg parsing; don't want to rely on getopt */
3868  for (i = 1; i < argc; i++)
3869    {
3870      if (strcmp (argv[i], dumpscript_opt) == 0)
3871        {
3872EOF
3873            case "$host" in
3874              *mingw* | *cygwin* )
3875                # make stdout use "unix" line endings
3876                echo "          setmode(1,_O_BINARY);"
3877                ;;
3878              esac
3879
3880            cat <<"EOF"
3881          printf ("%s", script_text_part1);
3882          printf ("%s", script_text_part2);
3883          return 0;
3884        }
3885    }
3886
3887  newargz = XMALLOC (char *, argc + 1);
3888  tmp_pathspec = find_executable (argv[0]);
3889  if (tmp_pathspec == NULL)
3890    lt_fatal ("Couldn't find %s", argv[0]);
3891  LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n",
3892                          tmp_pathspec));
3893
3894  actual_cwrapper_path = chase_symlinks (tmp_pathspec);
3895  LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",
3896                          actual_cwrapper_path));
3897  XFREE (tmp_pathspec);
3898
3899  actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));
3900  strendzap (actual_cwrapper_path, actual_cwrapper_name);
3901
3902  /* wrapper name transforms */
3903  strendzap (actual_cwrapper_name, ".exe");
3904  tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
3905  XFREE (actual_cwrapper_name);
3906  actual_cwrapper_name = tmp_pathspec;
3907  tmp_pathspec = 0;
3908
3909  /* target_name transforms -- use actual target program name; might have lt- prefix */
3910  target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
3911  strendzap (target_name, ".exe");
3912  tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
3913  XFREE (target_name);
3914  target_name = tmp_pathspec;
3915  tmp_pathspec = 0;
3916
3917  LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n",
3918                          target_name));
3919EOF
3920
3921            cat <<EOF
3922  newargz[0] =
3923    XMALLOC (char, (strlen (actual_cwrapper_path) +
3924                    strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
3925  strcpy (newargz[0], actual_cwrapper_path);
3926  strcat (newargz[0], "$objdir");
3927  strcat (newargz[0], "/");
3928EOF
3929
3930            cat <<"EOF"
3931  /* stop here, and copy so we don't have to do this twice */
3932  tmp_pathspec = xstrdup (newargz[0]);
3933
3934  /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
3935  strcat (newargz[0], actual_cwrapper_name);
3936
3937  /* DO want the lt- prefix here if it exists, so use target_name */
3938  lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
3939  XFREE (tmp_pathspec);
3940  tmp_pathspec = NULL;
3941EOF
3942
3943            case $host_os in
3944              mingw*)
3945            cat <<"EOF"
3946  {
3947    char* p;
3948    while ((p = strchr (newargz[0], '\\')) != NULL)
3949      {
3950        *p = '/';
3951      }
3952    while ((p = strchr (lt_argv_zero, '\\')) != NULL)
3953      {
3954        *p = '/';
3955      }
3956  }
3957EOF
3958            ;;
3959            esac
3960
3961            cat <<"EOF"
3962  XFREE (target_name);
3963  XFREE (actual_cwrapper_path);
3964  XFREE (actual_cwrapper_name);
3965
3966  lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
3967  lt_setenv ("DUALCASE", "1");  /* for MSK sh */
3968  lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
3969  lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
3970
3971  newargc=0;
3972  for (i = 1; i < argc; i++)
3973    {
3974      if (strncmp (argv[i], env_set_opt, env_set_opt_len) == 0)
3975        {
3976          if (argv[i][env_set_opt_len] == '=')
3977            {
3978              const char *p = argv[i] + env_set_opt_len + 1;
3979              lt_opt_process_env_set (p);
3980            }
3981          else if (argv[i][env_set_opt_len] == '\0' && i + 1 < argc)
3982            {
3983              lt_opt_process_env_set (argv[++i]); /* don't copy */
3984            }
3985          else
3986            lt_fatal ("%s missing required argument", env_set_opt);
3987          continue;
3988        }
3989      if (strncmp (argv[i], env_prepend_opt, env_prepend_opt_len) == 0)
3990        {
3991          if (argv[i][env_prepend_opt_len] == '=')
3992            {
3993              const char *p = argv[i] + env_prepend_opt_len + 1;
3994              lt_opt_process_env_prepend (p);
3995            }
3996          else if (argv[i][env_prepend_opt_len] == '\0' && i + 1 < argc)
3997            {
3998              lt_opt_process_env_prepend (argv[++i]); /* don't copy */
3999            }
4000          else
4001            lt_fatal ("%s missing required argument", env_prepend_opt);
4002          continue;
4003        }
4004      if (strncmp (argv[i], env_append_opt, env_append_opt_len) == 0)
4005        {
4006          if (argv[i][env_append_opt_len] == '=')
4007            {
4008              const char *p = argv[i] + env_append_opt_len + 1;
4009              lt_opt_process_env_append (p);
4010            }
4011          else if (argv[i][env_append_opt_len] == '\0' && i + 1 < argc)
4012            {
4013              lt_opt_process_env_append (argv[++i]); /* don't copy */
4014            }
4015          else
4016            lt_fatal ("%s missing required argument", env_append_opt);
4017          continue;
4018        }
4019      if (strncmp (argv[i], ltwrapper_option_prefix, opt_prefix_len) == 0)
4020        {
4021          /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
4022             namespace, but it is not one of the ones we know about and
4023             have already dealt with, above (inluding dump-script), then
4024             report an error. Otherwise, targets might begin to believe
4025             they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
4026             namespace. The first time any user complains about this, we'll
4027             need to make LTWRAPPER_OPTION_PREFIX a configure-time option
4028             or a configure.ac-settable value.
4029           */
4030          lt_fatal ("Unrecognized option in %s namespace: '%s'",
4031                    ltwrapper_option_prefix, argv[i]);
4032        }
4033      /* otherwise ... */
4034      newargz[++newargc] = xstrdup (argv[i]);
4035    }
4036  newargz[++newargc] = NULL;
4037
4038  LTWRAPPER_DEBUGPRINTF     (("(main) lt_argv_zero : %s\n", (lt_argv_zero ? lt_argv_zero : "<NULL>")));
4039  for (i = 0; i < newargc; i++)
4040    {
4041      LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d]   : %s\n", i, (newargz[i] ? newargz[i] : "<NULL>")));
4042    }
4043
4044EOF
4045
4046            case $host_os in
4047              mingw*)
4048                cat <<"EOF"
4049  /* execv doesn't actually work on mingw as expected on unix */
4050  rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
4051  if (rval == -1)
4052    {
4053      /* failed to start process */
4054      LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno));
4055      return 127;
4056    }
4057  return rval;
4058EOF
4059                ;;
4060              *)
4061                cat <<"EOF"
4062  execv (lt_argv_zero, newargz);
4063  return rval; /* =127, but avoids unused variable warning */
4064EOF
4065                ;;
4066            esac
4067
4068            cat <<"EOF"
4069}
4070
4071void *
4072xmalloc (size_t num)
4073{
4074  void *p = (void *) malloc (num);
4075  if (!p)
4076    lt_fatal ("Memory exhausted");
4077
4078  return p;
4079}
4080
4081char *
4082xstrdup (const char *string)
4083{
4084  return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
4085                          string) : NULL;
4086}
4087
4088const char *
4089base_name (const char *name)
4090{
4091  const char *base;
4092
4093#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4094  /* Skip over the disk name in MSDOS pathnames. */
4095  if (isalpha ((unsigned char) name[0]) && name[1] == ':')
4096    name += 2;
4097#endif
4098
4099  for (base = name; *name; name++)
4100    if (IS_DIR_SEPARATOR (*name))
4101      base = name + 1;
4102  return base;
4103}
4104
4105int
4106check_executable (const char *path)
4107{
4108  struct stat st;
4109
4110  LTWRAPPER_DEBUGPRINTF (("(check_executable)  : %s\n",
4111                          path ? (*path ? path : "EMPTY!") : "NULL!"));
4112  if ((!path) || (!*path))
4113    return 0;
4114
4115  if ((stat (path, &st) >= 0)
4116      && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
4117    return 1;
4118  else
4119    return 0;
4120}
4121
4122int
4123make_executable (const char *path)
4124{
4125  int rval = 0;
4126  struct stat st;
4127
4128  LTWRAPPER_DEBUGPRINTF (("(make_executable)   : %s\n",
4129                          path ? (*path ? path : "EMPTY!") : "NULL!"));
4130  if ((!path) || (!*path))
4131    return 0;
4132
4133  if (stat (path, &st) >= 0)
4134    {
4135      rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
4136    }
4137  return rval;
4138}
4139
4140/* Searches for the full path of the wrapper.  Returns
4141   newly allocated full path name if found, NULL otherwise
4142   Does not chase symlinks, even on platforms that support them.
4143*/
4144char *
4145find_executable (const char *wrapper)
4146{
4147  int has_slash = 0;
4148  const char *p;
4149  const char *p_next;
4150  /* static buffer for getcwd */
4151  char tmp[LT_PATHMAX + 1];
4152  int tmp_len;
4153  char *concat_name;
4154
4155  LTWRAPPER_DEBUGPRINTF (("(find_executable)   : %s\n",
4156                          wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));
4157
4158  if ((wrapper == NULL) || (*wrapper == '\0'))
4159    return NULL;
4160
4161  /* Absolute path? */
4162#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4163  if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
4164    {
4165      concat_name = xstrdup (wrapper);
4166      if (check_executable (concat_name))
4167        return concat_name;
4168      XFREE (concat_name);
4169    }
4170  else
4171    {
4172#endif
4173      if (IS_DIR_SEPARATOR (wrapper[0]))
4174        {
4175          concat_name = xstrdup (wrapper);
4176          if (check_executable (concat_name))
4177            return concat_name;
4178          XFREE (concat_name);
4179        }
4180#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4181    }
4182#endif
4183
4184  for (p = wrapper; *p; p++)
4185    if (*p == '/')
4186      {
4187        has_slash = 1;
4188        break;
4189      }
4190  if (!has_slash)
4191    {
4192      /* no slashes; search PATH */
4193      const char *path = getenv ("PATH");
4194      if (path != NULL)
4195        {
4196          for (p = path; *p; p = p_next)
4197            {
4198              const char *q;
4199              size_t p_len;
4200              for (q = p; *q; q++)
4201                if (IS_PATH_SEPARATOR (*q))
4202                  break;
4203              p_len = q - p;
4204              p_next = (*q == '\0' ? q : q + 1);
4205              if (p_len == 0)
4206                {
4207                  /* empty path: current directory */
4208                  if (getcwd (tmp, LT_PATHMAX) == NULL)
4209                    lt_fatal ("getcwd failed");
4210                  tmp_len = strlen (tmp);
4211                  concat_name =
4212                    XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4213                  memcpy (concat_name, tmp, tmp_len);
4214                  concat_name[tmp_len] = '/';
4215                  strcpy (concat_name + tmp_len + 1, wrapper);
4216                }
4217              else
4218                {
4219                  concat_name =
4220                    XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
4221                  memcpy (concat_name, p, p_len);
4222                  concat_name[p_len] = '/';
4223                  strcpy (concat_name + p_len + 1, wrapper);
4224                }
4225              if (check_executable (concat_name))
4226                return concat_name;
4227              XFREE (concat_name);
4228            }
4229        }
4230      /* not found in PATH; assume curdir */
4231    }
4232  /* Relative path | not found in path: prepend cwd */
4233  if (getcwd (tmp, LT_PATHMAX) == NULL)
4234    lt_fatal ("getcwd failed");
4235  tmp_len = strlen (tmp);
4236  concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4237  memcpy (concat_name, tmp, tmp_len);
4238  concat_name[tmp_len] = '/';
4239  strcpy (concat_name + tmp_len + 1, wrapper);
4240
4241  if (check_executable (concat_name))
4242    return concat_name;
4243  XFREE (concat_name);
4244  return NULL;
4245}
4246
4247char *
4248chase_symlinks (const char *pathspec)
4249{
4250#ifndef S_ISLNK
4251  return xstrdup (pathspec);
4252#else
4253  char buf[LT_PATHMAX];
4254  struct stat s;
4255  char *tmp_pathspec = xstrdup (pathspec);
4256  char *p;
4257  int has_symlinks = 0;
4258  while (strlen (tmp_pathspec) && !has_symlinks)
4259    {
4260      LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",
4261                              tmp_pathspec));
4262      if (lstat (tmp_pathspec, &s) == 0)
4263        {
4264          if (S_ISLNK (s.st_mode) != 0)
4265            {
4266              has_symlinks = 1;
4267              break;
4268            }
4269
4270          /* search backwards for last DIR_SEPARATOR */
4271          p = tmp_pathspec + strlen (tmp_pathspec) - 1;
4272          while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4273            p--;
4274          if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4275            {
4276              /* no more DIR_SEPARATORS left */
4277              break;
4278            }
4279          *p = '\0';
4280        }
4281      else
4282        {
4283          char *errstr = strerror (errno);
4284          lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);
4285        }
4286    }
4287  XFREE (tmp_pathspec);
4288
4289  if (!has_symlinks)
4290    {
4291      return xstrdup (pathspec);
4292    }
4293
4294  tmp_pathspec = realpath (pathspec, buf);
4295  if (tmp_pathspec == 0)
4296    {
4297      lt_fatal ("Could not follow symlinks for %s", pathspec);
4298    }
4299  return xstrdup (tmp_pathspec);
4300#endif
4301}
4302
4303char *
4304strendzap (char *str, const char *pat)
4305{
4306  size_t len, patlen;
4307
4308  assert (str != NULL);
4309  assert (pat != NULL);
4310
4311  len = strlen (str);
4312  patlen = strlen (pat);
4313
4314  if (patlen <= len)
4315    {
4316      str += len - patlen;
4317      if (strcmp (str, pat) == 0)
4318        *str = '\0';
4319    }
4320  return str;
4321}
4322
4323static void
4324lt_error_core (int exit_status, const char *mode,
4325               const char *message, va_list ap)
4326{
4327  fprintf (stderr, "%s: %s: ", program_name, mode);
4328  vfprintf (stderr, message, ap);
4329  fprintf (stderr, ".\n");
4330
4331  if (exit_status >= 0)
4332    exit (exit_status);
4333}
4334
4335void
4336lt_fatal (const char *message, ...)
4337{
4338  va_list ap;
4339  va_start (ap, message);
4340  lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
4341  va_end (ap);
4342}
4343
4344void
4345lt_setenv (const char *name, const char *value)
4346{
4347  LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n",
4348                          (name ? name : "<NULL>"),
4349                          (value ? value : "<NULL>")));
4350  {
4351#ifdef HAVE_SETENV
4352    /* always make a copy, for consistency with !HAVE_SETENV */
4353    char *str = xstrdup (value);
4354    setenv (name, str, 1);
4355#else
4356    int len = strlen (name) + 1 + strlen (value) + 1;
4357    char *str = XMALLOC (char, len);
4358    sprintf (str, "%s=%s", name, value);
4359    if (putenv (str) != EXIT_SUCCESS)
4360      {
4361        XFREE (str);
4362      }
4363#endif
4364  }
4365}
4366
4367char *
4368lt_extend_str (const char *orig_value, const char *add, int to_end)
4369{
4370  char *new_value;
4371  if (orig_value && *orig_value)
4372    {
4373      int orig_value_len = strlen (orig_value);
4374      int add_len = strlen (add);
4375      new_value = XMALLOC (char, add_len + orig_value_len + 1);
4376      if (to_end)
4377        {
4378          strcpy (new_value, orig_value);
4379          strcpy (new_value + orig_value_len, add);
4380        }
4381      else
4382        {
4383          strcpy (new_value, add);
4384          strcpy (new_value + add_len, orig_value);
4385        }
4386    }
4387  else
4388    {
4389      new_value = xstrdup (add);
4390    }
4391  return new_value;
4392}
4393
4394int
4395lt_split_name_value (const char *arg, char** name, char** value)
4396{
4397  const char *p;
4398  int len;
4399  if (!arg || !*arg)
4400    return 1;
4401
4402  p = strchr (arg, (int)'=');
4403
4404  if (!p)
4405    return 1;
4406
4407  *value = xstrdup (++p);
4408
4409  len = strlen (arg) - strlen (*value);
4410  *name = XMALLOC (char, len);
4411  strncpy (*name, arg, len-1);
4412  (*name)[len - 1] = '\0';
4413
4414  return 0;
4415}
4416
4417void
4418lt_opt_process_env_set (const char *arg)
4419{
4420  char *name = NULL;
4421  char *value = NULL;
4422
4423  if (lt_split_name_value (arg, &name, &value) != 0)
4424    {
4425      XFREE (name);
4426      XFREE (value);
4427      lt_fatal ("bad argument for %s: '%s'", env_set_opt, arg);
4428    }
4429
4430  lt_setenv (name, value);
4431  XFREE (name);
4432  XFREE (value);
4433}
4434
4435void
4436lt_opt_process_env_prepend (const char *arg)
4437{
4438  char *name = NULL;
4439  char *value = NULL;
4440  char *new_value = NULL;
4441
4442  if (lt_split_name_value (arg, &name, &value) != 0)
4443    {
4444      XFREE (name);
4445      XFREE (value);
4446      lt_fatal ("bad argument for %s: '%s'", env_prepend_opt, arg);
4447    }
4448
4449  new_value = lt_extend_str (getenv (name), value, 0);
4450  lt_setenv (name, new_value);
4451  XFREE (new_value);
4452  XFREE (name);
4453  XFREE (value);
4454}
4455
4456void
4457lt_opt_process_env_append (const char *arg)
4458{
4459  char *name = NULL;
4460  char *value = NULL;
4461  char *new_value = NULL;
4462
4463  if (lt_split_name_value (arg, &name, &value) != 0)
4464    {
4465      XFREE (name);
4466      XFREE (value);
4467      lt_fatal ("bad argument for %s: '%s'", env_append_opt, arg);
4468    }
4469
4470  new_value = lt_extend_str (getenv (name), value, 1);
4471  lt_setenv (name, new_value);
4472  XFREE (new_value);
4473  XFREE (name);
4474  XFREE (value);
4475}
4476
4477void
4478lt_update_exe_path (const char *name, const char *value)
4479{
4480  LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
4481                          (name ? name : "<NULL>"),
4482                          (value ? value : "<NULL>")));
4483
4484  if (name && *name && value && *value)
4485    {
4486      char *new_value = lt_extend_str (getenv (name), value, 0);
4487      /* some systems can't cope with a ':'-terminated path #' */
4488      int len = strlen (new_value);
4489      while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
4490        {
4491          new_value[len-1] = '\0';
4492        }
4493      lt_setenv (name, new_value);
4494      XFREE (new_value);
4495    }
4496}
4497
4498void
4499lt_update_lib_path (const char *name, const char *value)
4500{
4501  LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4502                          (name ? name : "<NULL>"),
4503                          (value ? value : "<NULL>")));
4504
4505  if (name && *name && value && *value)
4506    {
4507      char *new_value = lt_extend_str (getenv (name), value, 0);
4508      lt_setenv (name, new_value);
4509      XFREE (new_value);
4510    }
4511}
4512
4513
4514EOF
4515}
4516# end: func_emit_cwrapperexe_src
4517
4518# func_mode_link arg...
4519func_mode_link ()
4520{
4521    $opt_debug
4522    case $host in
4523    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4524      # It is impossible to link a dll without this setting, and
4525      # we shouldn't force the makefile maintainer to figure out
4526      # which system we are compiling for in order to pass an extra
4527      # flag for every libtool invocation.
4528      # allow_undefined=no
4529
4530      # FIXME: Unfortunately, there are problems with the above when trying
4531      # to make a dll which has undefined symbols, in which case not
4532      # even a static library is built.  For now, we need to specify
4533      # -no-undefined on the libtool link line when we can be certain
4534      # that all symbols are satisfied, otherwise we get a static library.
4535      allow_undefined=yes
4536      ;;
4537    *)
4538      allow_undefined=yes
4539      ;;
4540    esac
4541    libtool_args=$nonopt
4542    base_compile="$nonopt $@"
4543    compile_command=$nonopt
4544    finalize_command=$nonopt
4545
4546    compile_rpath=
4547    finalize_rpath=
4548    compile_shlibpath=
4549    finalize_shlibpath=
4550    convenience=
4551    old_convenience=
4552    deplibs=
4553    old_deplibs=
4554    compiler_flags=
4555    linker_flags=
4556    dllsearchpath=
4557    lib_search_path=`pwd`
4558    inst_prefix_dir=
4559    new_inherited_linker_flags=
4560
4561    avoid_version=no
4562    dlfiles=
4563    dlprefiles=
4564    dlself=no
4565    export_dynamic=no
4566    export_symbols=
4567    export_symbols_regex=
4568    generated=
4569    libobjs=
4570    ltlibs=
4571    module=no
4572    no_install=no
4573    objs=
4574    non_pic_objects=
4575    precious_files_regex=
4576    prefer_static_libs=no
4577    preload=no
4578    prev=
4579    prevarg=
4580    release=
4581    rpath=
4582    xrpath=
4583    perm_rpath=
4584    temp_rpath=
4585    thread_safe=no
4586    vinfo=
4587    vinfo_number=no
4588    weak_libs=
4589    single_module="${wl}-single_module"
4590    func_infer_tag $base_compile
4591
4592    # We need to know -static, to get the right output filenames.
4593    for arg
4594    do
4595      case $arg in
4596      -shared)
4597        test "$build_libtool_libs" != yes && \
4598          func_fatal_configuration "can not build a shared library"
4599        build_old_libs=no
4600        break
4601        ;;
4602      -all-static | -static | -static-libtool-libs)
4603        case $arg in
4604        -all-static)
4605          if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
4606            func_warning "complete static linking is impossible in this configuration"
4607          fi
4608          if test -n "$link_static_flag"; then
4609            dlopen_self=$dlopen_self_static
4610          fi
4611          prefer_static_libs=yes
4612          ;;
4613        -static)
4614          if test -z "$pic_flag" && test -n "$link_static_flag"; then
4615            dlopen_self=$dlopen_self_static
4616          fi
4617          prefer_static_libs=built
4618          ;;
4619        -static-libtool-libs)
4620          if test -z "$pic_flag" && test -n "$link_static_flag"; then
4621            dlopen_self=$dlopen_self_static
4622          fi
4623          prefer_static_libs=yes
4624          ;;
4625        esac
4626        build_libtool_libs=no
4627        build_old_libs=yes
4628        break
4629        ;;
4630      esac
4631    done
4632
4633    # See if our shared archives depend on static archives.
4634    test -n "$old_archive_from_new_cmds" && build_old_libs=yes
4635
4636    # Go through the arguments, transforming them on the way.
4637    while test "$#" -gt 0; do
4638      arg="$1"
4639      shift
4640      func_quote_for_eval "$arg"
4641      qarg=$func_quote_for_eval_unquoted_result
4642      func_append libtool_args " $func_quote_for_eval_result"
4643
4644      # If the previous option needs an argument, assign it.
4645      if test -n "$prev"; then
4646        case $prev in
4647        output)
4648          func_append compile_command " @OUTPUT@"
4649          func_append finalize_command " @OUTPUT@"
4650          ;;
4651        esac
4652
4653        case $prev in
4654        dlfiles|dlprefiles)
4655          if test "$preload" = no; then
4656            # Add the symbol object into the linking commands.
4657            func_append compile_command " @SYMFILE@"
4658            func_append finalize_command " @SYMFILE@"
4659            preload=yes
4660          fi
4661          case $arg in
4662          *.la | *.lo) ;;  # We handle these cases below.
4663          force)
4664            if test "$dlself" = no; then
4665              dlself=needless
4666              export_dynamic=yes
4667            fi
4668            prev=
4669            continue
4670            ;;
4671          self)
4672            if test "$prev" = dlprefiles; then
4673              dlself=yes
4674            elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
4675              dlself=yes
4676            else
4677              dlself=needless
4678              export_dynamic=yes
4679            fi
4680            prev=
4681            continue
4682            ;;
4683          *)
4684            if test "$prev" = dlfiles; then
4685              dlfiles="$dlfiles $arg"
4686            else
4687              dlprefiles="$dlprefiles $arg"
4688            fi
4689            prev=
4690            continue
4691            ;;
4692          esac
4693          ;;
4694        expsyms)
4695          export_symbols="$arg"
4696          test -f "$arg" \
4697            || func_fatal_error "symbol file \`$arg' does not exist"
4698          prev=
4699          continue
4700          ;;
4701        expsyms_regex)
4702          export_symbols_regex="$arg"
4703          prev=
4704          continue
4705          ;;
4706        framework)
4707          case $host in
4708            *-*-darwin*)
4709              case "$deplibs " in
4710                *" $qarg.ltframework "*) ;;
4711                *) deplibs="$deplibs $qarg.ltframework" # this is fixed later
4712                   ;;
4713              esac
4714              ;;
4715          esac
4716          prev=
4717          continue
4718          ;;
4719        inst_prefix)
4720          inst_prefix_dir="$arg"
4721          prev=
4722          continue
4723          ;;
4724        objectlist)
4725          if test -f "$arg"; then
4726            save_arg=$arg
4727            moreargs=
4728            for fil in `cat "$save_arg"`
4729            do
4730#             moreargs="$moreargs $fil"
4731              arg=$fil
4732              # A libtool-controlled object.
4733
4734              # Check to see that this really is a libtool object.
4735              if func_lalib_unsafe_p "$arg"; then
4736                pic_object=
4737                non_pic_object=
4738
4739                # Read the .lo file
4740                func_source "$arg"
4741
4742                if test -z "$pic_object" ||
4743                   test -z "$non_pic_object" ||
4744                   test "$pic_object" = none &&
4745                   test "$non_pic_object" = none; then
4746                  func_fatal_error "cannot find name of object for \`$arg'"
4747                fi
4748
4749                # Extract subdirectory from the argument.
4750                func_dirname "$arg" "/" ""
4751                xdir="$func_dirname_result"
4752
4753                if test "$pic_object" != none; then
4754                  # Prepend the subdirectory the object is found in.
4755                  pic_object="$xdir$pic_object"
4756
4757                  if test "$prev" = dlfiles; then
4758                    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
4759                      dlfiles="$dlfiles $pic_object"
4760                      prev=
4761                      continue
4762                    else
4763                      # If libtool objects are unsupported, then we need to preload.
4764                      prev=dlprefiles
4765                    fi
4766                  fi
4767
4768                  # CHECK ME:  I think I busted this.  -Ossama
4769                  if test "$prev" = dlprefiles; then
4770                    # Preload the old-style object.
4771                    dlprefiles="$dlprefiles $pic_object"
4772                    prev=
4773                  fi
4774
4775                  # A PIC object.
4776                  func_append libobjs " $pic_object"
4777                  arg="$pic_object"
4778                fi
4779
4780                # Non-PIC object.
4781                if test "$non_pic_object" != none; then
4782                  # Prepend the subdirectory the object is found in.
4783                  non_pic_object="$xdir$non_pic_object"
4784
4785                  # A standard non-PIC object
4786                  func_append non_pic_objects " $non_pic_object"
4787                  if test -z "$pic_object" || test "$pic_object" = none ; then
4788                    arg="$non_pic_object"
4789                  fi
4790                else
4791                  # If the PIC object exists, use it instead.
4792                  # $xdir was prepended to $pic_object above.
4793                  non_pic_object="$pic_object"
4794                  func_append non_pic_objects " $non_pic_object"
4795                fi
4796              else
4797                # Only an error if not doing a dry-run.
4798                if $opt_dry_run; then
4799                  # Extract subdirectory from the argument.
4800                  func_dirname "$arg" "/" ""
4801                  xdir="$func_dirname_result"
4802
4803                  func_lo2o "$arg"
4804                  pic_object=$xdir$objdir/$func_lo2o_result
4805                  non_pic_object=$xdir$func_lo2o_result
4806                  func_append libobjs " $pic_object"
4807                  func_append non_pic_objects " $non_pic_object"
4808                else
4809                  func_fatal_error "\`$arg' is not a valid libtool object"
4810                fi
4811              fi
4812            done
4813          else
4814            func_fatal_error "link input file \`$arg' does not exist"
4815          fi
4816          arg=$save_arg
4817          prev=
4818          continue
4819          ;;
4820        precious_regex)
4821          precious_files_regex="$arg"
4822          prev=
4823          continue
4824          ;;
4825        release)
4826          release="-$arg"
4827          prev=
4828          continue
4829          ;;
4830        rpath | xrpath)
4831          # We need an absolute path.
4832          case $arg in
4833          [\\/]* | [A-Za-z]:[\\/]*) ;;
4834          *)
4835            func_fatal_error "only absolute run-paths are allowed"
4836            ;;
4837          esac
4838          if test "$prev" = rpath; then
4839            case "$rpath " in
4840            *" $arg "*) ;;
4841            *) rpath="$rpath $arg" ;;
4842            esac
4843          else
4844            case "$xrpath " in
4845            *" $arg "*) ;;
4846            *) xrpath="$xrpath $arg" ;;
4847            esac
4848          fi
4849          prev=
4850          continue
4851          ;;
4852        shrext)
4853          shrext_cmds="$arg"
4854          prev=
4855          continue
4856          ;;
4857        weak)
4858          weak_libs="$weak_libs $arg"
4859          prev=
4860          continue
4861          ;;
4862        xcclinker)
4863          linker_flags="$linker_flags $qarg"
4864          compiler_flags="$compiler_flags $qarg"
4865          prev=
4866          func_append compile_command " $qarg"
4867          func_append finalize_command " $qarg"
4868          continue
4869          ;;
4870        xcompiler)
4871          compiler_flags="$compiler_flags $qarg"
4872          prev=
4873          func_append compile_command " $qarg"
4874          func_append finalize_command " $qarg"
4875          continue
4876          ;;
4877        xlinker)
4878          linker_flags="$linker_flags $qarg"
4879          compiler_flags="$compiler_flags $wl$qarg"
4880          prev=
4881          func_append compile_command " $wl$qarg"
4882          func_append finalize_command " $wl$qarg"
4883          continue
4884          ;;
4885        *)
4886          eval "$prev=\"\$arg\""
4887          prev=
4888          continue
4889          ;;
4890        esac
4891      fi # test -n "$prev"
4892
4893      prevarg="$arg"
4894
4895      case $arg in
4896      -all-static)
4897        if test -n "$link_static_flag"; then
4898          # See comment for -static flag below, for more details.
4899          func_append compile_command " $link_static_flag"
4900          func_append finalize_command " $link_static_flag"
4901        fi
4902        continue
4903        ;;
4904
4905      -allow-undefined)
4906        # FIXME: remove this flag sometime in the future.
4907        func_fatal_error "\`-allow-undefined' must not be used because it is the default"
4908        ;;
4909
4910      -avoid-version)
4911        avoid_version=yes
4912        continue
4913        ;;
4914
4915      -dlopen)
4916        prev=dlfiles
4917        continue
4918        ;;
4919
4920      -dlpreopen)
4921        prev=dlprefiles
4922        continue
4923        ;;
4924
4925      -export-dynamic)
4926        export_dynamic=yes
4927        continue
4928        ;;
4929
4930      -export-symbols | -export-symbols-regex)
4931        if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
4932          func_fatal_error "more than one -exported-symbols argument is not allowed"
4933        fi
4934        if test "X$arg" = "X-export-symbols"; then
4935          prev=expsyms
4936        else
4937          prev=expsyms_regex
4938        fi
4939        continue
4940        ;;
4941
4942      -framework)
4943        prev=framework
4944        continue
4945        ;;
4946
4947      -inst-prefix-dir)
4948        prev=inst_prefix
4949        continue
4950        ;;
4951
4952      # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
4953      # so, if we see these flags be careful not to treat them like -L
4954      -L[A-Z][A-Z]*:*)
4955        case $with_gcc/$host in
4956        no/*-*-irix* | /*-*-irix*)
4957          func_append compile_command " $arg"
4958          func_append finalize_command " $arg"
4959          ;;
4960        esac
4961        continue
4962        ;;
4963
4964      -L*)
4965        func_stripname '-L' '' "$arg"
4966        dir=$func_stripname_result
4967        if test -z "$dir"; then
4968          if test "$#" -gt 0; then
4969            func_fatal_error "require no space between \`-L' and \`$1'"
4970          else
4971            func_fatal_error "need path for \`-L' option"
4972          fi
4973        fi
4974        # We need an absolute path.
4975        case $dir in
4976        [\\/]* | [A-Za-z]:[\\/]*) ;;
4977        *)
4978          absdir=`cd "$dir" && pwd`
4979          test -z "$absdir" && \
4980            func_fatal_error "cannot determine absolute directory name of \`$dir'"
4981          dir="$absdir"
4982          ;;
4983        esac
4984        case "$deplibs " in
4985        *" -L$dir "*) ;;
4986        *)
4987          deplibs="$deplibs -L$dir"
4988          lib_search_path="$lib_search_path $dir"
4989          ;;
4990        esac
4991        case $host in
4992        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4993          testbindir=`$ECHO "X$dir" | $Xsed -e 's*/lib$*/bin*'`
4994          case :$dllsearchpath: in
4995          *":$dir:"*) ;;
4996          ::) dllsearchpath=$dir;;
4997          *) dllsearchpath="$dllsearchpath:$dir";;
4998          esac
4999          case :$dllsearchpath: in
5000          *":$testbindir:"*) ;;
5001          ::) dllsearchpath=$testbindir;;
5002          *) dllsearchpath="$dllsearchpath:$testbindir";;
5003          esac
5004          ;;
5005        esac
5006        continue
5007        ;;
5008
5009      -l*)
5010        if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
5011          case $host in
5012          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc*)
5013            # These systems don't actually have a C or math library (as such)
5014            continue
5015            ;;
5016          *-*-os2*)
5017            # These systems don't actually have a C library (as such)
5018            test "X$arg" = "X-lc" && continue
5019            ;;
5020          *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5021            # Do not include libc due to us having libc/libc_r.
5022            test "X$arg" = "X-lc" && continue
5023            ;;
5024          *-*-rhapsody* | *-*-darwin1.[012])
5025            # Rhapsody C and math libraries are in the System framework
5026            deplibs="$deplibs System.ltframework"
5027            continue
5028            ;;
5029          *-*-sco3.2v5* | *-*-sco5v6*)
5030            # Causes problems with __ctype
5031            test "X$arg" = "X-lc" && continue
5032            ;;
5033          *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
5034            # Compiler inserts libc in the correct place for threads to work
5035            test "X$arg" = "X-lc" && continue
5036            ;;
5037          esac
5038        elif test "X$arg" = "X-lc_r"; then
5039         case $host in
5040         *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5041           # Do not include libc_r directly, use -pthread flag.
5042           continue
5043           ;;
5044         esac
5045        fi
5046        deplibs="$deplibs $arg"
5047        continue
5048        ;;
5049
5050      -module)
5051        module=yes
5052        continue
5053        ;;
5054
5055      # Tru64 UNIX uses -model [arg] to determine the layout of C++
5056      # classes, name mangling, and exception handling.
5057      # Darwin uses the -arch flag to determine output architecture.
5058      -model|-arch|-isysroot)
5059        compiler_flags="$compiler_flags $arg"
5060        func_append compile_command " $arg"
5061        func_append finalize_command " $arg"
5062        prev=xcompiler
5063        continue
5064        ;;
5065
5066      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
5067        compiler_flags="$compiler_flags $arg"
5068        func_append compile_command " $arg"
5069        func_append finalize_command " $arg"
5070        case "$new_inherited_linker_flags " in
5071            *" $arg "*) ;;
5072            * ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
5073        esac
5074        continue
5075        ;;
5076
5077      -multi_module)
5078        single_module="${wl}-multi_module"
5079        continue
5080        ;;
5081
5082      -no-fast-install)
5083        fast_install=no
5084        continue
5085        ;;
5086
5087      -no-install)
5088        case $host in
5089        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
5090          # The PATH hackery in wrapper scripts is required on Windows
5091          # and Darwin in order for the loader to find any dlls it needs.
5092          func_warning "\`-no-install' is ignored for $host"
5093          func_warning "assuming \`-no-fast-install' instead"
5094          fast_install=no
5095          ;;
5096        *) no_install=yes ;;
5097        esac
5098        continue
5099        ;;
5100
5101      -no-undefined)
5102        allow_undefined=no
5103        continue
5104        ;;
5105
5106      -objectlist)
5107        prev=objectlist
5108        continue
5109        ;;
5110
5111      -o) prev=output ;;
5112
5113      -precious-files-regex)
5114        prev=precious_regex
5115        continue
5116        ;;
5117
5118      -release)
5119        prev=release
5120        continue
5121        ;;
5122
5123      -rpath)
5124        prev=rpath
5125        continue
5126        ;;
5127
5128      -R)
5129        prev=xrpath
5130        continue
5131        ;;
5132
5133      -R*)
5134        func_stripname '-R' '' "$arg"
5135        dir=$func_stripname_result
5136        # We need an absolute path.
5137        case $dir in
5138        [\\/]* | [A-Za-z]:[\\/]*) ;;
5139        *)
5140          func_fatal_error "only absolute run-paths are allowed"
5141          ;;
5142        esac
5143        case "$xrpath " in
5144        *" $dir "*) ;;
5145        *) xrpath="$xrpath $dir" ;;
5146        esac
5147        continue
5148        ;;
5149
5150      -shared)
5151        # The effects of -shared are defined in a previous loop.
5152        continue
5153        ;;
5154
5155      -shrext)
5156        prev=shrext
5157        continue
5158        ;;
5159
5160      -static | -static-libtool-libs)
5161        # The effects of -static are defined in a previous loop.
5162        # We used to do the same as -all-static on platforms that
5163        # didn't have a PIC flag, but the assumption that the effects
5164        # would be equivalent was wrong.  It would break on at least
5165        # Digital Unix and AIX.
5166        continue
5167        ;;
5168
5169      -thread-safe)
5170        thread_safe=yes
5171        continue
5172        ;;
5173
5174      -version-info)
5175        prev=vinfo
5176        continue
5177        ;;
5178
5179      -version-number)
5180        prev=vinfo
5181        vinfo_number=yes
5182        continue
5183        ;;
5184
5185      -weak)
5186        prev=weak
5187        continue
5188        ;;
5189
5190      -Wc,*)
5191        func_stripname '-Wc,' '' "$arg"
5192        args=$func_stripname_result
5193        arg=
5194        save_ifs="$IFS"; IFS=','
5195        for flag in $args; do
5196          IFS="$save_ifs"
5197          func_quote_for_eval "$flag"
5198          arg="$arg $wl$func_quote_for_eval_result"
5199          compiler_flags="$compiler_flags $func_quote_for_eval_result"
5200        done
5201        IFS="$save_ifs"
5202        func_stripname ' ' '' "$arg"
5203        arg=$func_stripname_result
5204        ;;
5205
5206      -Wl,*)
5207        func_stripname '-Wl,' '' "$arg"
5208        args=$func_stripname_result
5209        arg=
5210        save_ifs="$IFS"; IFS=','
5211        for flag in $args; do
5212          IFS="$save_ifs"
5213          func_quote_for_eval "$flag"
5214          arg="$arg $wl$func_quote_for_eval_result"
5215          compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"
5216          linker_flags="$linker_flags $func_quote_for_eval_result"
5217        done
5218        IFS="$save_ifs"
5219        func_stripname ' ' '' "$arg"
5220        arg=$func_stripname_result
5221        ;;
5222
5223      -Xcompiler)
5224        prev=xcompiler
5225        continue
5226        ;;
5227
5228      -Xlinker)
5229        prev=xlinker
5230        continue
5231        ;;
5232
5233      -XCClinker)
5234        prev=xcclinker
5235        continue
5236        ;;
5237
5238      # -msg_* for osf cc
5239      -msg_*)
5240        func_quote_for_eval "$arg"
5241        arg="$func_quote_for_eval_result"
5242        ;;
5243
5244      # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
5245      # -r[0-9][0-9]* specifies the processor on the SGI compiler
5246      # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
5247      # +DA*, +DD* enable 64-bit mode on the HP compiler
5248      # -q* pass through compiler args for the IBM compiler
5249      # -m*, -t[45]*, -txscale* pass through architecture-specific
5250      # compiler args for GCC
5251      # -F/path gives path to uninstalled frameworks, gcc on darwin
5252      # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
5253      # @file GCC response files
5254      -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
5255      -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
5256        func_quote_for_eval "$arg"
5257        arg="$func_quote_for_eval_result"
5258        func_append compile_command " $arg"
5259        func_append finalize_command " $arg"
5260        compiler_flags="$compiler_flags $arg"
5261        continue
5262        ;;
5263
5264      # Some other compiler flag.
5265      -* | +*)
5266        func_quote_for_eval "$arg"
5267        arg="$func_quote_for_eval_result"
5268        ;;
5269
5270      *.$objext)
5271        # A standard object.
5272        objs="$objs $arg"
5273        ;;
5274
5275      *.lo)
5276        # A libtool-controlled object.
5277
5278        # Check to see that this really is a libtool object.
5279        if func_lalib_unsafe_p "$arg"; then
5280          pic_object=
5281          non_pic_object=
5282
5283          # Read the .lo file
5284          func_source "$arg"
5285
5286          if test -z "$pic_object" ||
5287             test -z "$non_pic_object" ||
5288             test "$pic_object" = none &&
5289             test "$non_pic_object" = none; then
5290            func_fatal_error "cannot find name of object for \`$arg'"
5291          fi
5292
5293          # Extract subdirectory from the argument.
5294          func_dirname "$arg" "/" ""
5295          xdir="$func_dirname_result"
5296
5297          if test "$pic_object" != none; then
5298            # Prepend the subdirectory the object is found in.
5299            pic_object="$xdir$pic_object"
5300
5301            if test "$prev" = dlfiles; then
5302              if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5303                dlfiles="$dlfiles $pic_object"
5304                prev=
5305                continue
5306              else
5307                # If libtool objects are unsupported, then we need to preload.
5308                prev=dlprefiles
5309              fi
5310            fi
5311
5312            # CHECK ME:  I think I busted this.  -Ossama
5313            if test "$prev" = dlprefiles; then
5314              # Preload the old-style object.
5315              dlprefiles="$dlprefiles $pic_object"
5316              prev=
5317            fi
5318
5319            # A PIC object.
5320            func_append libobjs " $pic_object"
5321            arg="$pic_object"
5322          fi
5323
5324          # Non-PIC object.
5325          if test "$non_pic_object" != none; then
5326            # Prepend the subdirectory the object is found in.
5327            non_pic_object="$xdir$non_pic_object"
5328
5329            # A standard non-PIC object
5330            func_append non_pic_objects " $non_pic_object"
5331            if test -z "$pic_object" || test "$pic_object" = none ; then
5332              arg="$non_pic_object"
5333            fi
5334          else
5335            # If the PIC object exists, use it instead.
5336            # $xdir was prepended to $pic_object above.
5337            non_pic_object="$pic_object"
5338            func_append non_pic_objects " $non_pic_object"
5339          fi
5340        else
5341          # Only an error if not doing a dry-run.
5342          if $opt_dry_run; then
5343            # Extract subdirectory from the argument.
5344            func_dirname "$arg" "/" ""
5345            xdir="$func_dirname_result"
5346
5347            func_lo2o "$arg"
5348            pic_object=$xdir$objdir/$func_lo2o_result
5349            non_pic_object=$xdir$func_lo2o_result
5350            func_append libobjs " $pic_object"
5351            func_append non_pic_objects " $non_pic_object"
5352          else
5353            func_fatal_error "\`$arg' is not a valid libtool object"
5354          fi
5355        fi
5356        ;;
5357
5358      *.$libext)
5359        # An archive.
5360        deplibs="$deplibs $arg"
5361        old_deplibs="$old_deplibs $arg"
5362        continue
5363        ;;
5364
5365      *.la)
5366        # A libtool-controlled library.
5367
5368        if test "$prev" = dlfiles; then
5369          # This library was specified with -dlopen.
5370          dlfiles="$dlfiles $arg"
5371          prev=
5372        elif test "$prev" = dlprefiles; then
5373          # The library was specified with -dlpreopen.
5374          dlprefiles="$dlprefiles $arg"
5375          prev=
5376        else
5377          deplibs="$deplibs $arg"
5378        fi
5379        continue
5380        ;;
5381
5382      # Some other compiler argument.
5383      *)
5384        # Unknown arguments in both finalize_command and compile_command need
5385        # to be aesthetically quoted because they are evaled later.
5386        func_quote_for_eval "$arg"
5387        arg="$func_quote_for_eval_result"
5388        ;;
5389      esac # arg
5390
5391      # Now actually substitute the argument into the commands.
5392      if test -n "$arg"; then
5393        func_append compile_command " $arg"
5394        func_append finalize_command " $arg"
5395      fi
5396    done # argument parsing loop
5397
5398    test -n "$prev" && \
5399      func_fatal_help "the \`$prevarg' option requires an argument"
5400
5401    if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
5402      eval arg=\"$export_dynamic_flag_spec\"
5403      func_append compile_command " $arg"
5404      func_append finalize_command " $arg"
5405    fi
5406
5407    oldlibs=
5408    # calculate the name of the file, without its directory
5409    func_basename "$output"
5410    outputname="$func_basename_result"
5411    libobjs_save="$libobjs"
5412
5413    if test -n "$shlibpath_var"; then
5414      # get the directories listed in $shlibpath_var
5415      eval shlib_search_path=\`\$ECHO \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
5416    else
5417      shlib_search_path=
5418    fi
5419    eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
5420    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
5421
5422    func_dirname "$output" "/" ""
5423    output_objdir="$func_dirname_result$objdir"
5424    # Create the object directory.
5425    func_mkdir_p "$output_objdir"
5426
5427    # Determine the type of output
5428    case $output in
5429    "")
5430      func_fatal_help "you must specify an output file"
5431      ;;
5432    *.$libext) linkmode=oldlib ;;
5433    *.lo | *.$objext) linkmode=obj ;;
5434    *.la) linkmode=lib ;;
5435    *) linkmode=prog ;; # Anything else should be a program.
5436    esac
5437
5438    specialdeplibs=
5439
5440    libs=
5441    # Find all interdependent deplibs by searching for libraries
5442    # that are linked more than once (e.g. -la -lb -la)
5443    for deplib in $deplibs; do
5444      if $opt_duplicate_deps ; then
5445        case "$libs " in
5446        *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5447        esac
5448      fi
5449      libs="$libs $deplib"
5450    done
5451
5452    if test "$linkmode" = lib; then
5453      libs="$predeps $libs $compiler_lib_search_path $postdeps"
5454
5455      # Compute libraries that are listed more than once in $predeps
5456      # $postdeps and mark them as special (i.e., whose duplicates are
5457      # not to be eliminated).
5458      pre_post_deps=
5459      if $opt_duplicate_compiler_generated_deps; then
5460        for pre_post_dep in $predeps $postdeps; do
5461          case "$pre_post_deps " in
5462          *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
5463          esac
5464          pre_post_deps="$pre_post_deps $pre_post_dep"
5465        done
5466      fi
5467      pre_post_deps=
5468    fi
5469
5470    deplibs=
5471    newdependency_libs=
5472    newlib_search_path=
5473    need_relink=no # whether we're linking any uninstalled libtool libraries
5474    notinst_deplibs= # not-installed libtool libraries
5475    notinst_path= # paths that contain not-installed libtool libraries
5476
5477    case $linkmode in
5478    lib)
5479        passes="conv dlpreopen link"
5480        for file in $dlfiles $dlprefiles; do
5481          case $file in
5482          *.la) ;;
5483          *)
5484            func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
5485            ;;
5486          esac
5487        done
5488        ;;
5489    prog)
5490        compile_deplibs=
5491        finalize_deplibs=
5492        alldeplibs=no
5493        newdlfiles=
5494        newdlprefiles=
5495        passes="conv scan dlopen dlpreopen link"
5496        ;;
5497    *)  passes="conv"
5498        ;;
5499    esac
5500
5501    for pass in $passes; do
5502      # The preopen pass in lib mode reverses $deplibs; put it back here
5503      # so that -L comes before libs that need it for instance...
5504      if test "$linkmode,$pass" = "lib,link"; then
5505        ## FIXME: Find the place where the list is rebuilt in the wrong
5506        ##        order, and fix it there properly
5507        tmp_deplibs=
5508        for deplib in $deplibs; do
5509          tmp_deplibs="$deplib $tmp_deplibs"
5510        done
5511        deplibs="$tmp_deplibs"
5512      fi
5513
5514      if test "$linkmode,$pass" = "lib,link" ||
5515         test "$linkmode,$pass" = "prog,scan"; then
5516        libs="$deplibs"
5517        deplibs=
5518      fi
5519      if test "$linkmode" = prog; then
5520        case $pass in
5521        dlopen) libs="$dlfiles" ;;
5522        dlpreopen) libs="$dlprefiles" ;;
5523        link)
5524          libs="$deplibs %DEPLIBS%"
5525          test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
5526          ;;
5527        esac
5528      fi
5529      if test "$linkmode,$pass" = "lib,dlpreopen"; then
5530        # Collect and forward deplibs of preopened libtool libs
5531        for lib in $dlprefiles; do
5532          # Ignore non-libtool-libs
5533          dependency_libs=
5534          case $lib in
5535          *.la) func_source "$lib" ;;
5536          esac
5537
5538          # Collect preopened libtool deplibs, except any this library
5539          # has declared as weak libs
5540          for deplib in $dependency_libs; do
5541            deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`
5542            case " $weak_libs " in
5543            *" $deplib_base "*) ;;
5544            *) deplibs="$deplibs $deplib" ;;
5545            esac
5546          done
5547        done
5548        libs="$dlprefiles"
5549      fi
5550      if test "$pass" = dlopen; then
5551        # Collect dlpreopened libraries
5552        save_deplibs="$deplibs"
5553        deplibs=
5554      fi
5555
5556      for deplib in $libs; do
5557        lib=
5558        found=no
5559        case $deplib in
5560        -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
5561          if test "$linkmode,$pass" = "prog,link"; then
5562            compile_deplibs="$deplib $compile_deplibs"
5563            finalize_deplibs="$deplib $finalize_deplibs"
5564          else
5565            compiler_flags="$compiler_flags $deplib"
5566            if test "$linkmode" = lib ; then
5567                case "$new_inherited_linker_flags " in
5568                    *" $deplib "*) ;;
5569                    * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5570                esac
5571            fi
5572          fi
5573          continue
5574          ;;
5575        -l*)
5576          if test "$linkmode" != lib && test "$linkmode" != prog; then
5577            func_warning "\`-l' is ignored for archives/objects"
5578            continue
5579          fi
5580          func_stripname '-l' '' "$deplib"
5581          name=$func_stripname_result
5582          if test "$linkmode" = lib; then
5583            searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
5584          else
5585            searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
5586          fi
5587          for searchdir in $searchdirs; do
5588            for search_ext in .la $std_shrext .so .a; do
5589              # Search the libtool library
5590              lib="$searchdir/lib${name}${search_ext}"
5591              if test -f "$lib"; then
5592                if test "$search_ext" = ".la"; then
5593                  found=yes
5594                else
5595                  found=no
5596                fi
5597                break 2
5598              fi
5599            done
5600          done
5601          if test "$found" != yes; then
5602            # deplib doesn't seem to be a libtool library
5603            if test "$linkmode,$pass" = "prog,link"; then
5604              compile_deplibs="$deplib $compile_deplibs"
5605              finalize_deplibs="$deplib $finalize_deplibs"
5606            else
5607              deplibs="$deplib $deplibs"
5608              test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
5609            fi
5610            continue
5611          else # deplib is a libtool library
5612            # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
5613            # We need to do some special things here, and not later.
5614            if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
5615              case " $predeps $postdeps " in
5616              *" $deplib "*)
5617                if func_lalib_p "$lib"; then
5618                  library_names=
5619                  old_library=
5620                  func_source "$lib"
5621                  for l in $old_library $library_names; do
5622                    ll="$l"
5623                  done
5624                  if test "X$ll" = "X$old_library" ; then # only static version available
5625                    found=no
5626                    func_dirname "$lib" "" "."
5627                    ladir="$func_dirname_result"
5628                    lib=$ladir/$old_library
5629                    if test "$linkmode,$pass" = "prog,link"; then
5630                      compile_deplibs="$deplib $compile_deplibs"
5631                      finalize_deplibs="$deplib $finalize_deplibs"
5632                    else
5633                      deplibs="$deplib $deplibs"
5634                      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
5635                    fi
5636                    continue
5637                  fi
5638                fi
5639                ;;
5640              *) ;;
5641              esac
5642            fi
5643          fi
5644          ;; # -l
5645        *.ltframework)
5646          if test "$linkmode,$pass" = "prog,link"; then
5647            compile_deplibs="$deplib $compile_deplibs"
5648            finalize_deplibs="$deplib $finalize_deplibs"
5649          else
5650            deplibs="$deplib $deplibs"
5651            if test "$linkmode" = lib ; then
5652                case "$new_inherited_linker_flags " in
5653                    *" $deplib "*) ;;
5654                    * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5655                esac
5656            fi
5657          fi
5658          continue
5659          ;;
5660        -L*)
5661          case $linkmode in
5662          lib)
5663            deplibs="$deplib $deplibs"
5664            test "$pass" = conv && continue
5665            newdependency_libs="$deplib $newdependency_libs"
5666            func_stripname '-L' '' "$deplib"
5667            newlib_search_path="$newlib_search_path $func_stripname_result"
5668            ;;
5669          prog)
5670            if test "$pass" = conv; then
5671              deplibs="$deplib $deplibs"
5672              continue
5673            fi
5674            if test "$pass" = scan; then
5675              deplibs="$deplib $deplibs"
5676            else
5677              compile_deplibs="$deplib $compile_deplibs"
5678              finalize_deplibs="$deplib $finalize_deplibs"
5679            fi
5680            func_stripname '-L' '' "$deplib"
5681            newlib_search_path="$newlib_search_path $func_stripname_result"
5682            ;;
5683          *)
5684            func_warning "\`-L' is ignored for archives/objects"
5685            ;;
5686          esac # linkmode
5687          continue
5688          ;; # -L
5689        -R*)
5690          if test "$pass" = link; then
5691            func_stripname '-R' '' "$deplib"
5692            dir=$func_stripname_result
5693            # Make sure the xrpath contains only unique directories.
5694            case "$xrpath " in
5695            *" $dir "*) ;;
5696            *) xrpath="$xrpath $dir" ;;
5697            esac
5698          fi
5699          deplibs="$deplib $deplibs"
5700          continue
5701          ;;
5702        *.la) lib="$deplib" ;;
5703        *.$libext)
5704          if test "$pass" = conv; then
5705            deplibs="$deplib $deplibs"
5706            continue
5707          fi
5708          case $linkmode in
5709          lib)
5710            # Linking convenience modules into shared libraries is allowed,
5711            # but linking other static libraries is non-portable.
5712            case " $dlpreconveniencelibs " in
5713            *" $deplib "*) ;;
5714            *)
5715              valid_a_lib=no
5716              case $deplibs_check_method in
5717                match_pattern*)
5718                  set dummy $deplibs_check_method; shift
5719                  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
5720                  if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \
5721                    | $EGREP "$match_pattern_regex" > /dev/null; then
5722                    valid_a_lib=yes
5723                  fi
5724                ;;
5725                pass_all)
5726                  valid_a_lib=yes
5727                ;;
5728              esac
5729              if test "$valid_a_lib" != yes; then
5730                $ECHO
5731                $ECHO "*** Warning: Trying to link with static lib archive $deplib."
5732                $ECHO "*** I have the capability to make that library automatically link in when"
5733                $ECHO "*** you link to this library.  But I can only do this if you have a"
5734                $ECHO "*** shared version of the library, which you do not appear to have"
5735                $ECHO "*** because the file extensions .$libext of this argument makes me believe"
5736                $ECHO "*** that it is just a static archive that I should not use here."
5737              else
5738                $ECHO
5739                $ECHO "*** Warning: Linking the shared library $output against the"
5740                $ECHO "*** static library $deplib is not portable!"
5741                deplibs="$deplib $deplibs"
5742              fi
5743              ;;
5744            esac
5745            continue
5746            ;;
5747          prog)
5748            if test "$pass" != link; then
5749              deplibs="$deplib $deplibs"
5750            else
5751              compile_deplibs="$deplib $compile_deplibs"
5752              finalize_deplibs="$deplib $finalize_deplibs"
5753            fi
5754            continue
5755            ;;
5756          esac # linkmode
5757          ;; # *.$libext
5758        *.lo | *.$objext)
5759          if test "$pass" = conv; then
5760            deplibs="$deplib $deplibs"
5761          elif test "$linkmode" = prog; then
5762            if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
5763              # If there is no dlopen support or we're linking statically,
5764              # we need to preload.
5765              newdlprefiles="$newdlprefiles $deplib"
5766              compile_deplibs="$deplib $compile_deplibs"
5767              finalize_deplibs="$deplib $finalize_deplibs"
5768            else
5769              newdlfiles="$newdlfiles $deplib"
5770            fi
5771          fi
5772          continue
5773          ;;
5774        %DEPLIBS%)
5775          alldeplibs=yes
5776          continue
5777          ;;
5778        esac # case $deplib
5779
5780        if test "$found" = yes || test -f "$lib"; then :
5781        else
5782          func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
5783        fi
5784
5785        # Check to see that this really is a libtool archive.
5786        func_lalib_unsafe_p "$lib" \
5787          || func_fatal_error "\`$lib' is not a valid libtool archive"
5788
5789        func_dirname "$lib" "" "."
5790        ladir="$func_dirname_result"
5791
5792        dlname=
5793        dlopen=
5794        dlpreopen=
5795        libdir=
5796        library_names=
5797        old_library=
5798        inherited_linker_flags=
5799        # If the library was installed with an old release of libtool,
5800        # it will not redefine variables installed, or shouldnotlink
5801        installed=yes
5802        shouldnotlink=no
5803        avoidtemprpath=
5804
5805
5806        # Read the .la file
5807        func_source "$lib"
5808
5809        # Convert "-framework foo" to "foo.ltframework"
5810        if test -n "$inherited_linker_flags"; then
5811          tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework \([^ $]*\)/\1.ltframework/g'`
5812          for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
5813            case " $new_inherited_linker_flags " in
5814              *" $tmp_inherited_linker_flag "*) ;;
5815              *) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
5816            esac
5817          done
5818        fi
5819        dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
5820        if test "$linkmode,$pass" = "lib,link" ||
5821           test "$linkmode,$pass" = "prog,scan" ||
5822           { test "$linkmode" != prog && test "$linkmode" != lib; }; then
5823          test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
5824          test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
5825        fi
5826
5827        if test "$pass" = conv; then
5828          # Only check for convenience libraries
5829          deplibs="$lib $deplibs"
5830          if test -z "$libdir"; then
5831            if test -z "$old_library"; then
5832              func_fatal_error "cannot find name of link library for \`$lib'"
5833            fi
5834            # It is a libtool convenience library, so add in its objects.
5835            convenience="$convenience $ladir/$objdir/$old_library"
5836            old_convenience="$old_convenience $ladir/$objdir/$old_library"
5837            tmp_libs=
5838            for deplib in $dependency_libs; do
5839              deplibs="$deplib $deplibs"
5840              if $opt_duplicate_deps ; then
5841                case "$tmp_libs " in
5842                *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5843                esac
5844              fi
5845              tmp_libs="$tmp_libs $deplib"
5846            done
5847          elif test "$linkmode" != prog && test "$linkmode" != lib; then
5848            func_fatal_error "\`$lib' is not a convenience library"
5849          fi
5850          continue
5851        fi # $pass = conv
5852
5853
5854        # Get the name of the library we link against.
5855        linklib=
5856        for l in $old_library $library_names; do
5857          linklib="$l"
5858        done
5859        if test -z "$linklib"; then
5860          func_fatal_error "cannot find name of link library for \`$lib'"
5861        fi
5862
5863        # This library was specified with -dlopen.
5864        if test "$pass" = dlopen; then
5865          if test -z "$libdir"; then
5866            func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
5867          fi
5868          if test -z "$dlname" ||
5869             test "$dlopen_support" != yes ||
5870             test "$build_libtool_libs" = no; then
5871            # If there is no dlname, no dlopen support or we're linking
5872            # statically, we need to preload.  We also need to preload any
5873            # dependent libraries so libltdl's deplib preloader doesn't
5874            # bomb out in the load deplibs phase.
5875            dlprefiles="$dlprefiles $lib $dependency_libs"
5876          else
5877            newdlfiles="$newdlfiles $lib"
5878          fi
5879          continue
5880        fi # $pass = dlopen
5881
5882        # We need an absolute path.
5883        case $ladir in
5884        [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
5885        *)
5886          abs_ladir=`cd "$ladir" && pwd`
5887          if test -z "$abs_ladir"; then
5888            func_warning "cannot determine absolute directory name of \`$ladir'"
5889            func_warning "passing it literally to the linker, although it might fail"
5890            abs_ladir="$ladir"
5891          fi
5892          ;;
5893        esac
5894        func_basename "$lib"
5895        laname="$func_basename_result"
5896
5897        # Find the relevant object directory and library name.
5898        if test "X$installed" = Xyes; then
5899          if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5900            func_warning "library \`$lib' was moved."
5901            dir="$ladir"
5902            absdir="$abs_ladir"
5903            libdir="$abs_ladir"
5904          else
5905            dir="$libdir"
5906            absdir="$libdir"
5907          fi
5908          test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
5909        else
5910          if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5911            dir="$ladir"
5912            absdir="$abs_ladir"
5913            # Remove this search path later
5914            notinst_path="$notinst_path $abs_ladir"
5915          else
5916            dir="$ladir/$objdir"
5917            absdir="$abs_ladir/$objdir"
5918            # Remove this search path later
5919            notinst_path="$notinst_path $abs_ladir"
5920          fi
5921        fi # $installed = yes
5922        func_stripname 'lib' '.la' "$laname"
5923        name=$func_stripname_result
5924
5925        # This library was specified with -dlpreopen.
5926        if test "$pass" = dlpreopen; then
5927          if test -z "$libdir" && test "$linkmode" = prog; then
5928            func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
5929          fi
5930          # Prefer using a static library (so that no silly _DYNAMIC symbols
5931          # are required to link).
5932          if test -n "$old_library"; then
5933            newdlprefiles="$newdlprefiles $dir/$old_library"
5934            # Keep a list of preopened convenience libraries to check
5935            # that they are being used correctly in the link pass.
5936            test -z "$libdir" && \
5937                dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"
5938          # Otherwise, use the dlname, so that lt_dlopen finds it.
5939          elif test -n "$dlname"; then
5940            newdlprefiles="$newdlprefiles $dir/$dlname"
5941          else
5942            newdlprefiles="$newdlprefiles $dir/$linklib"
5943          fi
5944        fi # $pass = dlpreopen
5945
5946        if test -z "$libdir"; then
5947          # Link the convenience library
5948          if test "$linkmode" = lib; then
5949            deplibs="$dir/$old_library $deplibs"
5950          elif test "$linkmode,$pass" = "prog,link"; then
5951            compile_deplibs="$dir/$old_library $compile_deplibs"
5952            finalize_deplibs="$dir/$old_library $finalize_deplibs"
5953          else
5954            deplibs="$lib $deplibs" # used for prog,scan pass
5955          fi
5956          continue
5957        fi
5958
5959
5960        if test "$linkmode" = prog && test "$pass" != link; then
5961          newlib_search_path="$newlib_search_path $ladir"
5962          deplibs="$lib $deplibs"
5963
5964          linkalldeplibs=no
5965          if test "$link_all_deplibs" != no || test -z "$library_names" ||
5966             test "$build_libtool_libs" = no; then
5967            linkalldeplibs=yes
5968          fi
5969
5970          tmp_libs=
5971          for deplib in $dependency_libs; do
5972            case $deplib in
5973            -L*) func_stripname '-L' '' "$deplib"
5974                 newlib_search_path="$newlib_search_path $func_stripname_result"
5975                 ;;
5976            esac
5977            # Need to link against all dependency_libs?
5978            if test "$linkalldeplibs" = yes; then
5979              deplibs="$deplib $deplibs"
5980            else
5981              # Need to hardcode shared library paths
5982              # or/and link against static libraries
5983              newdependency_libs="$deplib $newdependency_libs"
5984            fi
5985            if $opt_duplicate_deps ; then
5986              case "$tmp_libs " in
5987              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5988              esac
5989            fi
5990            tmp_libs="$tmp_libs $deplib"
5991          done # for deplib
5992          continue
5993        fi # $linkmode = prog...
5994
5995        if test "$linkmode,$pass" = "prog,link"; then
5996          if test -n "$library_names" &&
5997             { { test "$prefer_static_libs" = no ||
5998                 test "$prefer_static_libs,$installed" = "built,yes"; } ||
5999               test -z "$old_library"; }; then
6000            # We need to hardcode the library path
6001            if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
6002              # Make sure the rpath contains only unique directories.
6003              case "$temp_rpath:" in
6004              *"$absdir:"*) ;;
6005              *) temp_rpath="$temp_rpath$absdir:" ;;
6006              esac
6007            fi
6008
6009            # Hardcode the library path.
6010            # Skip directories that are in the system default run-time
6011            # search path.
6012            case " $sys_lib_dlsearch_path " in
6013            *" $absdir "*) ;;
6014            *)
6015              case "$compile_rpath " in
6016              *" $absdir "*) ;;
6017              *) compile_rpath="$compile_rpath $absdir"
6018              esac
6019              ;;
6020            esac
6021            case " $sys_lib_dlsearch_path " in
6022            *" $libdir "*) ;;
6023            *)
6024              case "$finalize_rpath " in
6025              *" $libdir "*) ;;
6026              *) finalize_rpath="$finalize_rpath $libdir"
6027              esac
6028              ;;
6029            esac
6030          fi # $linkmode,$pass = prog,link...
6031
6032          if test "$alldeplibs" = yes &&
6033             { test "$deplibs_check_method" = pass_all ||
6034               { test "$build_libtool_libs" = yes &&
6035                 test -n "$library_names"; }; }; then
6036            # We only need to search for static libraries
6037            continue
6038          fi
6039        fi
6040
6041        link_static=no # Whether the deplib will be linked statically
6042        use_static_libs=$prefer_static_libs
6043        if test "$use_static_libs" = built && test "$installed" = yes; then
6044          use_static_libs=no
6045        fi
6046        if test -n "$library_names" &&
6047           { test "$use_static_libs" = no || test -z "$old_library"; }; then
6048          case $host in
6049          *cygwin* | *mingw* | *cegcc*)
6050              # No point in relinking DLLs because paths are not encoded
6051              notinst_deplibs="$notinst_deplibs $lib"
6052              need_relink=no
6053            ;;
6054          *)
6055            if test "$installed" = no; then
6056              notinst_deplibs="$notinst_deplibs $lib"
6057              need_relink=yes
6058            fi
6059            ;;
6060          esac
6061          # This is a shared library
6062
6063          # Warn about portability, can't link against -module's on some
6064          # systems (darwin).  Don't bleat about dlopened modules though!
6065          dlopenmodule=""
6066          for dlpremoduletest in $dlprefiles; do
6067            if test "X$dlpremoduletest" = "X$lib"; then
6068              dlopenmodule="$dlpremoduletest"
6069              break
6070            fi
6071          done
6072          if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
6073            $ECHO
6074            if test "$linkmode" = prog; then
6075              $ECHO "*** Warning: Linking the executable $output against the loadable module"
6076            else
6077              $ECHO "*** Warning: Linking the shared library $output against the loadable module"
6078            fi
6079            $ECHO "*** $linklib is not portable!"
6080          fi
6081          if test "$linkmode" = lib &&
6082             test "$hardcode_into_libs" = yes; then
6083            # Hardcode the library path.
6084            # Skip directories that are in the system default run-time
6085            # search path.
6086            case " $sys_lib_dlsearch_path " in
6087            *" $absdir "*) ;;
6088            *)
6089              case "$compile_rpath " in
6090              *" $absdir "*) ;;
6091              *) compile_rpath="$compile_rpath $absdir"
6092              esac
6093              ;;
6094            esac
6095            case " $sys_lib_dlsearch_path " in
6096            *" $libdir "*) ;;
6097            *)
6098              case "$finalize_rpath " in
6099              *" $libdir "*) ;;
6100              *) finalize_rpath="$finalize_rpath $libdir"
6101              esac
6102              ;;
6103            esac
6104          fi
6105
6106          if test -n "$old_archive_from_expsyms_cmds"; then
6107            # figure out the soname
6108            set dummy $library_names
6109            shift
6110            realname="$1"
6111            shift
6112            libname=`eval "\\$ECHO \"$libname_spec\""`
6113            # use dlname if we got it. it's perfectly good, no?
6114            if test -n "$dlname"; then
6115              soname="$dlname"
6116            elif test -n "$soname_spec"; then
6117              # bleh windows
6118              case $host in
6119              *cygwin* | mingw* | *cegcc*)
6120                func_arith $current - $age
6121                major=$func_arith_result
6122                versuffix="-$major"
6123                ;;
6124              esac
6125              eval soname=\"$soname_spec\"
6126            else
6127              soname="$realname"
6128            fi
6129
6130            # Make a new name for the extract_expsyms_cmds to use
6131            soroot="$soname"
6132            func_basename "$soroot"
6133            soname="$func_basename_result"
6134            func_stripname 'lib' '.dll' "$soname"
6135            newlib=libimp-$func_stripname_result.a
6136
6137            # If the library has no export list, then create one now
6138            if test -f "$output_objdir/$soname-def"; then :
6139            else
6140              func_verbose "extracting exported symbol list from \`$soname'"
6141              func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
6142            fi
6143
6144            # Create $newlib
6145            if test -f "$output_objdir/$newlib"; then :; else
6146              func_verbose "generating import library for \`$soname'"
6147              func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
6148            fi
6149            # make sure the library variables are pointing to the new library
6150            dir=$output_objdir
6151            linklib=$newlib
6152          fi # test -n "$old_archive_from_expsyms_cmds"
6153
6154          if test "$linkmode" = prog || test "$mode" != relink; then
6155            add_shlibpath=
6156            add_dir=
6157            add=
6158            lib_linked=yes
6159            case $hardcode_action in
6160            immediate | unsupported)
6161              if test "$hardcode_direct" = no; then
6162                add="$dir/$linklib"
6163                case $host in
6164                  *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
6165                  *-*-sysv4*uw2*) add_dir="-L$dir" ;;
6166                  *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
6167                    *-*-unixware7*) add_dir="-L$dir" ;;
6168                  *-*-darwin* )
6169                    # if the lib is a (non-dlopened) module then we can not
6170                    # link against it, someone is ignoring the earlier warnings
6171                    if /usr/bin/file -L $add 2> /dev/null |
6172                         $GREP ": [^:]* bundle" >/dev/null ; then
6173                      if test "X$dlopenmodule" != "X$lib"; then
6174                        $ECHO "*** Warning: lib $linklib is a module, not a shared library"
6175                        if test -z "$old_library" ; then
6176                          $ECHO
6177                          $ECHO "*** And there doesn't seem to be a static archive available"
6178                          $ECHO "*** The link will probably fail, sorry"
6179                        else
6180                          add="$dir/$old_library"
6181                        fi
6182                      elif test -n "$old_library"; then
6183                        add="$dir/$old_library"
6184                      fi
6185                    fi
6186                esac
6187              elif test "$hardcode_minus_L" = no; then
6188                case $host in
6189                *-*-sunos*) add_shlibpath="$dir" ;;
6190                esac
6191                add_dir="-L$dir"
6192                add="-l$name"
6193              elif test "$hardcode_shlibpath_var" = no; then
6194                add_shlibpath="$dir"
6195                add="-l$name"
6196              else
6197                lib_linked=no
6198              fi
6199              ;;
6200            relink)
6201              if test "$hardcode_direct" = yes &&
6202                 test "$hardcode_direct_absolute" = no; then
6203                add="$dir/$linklib"
6204              elif test "$hardcode_minus_L" = yes; then
6205                add_dir="-L$dir"
6206                # Try looking first in the location we're being installed to.
6207                if test -n "$inst_prefix_dir"; then
6208                  case $libdir in
6209                    [\\/]*)
6210                      add_dir="$add_dir -L$inst_prefix_dir$libdir"
6211                      ;;
6212                  esac
6213                fi
6214                add="-l$name"
6215              elif test "$hardcode_shlibpath_var" = yes; then
6216                add_shlibpath="$dir"
6217                add="-l$name"
6218              else
6219                lib_linked=no
6220              fi
6221              ;;
6222            *) lib_linked=no ;;
6223            esac
6224
6225            if test "$lib_linked" != yes; then
6226              func_fatal_configuration "unsupported hardcode properties"
6227            fi
6228
6229            if test -n "$add_shlibpath"; then
6230              case :$compile_shlibpath: in
6231              *":$add_shlibpath:"*) ;;
6232              *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
6233              esac
6234            fi
6235            if test "$linkmode" = prog; then
6236              test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
6237              test -n "$add" && compile_deplibs="$add $compile_deplibs"
6238            else
6239              test -n "$add_dir" && deplibs="$add_dir $deplibs"
6240              test -n "$add" && deplibs="$add $deplibs"
6241              if test "$hardcode_direct" != yes &&
6242                 test "$hardcode_minus_L" != yes &&
6243                 test "$hardcode_shlibpath_var" = yes; then
6244                case :$finalize_shlibpath: in
6245                *":$libdir:"*) ;;
6246                *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
6247                esac
6248              fi
6249            fi
6250          fi
6251
6252          if test "$linkmode" = prog || test "$mode" = relink; then
6253            add_shlibpath=
6254            add_dir=
6255            add=
6256            # Finalize command for both is simple: just hardcode it.
6257            if test "$hardcode_direct" = yes &&
6258               test "$hardcode_direct_absolute" = no; then
6259              add="$libdir/$linklib"
6260            elif test "$hardcode_minus_L" = yes; then
6261              add_dir="-L$libdir"
6262              add="-l$name"
6263            elif test "$hardcode_shlibpath_var" = yes; then
6264              case :$finalize_shlibpath: in
6265              *":$libdir:"*) ;;
6266              *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
6267              esac
6268              add="-l$name"
6269            elif test "$hardcode_automatic" = yes; then
6270              if test -n "$inst_prefix_dir" &&
6271                 test -f "$inst_prefix_dir$libdir/$linklib" ; then
6272                add="$inst_prefix_dir$libdir/$linklib"
6273              else
6274                add="$libdir/$linklib"
6275              fi
6276            else
6277              # We cannot seem to hardcode it, guess we'll fake it.
6278              add_dir="-L$libdir"
6279              # Try looking first in the location we're being installed to.
6280              if test -n "$inst_prefix_dir"; then
6281                case $libdir in
6282                  [\\/]*)
6283                    add_dir="$add_dir -L$inst_prefix_dir$libdir"
6284                    ;;
6285                esac
6286              fi
6287              add="-l$name"
6288            fi
6289
6290            if test "$linkmode" = prog; then
6291              test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
6292              test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
6293            else
6294              test -n "$add_dir" && deplibs="$add_dir $deplibs"
6295              test -n "$add" && deplibs="$add $deplibs"
6296            fi
6297          fi
6298        elif test "$linkmode" = prog; then
6299          # Here we assume that one of hardcode_direct or hardcode_minus_L
6300          # is not unsupported.  This is valid on all known static and
6301          # shared platforms.
6302          if test "$hardcode_direct" != unsupported; then
6303            test -n "$old_library" && linklib="$old_library"
6304            compile_deplibs="$dir/$linklib $compile_deplibs"
6305            finalize_deplibs="$dir/$linklib $finalize_deplibs"
6306          else
6307            compile_deplibs="-l$name -L$dir $compile_deplibs"
6308            finalize_deplibs="-l$name -L$dir $finalize_deplibs"
6309          fi
6310        elif test "$build_libtool_libs" = yes; then
6311          # Not a shared library
6312          if test "$deplibs_check_method" != pass_all; then
6313            # We're trying link a shared library against a static one
6314            # but the system doesn't support it.
6315
6316            # Just print a warning and add the library to dependency_libs so
6317            # that the program can be linked against the static library.
6318            $ECHO
6319            $ECHO "*** Warning: This system can not link to static lib archive $lib."
6320            $ECHO "*** I have the capability to make that library automatically link in when"
6321            $ECHO "*** you link to this library.  But I can only do this if you have a"
6322            $ECHO "*** shared version of the library, which you do not appear to have."
6323            if test "$module" = yes; then
6324              $ECHO "*** But as you try to build a module library, libtool will still create "
6325              $ECHO "*** a static module, that should work as long as the dlopening application"
6326              $ECHO "*** is linked with the -dlopen flag to resolve symbols at runtime."
6327              if test -z "$global_symbol_pipe"; then
6328                $ECHO
6329                $ECHO "*** However, this would only work if libtool was able to extract symbol"
6330                $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
6331                $ECHO "*** not find such a program.  So, this module is probably useless."
6332                $ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
6333              fi
6334              if test "$build_old_libs" = no; then
6335                build_libtool_libs=module
6336                build_old_libs=yes
6337              else
6338                build_libtool_libs=no
6339              fi
6340            fi
6341          else
6342            deplibs="$dir/$old_library $deplibs"
6343            link_static=yes
6344          fi
6345        fi # link shared/static library?
6346
6347        if test "$linkmode" = lib; then
6348          if test -n "$dependency_libs" &&
6349             { test "$hardcode_into_libs" != yes ||
6350               test "$build_old_libs" = yes ||
6351               test "$link_static" = yes; }; then
6352            # Extract -R from dependency_libs
6353            temp_deplibs=
6354            for libdir in $dependency_libs; do
6355              case $libdir in
6356              -R*) func_stripname '-R' '' "$libdir"
6357                   temp_xrpath=$func_stripname_result
6358                   case " $xrpath " in
6359                   *" $temp_xrpath "*) ;;
6360                   *) xrpath="$xrpath $temp_xrpath";;
6361                   esac;;
6362              *) temp_deplibs="$temp_deplibs $libdir";;
6363              esac
6364            done
6365            dependency_libs="$temp_deplibs"
6366          fi
6367
6368          newlib_search_path="$newlib_search_path $absdir"
6369          # Link against this library
6370          test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
6371          # ... and its dependency_libs
6372          tmp_libs=
6373          for deplib in $dependency_libs; do
6374            newdependency_libs="$deplib $newdependency_libs"
6375            if $opt_duplicate_deps ; then
6376              case "$tmp_libs " in
6377              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
6378              esac
6379            fi
6380            tmp_libs="$tmp_libs $deplib"
6381          done
6382
6383          if test "$link_all_deplibs" != no; then
6384            # Add the search paths of all dependency libraries
6385            for deplib in $dependency_libs; do
6386              path=
6387              case $deplib in
6388              -L*) path="$deplib" ;;
6389              *.la)
6390                func_dirname "$deplib" "" "."
6391                dir="$func_dirname_result"
6392                # We need an absolute path.
6393                case $dir in
6394                [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
6395                *)
6396                  absdir=`cd "$dir" && pwd`
6397                  if test -z "$absdir"; then
6398                    func_warning "cannot determine absolute directory name of \`$dir'"
6399                    absdir="$dir"
6400                  fi
6401                  ;;
6402                esac
6403                if $GREP "^installed=no" $deplib > /dev/null; then
6404                case $host in
6405                *-*-darwin*)
6406                  depdepl=
6407                  eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
6408                  if test -n "$deplibrary_names" ; then
6409                    for tmp in $deplibrary_names ; do
6410                      depdepl=$tmp
6411                    done
6412                    if test -f "$absdir/$objdir/$depdepl" ; then
6413                      depdepl="$absdir/$objdir/$depdepl"
6414                      darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
6415                      if test -z "$darwin_install_name"; then
6416                          darwin_install_name=`${OTOOL64} -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
6417                      fi
6418                      compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
6419                      linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
6420                      path=
6421                    fi
6422                  fi
6423                  ;;
6424                *)
6425                  path="-L$absdir/$objdir"
6426                  ;;
6427                esac
6428                else
6429                  eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
6430                  test -z "$libdir" && \
6431                    func_fatal_error "\`$deplib' is not a valid libtool archive"
6432                  test "$absdir" != "$libdir" && \
6433                    func_warning "\`$deplib' seems to be moved"
6434
6435                  path="-L$absdir"
6436                fi
6437                ;;
6438              esac
6439              case " $deplibs " in
6440              *" $path "*) ;;
6441              *) deplibs="$path $deplibs" ;;
6442              esac
6443            done
6444          fi # link_all_deplibs != no
6445        fi # linkmode = lib
6446      done # for deplib in $libs
6447      if test "$pass" = link; then
6448        if test "$linkmode" = "prog"; then
6449          compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
6450          finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
6451        else
6452          compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6453        fi
6454      fi
6455      dependency_libs="$newdependency_libs"
6456      if test "$pass" = dlpreopen; then
6457        # Link the dlpreopened libraries before other libraries
6458        for deplib in $save_deplibs; do
6459          deplibs="$deplib $deplibs"
6460        done
6461      fi
6462      if test "$pass" != dlopen; then
6463        if test "$pass" != conv; then
6464          # Make sure lib_search_path contains only unique directories.
6465          lib_search_path=
6466          for dir in $newlib_search_path; do
6467            case "$lib_search_path " in
6468            *" $dir "*) ;;
6469            *) lib_search_path="$lib_search_path $dir" ;;
6470            esac
6471          done
6472          newlib_search_path=
6473        fi
6474
6475        if test "$linkmode,$pass" != "prog,link"; then
6476          vars="deplibs"
6477        else
6478          vars="compile_deplibs finalize_deplibs"
6479        fi
6480        for var in $vars dependency_libs; do
6481          # Add libraries to $var in reverse order
6482          eval tmp_libs=\"\$$var\"
6483          new_libs=
6484          for deplib in $tmp_libs; do
6485            # FIXME: Pedantically, this is the right thing to do, so
6486            #        that some nasty dependency loop isn't accidentally
6487            #        broken:
6488            #new_libs="$deplib $new_libs"
6489            # Pragmatically, this seems to cause very few problems in
6490            # practice:
6491            case $deplib in
6492            -L*) new_libs="$deplib $new_libs" ;;
6493            -R*) ;;
6494            *)
6495              # And here is the reason: when a library appears more
6496              # than once as an explicit dependence of a library, or
6497              # is implicitly linked in more than once by the
6498              # compiler, it is considered special, and multiple
6499              # occurrences thereof are not removed.  Compare this
6500              # with having the same library being listed as a
6501              # dependency of multiple other libraries: in this case,
6502              # we know (pedantically, we assume) the library does not
6503              # need to be listed more than once, so we keep only the
6504              # last copy.  This is not always right, but it is rare
6505              # enough that we require users that really mean to play
6506              # such unportable linking tricks to link the library
6507              # using -Wl,-lname, so that libtool does not consider it
6508              # for duplicate removal.
6509              case " $specialdeplibs " in
6510              *" $deplib "*) new_libs="$deplib $new_libs" ;;
6511              *)
6512                case " $new_libs " in
6513                *" $deplib "*) ;;
6514                *) new_libs="$deplib $new_libs" ;;
6515                esac
6516                ;;
6517              esac
6518              ;;
6519            esac
6520          done
6521          tmp_libs=
6522          for deplib in $new_libs; do
6523            case $deplib in
6524            -L*)
6525              case " $tmp_libs " in
6526              *" $deplib "*) ;;
6527              *) tmp_libs="$tmp_libs $deplib" ;;
6528              esac
6529              ;;
6530            *) tmp_libs="$tmp_libs $deplib" ;;
6531            esac
6532          done
6533          eval $var=\"$tmp_libs\"
6534        done # for var
6535      fi
6536      # Last step: remove runtime libs from dependency_libs
6537      # (they stay in deplibs)
6538      tmp_libs=
6539      for i in $dependency_libs ; do
6540        case " $predeps $postdeps $compiler_lib_search_path " in
6541        *" $i "*)
6542          i=""
6543          ;;
6544        esac
6545        if test -n "$i" ; then
6546          tmp_libs="$tmp_libs $i"
6547        fi
6548      done
6549      dependency_libs=$tmp_libs
6550    done # for pass
6551    if test "$linkmode" = prog; then
6552      dlfiles="$newdlfiles"
6553    fi
6554    if test "$linkmode" = prog || test "$linkmode" = lib; then
6555      dlprefiles="$newdlprefiles"
6556    fi
6557
6558    case $linkmode in
6559    oldlib)
6560      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
6561        func_warning "\`-dlopen' is ignored for archives"
6562      fi
6563
6564      case " $deplibs" in
6565      *\ -l* | *\ -L*)
6566        func_warning "\`-l' and \`-L' are ignored for archives" ;;
6567      esac
6568
6569      test -n "$rpath" && \
6570        func_warning "\`-rpath' is ignored for archives"
6571
6572      test -n "$xrpath" && \
6573        func_warning "\`-R' is ignored for archives"
6574
6575      test -n "$vinfo" && \
6576        func_warning "\`-version-info/-version-number' is ignored for archives"
6577
6578      test -n "$release" && \
6579        func_warning "\`-release' is ignored for archives"
6580
6581      test -n "$export_symbols$export_symbols_regex" && \
6582        func_warning "\`-export-symbols' is ignored for archives"
6583
6584      # Now set the variables for building old libraries.
6585      build_libtool_libs=no
6586      oldlibs="$output"
6587      objs="$objs$old_deplibs"
6588      ;;
6589
6590    lib)
6591      # Make sure we only generate libraries of the form `libNAME.la'.
6592      case $outputname in
6593      lib*)
6594        func_stripname 'lib' '.la' "$outputname"
6595        name=$func_stripname_result
6596        eval shared_ext=\"$shrext_cmds\"
6597        eval libname=\"$libname_spec\"
6598        ;;
6599      *)
6600        test "$module" = no && \
6601          func_fatal_help "libtool library \`$output' must begin with \`lib'"
6602
6603        if test "$need_lib_prefix" != no; then
6604          # Add the "lib" prefix for modules if required
6605          func_stripname '' '.la' "$outputname"
6606          name=$func_stripname_result
6607          eval shared_ext=\"$shrext_cmds\"
6608          eval libname=\"$libname_spec\"
6609        else
6610          func_stripname '' '.la' "$outputname"
6611          libname=$func_stripname_result
6612        fi
6613        ;;
6614      esac
6615
6616      if test -n "$objs"; then
6617        if test "$deplibs_check_method" != pass_all; then
6618          func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
6619        else
6620          $ECHO
6621          $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
6622          $ECHO "*** objects $objs is not portable!"
6623          libobjs="$libobjs $objs"
6624        fi
6625      fi
6626
6627      test "$dlself" != no && \
6628        func_warning "\`-dlopen self' is ignored for libtool libraries"
6629
6630      set dummy $rpath
6631      shift
6632      test "$#" -gt 1 && \
6633        func_warning "ignoring multiple \`-rpath's for a libtool library"
6634
6635      install_libdir="$1"
6636
6637      oldlibs=
6638      if test -z "$rpath"; then
6639        if test "$build_libtool_libs" = yes; then
6640          # Building a libtool convenience library.
6641          # Some compilers have problems with a `.al' extension so
6642          # convenience libraries should have the same extension an
6643          # archive normally would.
6644          oldlibs="$output_objdir/$libname.$libext $oldlibs"
6645          build_libtool_libs=convenience
6646          build_old_libs=yes
6647        fi
6648
6649        test -n "$vinfo" && \
6650          func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
6651
6652        test -n "$release" && \
6653          func_warning "\`-release' is ignored for convenience libraries"
6654      else
6655
6656        # Parse the version information argument.
6657        save_ifs="$IFS"; IFS=':'
6658        set dummy $vinfo 0 0 0
6659        shift
6660        IFS="$save_ifs"
6661
6662        test -n "$7" && \
6663          func_fatal_help "too many parameters to \`-version-info'"
6664
6665        # convert absolute version numbers to libtool ages
6666        # this retains compatibility with .la files and attempts
6667        # to make the code below a bit more comprehensible
6668
6669        case $vinfo_number in
6670        yes)
6671          number_major="$1"
6672          number_minor="$2"
6673          number_revision="$3"
6674          #
6675          # There are really only two kinds -- those that
6676          # use the current revision as the major version
6677          # and those that subtract age and use age as
6678          # a minor version.  But, then there is irix
6679          # which has an extra 1 added just for fun
6680          #
6681          case $version_type in
6682          darwin|linux|osf|windows|none)
6683            func_arith $number_major + $number_minor
6684            current=$func_arith_result
6685            age="$number_minor"
6686            revision="$number_revision"
6687            ;;
6688          freebsd-aout|freebsd-elf|sunos)
6689            current="$number_major"
6690            revision="$number_minor"
6691            age="0"
6692            ;;
6693          irix|nonstopux)
6694            func_arith $number_major + $number_minor
6695            current=$func_arith_result
6696            age="$number_minor"
6697            revision="$number_minor"
6698            lt_irix_increment=no
6699            ;;
6700          *)
6701            func_fatal_configuration "$modename: unknown library version type \`$version_type'"
6702            ;;
6703          esac
6704          ;;
6705        no)
6706          current="$1"
6707          revision="$2"
6708          age="$3"
6709          ;;
6710        esac
6711
6712        # Check that each of the things are valid numbers.
6713        case $current in
6714        0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
6715        *)
6716          func_error "CURRENT \`$current' must be a nonnegative integer"
6717          func_fatal_error "\`$vinfo' is not valid version information"
6718          ;;
6719        esac
6720
6721        case $revision in
6722        0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
6723        *)
6724          func_error "REVISION \`$revision' must be a nonnegative integer"
6725          func_fatal_error "\`$vinfo' is not valid version information"
6726          ;;
6727        esac
6728
6729        case $age in
6730        0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
6731        *)
6732          func_error "AGE \`$age' must be a nonnegative integer"
6733          func_fatal_error "\`$vinfo' is not valid version information"
6734          ;;
6735        esac
6736
6737        if test "$age" -gt "$current"; then
6738          func_error "AGE \`$age' is greater than the current interface number \`$current'"
6739          func_fatal_error "\`$vinfo' is not valid version information"
6740        fi
6741
6742        # Calculate the version variables.
6743        major=
6744        versuffix=
6745        verstring=
6746        case $version_type in
6747        none) ;;
6748
6749        darwin)
6750          # Like Linux, but with the current version available in
6751          # verstring for coding it into the library header
6752          func_arith $current - $age
6753          major=.$func_arith_result
6754          versuffix="$major.$age.$revision"
6755          # Darwin ld doesn't like 0 for these options...
6756          func_arith $current + 1
6757          minor_current=$func_arith_result
6758          xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
6759          verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
6760          ;;
6761
6762        freebsd-aout)
6763          major=".$current"
6764          versuffix=".$current.$revision";
6765          ;;
6766
6767        freebsd-elf)
6768          major=".$current"
6769          versuffix=".$current"
6770          ;;
6771
6772        irix | nonstopux)
6773          if test "X$lt_irix_increment" = "Xno"; then
6774            func_arith $current - $age
6775          else
6776            func_arith $current - $age + 1
6777          fi
6778          major=$func_arith_result
6779
6780          case $version_type in
6781            nonstopux) verstring_prefix=nonstopux ;;
6782            *)         verstring_prefix=sgi ;;
6783          esac
6784          verstring="$verstring_prefix$major.$revision"
6785
6786          # Add in all the interfaces that we are compatible with.
6787          loop=$revision
6788          while test "$loop" -ne 0; do
6789            func_arith $revision - $loop
6790            iface=$func_arith_result
6791            func_arith $loop - 1
6792            loop=$func_arith_result
6793            verstring="$verstring_prefix$major.$iface:$verstring"
6794          done
6795
6796          # Before this point, $major must not contain `.'.
6797          major=.$major
6798          versuffix="$major.$revision"
6799          ;;
6800
6801        linux)
6802          func_arith $current - $age
6803          major=.$func_arith_result
6804          versuffix="$major.$age.$revision"
6805          ;;
6806
6807        osf)
6808          func_arith $current - $age
6809          major=.$func_arith_result
6810          versuffix=".$current.$age.$revision"
6811          verstring="$current.$age.$revision"
6812
6813          # Add in all the interfaces that we are compatible with.
6814          loop=$age
6815          while test "$loop" -ne 0; do
6816            func_arith $current - $loop
6817            iface=$func_arith_result
6818            func_arith $loop - 1
6819            loop=$func_arith_result
6820            verstring="$verstring:${iface}.0"
6821          done
6822
6823          # Make executables depend on our current version.
6824          verstring="$verstring:${current}.0"
6825          ;;
6826
6827        qnx)
6828          major=".$current"
6829          versuffix=".$current"
6830          ;;
6831
6832        sunos)
6833          major=".$current"
6834          versuffix=".$current.$revision"
6835          ;;
6836
6837        windows)
6838          # Use '-' rather than '.', since we only want one
6839          # extension on DOS 8.3 filesystems.
6840          func_arith $current - $age
6841          major=$func_arith_result
6842          versuffix="-$major"
6843          ;;
6844
6845        *)
6846          func_fatal_configuration "unknown library version type \`$version_type'"
6847          ;;
6848        esac
6849
6850        # Clear the version info if we defaulted, and they specified a release.
6851        if test -z "$vinfo" && test -n "$release"; then
6852          major=
6853          case $version_type in
6854          darwin)
6855            # we can't check for "0.0" in archive_cmds due to quoting
6856            # problems, so we reset it completely
6857            verstring=
6858            ;;
6859          *)
6860            verstring="0.0"
6861            ;;
6862          esac
6863          if test "$need_version" = no; then
6864            versuffix=
6865          else
6866            versuffix=".0.0"
6867          fi
6868        fi
6869
6870        # Remove version info from name if versioning should be avoided
6871        if test "$avoid_version" = yes && test "$need_version" = no; then
6872          major=
6873          versuffix=
6874          verstring=""
6875        fi
6876
6877        # Check to see if the archive will have undefined symbols.
6878        if test "$allow_undefined" = yes; then
6879          if test "$allow_undefined_flag" = unsupported; then
6880            func_warning "undefined symbols not allowed in $host shared libraries"
6881            build_libtool_libs=no
6882            build_old_libs=yes
6883          fi
6884        else
6885          # Don't allow undefined symbols.
6886          allow_undefined_flag="$no_undefined_flag"
6887        fi
6888
6889      fi
6890
6891      func_generate_dlsyms "$libname" "$libname" "yes"
6892      libobjs="$libobjs $symfileobj"
6893      test "X$libobjs" = "X " && libobjs=
6894
6895      if test "$mode" != relink; then
6896        # Remove our outputs, but don't remove object files since they
6897        # may have been created when compiling PIC objects.
6898        removelist=
6899        tempremovelist=`$ECHO "$output_objdir/*"`
6900        for p in $tempremovelist; do
6901          case $p in
6902            *.$objext | *.gcno)
6903               ;;
6904            $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
6905               if test "X$precious_files_regex" != "X"; then
6906                 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
6907                 then
6908                   continue
6909                 fi
6910               fi
6911               removelist="$removelist $p"
6912               ;;
6913            *) ;;
6914          esac
6915        done
6916        test -n "$removelist" && \
6917          func_show_eval "${RM}r \$removelist"
6918      fi
6919
6920      # Now set the variables for building old libraries.
6921      if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
6922        oldlibs="$oldlibs $output_objdir/$libname.$libext"
6923
6924        # Transform .lo files to .o files.
6925        oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
6926      fi
6927
6928      # Eliminate all temporary directories.
6929      #for path in $notinst_path; do
6930      # lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`
6931      # deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`
6932      # dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`
6933      #done
6934
6935      if test -n "$xrpath"; then
6936        # If the user specified any rpath flags, then add them.
6937        temp_xrpath=
6938        for libdir in $xrpath; do
6939          temp_xrpath="$temp_xrpath -R$libdir"
6940          case "$finalize_rpath " in
6941          *" $libdir "*) ;;
6942          *) finalize_rpath="$finalize_rpath $libdir" ;;
6943          esac
6944        done
6945        if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
6946          dependency_libs="$temp_xrpath $dependency_libs"
6947        fi
6948      fi
6949
6950      # Make sure dlfiles contains only unique files that won't be dlpreopened
6951      old_dlfiles="$dlfiles"
6952      dlfiles=
6953      for lib in $old_dlfiles; do
6954        case " $dlprefiles $dlfiles " in
6955        *" $lib "*) ;;
6956        *) dlfiles="$dlfiles $lib" ;;
6957        esac
6958      done
6959
6960      # Make sure dlprefiles contains only unique files
6961      old_dlprefiles="$dlprefiles"
6962      dlprefiles=
6963      for lib in $old_dlprefiles; do
6964        case "$dlprefiles " in
6965        *" $lib "*) ;;
6966        *) dlprefiles="$dlprefiles $lib" ;;
6967        esac
6968      done
6969
6970      if test "$build_libtool_libs" = yes; then
6971        if test -n "$rpath"; then
6972          case $host in
6973          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc*)
6974            # these systems don't actually have a c library (as such)!
6975            ;;
6976          *-*-rhapsody* | *-*-darwin1.[012])
6977            # Rhapsody C library is in the System framework
6978            deplibs="$deplibs System.ltframework"
6979            ;;
6980          *-*-netbsd*)
6981            # Don't link with libc until the a.out ld.so is fixed.
6982            ;;
6983          *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
6984            # Do not include libc due to us having libc/libc_r.
6985            ;;
6986          *-*-sco3.2v5* | *-*-sco5v6*)
6987            # Causes problems with __ctype
6988            ;;
6989          *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
6990            # Compiler inserts libc in the correct place for threads to work
6991            ;;
6992          *)
6993            # Add libc to deplibs on all other systems if necessary.
6994            if test "$build_libtool_need_lc" = "yes"; then
6995              deplibs="$deplibs -lc"
6996            fi
6997            ;;
6998          esac
6999        fi
7000
7001        # Transform deplibs into only deplibs that can be linked in shared.
7002        name_save=$name
7003        libname_save=$libname
7004        release_save=$release
7005        versuffix_save=$versuffix
7006        major_save=$major
7007        # I'm not sure if I'm treating the release correctly.  I think
7008        # release should show up in the -l (ie -lgmp5) so we don't want to
7009        # add it in twice.  Is that correct?
7010        release=""
7011        versuffix=""
7012        major=""
7013        newdeplibs=
7014        droppeddeps=no
7015        case $deplibs_check_method in
7016        pass_all)
7017          # Don't check for shared/static.  Everything works.
7018          # This might be a little naive.  We might want to check
7019          # whether the library exists or not.  But this is on
7020          # osf3 & osf4 and I'm not really sure... Just
7021          # implementing what was already the behavior.
7022          newdeplibs=$deplibs
7023          ;;
7024        test_compile)
7025          # This code stresses the "libraries are programs" paradigm to its
7026          # limits. Maybe even breaks it.  We compile a program, linking it
7027          # against the deplibs as a proxy for the library.  Then we can check
7028          # whether they linked in statically or dynamically with ldd.
7029          $opt_dry_run || $RM conftest.c
7030          cat > conftest.c <<EOF
7031          int main() { return 0; }
7032EOF
7033          $opt_dry_run || $RM conftest
7034          if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
7035            ldd_output=`ldd conftest`
7036            for i in $deplibs; do
7037              case $i in
7038              -l*)
7039                func_stripname -l '' "$i"
7040                name=$func_stripname_result
7041                if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7042                  case " $predeps $postdeps " in
7043                  *" $i "*)
7044                    newdeplibs="$newdeplibs $i"
7045                    i=""
7046                    ;;
7047                  esac
7048                fi
7049                if test -n "$i" ; then
7050                  libname=`eval "\\$ECHO \"$libname_spec\""`
7051                  deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7052                  set dummy $deplib_matches; shift
7053                  deplib_match=$1
7054                  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7055                    newdeplibs="$newdeplibs $i"
7056                  else
7057                    droppeddeps=yes
7058                    $ECHO
7059                    $ECHO "*** Warning: dynamic linker does not accept needed library $i."
7060                    $ECHO "*** I have the capability to make that library automatically link in when"
7061                    $ECHO "*** you link to this library.  But I can only do this if you have a"
7062                    $ECHO "*** shared version of the library, which I believe you do not have"
7063                    $ECHO "*** because a test_compile did reveal that the linker did not use it for"
7064                    $ECHO "*** its dynamic dependency list that programs get resolved with at runtime."
7065                  fi
7066                fi
7067                ;;
7068              *)
7069                newdeplibs="$newdeplibs $i"
7070                ;;
7071              esac
7072            done
7073          else
7074            # Error occurred in the first compile.  Let's try to salvage
7075            # the situation: Compile a separate program for each library.
7076            for i in $deplibs; do
7077              case $i in
7078              -l*)
7079                func_stripname -l '' "$i"
7080                name=$func_stripname_result
7081                $opt_dry_run || $RM conftest
7082                if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
7083                  ldd_output=`ldd conftest`
7084                  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7085                    case " $predeps $postdeps " in
7086                    *" $i "*)
7087                      newdeplibs="$newdeplibs $i"
7088                      i=""
7089                      ;;
7090                    esac
7091                  fi
7092                  if test -n "$i" ; then
7093                    libname=`eval "\\$ECHO \"$libname_spec\""`
7094                    deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7095                    set dummy $deplib_matches; shift
7096                    deplib_match=$1
7097                    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7098                      newdeplibs="$newdeplibs $i"
7099                    else
7100                      droppeddeps=yes
7101                      $ECHO
7102                      $ECHO "*** Warning: dynamic linker does not accept needed library $i."
7103                      $ECHO "*** I have the capability to make that library automatically link in when"
7104                      $ECHO "*** you link to this library.  But I can only do this if you have a"
7105                      $ECHO "*** shared version of the library, which you do not appear to have"
7106                      $ECHO "*** because a test_compile did reveal that the linker did not use this one"
7107                      $ECHO "*** as a dynamic dependency that programs can get resolved with at runtime."
7108                    fi
7109                  fi
7110                else
7111                  droppeddeps=yes
7112                  $ECHO
7113                  $ECHO "*** Warning!  Library $i is needed by this library but I was not able to"
7114                  $ECHO "*** make it link in!  You will probably need to install it or some"
7115                  $ECHO "*** library that it depends on before this library will be fully"
7116                  $ECHO "*** functional.  Installing it before continuing would be even better."
7117                fi
7118                ;;
7119              *)
7120                newdeplibs="$newdeplibs $i"
7121                ;;
7122              esac
7123            done
7124          fi
7125          ;;
7126        file_magic*)
7127          set dummy $deplibs_check_method; shift
7128          file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7129          for a_deplib in $deplibs; do
7130            case $a_deplib in
7131            -l*)
7132              func_stripname -l '' "$a_deplib"
7133              name=$func_stripname_result
7134              if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7135                case " $predeps $postdeps " in
7136                *" $a_deplib "*)
7137                  newdeplibs="$newdeplibs $a_deplib"
7138                  a_deplib=""
7139                  ;;
7140                esac
7141              fi
7142              if test -n "$a_deplib" ; then
7143                libname=`eval "\\$ECHO \"$libname_spec\""`
7144                for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7145                  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
7146                  for potent_lib in $potential_libs; do
7147                      # Follow soft links.
7148                      if ls -lLd "$potent_lib" 2>/dev/null |
7149                         $GREP " -> " >/dev/null; then
7150                        continue
7151                      fi
7152                      # The statement above tries to avoid entering an
7153                      # endless loop below, in case of cyclic links.
7154                      # We might still enter an endless loop, since a link
7155                      # loop can be closed while we follow links,
7156                      # but so what?
7157                      potlib="$potent_lib"
7158                      while test -h "$potlib" 2>/dev/null; do
7159                        potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
7160                        case $potliblink in
7161                        [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
7162                        *) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
7163                        esac
7164                      done
7165                      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
7166                         $SED -e 10q |
7167                         $EGREP "$file_magic_regex" > /dev/null; then
7168                        newdeplibs="$newdeplibs $a_deplib"
7169                        a_deplib=""
7170                        break 2
7171                      fi
7172                  done
7173                done
7174              fi
7175              if test -n "$a_deplib" ; then
7176                droppeddeps=yes
7177                $ECHO
7178                $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7179                $ECHO "*** I have the capability to make that library automatically link in when"
7180                $ECHO "*** you link to this library.  But I can only do this if you have a"
7181                $ECHO "*** shared version of the library, which you do not appear to have"
7182                $ECHO "*** because I did check the linker path looking for a file starting"
7183                if test -z "$potlib" ; then
7184                  $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
7185                else
7186                  $ECHO "*** with $libname and none of the candidates passed a file format test"
7187                  $ECHO "*** using a file magic. Last file checked: $potlib"
7188                fi
7189              fi
7190              ;;
7191            *)
7192              # Add a -L argument.
7193              newdeplibs="$newdeplibs $a_deplib"
7194              ;;
7195            esac
7196          done # Gone through all deplibs.
7197          ;;
7198        match_pattern*)
7199          set dummy $deplibs_check_method; shift
7200          match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7201          for a_deplib in $deplibs; do
7202            case $a_deplib in
7203            -l*)
7204              func_stripname -l '' "$a_deplib"
7205              name=$func_stripname_result
7206              if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7207                case " $predeps $postdeps " in
7208                *" $a_deplib "*)
7209                  newdeplibs="$newdeplibs $a_deplib"
7210                  a_deplib=""
7211                  ;;
7212                esac
7213              fi
7214              if test -n "$a_deplib" ; then
7215                libname=`eval "\\$ECHO \"$libname_spec\""`
7216                for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7217                  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
7218                  for potent_lib in $potential_libs; do
7219                    potlib="$potent_lib" # see symlink-check above in file_magic test
7220                    if eval "\$ECHO \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \
7221                       $EGREP "$match_pattern_regex" > /dev/null; then
7222                      newdeplibs="$newdeplibs $a_deplib"
7223                      a_deplib=""
7224                      break 2
7225                    fi
7226                  done
7227                done
7228              fi
7229              if test -n "$a_deplib" ; then
7230                droppeddeps=yes
7231                $ECHO
7232                $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7233                $ECHO "*** I have the capability to make that library automatically link in when"
7234                $ECHO "*** you link to this library.  But I can only do this if you have a"
7235                $ECHO "*** shared version of the library, which you do not appear to have"
7236                $ECHO "*** because I did check the linker path looking for a file starting"
7237                if test -z "$potlib" ; then
7238                  $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
7239                else
7240                  $ECHO "*** with $libname and none of the candidates passed a file format test"
7241                  $ECHO "*** using a regex pattern. Last file checked: $potlib"
7242                fi
7243              fi
7244              ;;
7245            *)
7246              # Add a -L argument.
7247              newdeplibs="$newdeplibs $a_deplib"
7248              ;;
7249            esac
7250          done # Gone through all deplibs.
7251          ;;
7252        none | unknown | *)
7253          newdeplibs=""
7254          tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \
7255              -e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'`
7256          if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7257            for i in $predeps $postdeps ; do
7258              # can't use Xsed below, because $i might contain '/'
7259              tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`
7260            done
7261          fi
7262          if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[      ]//g' |
7263             $GREP . >/dev/null; then
7264            $ECHO
7265            if test "X$deplibs_check_method" = "Xnone"; then
7266              $ECHO "*** Warning: inter-library dependencies are not supported in this platform."
7267            else
7268              $ECHO "*** Warning: inter-library dependencies are not known to be supported."
7269            fi
7270            $ECHO "*** All declared inter-library dependencies are being dropped."
7271            droppeddeps=yes
7272          fi
7273          ;;
7274        esac
7275        versuffix=$versuffix_save
7276        major=$major_save
7277        release=$release_save
7278        libname=$libname_save
7279        name=$name_save
7280
7281        case $host in
7282        *-*-rhapsody* | *-*-darwin1.[012])
7283          # On Rhapsody replace the C library with the System framework
7284          newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
7285          ;;
7286        esac
7287
7288        if test "$droppeddeps" = yes; then
7289          if test "$module" = yes; then
7290            $ECHO
7291            $ECHO "*** Warning: libtool could not satisfy all declared inter-library"
7292            $ECHO "*** dependencies of module $libname.  Therefore, libtool will create"
7293            $ECHO "*** a static module, that should work as long as the dlopening"
7294            $ECHO "*** application is linked with the -dlopen flag."
7295            if test -z "$global_symbol_pipe"; then
7296              $ECHO
7297              $ECHO "*** However, this would only work if libtool was able to extract symbol"
7298              $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
7299              $ECHO "*** not find such a program.  So, this module is probably useless."
7300              $ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
7301            fi
7302            if test "$build_old_libs" = no; then
7303              oldlibs="$output_objdir/$libname.$libext"
7304              build_libtool_libs=module
7305              build_old_libs=yes
7306            else
7307              build_libtool_libs=no
7308            fi
7309          else
7310            $ECHO "*** The inter-library dependencies that have been dropped here will be"
7311            $ECHO "*** automatically added whenever a program is linked with this library"
7312            $ECHO "*** or is declared to -dlopen it."
7313
7314            if test "$allow_undefined" = no; then
7315              $ECHO
7316              $ECHO "*** Since this library must not contain undefined symbols,"
7317              $ECHO "*** because either the platform does not support them or"
7318              $ECHO "*** it was explicitly requested with -no-undefined,"
7319              $ECHO "*** libtool will only create a static version of it."
7320              if test "$build_old_libs" = no; then
7321                oldlibs="$output_objdir/$libname.$libext"
7322                build_libtool_libs=module
7323                build_old_libs=yes
7324              else
7325                build_libtool_libs=no
7326              fi
7327            fi
7328          fi
7329        fi
7330        # Done checking deplibs!
7331        deplibs=$newdeplibs
7332      fi
7333      # Time to change all our "foo.ltframework" stuff back to "-framework foo"
7334      case $host in
7335        *-*-darwin*)
7336          newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7337          new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7338          deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7339          ;;
7340      esac
7341
7342      # move library search paths that coincide with paths to not yet
7343      # installed libraries to the beginning of the library search list
7344      new_libs=
7345      for path in $notinst_path; do
7346        case " $new_libs " in
7347        *" -L$path/$objdir "*) ;;
7348        *)
7349          case " $deplibs " in
7350          *" -L$path/$objdir "*)
7351            new_libs="$new_libs -L$path/$objdir" ;;
7352          esac
7353          ;;
7354        esac
7355      done
7356      for deplib in $deplibs; do
7357        case $deplib in
7358        -L*)
7359          case " $new_libs " in
7360          *" $deplib "*) ;;
7361          *) new_libs="$new_libs $deplib" ;;
7362          esac
7363          ;;
7364        *) new_libs="$new_libs $deplib" ;;
7365        esac
7366      done
7367      deplibs="$new_libs"
7368
7369      # All the library-specific variables (install_libdir is set above).
7370      library_names=
7371      old_library=
7372      dlname=
7373
7374      # Test again, we may have decided not to build it any more
7375      if test "$build_libtool_libs" = yes; then
7376        if test "$hardcode_into_libs" = yes; then
7377          # Hardcode the library paths
7378          hardcode_libdirs=
7379          dep_rpath=
7380          rpath="$finalize_rpath"
7381          test "$mode" != relink && rpath="$compile_rpath$rpath"
7382          for libdir in $rpath; do
7383            if test -n "$hardcode_libdir_flag_spec"; then
7384              if test -n "$hardcode_libdir_separator"; then
7385                if test -z "$hardcode_libdirs"; then
7386                  hardcode_libdirs="$libdir"
7387                else
7388                  # Just accumulate the unique libdirs.
7389                  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7390                  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7391                    ;;
7392                  *)
7393                    hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7394                    ;;
7395                  esac
7396                fi
7397              else
7398                eval flag=\"$hardcode_libdir_flag_spec\"
7399                dep_rpath="$dep_rpath $flag"
7400              fi
7401            elif test -n "$runpath_var"; then
7402              case "$perm_rpath " in
7403              *" $libdir "*) ;;
7404              *) perm_rpath="$perm_rpath $libdir" ;;
7405              esac
7406            fi
7407          done
7408          # Substitute the hardcoded libdirs into the rpath.
7409          if test -n "$hardcode_libdir_separator" &&
7410             test -n "$hardcode_libdirs"; then
7411            libdir="$hardcode_libdirs"
7412            if test -n "$hardcode_libdir_flag_spec_ld"; then
7413              eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
7414            else
7415              eval dep_rpath=\"$hardcode_libdir_flag_spec\"
7416            fi
7417          fi
7418          if test -n "$runpath_var" && test -n "$perm_rpath"; then
7419            # We should set the runpath_var.
7420            rpath=
7421            for dir in $perm_rpath; do
7422              rpath="$rpath$dir:"
7423            done
7424            eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
7425          fi
7426          test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
7427        fi
7428
7429        shlibpath="$finalize_shlibpath"
7430        test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
7431        if test -n "$shlibpath"; then
7432          eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
7433        fi
7434
7435        # Get the real and link names of the library.
7436        eval shared_ext=\"$shrext_cmds\"
7437        eval library_names=\"$library_names_spec\"
7438        set dummy $library_names
7439        shift
7440        realname="$1"
7441        shift
7442
7443        if test -n "$soname_spec"; then
7444          eval soname=\"$soname_spec\"
7445        else
7446          soname="$realname"
7447        fi
7448        if test -z "$dlname"; then
7449          dlname=$soname
7450        fi
7451
7452        lib="$output_objdir/$realname"
7453        linknames=
7454        for link
7455        do
7456          linknames="$linknames $link"
7457        done
7458
7459        # Use standard objects if they are pic
7460        test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
7461        test "X$libobjs" = "X " && libobjs=
7462
7463        delfiles=
7464        if test -n "$export_symbols" && test -n "$include_expsyms"; then
7465          $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
7466          export_symbols="$output_objdir/$libname.uexp"
7467          delfiles="$delfiles $export_symbols"
7468        fi
7469
7470        orig_export_symbols=
7471        case $host_os in
7472        cygwin* | mingw* | cegcc*)
7473          if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
7474            # exporting using user supplied symfile
7475            if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
7476              # and it's NOT already a .def file. Must figure out
7477              # which of the given symbols are data symbols and tag
7478              # them as such. So, trigger use of export_symbols_cmds.
7479              # export_symbols gets reassigned inside the "prepare
7480              # the list of exported symbols" if statement, so the
7481              # include_expsyms logic still works.
7482              orig_export_symbols="$export_symbols"
7483              export_symbols=
7484              always_export_symbols=yes
7485            fi
7486          fi
7487          ;;
7488        esac
7489
7490        # Prepare the list of exported symbols
7491        if test -z "$export_symbols"; then
7492          if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
7493            func_verbose "generating symbol list for \`$libname.la'"
7494            export_symbols="$output_objdir/$libname.exp"
7495            $opt_dry_run || $RM $export_symbols
7496            cmds=$export_symbols_cmds
7497            save_ifs="$IFS"; IFS='~'
7498            for cmd in $cmds; do
7499              IFS="$save_ifs"
7500              eval cmd=\"$cmd\"
7501              func_len " $cmd"
7502              len=$func_len_result
7503              if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7504                func_show_eval "$cmd" 'exit $?'
7505                skipped_export=false
7506              else
7507                # The command line is too long to execute in one step.
7508                func_verbose "using reloadable object file for export list..."
7509                skipped_export=:
7510                # Break out early, otherwise skipped_export may be
7511                # set to false by a later but shorter cmd.
7512                break
7513              fi
7514            done
7515            IFS="$save_ifs"
7516            if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
7517              func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
7518              func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
7519            fi
7520          fi
7521        fi
7522
7523        if test -n "$export_symbols" && test -n "$include_expsyms"; then
7524          tmp_export_symbols="$export_symbols"
7525          test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
7526          $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
7527        fi
7528
7529        if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
7530          # The given exports_symbols file has to be filtered, so filter it.
7531          func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
7532          # FIXME: $output_objdir/$libname.filter potentially contains lots of
7533          # 's' commands which not all seds can handle. GNU sed should be fine
7534          # though. Also, the filter scales superlinearly with the number of
7535          # global variables. join(1) would be nice here, but unfortunately
7536          # isn't a blessed tool.
7537          $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
7538          delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
7539          export_symbols=$output_objdir/$libname.def
7540          $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7541        fi
7542
7543        tmp_deplibs=
7544        for test_deplib in $deplibs; do
7545          case " $convenience " in
7546          *" $test_deplib "*) ;;
7547          *)
7548            tmp_deplibs="$tmp_deplibs $test_deplib"
7549            ;;
7550          esac
7551        done
7552        deplibs="$tmp_deplibs"
7553
7554        if test -n "$convenience"; then
7555          if test -n "$whole_archive_flag_spec" &&
7556            test "$compiler_needs_object" = yes &&
7557            test -z "$libobjs"; then
7558            # extract the archives, so we have objects to list.
7559            # TODO: could optimize this to just extract one archive.
7560            whole_archive_flag_spec=
7561          fi
7562          if test -n "$whole_archive_flag_spec"; then
7563            save_libobjs=$libobjs
7564            eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
7565            test "X$libobjs" = "X " && libobjs=
7566          else
7567            gentop="$output_objdir/${outputname}x"
7568            generated="$generated $gentop"
7569
7570            func_extract_archives $gentop $convenience
7571            libobjs="$libobjs $func_extract_archives_result"
7572            test "X$libobjs" = "X " && libobjs=
7573          fi
7574        fi
7575
7576        if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
7577          eval flag=\"$thread_safe_flag_spec\"
7578          linker_flags="$linker_flags $flag"
7579        fi
7580
7581        # Make a backup of the uninstalled library when relinking
7582        if test "$mode" = relink; then
7583          $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
7584        fi
7585
7586        # Do each of the archive commands.
7587        if test "$module" = yes && test -n "$module_cmds" ; then
7588          if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
7589            eval test_cmds=\"$module_expsym_cmds\"
7590            cmds=$module_expsym_cmds
7591          else
7592            eval test_cmds=\"$module_cmds\"
7593            cmds=$module_cmds
7594          fi
7595        else
7596          if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
7597            eval test_cmds=\"$archive_expsym_cmds\"
7598            cmds=$archive_expsym_cmds
7599          else
7600            eval test_cmds=\"$archive_cmds\"
7601            cmds=$archive_cmds
7602          fi
7603        fi
7604
7605        if test "X$skipped_export" != "X:" &&
7606           func_len " $test_cmds" &&
7607           len=$func_len_result &&
7608           test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7609          :
7610        else
7611          # The command line is too long to link in one step, link piecewise
7612          # or, if using GNU ld and skipped_export is not :, use a linker
7613          # script.
7614
7615          # Save the value of $output and $libobjs because we want to
7616          # use them later.  If we have whole_archive_flag_spec, we
7617          # want to use save_libobjs as it was before
7618          # whole_archive_flag_spec was expanded, because we can't
7619          # assume the linker understands whole_archive_flag_spec.
7620          # This may have to be revisited, in case too many
7621          # convenience libraries get linked in and end up exceeding
7622          # the spec.
7623          if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
7624            save_libobjs=$libobjs
7625          fi
7626          save_output=$output
7627          output_la=`$ECHO "X$output" | $Xsed -e "$basename"`
7628
7629          # Clear the reloadable object creation command queue and
7630          # initialize k to one.
7631          test_cmds=
7632          concat_cmds=
7633          objlist=
7634          last_robj=
7635          k=1
7636
7637          if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
7638            output=${output_objdir}/${output_la}.lnkscript
7639            func_verbose "creating GNU ld script: $output"
7640            $ECHO 'INPUT (' > $output
7641            for obj in $save_libobjs
7642            do
7643              $ECHO "$obj" >> $output
7644            done
7645            $ECHO ')' >> $output
7646            delfiles="$delfiles $output"
7647          elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
7648            output=${output_objdir}/${output_la}.lnk
7649            func_verbose "creating linker input file list: $output"
7650            : > $output
7651            set x $save_libobjs
7652            shift
7653            firstobj=
7654            if test "$compiler_needs_object" = yes; then
7655              firstobj="$1 "
7656              shift
7657            fi
7658            for obj
7659            do
7660              $ECHO "$obj" >> $output
7661            done
7662            delfiles="$delfiles $output"
7663            output=$firstobj\"$file_list_spec$output\"
7664          else
7665            if test -n "$save_libobjs"; then
7666              func_verbose "creating reloadable object files..."
7667              output=$output_objdir/$output_la-${k}.$objext
7668              eval test_cmds=\"$reload_cmds\"
7669              func_len " $test_cmds"
7670              len0=$func_len_result
7671              len=$len0
7672
7673              # Loop over the list of objects to be linked.
7674              for obj in $save_libobjs
7675              do
7676                func_len " $obj"
7677                func_arith $len + $func_len_result
7678                len=$func_arith_result
7679                if test "X$objlist" = X ||
7680                   test "$len" -lt "$max_cmd_len"; then
7681                  func_append objlist " $obj"
7682                else
7683                  # The command $test_cmds is almost too long, add a
7684                  # command to the queue.
7685                  if test "$k" -eq 1 ; then
7686                    # The first file doesn't have a previous command to add.
7687                    eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
7688                  else
7689                    # All subsequent reloadable object files will link in
7690                    # the last one created.
7691                    eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj~\$RM $last_robj\"
7692                  fi
7693                  last_robj=$output_objdir/$output_la-${k}.$objext
7694                  func_arith $k + 1
7695                  k=$func_arith_result
7696                  output=$output_objdir/$output_la-${k}.$objext
7697                  objlist=$obj
7698                  func_len " $last_robj"
7699                  func_arith $len0 + $func_len_result
7700                  len=$func_arith_result
7701                fi
7702              done
7703              # Handle the remaining objects by creating one last
7704              # reloadable object file.  All subsequent reloadable object
7705              # files will link in the last one created.
7706              test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7707              eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
7708              if test -n "$last_robj"; then
7709                eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
7710              fi
7711              delfiles="$delfiles $output"
7712
7713            else
7714              output=
7715            fi
7716
7717            if ${skipped_export-false}; then
7718              func_verbose "generating symbol list for \`$libname.la'"
7719              export_symbols="$output_objdir/$libname.exp"
7720              $opt_dry_run || $RM $export_symbols
7721              libobjs=$output
7722              # Append the command to create the export file.
7723              test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7724              eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
7725              if test -n "$last_robj"; then
7726                eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
7727              fi
7728            fi
7729
7730            test -n "$save_libobjs" &&
7731              func_verbose "creating a temporary reloadable object file: $output"
7732
7733            # Loop through the commands generated above and execute them.
7734            save_ifs="$IFS"; IFS='~'
7735            for cmd in $concat_cmds; do
7736              IFS="$save_ifs"
7737              $opt_silent || {
7738                  func_quote_for_expand "$cmd"
7739                  eval "func_echo $func_quote_for_expand_result"
7740              }
7741              $opt_dry_run || eval "$cmd" || {
7742                lt_exit=$?
7743
7744                # Restore the uninstalled library and exit
7745                if test "$mode" = relink; then
7746                  ( cd "$output_objdir" && \
7747                    $RM "${realname}T" && \
7748                    $MV "${realname}U" "$realname" )
7749                fi
7750
7751                exit $lt_exit
7752              }
7753            done
7754            IFS="$save_ifs"
7755
7756            if test -n "$export_symbols_regex" && ${skipped_export-false}; then
7757              func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
7758              func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
7759            fi
7760          fi
7761
7762          if ${skipped_export-false}; then
7763            if test -n "$export_symbols" && test -n "$include_expsyms"; then
7764              tmp_export_symbols="$export_symbols"
7765              test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
7766              $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
7767            fi
7768
7769            if test -n "$orig_export_symbols"; then
7770              # The given exports_symbols file has to be filtered, so filter it.
7771              func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
7772              # FIXME: $output_objdir/$libname.filter potentially contains lots of
7773              # 's' commands which not all seds can handle. GNU sed should be fine
7774              # though. Also, the filter scales superlinearly with the number of
7775              # global variables. join(1) would be nice here, but unfortunately
7776              # isn't a blessed tool.
7777              $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
7778              delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
7779              export_symbols=$output_objdir/$libname.def
7780              $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7781            fi
7782          fi
7783
7784          libobjs=$output
7785          # Restore the value of output.
7786          output=$save_output
7787
7788          if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
7789            eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
7790            test "X$libobjs" = "X " && libobjs=
7791          fi
7792          # Expand the library linking commands again to reset the
7793          # value of $libobjs for piecewise linking.
7794
7795          # Do each of the archive commands.
7796          if test "$module" = yes && test -n "$module_cmds" ; then
7797            if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
7798              cmds=$module_expsym_cmds
7799            else
7800              cmds=$module_cmds
7801            fi
7802          else
7803            if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
7804              cmds=$archive_expsym_cmds
7805            else
7806              cmds=$archive_cmds
7807            fi
7808          fi
7809        fi
7810
7811        if test -n "$delfiles"; then
7812          # Append the command to remove temporary files to $cmds.
7813          eval cmds=\"\$cmds~\$RM $delfiles\"
7814        fi
7815
7816        # Add any objects from preloaded convenience libraries
7817        if test -n "$dlprefiles"; then
7818          gentop="$output_objdir/${outputname}x"
7819          generated="$generated $gentop"
7820
7821          func_extract_archives $gentop $dlprefiles
7822          libobjs="$libobjs $func_extract_archives_result"
7823          test "X$libobjs" = "X " && libobjs=
7824        fi
7825
7826        save_ifs="$IFS"; IFS='~'
7827        for cmd in $cmds; do
7828          IFS="$save_ifs"
7829          eval cmd=\"$cmd\"
7830          $opt_silent || {
7831            func_quote_for_expand "$cmd"
7832            eval "func_echo $func_quote_for_expand_result"
7833          }
7834          $opt_dry_run || eval "$cmd" || {
7835            lt_exit=$?
7836
7837            # Restore the uninstalled library and exit
7838            if test "$mode" = relink; then
7839              ( cd "$output_objdir" && \
7840                $RM "${realname}T" && \
7841                $MV "${realname}U" "$realname" )
7842            fi
7843
7844            exit $lt_exit
7845          }
7846        done
7847        IFS="$save_ifs"
7848
7849        # Restore the uninstalled library and exit
7850        if test "$mode" = relink; then
7851          $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
7852
7853          if test -n "$convenience"; then
7854            if test -z "$whole_archive_flag_spec"; then
7855              func_show_eval '${RM}r "$gentop"'
7856            fi
7857          fi
7858
7859          exit $EXIT_SUCCESS
7860        fi
7861
7862        # Create links to the real library.
7863        for linkname in $linknames; do
7864          if test "$realname" != "$linkname"; then
7865            func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
7866          fi
7867        done
7868
7869        # If -module or -export-dynamic was specified, set the dlname.
7870        if test "$module" = yes || test "$export_dynamic" = yes; then
7871          # On all known operating systems, these are identical.
7872          dlname="$soname"
7873        fi
7874      fi
7875      ;;
7876
7877    obj)
7878      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
7879        func_warning "\`-dlopen' is ignored for objects"
7880      fi
7881
7882      case " $deplibs" in
7883      *\ -l* | *\ -L*)
7884        func_warning "\`-l' and \`-L' are ignored for objects" ;;
7885      esac
7886
7887      test -n "$rpath" && \
7888        func_warning "\`-rpath' is ignored for objects"
7889
7890      test -n "$xrpath" && \
7891        func_warning "\`-R' is ignored for objects"
7892
7893      test -n "$vinfo" && \
7894        func_warning "\`-version-info' is ignored for objects"
7895
7896      test -n "$release" && \
7897        func_warning "\`-release' is ignored for objects"
7898
7899      case $output in
7900      *.lo)
7901        test -n "$objs$old_deplibs" && \
7902          func_fatal_error "cannot build library object \`$output' from non-libtool objects"
7903
7904        libobj=$output
7905        func_lo2o "$libobj"
7906        obj=$func_lo2o_result
7907        ;;
7908      *)
7909        libobj=
7910        obj="$output"
7911        ;;
7912      esac
7913
7914      # Delete the old objects.
7915      $opt_dry_run || $RM $obj $libobj
7916
7917      # Objects from convenience libraries.  This assumes
7918      # single-version convenience libraries.  Whenever we create
7919      # different ones for PIC/non-PIC, this we'll have to duplicate
7920      # the extraction.
7921      reload_conv_objs=
7922      gentop=
7923      # reload_cmds runs $LD directly, so let us get rid of
7924      # -Wl from whole_archive_flag_spec and hope we can get by with
7925      # turning comma into space..
7926      wl=
7927
7928      if test -n "$convenience"; then
7929        if test -n "$whole_archive_flag_spec"; then
7930          eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
7931          reload_conv_objs=$reload_objs\ `$ECHO "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`
7932        else
7933          gentop="$output_objdir/${obj}x"
7934          generated="$generated $gentop"
7935
7936          func_extract_archives $gentop $convenience
7937          reload_conv_objs="$reload_objs $func_extract_archives_result"
7938        fi
7939      fi
7940
7941      # Create the old-style object.
7942      reload_objs="$objs$old_deplibs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
7943
7944      output="$obj"
7945      func_execute_cmds "$reload_cmds" 'exit $?'
7946
7947      # Exit if we aren't doing a library object file.
7948      if test -z "$libobj"; then
7949        if test -n "$gentop"; then
7950          func_show_eval '${RM}r "$gentop"'
7951        fi
7952
7953        exit $EXIT_SUCCESS
7954      fi
7955
7956      if test "$build_libtool_libs" != yes; then
7957        if test -n "$gentop"; then
7958          func_show_eval '${RM}r "$gentop"'
7959        fi
7960
7961        # Create an invalid libtool object if no PIC, so that we don't
7962        # accidentally link it into a program.
7963        # $show "echo timestamp > $libobj"
7964        # $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
7965        exit $EXIT_SUCCESS
7966      fi
7967
7968      if test -n "$pic_flag" || test "$pic_mode" != default; then
7969        # Only do commands if we really have different PIC objects.
7970        reload_objs="$libobjs $reload_conv_objs"
7971        output="$libobj"
7972        func_execute_cmds "$reload_cmds" 'exit $?'
7973      fi
7974
7975      if test -n "$gentop"; then
7976        func_show_eval '${RM}r "$gentop"'
7977      fi
7978
7979      exit $EXIT_SUCCESS
7980      ;;
7981
7982    prog)
7983      case $host in
7984        *cygwin*) func_stripname '' '.exe' "$output"
7985                  output=$func_stripname_result.exe;;
7986      esac
7987      test -n "$vinfo" && \
7988        func_warning "\`-version-info' is ignored for programs"
7989
7990      test -n "$release" && \
7991        func_warning "\`-release' is ignored for programs"
7992
7993      test "$preload" = yes \
7994        && test "$dlopen_support" = unknown \
7995        && test "$dlopen_self" = unknown \
7996        && test "$dlopen_self_static" = unknown && \
7997          func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
7998
7999      case $host in
8000      *-*-rhapsody* | *-*-darwin1.[012])
8001        # On Rhapsody replace the C library is the System framework
8002        compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
8003        finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
8004        ;;
8005      esac
8006
8007      case $host in
8008      *-*-darwin*)
8009        # Don't allow lazy linking, it breaks C++ global constructors
8010        # But is supposedly fixed on 10.4 or later (yay!).
8011        if test "$tagname" = CXX ; then
8012          case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
8013            10.[0123])
8014              compile_command="$compile_command ${wl}-bind_at_load"
8015              finalize_command="$finalize_command ${wl}-bind_at_load"
8016            ;;
8017          esac
8018        fi
8019        # Time to change all our "foo.ltframework" stuff back to "-framework foo"
8020        compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
8021        finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
8022        ;;
8023      esac
8024
8025
8026      # move library search paths that coincide with paths to not yet
8027      # installed libraries to the beginning of the library search list
8028      new_libs=
8029      for path in $notinst_path; do
8030        case " $new_libs " in
8031        *" -L$path/$objdir "*) ;;
8032        *)
8033          case " $compile_deplibs " in
8034          *" -L$path/$objdir "*)
8035            new_libs="$new_libs -L$path/$objdir" ;;
8036          esac
8037          ;;
8038        esac
8039      done
8040      for deplib in $compile_deplibs; do
8041        case $deplib in
8042        -L*)
8043          case " $new_libs " in
8044          *" $deplib "*) ;;
8045          *) new_libs="$new_libs $deplib" ;;
8046          esac
8047          ;;
8048        *) new_libs="$new_libs $deplib" ;;
8049        esac
8050      done
8051      compile_deplibs="$new_libs"
8052
8053
8054      compile_command="$compile_command $compile_deplibs"
8055      finalize_command="$finalize_command $finalize_deplibs"
8056
8057      if test -n "$rpath$xrpath"; then
8058        # If the user specified any rpath flags, then add them.
8059        for libdir in $rpath $xrpath; do
8060          # This is the magic to use -rpath.
8061          case "$finalize_rpath " in
8062          *" $libdir "*) ;;
8063          *) finalize_rpath="$finalize_rpath $libdir" ;;
8064          esac
8065        done
8066      fi
8067
8068      # Now hardcode the library paths
8069      rpath=
8070      hardcode_libdirs=
8071      for libdir in $compile_rpath $finalize_rpath; do
8072        if test -n "$hardcode_libdir_flag_spec"; then
8073          if test -n "$hardcode_libdir_separator"; then
8074            if test -z "$hardcode_libdirs"; then
8075              hardcode_libdirs="$libdir"
8076            else
8077              # Just accumulate the unique libdirs.
8078              case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8079              *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8080                ;;
8081              *)
8082                hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
8083                ;;
8084              esac
8085            fi
8086          else
8087            eval flag=\"$hardcode_libdir_flag_spec\"
8088            rpath="$rpath $flag"
8089          fi
8090        elif test -n "$runpath_var"; then
8091          case "$perm_rpath " in
8092          *" $libdir "*) ;;
8093          *) perm_rpath="$perm_rpath $libdir" ;;
8094          esac
8095        fi
8096        case $host in
8097        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
8098          testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
8099          case :$dllsearchpath: in
8100          *":$libdir:"*) ;;
8101          ::) dllsearchpath=$libdir;;
8102          *) dllsearchpath="$dllsearchpath:$libdir";;
8103          esac
8104          case :$dllsearchpath: in
8105          *":$testbindir:"*) ;;
8106          ::) dllsearchpath=$testbindir;;
8107          *) dllsearchpath="$dllsearchpath:$testbindir";;
8108          esac
8109          ;;
8110        esac
8111      done
8112      # Substitute the hardcoded libdirs into the rpath.
8113      if test -n "$hardcode_libdir_separator" &&
8114         test -n "$hardcode_libdirs"; then
8115        libdir="$hardcode_libdirs"
8116        eval rpath=\" $hardcode_libdir_flag_spec\"
8117      fi
8118      compile_rpath="$rpath"
8119
8120      rpath=
8121      hardcode_libdirs=
8122      for libdir in $finalize_rpath; do
8123        if test -n "$hardcode_libdir_flag_spec"; then
8124          if test -n "$hardcode_libdir_separator"; then
8125            if test -z "$hardcode_libdirs"; then
8126              hardcode_libdirs="$libdir"
8127            else
8128              # Just accumulate the unique libdirs.
8129              case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8130              *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8131                ;;
8132              *)
8133                hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
8134                ;;
8135              esac
8136            fi
8137          else
8138            eval flag=\"$hardcode_libdir_flag_spec\"
8139            rpath="$rpath $flag"
8140          fi
8141        elif test -n "$runpath_var"; then
8142          case "$finalize_perm_rpath " in
8143          *" $libdir "*) ;;
8144          *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
8145          esac
8146        fi
8147      done
8148      # Substitute the hardcoded libdirs into the rpath.
8149      if test -n "$hardcode_libdir_separator" &&
8150         test -n "$hardcode_libdirs"; then
8151        libdir="$hardcode_libdirs"
8152        eval rpath=\" $hardcode_libdir_flag_spec\"
8153      fi
8154      finalize_rpath="$rpath"
8155
8156      if test -n "$libobjs" && test "$build_old_libs" = yes; then
8157        # Transform all the library objects into standard objects.
8158        compile_command=`$ECHO "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
8159        finalize_command=`$ECHO "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
8160      fi
8161
8162      func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
8163
8164      # template prelinking step
8165      if test -n "$prelink_cmds"; then
8166        func_execute_cmds "$prelink_cmds" 'exit $?'
8167      fi
8168
8169      wrappers_required=yes
8170      case $host in
8171      *cygwin* | *mingw* )
8172        if test "$build_libtool_libs" != yes; then
8173          wrappers_required=no
8174        fi
8175        ;;
8176      *cegcc)
8177        # Disable wrappers for cegcc, we are cross compiling anyway.
8178        wrappers_required=no
8179        ;;
8180      *)
8181        if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
8182          wrappers_required=no
8183        fi
8184        ;;
8185      esac
8186      if test "$wrappers_required" = no; then
8187        # Replace the output file specification.
8188        compile_command=`$ECHO "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
8189        link_command="$compile_command$compile_rpath"
8190
8191        # We have no uninstalled library dependencies, so finalize right now.
8192        exit_status=0
8193        func_show_eval "$link_command" 'exit_status=$?'
8194
8195        # Delete the generated files.
8196        if test -f "$output_objdir/${outputname}S.${objext}"; then
8197          func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
8198        fi
8199
8200        exit $exit_status
8201      fi
8202
8203      if test -n "$compile_shlibpath$finalize_shlibpath"; then
8204        compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
8205      fi
8206      if test -n "$finalize_shlibpath"; then
8207        finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
8208      fi
8209
8210      compile_var=
8211      finalize_var=
8212      if test -n "$runpath_var"; then
8213        if test -n "$perm_rpath"; then
8214          # We should set the runpath_var.
8215          rpath=
8216          for dir in $perm_rpath; do
8217            rpath="$rpath$dir:"
8218          done
8219          compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
8220        fi
8221        if test -n "$finalize_perm_rpath"; then
8222          # We should set the runpath_var.
8223          rpath=
8224          for dir in $finalize_perm_rpath; do
8225            rpath="$rpath$dir:"
8226          done
8227          finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
8228        fi
8229      fi
8230
8231      if test "$no_install" = yes; then
8232        # We don't need to create a wrapper script.
8233        link_command="$compile_var$compile_command$compile_rpath"
8234        # Replace the output file specification.
8235        link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
8236        # Delete the old output file.
8237        $opt_dry_run || $RM $output
8238        # Link the executable and exit
8239        func_show_eval "$link_command" 'exit $?'
8240        exit $EXIT_SUCCESS
8241      fi
8242
8243      if test "$hardcode_action" = relink; then
8244        # Fast installation is not supported
8245        link_command="$compile_var$compile_command$compile_rpath"
8246        relink_command="$finalize_var$finalize_command$finalize_rpath"
8247
8248        func_warning "this platform does not like uninstalled shared libraries"
8249        func_warning "\`$output' will be relinked during installation"
8250      else
8251        if test "$fast_install" != no; then
8252          link_command="$finalize_var$compile_command$finalize_rpath"
8253          if test "$fast_install" = yes; then
8254            relink_command=`$ECHO "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
8255          else
8256            # fast_install is set to needless
8257            relink_command=
8258          fi
8259        else
8260          link_command="$compile_var$compile_command$compile_rpath"
8261          relink_command="$finalize_var$finalize_command$finalize_rpath"
8262        fi
8263      fi
8264
8265      # Replace the output file specification.
8266      link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
8267
8268      # Delete the old output files.
8269      $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
8270
8271      func_show_eval "$link_command" 'exit $?'
8272
8273      # Now create the wrapper script.
8274      func_verbose "creating $output"
8275
8276      # Quote the relink command for shipping.
8277      if test -n "$relink_command"; then
8278        # Preserve any variables that may affect compiler behavior
8279        for var in $variables_saved_for_relink; do
8280          if eval test -z \"\${$var+set}\"; then
8281            relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
8282          elif eval var_value=\$$var; test -z "$var_value"; then
8283            relink_command="$var=; export $var; $relink_command"
8284          else
8285            func_quote_for_eval "$var_value"
8286            relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
8287          fi
8288        done
8289        relink_command="(cd `pwd`; $relink_command)"
8290        relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
8291      fi
8292
8293      # Quote $ECHO for shipping.
8294      if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then
8295        case $progpath in
8296        [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
8297        *) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
8298        esac
8299        qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"`
8300      else
8301        qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"`
8302      fi
8303
8304      # Only actually do things if not in dry run mode.
8305      $opt_dry_run || {
8306        # win32 will think the script is a binary if it has
8307        # a .exe suffix, so we strip it off here.
8308        case $output in
8309          *.exe) func_stripname '' '.exe' "$output"
8310                 output=$func_stripname_result ;;
8311        esac
8312        # test for cygwin because mv fails w/o .exe extensions
8313        case $host in
8314          *cygwin*)
8315            exeext=.exe
8316            func_stripname '' '.exe' "$outputname"
8317            outputname=$func_stripname_result ;;
8318          *) exeext= ;;
8319        esac
8320        case $host in
8321          *cygwin* | *mingw* )
8322            func_dirname_and_basename "$output" "" "."
8323            output_name=$func_basename_result
8324            output_path=$func_dirname_result
8325            cwrappersource="$output_path/$objdir/lt-$output_name.c"
8326            cwrapper="$output_path/$output_name.exe"
8327            $RM $cwrappersource $cwrapper
8328            trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
8329
8330            func_emit_cwrapperexe_src > $cwrappersource
8331
8332            # The wrapper executable is built using the $host compiler,
8333            # because it contains $host paths and files. If cross-
8334            # compiling, it, like the target executable, must be
8335            # executed on the $host or under an emulation environment.
8336            $opt_dry_run || {
8337              $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
8338              $STRIP $cwrapper
8339            }
8340
8341            # Now, create the wrapper script for func_source use:
8342            func_ltwrapper_scriptname $cwrapper
8343            $RM $func_ltwrapper_scriptname_result
8344            trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
8345            $opt_dry_run || {
8346              # note: this script will not be executed, so do not chmod.
8347              if test "x$build" = "x$host" ; then
8348                $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
8349              else
8350                func_emit_wrapper no > $func_ltwrapper_scriptname_result
8351              fi
8352            }
8353          ;;
8354          * )
8355            $RM $output
8356            trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
8357
8358            func_emit_wrapper no > $output
8359            chmod +x $output
8360          ;;
8361        esac
8362      }
8363      exit $EXIT_SUCCESS
8364      ;;
8365    esac
8366
8367    # See if we need to build an old-fashioned archive.
8368    for oldlib in $oldlibs; do
8369
8370      if test "$build_libtool_libs" = convenience; then
8371        oldobjs="$libobjs_save $symfileobj"
8372        addlibs="$convenience"
8373        build_libtool_libs=no
8374      else
8375        if test "$build_libtool_libs" = module; then
8376          oldobjs="$libobjs_save"
8377          build_libtool_libs=no
8378        else
8379          oldobjs="$old_deplibs $non_pic_objects"
8380          if test "$preload" = yes && test -f "$symfileobj"; then
8381            oldobjs="$oldobjs $symfileobj"
8382          fi
8383        fi
8384        addlibs="$old_convenience"
8385      fi
8386
8387      if test -n "$addlibs"; then
8388        gentop="$output_objdir/${outputname}x"
8389        generated="$generated $gentop"
8390
8391        func_extract_archives $gentop $addlibs
8392        oldobjs="$oldobjs $func_extract_archives_result"
8393      fi
8394
8395      # Do each command in the archive commands.
8396      if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
8397        cmds=$old_archive_from_new_cmds
8398      else
8399
8400        # Add any objects from preloaded convenience libraries
8401        if test -n "$dlprefiles"; then
8402          gentop="$output_objdir/${outputname}x"
8403          generated="$generated $gentop"
8404
8405          func_extract_archives $gentop $dlprefiles
8406          oldobjs="$oldobjs $func_extract_archives_result"
8407        fi
8408
8409        # POSIX demands no paths to be encoded in archives.  We have
8410        # to avoid creating archives with duplicate basenames if we
8411        # might have to extract them afterwards, e.g., when creating a
8412        # static archive out of a convenience library, or when linking
8413        # the entirety of a libtool archive into another (currently
8414        # not supported by libtool).
8415        if (for obj in $oldobjs
8416            do
8417              func_basename "$obj"
8418              $ECHO "$func_basename_result"
8419            done | sort | sort -uc >/dev/null 2>&1); then
8420          :
8421        else
8422          $ECHO "copying selected object files to avoid basename conflicts..."
8423          gentop="$output_objdir/${outputname}x"
8424          generated="$generated $gentop"
8425          func_mkdir_p "$gentop"
8426          save_oldobjs=$oldobjs
8427          oldobjs=
8428          counter=1
8429          for obj in $save_oldobjs
8430          do
8431            func_basename "$obj"
8432            objbase="$func_basename_result"
8433            case " $oldobjs " in
8434            " ") oldobjs=$obj ;;
8435            *[\ /]"$objbase "*)
8436              while :; do
8437                # Make sure we don't pick an alternate name that also
8438                # overlaps.
8439                newobj=lt$counter-$objbase
8440                func_arith $counter + 1
8441                counter=$func_arith_result
8442                case " $oldobjs " in
8443                *[\ /]"$newobj "*) ;;
8444                *) if test ! -f "$gentop/$newobj"; then break; fi ;;
8445                esac
8446              done
8447              func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
8448              oldobjs="$oldobjs $gentop/$newobj"
8449              ;;
8450            *) oldobjs="$oldobjs $obj" ;;
8451            esac
8452          done
8453        fi
8454        eval cmds=\"$old_archive_cmds\"
8455
8456        func_len " $cmds"
8457        len=$func_len_result
8458        if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
8459          cmds=$old_archive_cmds
8460        else
8461          # the command line is too long to link in one step, link in parts
8462          func_verbose "using piecewise archive linking..."
8463          save_RANLIB=$RANLIB
8464          RANLIB=:
8465          objlist=
8466          concat_cmds=
8467          save_oldobjs=$oldobjs
8468          oldobjs=
8469          # Is there a better way of finding the last object in the list?
8470          for obj in $save_oldobjs
8471          do
8472            last_oldobj=$obj
8473          done
8474          eval test_cmds=\"$old_archive_cmds\"
8475          func_len " $test_cmds"
8476          len0=$func_len_result
8477          len=$len0
8478          for obj in $save_oldobjs
8479          do
8480            func_len " $obj"
8481            func_arith $len + $func_len_result
8482            len=$func_arith_result
8483            func_append objlist " $obj"
8484            if test "$len" -lt "$max_cmd_len"; then
8485              :
8486            else
8487              # the above command should be used before it gets too long
8488              oldobjs=$objlist
8489              if test "$obj" = "$last_oldobj" ; then
8490                RANLIB=$save_RANLIB
8491              fi
8492              test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8493              eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
8494              objlist=
8495              len=$len0
8496            fi
8497          done
8498          RANLIB=$save_RANLIB
8499          oldobjs=$objlist
8500          if test "X$oldobjs" = "X" ; then
8501            eval cmds=\"\$concat_cmds\"
8502          else
8503            eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
8504          fi
8505        fi
8506      fi
8507      func_execute_cmds "$cmds" 'exit $?'
8508    done
8509
8510    test -n "$generated" && \
8511      func_show_eval "${RM}r$generated"
8512
8513    # Now create the libtool archive.
8514    case $output in
8515    *.la)
8516      old_library=
8517      test "$build_old_libs" = yes && old_library="$libname.$libext"
8518      func_verbose "creating $output"
8519
8520      # Preserve any variables that may affect compiler behavior
8521      for var in $variables_saved_for_relink; do
8522        if eval test -z \"\${$var+set}\"; then
8523          relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
8524        elif eval var_value=\$$var; test -z "$var_value"; then
8525          relink_command="$var=; export $var; $relink_command"
8526        else
8527          func_quote_for_eval "$var_value"
8528          relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
8529        fi
8530      done
8531      # Quote the link command for shipping.
8532      relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
8533      relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
8534      if test "$hardcode_automatic" = yes ; then
8535        relink_command=
8536      fi
8537
8538      # Only create the output if not a dry run.
8539      $opt_dry_run || {
8540        for installed in no yes; do
8541          if test "$installed" = yes; then
8542            if test -z "$install_libdir"; then
8543              break
8544            fi
8545            output="$output_objdir/$outputname"i
8546            # Replace all uninstalled libtool libraries with the installed ones
8547            newdependency_libs=
8548            for deplib in $dependency_libs; do
8549              case $deplib in
8550              *.la)
8551                func_basename "$deplib"
8552                name="$func_basename_result"
8553                eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
8554                test -z "$libdir" && \
8555                  func_fatal_error "\`$deplib' is not a valid libtool archive"
8556                newdependency_libs="$newdependency_libs $libdir/$name"
8557                ;;
8558              *) newdependency_libs="$newdependency_libs $deplib" ;;
8559              esac
8560            done
8561            dependency_libs="$newdependency_libs"
8562            newdlfiles=
8563
8564            for lib in $dlfiles; do
8565              case $lib in
8566              *.la)
8567                func_basename "$lib"
8568                name="$func_basename_result"
8569                eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8570                test -z "$libdir" && \
8571                  func_fatal_error "\`$lib' is not a valid libtool archive"
8572                newdlfiles="$newdlfiles $libdir/$name"
8573                ;;
8574              *) newdlfiles="$newdlfiles $lib" ;;
8575              esac
8576            done
8577            dlfiles="$newdlfiles"
8578            newdlprefiles=
8579            for lib in $dlprefiles; do
8580              case $lib in
8581              *.la)
8582                # Only pass preopened files to the pseudo-archive (for
8583                # eventual linking with the app. that links it) if we
8584                # didn't already link the preopened objects directly into
8585                # the library:
8586                func_basename "$lib"
8587                name="$func_basename_result"
8588                eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8589                test -z "$libdir" && \
8590                  func_fatal_error "\`$lib' is not a valid libtool archive"
8591                newdlprefiles="$newdlprefiles $libdir/$name"
8592                ;;
8593              esac
8594            done
8595            dlprefiles="$newdlprefiles"
8596          else
8597            newdlfiles=
8598            for lib in $dlfiles; do
8599              case $lib in
8600                [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
8601                *) abs=`pwd`"/$lib" ;;
8602              esac
8603              newdlfiles="$newdlfiles $abs"
8604            done
8605            dlfiles="$newdlfiles"
8606            newdlprefiles=
8607            for lib in $dlprefiles; do
8608              case $lib in
8609                [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
8610                *) abs=`pwd`"/$lib" ;;
8611              esac
8612              newdlprefiles="$newdlprefiles $abs"
8613            done
8614            dlprefiles="$newdlprefiles"
8615          fi
8616          $RM $output
8617          # place dlname in correct position for cygwin
8618          tdlname=$dlname
8619          case $host,$output,$installed,$module,$dlname in
8620            *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
8621          esac
8622          $ECHO > $output "\
8623# $outputname - a libtool library file
8624# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
8625#
8626# Please DO NOT delete this file!
8627# It is necessary for linking the library.
8628
8629# The name that we can dlopen(3).
8630dlname='$tdlname'
8631
8632# Names of this library.
8633library_names='$library_names'
8634
8635# The name of the static archive.
8636old_library='$old_library'
8637
8638# Linker flags that can not go in dependency_libs.
8639inherited_linker_flags='$new_inherited_linker_flags'
8640
8641# Libraries that this one depends upon.
8642dependency_libs='$dependency_libs'
8643
8644# Names of additional weak libraries provided by this library
8645weak_library_names='$weak_libs'
8646
8647# Version information for $libname.
8648current=$current
8649age=$age
8650revision=$revision
8651
8652# Is this an already installed library?
8653installed=$installed
8654
8655# Should we warn about portability when linking against -modules?
8656shouldnotlink=$module
8657
8658# Files to dlopen/dlpreopen
8659dlopen='$dlfiles'
8660dlpreopen='$dlprefiles'
8661
8662# Directory that this library needs to be installed in:
8663libdir='$install_libdir'"
8664          if test "$installed" = no && test "$need_relink" = yes; then
8665            $ECHO >> $output "\
8666relink_command=\"$relink_command\""
8667          fi
8668        done
8669      }
8670
8671      # Do a symbolic link so that the libtool archive can be found in
8672      # LD_LIBRARY_PATH before the program is installed.
8673      func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
8674      ;;
8675    esac
8676    exit $EXIT_SUCCESS
8677}
8678
8679{ test "$mode" = link || test "$mode" = relink; } &&
8680    func_mode_link ${1+"$@"}
8681
8682
8683# func_mode_uninstall arg...
8684func_mode_uninstall ()
8685{
8686    $opt_debug
8687    RM="$nonopt"
8688    files=
8689    rmforce=
8690    exit_status=0
8691
8692    # This variable tells wrapper scripts just to set variables rather
8693    # than running their programs.
8694    libtool_install_magic="$magic"
8695
8696    for arg
8697    do
8698      case $arg in
8699      -f) RM="$RM $arg"; rmforce=yes ;;
8700      -*) RM="$RM $arg" ;;
8701      *) files="$files $arg" ;;
8702      esac
8703    done
8704
8705    test -z "$RM" && \
8706      func_fatal_help "you must specify an RM program"
8707
8708    rmdirs=
8709
8710    origobjdir="$objdir"
8711    for file in $files; do
8712      func_dirname "$file" "" "."
8713      dir="$func_dirname_result"
8714      if test "X$dir" = X.; then
8715        objdir="$origobjdir"
8716      else
8717        objdir="$dir/$origobjdir"
8718      fi
8719      func_basename "$file"
8720      name="$func_basename_result"
8721      test "$mode" = uninstall && objdir="$dir"
8722
8723      # Remember objdir for removal later, being careful to avoid duplicates
8724      if test "$mode" = clean; then
8725        case " $rmdirs " in
8726          *" $objdir "*) ;;
8727          *) rmdirs="$rmdirs $objdir" ;;
8728        esac
8729      fi
8730
8731      # Don't error if the file doesn't exist and rm -f was used.
8732      if { test -L "$file"; } >/dev/null 2>&1 ||
8733         { test -h "$file"; } >/dev/null 2>&1 ||
8734         test -f "$file"; then
8735        :
8736      elif test -d "$file"; then
8737        exit_status=1
8738        continue
8739      elif test "$rmforce" = yes; then
8740        continue
8741      fi
8742
8743      rmfiles="$file"
8744
8745      case $name in
8746      *.la)
8747        # Possibly a libtool archive, so verify it.
8748        if func_lalib_p "$file"; then
8749          func_source $dir/$name
8750
8751          # Delete the libtool libraries and symlinks.
8752          for n in $library_names; do
8753            rmfiles="$rmfiles $objdir/$n"
8754          done
8755          test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
8756
8757          case "$mode" in
8758          clean)
8759            case "  $library_names " in
8760            # "  " in the beginning catches empty $dlname
8761            *" $dlname "*) ;;
8762            *) rmfiles="$rmfiles $objdir/$dlname" ;;
8763            esac
8764            test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
8765            ;;
8766          uninstall)
8767            if test -n "$library_names"; then
8768              # Do each command in the postuninstall commands.
8769              func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
8770            fi
8771
8772            if test -n "$old_library"; then
8773              # Do each command in the old_postuninstall commands.
8774              func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
8775            fi
8776            # FIXME: should reinstall the best remaining shared library.
8777            ;;
8778          esac
8779        fi
8780        ;;
8781
8782      *.lo)
8783        # Possibly a libtool object, so verify it.
8784        if func_lalib_p "$file"; then
8785
8786          # Read the .lo file
8787          func_source $dir/$name
8788
8789          # Add PIC object to the list of files to remove.
8790          if test -n "$pic_object" &&
8791             test "$pic_object" != none; then
8792            rmfiles="$rmfiles $dir/$pic_object"
8793          fi
8794
8795          # Add non-PIC object to the list of files to remove.
8796          if test -n "$non_pic_object" &&
8797             test "$non_pic_object" != none; then
8798            rmfiles="$rmfiles $dir/$non_pic_object"
8799          fi
8800        fi
8801        ;;
8802
8803      *)
8804        if test "$mode" = clean ; then
8805          noexename=$name
8806          case $file in
8807          *.exe)
8808            func_stripname '' '.exe' "$file"
8809            file=$func_stripname_result
8810            func_stripname '' '.exe' "$name"
8811            noexename=$func_stripname_result
8812            # $file with .exe has already been added to rmfiles,
8813            # add $file without .exe
8814            rmfiles="$rmfiles $file"
8815            ;;
8816          esac
8817          # Do a test to see if this is a libtool program.
8818          if func_ltwrapper_p "$file"; then
8819            if func_ltwrapper_executable_p "$file"; then
8820              func_ltwrapper_scriptname "$file"
8821              relink_command=
8822              func_source $func_ltwrapper_scriptname_result
8823              rmfiles="$rmfiles $func_ltwrapper_scriptname_result"
8824            else
8825              relink_command=
8826              func_source $dir/$noexename
8827            fi
8828
8829            # note $name still contains .exe if it was in $file originally
8830            # as does the version of $file that was added into $rmfiles
8831            rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
8832            if test "$fast_install" = yes && test -n "$relink_command"; then
8833              rmfiles="$rmfiles $objdir/lt-$name"
8834            fi
8835            if test "X$noexename" != "X$name" ; then
8836              rmfiles="$rmfiles $objdir/lt-${noexename}.c"
8837            fi
8838          fi
8839        fi
8840        ;;
8841      esac
8842      func_show_eval "$RM $rmfiles" 'exit_status=1'
8843    done
8844    objdir="$origobjdir"
8845
8846    # Try to remove the ${objdir}s in the directories where we deleted files
8847    for dir in $rmdirs; do
8848      if test -d "$dir"; then
8849        func_show_eval "rmdir $dir >/dev/null 2>&1"
8850      fi
8851    done
8852
8853    exit $exit_status
8854}
8855
8856{ test "$mode" = uninstall || test "$mode" = clean; } &&
8857    func_mode_uninstall ${1+"$@"}
8858
8859test -z "$mode" && {
8860  help="$generic_help"
8861  func_fatal_help "you must specify a MODE"
8862}
8863
8864test -z "$exec_cmd" && \
8865  func_fatal_help "invalid operation mode \`$mode'"
8866
8867if test -n "$exec_cmd"; then
8868  eval exec "$exec_cmd"
8869  exit $EXIT_FAILURE
8870fi
8871
8872exit $exit_status
8873
8874
8875# The TAGs below are defined such that we never get into a situation
8876# in which we disable both kinds of libraries.  Given conflicting
8877# choices, we go for a static library, that is the most portable,
8878# since we can't tell whether shared libraries were disabled because
8879# the user asked for that or because the platform doesn't support
8880# them.  This is particularly important on AIX, because we don't
8881# support having both static and shared libraries enabled at the same
8882# time on that platform, so we default to a shared-only configuration.
8883# If a disable-shared tag is given, we'll fallback to a static-only
8884# configuration.  But we'll never go from static-only to shared-only.
8885
8886# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
8887build_libtool_libs=no
8888build_old_libs=yes
8889# ### END LIBTOOL TAG CONFIG: disable-shared
8890
8891# ### BEGIN LIBTOOL TAG CONFIG: disable-static
8892build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
8893# ### END LIBTOOL TAG CONFIG: disable-static
8894
8895# Local Variables:
8896# mode:shell-script
8897# sh-indentation:2
8898# End:
8899# vi:sw=2
8900
Note: See TracBrowser for help on using the repository browser.