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