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
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
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    exit $EXIT_SUCCESS
2718}
2719
2720test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
2721
2722
2723# func_mode_install arg...
2724func_mode_install ()
2725{
2726    $opt_debug
2727    # There may be an optional sh(1) argument at the beginning of
2728    # install_prog (especially on Windows NT).
2729    if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
2730       # Allow the use of GNU shtool's install command.
2731       case $nonopt in *shtool*) :;; *) false;; esac; then
2732      # Aesthetically quote it.
2733      func_quote_for_eval "$nonopt"
2734      install_prog="$func_quote_for_eval_result "
2735      arg=$1
2736      shift
2737    else
2738      install_prog=
2739      arg=$nonopt
2740    fi
2741
2742    # The real first argument should be the name of the installation program.
2743    # Aesthetically quote it.
2744    func_quote_for_eval "$arg"
2745    func_append install_prog "$func_quote_for_eval_result"
2746    install_shared_prog=$install_prog
2747    case " $install_prog " in
2748      *[\\\ /]cp\ *) install_cp=: ;;
2749      *) install_cp=false ;;
2750    esac
2751
2752    # We need to accept at least all the BSD install flags.
2753    dest=
2754    files=
2755    opts=
2756    prev=
2757    install_type=
2758    isdir=no
2759    stripme=
2760    no_mode=:
2761    for arg
2762    do
2763      arg2=
2764      if test -n "$dest"; then
2765	func_append files " $dest"
2766	dest=$arg
2767	continue
2768      fi
2769
2770      case $arg in
2771      -d) isdir=yes ;;
2772      -f)
2773	if $install_cp; then :; else
2774	  prev=$arg
2775	fi
2776	;;
2777      -g | -m | -o)
2778	prev=$arg
2779	;;
2780      -s)
2781	stripme=" -s"
2782	continue
2783	;;
2784      -*)
2785	;;
2786      *)
2787	# If the previous option needed an argument, then skip it.
2788	if test -n "$prev"; then
2789	  if test "x$prev" = x-m && test -n "$install_override_mode"; then
2790	    arg2=$install_override_mode
2791	    no_mode=false
2792	  fi
2793	  prev=
2794	else
2795	  dest=$arg
2796	  continue
2797	fi
2798	;;
2799      esac
2800
2801      # Aesthetically quote the argument.
2802      func_quote_for_eval "$arg"
2803      func_append install_prog " $func_quote_for_eval_result"
2804      if test -n "$arg2"; then
2805	func_quote_for_eval "$arg2"
2806      fi
2807      func_append install_shared_prog " $func_quote_for_eval_result"
2808    done
2809    case " $install_prog " in
2810    *[\\\ /]cp\ *) extra_mode=;;
2811    *) extra_mode='-m 644';;
2812    esac
2813
2814    test -z "$install_prog" && \
2815      func_fatal_help "you must specify an install program"
2816
2817    test -n "$prev" && \
2818      func_fatal_help "the \`$prev' option requires an argument"
2819
2820    if test -n "$install_override_mode" && $no_mode; then
2821      if $install_cp; then :; else
2822	func_quote_for_eval "$install_override_mode"
2823	func_append install_shared_prog " -m $func_quote_for_eval_result"
2824      fi
2825    fi
2826
2827    if test -z "$files"; then
2828      if test -z "$dest"; then
2829	func_fatal_help "no file or destination specified"
2830      else
2831	func_fatal_help "you must specify a destination"
2832      fi
2833    fi
2834
2835    # Strip any trailing slash from the destination.
2836    func_stripname '' '/' "$dest"
2837    dest=$func_stripname_result
2838
2839    # Check to see that the destination is a directory.
2840    test -d "$dest" && isdir=yes
2841    if test "$isdir" = yes; then
2842      destdir="$dest"
2843      destname=
2844    else
2845      func_dirname_and_basename "$dest" "" "."
2846      destdir="$func_dirname_result"
2847      destname="$func_basename_result"
2848
2849      # Not a directory, so check to see that there is only one file specified.
2850      set dummy $files; shift
2851      test "$#" -gt 1 && \
2852	func_fatal_help "\`$dest' is not a directory"
2853    fi
2854    case $destdir in
2855    [\\/]* | [A-Za-z]:[\\/]*) ;;
2856    *)
2857      for file in $files; do
2858	case $file in
2859	*.lo) ;;
2860	*)
2861	  func_fatal_help "\`$destdir' must be an absolute directory name"
2862	  ;;
2863	esac
2864      done
2865      ;;
2866    esac
2867
2868    # This variable tells wrapper scripts just to set variables rather
2869    # than running their programs.
2870    libtool_install_magic="$magic"
2871
2872    staticlibs=
2873    future_libdirs=
2874    current_libdirs=
2875    for file in $files; do
2876
2877      # Do each installation.
2878      case $file in
2879      *.$libext)
2880	# Do the static libraries later.
2881	func_append staticlibs " $file"
2882	;;
2883
2884      *.la)
2885	func_resolve_sysroot "$file"
2886	file=$func_resolve_sysroot_result
2887
2888	# Check to see that this really is a libtool archive.
2889	func_lalib_unsafe_p "$file" \
2890	  || func_fatal_help "\`$file' is not a valid libtool archive"
2891
2892	library_names=
2893	old_library=
2894	relink_command=
2895	func_source "$file"
2896
2897	# Add the libdir to current_libdirs if it is the destination.
2898	if test "X$destdir" = "X$libdir"; then
2899	  case "$current_libdirs " in
2900	  *" $libdir "*) ;;
2901	  *) func_append current_libdirs " $libdir" ;;
2902	  esac
2903	else
2904	  # Note the libdir as a future libdir.
2905	  case "$future_libdirs " in
2906	  *" $libdir "*) ;;
2907	  *) func_append future_libdirs " $libdir" ;;
2908	  esac
2909	fi
2910
2911	func_dirname "$file" "/" ""
2912	dir="$func_dirname_result"
2913	func_append dir "$objdir"
2914
2915	if test -n "$relink_command"; then
2916	  # Determine the prefix the user has applied to our future dir.
2917	  inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
2918
2919	  # Don't allow the user to place us outside of our expected
2920	  # location b/c this prevents finding dependent libraries that
2921	  # are installed to the same prefix.
2922	  # At present, this check doesn't affect windows .dll's that
2923	  # are installed into $libdir/../bin (currently, that works fine)
2924	  # but it's something to keep an eye on.
2925	  test "$inst_prefix_dir" = "$destdir" && \
2926	    func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2927
2928	  if test -n "$inst_prefix_dir"; then
2929	    # Stick the inst_prefix_dir data into the link command.
2930	    relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2931	  else
2932	    relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
2933	  fi
2934
2935	  func_warning "relinking \`$file'"
2936	  func_show_eval "$relink_command" \
2937	    'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2938	fi
2939
2940	# See the names of the shared library.
2941	set dummy $library_names; shift
2942	if test -n "$1"; then
2943	  realname="$1"
2944	  shift
2945
2946	  srcname="$realname"
2947	  test -n "$relink_command" && srcname="$realname"T
2948
2949	  # Install the shared library and build the symlinks.
2950	  func_show_eval "$install_shared_prog $extra_mode $dir/$srcname $destdir/$realname" \
2951	      'exit $?'
2952	  tstripme="$stripme"
2953	  case $host_os in
2954	  cygwin* | mingw* | pw32* | cegcc*)
2955	    case $realname in
2956	    *.dll.a)
2957	      tstripme=""
2958	      ;;
2959	    esac
2960	    ;;
2961	  esac
2962	  if test -n "$tstripme" && test -n "$striplib"; then
2963	    func_show_eval "$striplib $destdir/$realname" 'exit $?'
2964	  fi
2965
2966	  if test "$#" -gt 0; then
2967	    # Delete the old symlinks, and create new ones.
2968	    # Try `ln -sf' first, because the `ln' binary might depend on
2969	    # the symlink we replace!  Solaris /bin/ln does not understand -f,
2970	    # so we also need to try rm && ln -s.
2971	    for linkname
2972	    do
2973	      test "$linkname" != "$realname" \
2974		&& func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
2975	    done
2976	  fi
2977
2978	  # Do each command in the postinstall commands.
2979	  lib="$destdir/$realname"
2980	  func_execute_cmds "$postinstall_cmds" 'exit $?'
2981	fi
2982
2983	# Install the pseudo-library for information purposes.
2984	func_basename "$file"
2985	name="$func_basename_result"
2986	instname="$dir/$name"i
2987	func_show_eval "$install_prog $extra_mode $instname $destdir/$name" 'exit $?'
2988
2989	# Maybe install the static library, too.
2990	test -n "$old_library" && func_append staticlibs " $dir/$old_library"
2991	;;
2992
2993      *.lo)
2994	# Install (i.e. copy) a libtool object.
2995
2996	# Figure out destination file name, if it wasn't already specified.
2997	if test -n "$destname"; then
2998	  destfile="$destdir/$destname"
2999	else
3000	  func_basename "$file"
3001	  destfile="$func_basename_result"
3002	  destfile="$destdir/$destfile"
3003	fi
3004
3005	# Deduce the name of the destination old-style object file.
3006	case $destfile in
3007	*.lo)
3008	  func_lo2o "$destfile"
3009	  staticdest=$func_lo2o_result
3010	  ;;
3011	*.$objext)
3012	  staticdest="$destfile"
3013	  destfile=
3014	  ;;
3015	*)
3016	  func_fatal_help "cannot copy a libtool object to \`$destfile'"
3017	  ;;
3018	esac
3019
3020	# Install the libtool object if requested.
3021	test -n "$destfile" && \
3022	  func_show_eval "$install_prog $extra_mode $file $destfile" 'exit $?'
3023
3024	# Install the old object if enabled.
3025	if test "$build_old_libs" = yes; then
3026	  # Deduce the name of the old-style object file.
3027	  func_lo2o "$file"
3028	  staticobj=$func_lo2o_result
3029	  func_show_eval "$install_prog $extra_mode \$staticobj \$staticdest" 'exit $?'
3030	fi
3031	exit $EXIT_SUCCESS
3032	;;
3033
3034      *)
3035	# Figure out destination file name, if it wasn't already specified.
3036	if test -n "$destname"; then
3037	  destfile="$destdir/$destname"
3038	else
3039	  func_basename "$file"
3040	  destfile="$func_basename_result"
3041	  destfile="$destdir/$destfile"
3042	fi
3043
3044	# If the file is missing, and there is a .exe on the end, strip it
3045	# because it is most likely a libtool script we actually want to
3046	# install
3047	stripped_ext=""
3048	case $file in
3049	  *.exe)
3050	    if test ! -f "$file"; then
3051	      func_stripname '' '.exe' "$file"
3052	      file=$func_stripname_result
3053	      stripped_ext=".exe"
3054	    fi
3055	    ;;
3056	esac
3057
3058	# Do a test to see if this is really a libtool program.
3059	case $host in
3060	*cygwin* | *mingw*)
3061	    if func_ltwrapper_executable_p "$file"; then
3062	      func_ltwrapper_scriptname "$file"
3063	      wrapper=$func_ltwrapper_scriptname_result
3064	    else
3065	      func_stripname '' '.exe' "$file"
3066	      wrapper=$func_stripname_result
3067	    fi
3068	    ;;
3069	*)
3070	    wrapper=$file
3071	    ;;
3072	esac
3073	if func_ltwrapper_script_p "$wrapper"; then
3074	  notinst_deplibs=
3075	  relink_command=
3076
3077	  func_source "$wrapper"
3078
3079	  # Check the variables that should have been set.
3080	  test -z "$generated_by_libtool_version" && \
3081	    func_fatal_error "invalid libtool wrapper script \`$wrapper'"
3082
3083	  finalize=yes
3084	  for lib in $notinst_deplibs; do
3085	    # Check to see that each library is installed.
3086	    libdir=
3087	    if test -f "$lib"; then
3088	      func_source "$lib"
3089	    fi
3090	    libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
3091	    if test -n "$libdir" && test ! -f "$libfile"; then
3092	      func_warning "\`$lib' has not been installed in \`$libdir'"
3093	      finalize=no
3094	    fi
3095	  done
3096
3097	  relink_command=
3098	  func_source "$wrapper"
3099
3100	  outputname=
3101	  if test "$fast_install" = no && test -n "$relink_command"; then
3102	    $opt_dry_run || {
3103	      if test "$finalize" = yes; then
3104	        tmpdir=`func_mktempdir`
3105		func_basename "$file$stripped_ext"
3106		file="$func_basename_result"
3107	        outputname="$tmpdir/$file"
3108	        # Replace the output file specification.
3109	        relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
3110
3111	        $opt_silent || {
3112	          func_quote_for_expand "$relink_command"
3113		  eval "func_echo $func_quote_for_expand_result"
3114	        }
3115	        if eval "$relink_command"; then :
3116	          else
3117		  func_error "error: relink \`$file' with the above command before installing it"
3118		  $opt_dry_run || ${RM}r "$tmpdir"
3119		  continue
3120	        fi
3121	        file="$outputname"
3122	      else
3123	        func_warning "cannot relink \`$file'"
3124	      fi
3125	    }
3126	  else
3127	    # Install the binary that we compiled earlier.
3128	    file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
3129	  fi
3130	fi
3131
3132	# remove .exe since cygwin /usr/bin/install will append another
3133	# one anyway
3134	case $install_prog,$host in
3135	*/usr/bin/install*,*cygwin*)
3136	  case $file:$destfile in
3137	  *.exe:*.exe)
3138	    # this is ok
3139	    ;;
3140	  *.exe:*)
3141	    destfile=$destfile.exe
3142	    ;;
3143	  *:*.exe)
3144	    func_stripname '' '.exe' "$destfile"
3145	    destfile=$func_stripname_result
3146	    ;;
3147	  esac
3148	  ;;
3149	esac
3150	func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
3151	$opt_dry_run || if test -n "$outputname"; then
3152	  ${RM}r "$tmpdir"
3153	fi
3154	;;
3155      esac
3156    done
3157
3158    for file in $staticlibs; do
3159      func_basename "$file"
3160      name="$func_basename_result"
3161
3162      # Set up the ranlib parameters.
3163      oldlib="$destdir/$name"
3164      func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
3165      tool_oldlib=$func_to_tool_file_result
3166
3167      func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
3168
3169      if test -n "$stripme" && test -n "$old_striplib"; then
3170	func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
3171      fi
3172
3173      # Do each command in the postinstall commands.
3174      func_execute_cmds "$old_postinstall_cmds" 'exit $?'
3175    done
3176
3177    test -n "$future_libdirs" && \
3178      func_warning "remember to run \`$progname --finish$future_libdirs'"
3179
3180    if test -n "$current_libdirs"; then
3181      # Maybe just do a dry run.
3182      $opt_dry_run && current_libdirs=" -n$current_libdirs"
3183      exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
3184    else
3185      exit $EXIT_SUCCESS
3186    fi
3187}
3188
3189test "$opt_mode" = install && func_mode_install ${1+"$@"}
3190
3191
3192# func_generate_dlsyms outputname originator pic_p
3193# Extract symbols from dlprefiles and create ${outputname}S.o with
3194# a dlpreopen symbol table.
3195func_generate_dlsyms ()
3196{
3197    $opt_debug
3198    my_outputname="$1"
3199    my_originator="$2"
3200    my_pic_p="${3-no}"
3201    my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
3202    my_dlsyms=
3203
3204    if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3205      if test -n "$NM" && test -n "$global_symbol_pipe"; then
3206	my_dlsyms="${my_outputname}S.c"
3207      else
3208	func_error "not configured to extract global symbols from dlpreopened files"
3209      fi
3210    fi
3211
3212    if test -n "$my_dlsyms"; then
3213      case $my_dlsyms in
3214      "") ;;
3215      *.c)
3216	# Discover the nlist of each of the dlfiles.
3217	nlist="$output_objdir/${my_outputname}.nm"
3218
3219	func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
3220
3221	# Parse the name list into a source file.
3222	func_verbose "creating $output_objdir/$my_dlsyms"
3223
3224	$opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
3225/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
3226/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
3227
3228#ifdef __cplusplus
3229extern \"C\" {
3230#endif
3231
3232#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
3233#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
3234#endif
3235
3236/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
3237#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
3238/* DATA imports from DLLs on WIN32 con't be const, because runtime
3239   relocations are performed -- see ld's documentation on pseudo-relocs.  */
3240# define LT_DLSYM_CONST
3241#elif defined(__osf__)
3242/* This system does not cope well with relocations in const data.  */
3243# define LT_DLSYM_CONST
3244#else
3245# define LT_DLSYM_CONST const
3246#endif
3247
3248/* External symbol declarations for the compiler. */\
3249"
3250
3251	if test "$dlself" = yes; then
3252	  func_verbose "generating symbol list for \`$output'"
3253
3254	  $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
3255
3256	  # Add our own program objects to the symbol list.
3257	  progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
3258	  for progfile in $progfiles; do
3259	    func_to_tool_file "$progfile" func_convert_file_msys_to_w32
3260	    func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"
3261	    $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
3262	  done
3263
3264	  if test -n "$exclude_expsyms"; then
3265	    $opt_dry_run || {
3266	      eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
3267	      eval '$MV "$nlist"T "$nlist"'
3268	    }
3269	  fi
3270
3271	  if test -n "$export_symbols_regex"; then
3272	    $opt_dry_run || {
3273	      eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
3274	      eval '$MV "$nlist"T "$nlist"'
3275	    }
3276	  fi
3277
3278	  # Prepare the list of exported symbols
3279	  if test -z "$export_symbols"; then
3280	    export_symbols="$output_objdir/$outputname.exp"
3281	    $opt_dry_run || {
3282	      $RM $export_symbols
3283	      eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
3284	      case $host in
3285	      *cygwin* | *mingw* | *cegcc* )
3286                eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3287                eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
3288	        ;;
3289	      esac
3290	    }
3291	  else
3292	    $opt_dry_run || {
3293	      eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
3294	      eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
3295	      eval '$MV "$nlist"T "$nlist"'
3296	      case $host in
3297	        *cygwin* | *mingw* | *cegcc* )
3298	          eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3299	          eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
3300	          ;;
3301	      esac
3302	    }
3303	  fi
3304	fi
3305
3306	for dlprefile in $dlprefiles; do
3307	  func_verbose "extracting global C symbols from \`$dlprefile'"
3308	  func_basename "$dlprefile"
3309	  name="$func_basename_result"
3310          case $host in
3311	    *cygwin* | *mingw* | *cegcc* )
3312	      # if an import library, we need to obtain dlname
3313	      if func_win32_import_lib_p "$dlprefile"; then
3314	        func_tr_sh "$dlprefile"
3315	        eval "curr_lafile=\$libfile_$func_tr_sh_result"
3316	        dlprefile_dlbasename=""
3317	        if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
3318	          # Use subshell, to avoid clobbering current variable values
3319	          dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
3320	          if test -n "$dlprefile_dlname" ; then
3321	            func_basename "$dlprefile_dlname"
3322	            dlprefile_dlbasename="$func_basename_result"
3323	          else
3324	            # no lafile. user explicitly requested -dlpreopen <import library>.
3325	            $sharedlib_from_linklib_cmd "$dlprefile"
3326	            dlprefile_dlbasename=$sharedlib_from_linklib_result
3327	          fi
3328	        fi
3329	        $opt_dry_run || {
3330	          if test -n "$dlprefile_dlbasename" ; then
3331	            eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
3332	          else
3333	            func_warning "Could not compute DLL name from $name"
3334	            eval '$ECHO ": $name " >> "$nlist"'
3335	          fi
3336	          func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3337	          eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
3338	            $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
3339	        }
3340	      else # not an import lib
3341	        $opt_dry_run || {
3342	          eval '$ECHO ": $name " >> "$nlist"'
3343	          func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3344	          eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3345	        }
3346	      fi
3347	    ;;
3348	    *)
3349	      $opt_dry_run || {
3350	        eval '$ECHO ": $name " >> "$nlist"'
3351	        func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3352	        eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3353	      }
3354	    ;;
3355          esac
3356	done
3357
3358	$opt_dry_run || {
3359	  # Make sure we have at least an empty file.
3360	  test -f "$nlist" || : > "$nlist"
3361
3362	  if test -n "$exclude_expsyms"; then
3363	    $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
3364	    $MV "$nlist"T "$nlist"
3365	  fi
3366
3367	  # Try sorting and uniquifying the output.
3368	  if $GREP -v "^: " < "$nlist" |
3369	      if sort -k 3 </dev/null >/dev/null 2>&1; then
3370		sort -k 3
3371	      else
3372		sort +2
3373	      fi |
3374	      uniq > "$nlist"S; then
3375	    :
3376	  else
3377	    $GREP -v "^: " < "$nlist" > "$nlist"S
3378	  fi
3379
3380	  if test -f "$nlist"S; then
3381	    eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
3382	  else
3383	    echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
3384	  fi
3385
3386	  echo >> "$output_objdir/$my_dlsyms" "\
3387
3388/* The mapping between symbol names and symbols.  */
3389typedef struct {
3390  const char *name;
3391  void *address;
3392} lt_dlsymlist;
3393extern LT_DLSYM_CONST lt_dlsymlist
3394lt_${my_prefix}_LTX_preloaded_symbols[];
3395LT_DLSYM_CONST lt_dlsymlist
3396lt_${my_prefix}_LTX_preloaded_symbols[] =
3397{\
3398  { \"$my_originator\", (void *) 0 },"
3399
3400	  case $need_lib_prefix in
3401	  no)
3402	    eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
3403	    ;;
3404	  *)
3405	    eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
3406	    ;;
3407	  esac
3408	  echo >> "$output_objdir/$my_dlsyms" "\
3409  {0, (void *) 0}
3410};
3411
3412/* This works around a problem in FreeBSD linker */
3413#ifdef FREEBSD_WORKAROUND
3414static const void *lt_preloaded_setup() {
3415  return lt_${my_prefix}_LTX_preloaded_symbols;
3416}
3417#endif
3418
3419#ifdef __cplusplus
3420}
3421#endif\
3422"
3423	} # !$opt_dry_run
3424
3425	pic_flag_for_symtable=
3426	case "$compile_command " in
3427	*" -static "*) ;;
3428	*)
3429	  case $host in
3430	  # compiling the symbol table file with pic_flag works around
3431	  # a FreeBSD bug that causes programs to crash when -lm is
3432	  # linked before any other PIC object.  But we must not use
3433	  # pic_flag when linking with -static.  The problem exists in
3434	  # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
3435	  *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
3436	    pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
3437	  *-*-hpux*)
3438	    pic_flag_for_symtable=" $pic_flag"  ;;
3439	  *)
3440	    if test "X$my_pic_p" != Xno; then
3441	      pic_flag_for_symtable=" $pic_flag"
3442	    fi
3443	    ;;
3444	  esac
3445	  ;;
3446	esac
3447	symtab_cflags=
3448	for arg in $LTCFLAGS; do
3449	  case $arg in
3450	  -pie | -fpie | -fPIE) ;;
3451	  *) func_append symtab_cflags " $arg" ;;
3452	  esac
3453	done
3454
3455	# Now compile the dynamic symbol file.
3456	func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
3457
3458	# Clean up the generated files.
3459	func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
3460
3461	# Transform the symbol file into the correct name.
3462	symfileobj="$output_objdir/${my_outputname}S.$objext"
3463	case $host in
3464	*cygwin* | *mingw* | *cegcc* )
3465	  if test -f "$output_objdir/$my_outputname.def"; then
3466	    compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3467	    finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3468	  else
3469	    compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3470	    finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3471	  fi
3472	  ;;
3473	*)
3474	  compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3475	  finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3476	  ;;
3477	esac
3478	;;
3479      *)
3480	func_fatal_error "unknown suffix for \`$my_dlsyms'"
3481	;;
3482      esac
3483    else
3484      # We keep going just in case the user didn't refer to
3485      # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
3486      # really was required.
3487
3488      # Nullify the symbol file.
3489      compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
3490      finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
3491    fi
3492}
3493
3494# func_win32_libid arg
3495# return the library type of file 'arg'
3496#
3497# Need a lot of goo to handle *both* DLLs and import libs
3498# Has to be a shell function in order to 'eat' the argument
3499# that is supplied when $file_magic_command is called.
3500# Despite the name, also deal with 64 bit binaries.
3501func_win32_libid ()
3502{
3503  $opt_debug
3504  win32_libid_type="unknown"
3505  win32_fileres=`file -L $1 2>/dev/null`
3506  case $win32_fileres in
3507  *ar\ archive\ import\ library*) # definitely import
3508    win32_libid_type="x86 archive import"
3509    ;;
3510  *ar\ archive*) # could be an import, or static
3511    # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
3512    if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
3513       $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
3514      func_to_tool_file "$1" func_convert_file_msys_to_w32
3515      win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
3516	$SED -n -e '
3517	    1,100{
3518		/ I /{
3519		    s,.*,import,
3520		    p
3521		    q
3522		}
3523	    }'`
3524      case $win32_nmres in
3525      import*)  win32_libid_type="x86 archive import";;
3526      *)        win32_libid_type="x86 archive static";;
3527      esac
3528    fi
3529    ;;
3530  *DLL*)
3531    win32_libid_type="x86 DLL"
3532    ;;
3533  *executable*) # but shell scripts are "executable" too...
3534    case $win32_fileres in
3535    *MS\ Windows\ PE\ Intel*)
3536      win32_libid_type="x86 DLL"
3537      ;;
3538    esac
3539    ;;
3540  esac
3541  $ECHO "$win32_libid_type"
3542}
3543
3544# func_cygming_dll_for_implib ARG
3545#
3546# Platform-specific function to extract the
3547# name of the DLL associated with the specified
3548# import library ARG.
3549# Invoked by eval'ing the libtool variable
3550#    $sharedlib_from_linklib_cmd
3551# Result is available in the variable
3552#    $sharedlib_from_linklib_result
3553func_cygming_dll_for_implib ()
3554{
3555  $opt_debug
3556  sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
3557}
3558
3559# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
3560#
3561# The is the core of a fallback implementation of a
3562# platform-specific function to extract the name of the
3563# DLL associated with the specified import library LIBNAME.
3564#
3565# SECTION_NAME is either .idata$6 or .idata$7, depending
3566# on the platform and compiler that created the implib.
3567#
3568# Echos the name of the DLL associated with the
3569# specified import library.
3570func_cygming_dll_for_implib_fallback_core ()
3571{
3572  $opt_debug
3573  match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
3574  $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
3575    $SED '/^Contents of section '"$match_literal"':/{
3576      # Place marker at beginning of archive member dllname section
3577      s/.*/====MARK====/
3578      p
3579      d
3580    }
3581    # These lines can sometimes be longer than 43 characters, but
3582    # are always uninteresting
3583    /:[	 ]*file format pe[i]\{,1\}-/d
3584    /^In archive [^:]*:/d
3585    # Ensure marker is printed
3586    /^====MARK====/p
3587    # Remove all lines with less than 43 characters
3588    /^.\{43\}/!d
3589    # From remaining lines, remove first 43 characters
3590    s/^.\{43\}//' |
3591    $SED -n '
3592      # Join marker and all lines until next marker into a single line
3593      /^====MARK====/ b para
3594      H
3595      $ b para
3596      b
3597      :para
3598      x
3599      s/\n//g
3600      # Remove the marker
3601      s/^====MARK====//
3602      # Remove trailing dots and whitespace
3603      s/[\. \t]*$//
3604      # Print
3605      /./p' |
3606    # we now have a list, one entry per line, of the stringified
3607    # contents of the appropriate section of all members of the
3608    # archive which possess that section. Heuristic: eliminate
3609    # all those which have a first or second character that is
3610    # a '.' (that is, objdump's representation of an unprintable
3611    # character.) This should work for all archives with less than
3612    # 0x302f exports -- but will fail for DLLs whose name actually
3613    # begins with a literal '.' or a single character followed by
3614    # a '.'.
3615    #
3616    # Of those that remain, print the first one.
3617    $SED -e '/^\./d;/^.\./d;q'
3618}
3619
3620# func_cygming_gnu_implib_p ARG
3621# This predicate returns with zero status (TRUE) if
3622# ARG is a GNU/binutils-style import library. Returns
3623# with nonzero status (FALSE) otherwise.
3624func_cygming_gnu_implib_p ()
3625{
3626  $opt_debug
3627  func_to_tool_file "$1" func_convert_file_msys_to_w32
3628  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)$'`
3629  test -n "$func_cygming_gnu_implib_tmp"
3630}
3631
3632# func_cygming_ms_implib_p ARG
3633# This predicate returns with zero status (TRUE) if
3634# ARG is an MS-style import library. Returns
3635# with nonzero status (FALSE) otherwise.
3636func_cygming_ms_implib_p ()
3637{
3638  $opt_debug
3639  func_to_tool_file "$1" func_convert_file_msys_to_w32
3640  func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
3641  test -n "$func_cygming_ms_implib_tmp"
3642}
3643
3644# func_cygming_dll_for_implib_fallback ARG
3645# Platform-specific function to extract the
3646# name of the DLL associated with the specified
3647# import library ARG.
3648#
3649# This fallback implementation is for use when $DLLTOOL
3650# does not support the --identify-strict option.
3651# Invoked by eval'ing the libtool variable
3652#    $sharedlib_from_linklib_cmd
3653# Result is available in the variable
3654#    $sharedlib_from_linklib_result
3655func_cygming_dll_for_implib_fallback ()
3656{
3657  $opt_debug
3658  if func_cygming_gnu_implib_p "$1" ; then
3659    # binutils import library
3660    sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
3661  elif func_cygming_ms_implib_p "$1" ; then
3662    # ms-generated import library
3663    sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
3664  else
3665    # unknown
3666    sharedlib_from_linklib_result=""
3667  fi
3668}
3669
3670
3671# func_extract_an_archive dir oldlib
3672func_extract_an_archive ()
3673{
3674    $opt_debug
3675    f_ex_an_ar_dir="$1"; shift
3676    f_ex_an_ar_oldlib="$1"
3677    if test "$lock_old_archive_extraction" = yes; then
3678      lockfile=$f_ex_an_ar_oldlib.lock
3679      until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
3680	func_echo "Waiting for $lockfile to be removed"
3681	sleep 2
3682      done
3683    fi
3684    func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
3685		   'stat=$?; rm -f "$lockfile"; exit $stat'
3686    if test "$lock_old_archive_extraction" = yes; then
3687      $opt_dry_run || rm -f "$lockfile"
3688    fi
3689    if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
3690     :
3691    else
3692      func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
3693    fi
3694}
3695
3696
3697# func_extract_archives gentop oldlib ...
3698func_extract_archives ()
3699{
3700    $opt_debug
3701    my_gentop="$1"; shift
3702    my_oldlibs=${1+"$@"}
3703    my_oldobjs=""
3704    my_xlib=""
3705    my_xabs=""
3706    my_xdir=""
3707
3708    for my_xlib in $my_oldlibs; do
3709      # Extract the objects.
3710      case $my_xlib in
3711	[\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
3712	*) my_xabs=`pwd`"/$my_xlib" ;;
3713      esac
3714      func_basename "$my_xlib"
3715      my_xlib="$func_basename_result"
3716      my_xlib_u=$my_xlib
3717      while :; do
3718        case " $extracted_archives " in
3719	*" $my_xlib_u "*)
3720	  func_arith $extracted_serial + 1
3721	  extracted_serial=$func_arith_result
3722	  my_xlib_u=lt$extracted_serial-$my_xlib ;;
3723	*) break ;;
3724	esac
3725      done
3726      extracted_archives="$extracted_archives $my_xlib_u"
3727      my_xdir="$my_gentop/$my_xlib_u"
3728
3729      func_mkdir_p "$my_xdir"
3730
3731      case $host in
3732      *-darwin*)
3733	func_verbose "Extracting $my_xabs"
3734	# Do not bother doing anything if just a dry run
3735	$opt_dry_run || {
3736	  darwin_orig_dir=`pwd`
3737	  cd $my_xdir || exit $?
3738	  darwin_archive=$my_xabs
3739	  darwin_curdir=`pwd`
3740	  darwin_base_archive=`basename "$darwin_archive"`
3741	  darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
3742	  if test -n "$darwin_arches"; then
3743	    darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
3744	    darwin_arch=
3745	    func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
3746	    for darwin_arch in  $darwin_arches ; do
3747	      func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3748	      $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
3749	      cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3750	      func_extract_an_archive "`pwd`" "${darwin_base_archive}"
3751	      cd "$darwin_curdir"
3752	      $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
3753	    done # $darwin_arches
3754            ## Okay now we've a bunch of thin objects, gotta fatten them up :)
3755	    darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
3756	    darwin_file=
3757	    darwin_files=
3758	    for darwin_file in $darwin_filelist; do
3759	      darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
3760	      $LIPO -create -output "$darwin_file" $darwin_files
3761	    done # $darwin_filelist
3762	    $RM -rf unfat-$$
3763	    cd "$darwin_orig_dir"
3764	  else
3765	    cd $darwin_orig_dir
3766	    func_extract_an_archive "$my_xdir" "$my_xabs"
3767	  fi # $darwin_arches
3768	} # !$opt_dry_run
3769	;;
3770      *)
3771        func_extract_an_archive "$my_xdir" "$my_xabs"
3772	;;
3773      esac
3774      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
3775    done
3776
3777    func_extract_archives_result="$my_oldobjs"
3778}
3779
3780
3781# func_emit_wrapper [arg=no]
3782#
3783# Emit a libtool wrapper script on stdout.
3784# Don't directly open a file because we may want to
3785# incorporate the script contents within a cygwin/mingw
3786# wrapper executable.  Must ONLY be called from within
3787# func_mode_link because it depends on a number of variables
3788# set therein.
3789#
3790# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
3791# variable will take.  If 'yes', then the emitted script
3792# will assume that the directory in which it is stored is
3793# the $objdir directory.  This is a cygwin/mingw-specific
3794# behavior.
3795func_emit_wrapper ()
3796{
3797	func_emit_wrapper_arg1=${1-no}
3798
3799	$ECHO "\
3800#! $SHELL
3801
3802# $output - temporary wrapper script for $objdir/$outputname
3803# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3804#
3805# The $output program cannot be directly executed until all the libtool
3806# libraries that it depends on are installed.
3807#
3808# This wrapper script should never be moved out of the build directory.
3809# If it is, it will not operate correctly.
3810
3811# Sed substitution that helps us do robust quoting.  It backslashifies
3812# metacharacters that are still active within double-quoted strings.
3813sed_quote_subst='$sed_quote_subst'
3814
3815# Be Bourne compatible
3816if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
3817  emulate sh
3818  NULLCMD=:
3819  # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
3820  # is contrary to our usage.  Disable this feature.
3821  alias -g '\${1+\"\$@\"}'='\"\$@\"'
3822  setopt NO_GLOB_SUBST
3823else
3824  case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
3825fi
3826BIN_SH=xpg4; export BIN_SH # for Tru64
3827DUALCASE=1; export DUALCASE # for MKS sh
3828
3829# The HP-UX ksh and POSIX shell print the target directory to stdout
3830# if CDPATH is set.
3831(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
3832
3833relink_command=\"$relink_command\"
3834
3835# This environment variable determines our operation mode.
3836if test \"\$libtool_install_magic\" = \"$magic\"; then
3837  # install mode needs the following variables:
3838  generated_by_libtool_version='$macro_version'
3839  notinst_deplibs='$notinst_deplibs'
3840else
3841  # When we are sourced in execute mode, \$file and \$ECHO are already set.
3842  if test \"\$libtool_execute_magic\" != \"$magic\"; then
3843    file=\"\$0\""
3844
3845    qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
3846    $ECHO "\
3847
3848# A function that is used when there is no print builtin or printf.
3849func_fallback_echo ()
3850{
3851  eval 'cat <<_LTECHO_EOF
3852\$1
3853_LTECHO_EOF'
3854}
3855    ECHO=\"$qECHO\"
3856  fi
3857
3858# Very basic option parsing. These options are (a) specific to
3859# the libtool wrapper, (b) are identical between the wrapper
3860# /script/ and the wrapper /executable/ which is used only on
3861# windows platforms, and (c) all begin with the string "--lt-"
3862# (application programs are unlikely to have options which match
3863# this pattern).
3864#
3865# There are only two supported options: --lt-debug and
3866# --lt-dump-script. There is, deliberately, no --lt-help.
3867#
3868# The first argument to this parsing function should be the
3869# script's $0 value, followed by "$@".
3870lt_option_debug=
3871func_parse_lt_options ()
3872{
3873  lt_script_arg0=\$0
3874  shift
3875  for lt_opt
3876  do
3877    case \"\$lt_opt\" in
3878    --lt-debug) lt_option_debug=1 ;;
3879    --lt-dump-script)
3880        lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
3881        test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
3882        lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
3883        cat \"\$lt_dump_D/\$lt_dump_F\"
3884        exit 0
3885      ;;
3886    --lt-*)
3887        \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
3888        exit 1
3889      ;;
3890    esac
3891  done
3892
3893  # Print the debug banner immediately:
3894  if test -n \"\$lt_option_debug\"; then
3895    echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
3896  fi
3897}
3898
3899# Used when --lt-debug. Prints its arguments to stdout
3900# (redirection is the responsibility of the caller)
3901func_lt_dump_args ()
3902{
3903  lt_dump_args_N=1;
3904  for lt_arg
3905  do
3906    \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
3907    lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
3908  done
3909}
3910
3911# Core function for launching the target application
3912func_exec_program_core ()
3913{
3914"
3915  case $host in
3916  # Backslashes separate directories on plain windows
3917  *-*-mingw | *-*-os2* | *-cegcc*)
3918    $ECHO "\
3919      if test -n \"\$lt_option_debug\"; then
3920        \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
3921        func_lt_dump_args \${1+\"\$@\"} 1>&2
3922      fi
3923      exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
3924"
3925    ;;
3926
3927  *)
3928    $ECHO "\
3929      if test -n \"\$lt_option_debug\"; then
3930        \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
3931        func_lt_dump_args \${1+\"\$@\"} 1>&2
3932      fi
3933      exec \"\$progdir/\$program\" \${1+\"\$@\"}
3934"
3935    ;;
3936  esac
3937  $ECHO "\
3938      \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
3939      exit 1
3940}
3941
3942# A function to encapsulate launching the target application
3943# Strips options in the --lt-* namespace from \$@ and
3944# launches target application with the remaining arguments.
3945func_exec_program ()
3946{
3947  case \" \$* \" in
3948  *\\ --lt-*)
3949    for lt_wr_arg
3950    do
3951      case \$lt_wr_arg in
3952      --lt-*) ;;
3953      *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
3954      esac
3955      shift
3956    done ;;
3957  esac
3958  func_exec_program_core \${1+\"\$@\"}
3959}
3960
3961  # Parse options
3962  func_parse_lt_options \"\$0\" \${1+\"\$@\"}
3963
3964  # Find the directory that this script lives in.
3965  thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
3966  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
3967
3968  # Follow symbolic links until we get to the real thisdir.
3969  file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
3970  while test -n \"\$file\"; do
3971    destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
3972
3973    # If there was a directory component, then change thisdir.
3974    if test \"x\$destdir\" != \"x\$file\"; then
3975      case \"\$destdir\" in
3976      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
3977      *) thisdir=\"\$thisdir/\$destdir\" ;;
3978      esac
3979    fi
3980
3981    file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
3982    file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
3983  done
3984
3985  # Usually 'no', except on cygwin/mingw when embedded into
3986  # the cwrapper.
3987  WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
3988  if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
3989    # special case for '.'
3990    if test \"\$thisdir\" = \".\"; then
3991      thisdir=\`pwd\`
3992    fi
3993    # remove .libs from thisdir
3994    case \"\$thisdir\" in
3995    *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
3996    $objdir )   thisdir=. ;;
3997    esac
3998  fi
3999
4000  # Try to get the absolute directory name.
4001  absdir=\`cd \"\$thisdir\" && pwd\`
4002  test -n \"\$absdir\" && thisdir=\"\$absdir\"
4003"
4004
4005	if test "$fast_install" = yes; then
4006	  $ECHO "\
4007  program=lt-'$outputname'$exeext
4008  progdir=\"\$thisdir/$objdir\"
4009
4010  if test ! -f \"\$progdir/\$program\" ||
4011     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
4012       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
4013
4014    file=\"\$\$-\$program\"
4015
4016    if test ! -d \"\$progdir\"; then
4017      $MKDIR \"\$progdir\"
4018    else
4019      $RM \"\$progdir/\$file\"
4020    fi"
4021
4022	  $ECHO "\
4023
4024    # relink executable if necessary
4025    if test -n \"\$relink_command\"; then
4026      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
4027      else
4028	$ECHO \"\$relink_command_output\" >&2
4029	$RM \"\$progdir/\$file\"
4030	exit 1
4031      fi
4032    fi
4033
4034    $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
4035    { $RM \"\$progdir/\$program\";
4036      $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
4037    $RM \"\$progdir/\$file\"
4038  fi"
4039	else
4040	  $ECHO "\
4041  program='$outputname'
4042  progdir=\"\$thisdir/$objdir\"
4043"
4044	fi
4045
4046	$ECHO "\
4047
4048  if test -f \"\$progdir/\$program\"; then"
4049
4050	# fixup the dll searchpath if we need to.
4051	#
4052	# Fix the DLL searchpath if we need to.  Do this before prepending
4053	# to shlibpath, because on Windows, both are PATH and uninstalled
4054	# libraries must come first.
4055	if test -n "$dllsearchpath"; then
4056	  $ECHO "\
4057    # Add the dll search path components to the executable PATH
4058    PATH=$dllsearchpath:\$PATH
4059"
4060	fi
4061
4062	# Export our shlibpath_var if we have one.
4063	if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4064	  $ECHO "\
4065    # Add our own library path to $shlibpath_var
4066    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
4067
4068    # Some systems cannot cope with colon-terminated $shlibpath_var
4069    # The second colon is a workaround for a bug in BeOS R4 sed
4070    $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
4071
4072    export $shlibpath_var
4073"
4074	fi
4075
4076	$ECHO "\
4077    if test \"\$libtool_execute_magic\" != \"$magic\"; then
4078      # Run the actual program with our arguments.
4079      func_exec_program \${1+\"\$@\"}
4080    fi
4081  else
4082    # The program doesn't exist.
4083    \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
4084    \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
4085    \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
4086    exit 1
4087  fi
4088fi\
4089"
4090}
4091
4092
4093# func_emit_cwrapperexe_src
4094# emit the source code for a wrapper executable on stdout
4095# Must ONLY be called from within func_mode_link because
4096# it depends on a number of variable set therein.
4097func_emit_cwrapperexe_src ()
4098{
4099	cat <<EOF
4100
4101/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4102   Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
4103
4104   The $output program cannot be directly executed until all the libtool
4105   libraries that it depends on are installed.
4106
4107   This wrapper executable should never be moved out of the build directory.
4108   If it is, it will not operate correctly.
4109*/
4110EOF
4111	    cat <<"EOF"
4112#ifdef _MSC_VER
4113# define _CRT_SECURE_NO_DEPRECATE 1
4114#endif
4115#include <stdio.h>
4116#include <stdlib.h>
4117#ifdef _MSC_VER
4118# include <direct.h>
4119# include <process.h>
4120# include <io.h>
4121#else
4122# include <unistd.h>
4123# include <stdint.h>
4124# ifdef __CYGWIN__
4125#  include <io.h>
4126# endif
4127#endif
4128#include <malloc.h>
4129#include <stdarg.h>
4130#include <assert.h>
4131#include <string.h>
4132#include <ctype.h>
4133#include <errno.h>
4134#include <fcntl.h>
4135#include <sys/stat.h>
4136
4137/* declarations of non-ANSI functions */
4138#if defined(__MINGW32__)
4139# ifdef __STRICT_ANSI__
4140int _putenv (const char *);
4141# endif
4142#elif defined(__CYGWIN__)
4143# ifdef __STRICT_ANSI__
4144char *realpath (const char *, char *);
4145int putenv (char *);
4146int setenv (const char *, const char *, int);
4147# endif
4148/* #elif defined (other platforms) ... */
4149#endif
4150
4151/* portability defines, excluding path handling macros */
4152#if defined(_MSC_VER)
4153# define setmode _setmode
4154# define stat    _stat
4155# define chmod   _chmod
4156# define getcwd  _getcwd
4157# define putenv  _putenv
4158# define S_IXUSR _S_IEXEC
4159# ifndef _INTPTR_T_DEFINED
4160#  define _INTPTR_T_DEFINED
4161#  define intptr_t int
4162# endif
4163#elif defined(__MINGW32__)
4164# define setmode _setmode
4165# define stat    _stat
4166# define chmod   _chmod
4167# define getcwd  _getcwd
4168# define putenv  _putenv
4169#elif defined(__CYGWIN__)
4170# define HAVE_SETENV
4171# define FOPEN_WB "wb"
4172/* #elif defined (other platforms) ... */
4173#endif
4174
4175#if defined(PATH_MAX)
4176# define LT_PATHMAX PATH_MAX
4177#elif defined(MAXPATHLEN)
4178# define LT_PATHMAX MAXPATHLEN
4179#else
4180# define LT_PATHMAX 1024
4181#endif
4182
4183#ifndef S_IXOTH
4184# define S_IXOTH 0
4185#endif
4186#ifndef S_IXGRP
4187# define S_IXGRP 0
4188#endif
4189
4190/* path handling portability macros */
4191#ifndef DIR_SEPARATOR
4192# define DIR_SEPARATOR '/'
4193# define PATH_SEPARATOR ':'
4194#endif
4195
4196#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
4197  defined (__OS2__)
4198# define HAVE_DOS_BASED_FILE_SYSTEM
4199# define FOPEN_WB "wb"
4200# ifndef DIR_SEPARATOR_2
4201#  define DIR_SEPARATOR_2 '\\'
4202# endif
4203# ifndef PATH_SEPARATOR_2
4204#  define PATH_SEPARATOR_2 ';'
4205# endif
4206#endif
4207
4208#ifndef DIR_SEPARATOR_2
4209# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
4210#else /* DIR_SEPARATOR_2 */
4211# define IS_DIR_SEPARATOR(ch) \
4212	(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
4213#endif /* DIR_SEPARATOR_2 */
4214
4215#ifndef PATH_SEPARATOR_2
4216# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
4217#else /* PATH_SEPARATOR_2 */
4218# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
4219#endif /* PATH_SEPARATOR_2 */
4220
4221#ifndef FOPEN_WB
4222# define FOPEN_WB "w"
4223#endif
4224#ifndef _O_BINARY
4225# define _O_BINARY 0
4226#endif
4227
4228#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
4229#define XFREE(stale) do { \
4230  if (stale) { free ((void *) stale); stale = 0; } \
4231} while (0)
4232
4233#if defined(LT_DEBUGWRAPPER)
4234static int lt_debug = 1;
4235#else
4236static int lt_debug = 0;
4237#endif
4238
4239const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
4240
4241void *xmalloc (size_t num);
4242char *xstrdup (const char *string);
4243const char *base_name (const char *name);
4244char *find_executable (const char *wrapper);
4245char *chase_symlinks (const char *pathspec);
4246int make_executable (const char *path);
4247int check_executable (const char *path);
4248char *strendzap (char *str, const char *pat);
4249void lt_debugprintf (const char *file, int line, const char *fmt, ...);
4250void lt_fatal (const char *file, int line, const char *message, ...);
4251static const char *nonnull (const char *s);
4252static const char *nonempty (const char *s);
4253void lt_setenv (const char *name, const char *value);
4254char *lt_extend_str (const char *orig_value, const char *add, int to_end);
4255void lt_update_exe_path (const char *name, const char *value);
4256void lt_update_lib_path (const char *name, const char *value);
4257char **prepare_spawn (char **argv);
4258void lt_dump_script (FILE *f);
4259EOF
4260
4261	    cat <<EOF
4262volatile const char * MAGIC_EXE = "$magic_exe";
4263const char * LIB_PATH_VARNAME = "$shlibpath_var";
4264EOF
4265
4266	    if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4267              func_to_host_path "$temp_rpath"
4268	      cat <<EOF
4269const char * LIB_PATH_VALUE   = "$func_to_host_path_result";
4270EOF
4271	    else
4272	      cat <<"EOF"
4273const char * LIB_PATH_VALUE   = "";
4274EOF
4275	    fi
4276
4277	    if test -n "$dllsearchpath"; then
4278              func_to_host_path "$dllsearchpath:"
4279	      cat <<EOF
4280const char * EXE_PATH_VARNAME = "PATH";
4281const char * EXE_PATH_VALUE   = "$func_to_host_path_result";
4282EOF
4283	    else
4284	      cat <<"EOF"
4285const char * EXE_PATH_VARNAME = "";
4286const char * EXE_PATH_VALUE   = "";
4287EOF
4288	    fi
4289
4290	    if test "$fast_install" = yes; then
4291	      cat <<EOF
4292const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
4293EOF
4294	    else
4295	      cat <<EOF
4296const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
4297EOF
4298	    fi
4299
4300
4301	    cat <<"EOF"
4302
4303#define LTWRAPPER_OPTION_PREFIX         "--lt-"
4304
4305static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
4306static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
4307static const char *debug_opt            = LTWRAPPER_OPTION_PREFIX "debug";
4308
4309int
4310main (int argc, char *argv[])
4311{
4312  char **newargz;
4313  int  newargc;
4314  char *tmp_pathspec;
4315  char *actual_cwrapper_path;
4316  char *actual_cwrapper_name;
4317  char *target_name;
4318  char *lt_argv_zero;
4319  intptr_t rval = 127;
4320
4321  int i;
4322
4323  program_name = (char *) xstrdup (base_name (argv[0]));
4324  newargz = XMALLOC (char *, argc + 1);
4325
4326  /* very simple arg parsing; don't want to rely on getopt
4327   * also, copy all non cwrapper options to newargz, except
4328   * argz[0], which is handled differently
4329   */
4330  newargc=0;
4331  for (i = 1; i < argc; i++)
4332    {
4333      if (strcmp (argv[i], dumpscript_opt) == 0)
4334	{
4335EOF
4336	    case "$host" in
4337	      *mingw* | *cygwin* )
4338		# make stdout use "unix" line endings
4339		echo "          setmode(1,_O_BINARY);"
4340		;;
4341	      esac
4342
4343	    cat <<"EOF"
4344	  lt_dump_script (stdout);
4345	  return 0;
4346	}
4347      if (strcmp (argv[i], debug_opt) == 0)
4348	{
4349          lt_debug = 1;
4350          continue;
4351	}
4352      if (strcmp (argv[i], ltwrapper_option_prefix) == 0)
4353        {
4354          /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
4355             namespace, but it is not one of the ones we know about and
4356             have already dealt with, above (inluding dump-script), then
4357             report an error. Otherwise, targets might begin to believe
4358             they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
4359             namespace. The first time any user complains about this, we'll
4360             need to make LTWRAPPER_OPTION_PREFIX a configure-time option
4361             or a configure.ac-settable value.
4362           */
4363          lt_fatal (__FILE__, __LINE__,
4364		    "unrecognized %s option: '%s'",
4365                    ltwrapper_option_prefix, argv[i]);
4366        }
4367      /* otherwise ... */
4368      newargz[++newargc] = xstrdup (argv[i]);
4369    }
4370  newargz[++newargc] = NULL;
4371
4372EOF
4373	    cat <<EOF
4374  /* The GNU banner must be the first non-error debug message */
4375  lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");
4376EOF
4377	    cat <<"EOF"
4378  lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
4379  lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
4380
4381  tmp_pathspec = find_executable (argv[0]);
4382  if (tmp_pathspec == NULL)
4383    lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
4384  lt_debugprintf (__FILE__, __LINE__,
4385                  "(main) found exe (before symlink chase) at: %s\n",
4386		  tmp_pathspec);
4387
4388  actual_cwrapper_path = chase_symlinks (tmp_pathspec);
4389  lt_debugprintf (__FILE__, __LINE__,
4390                  "(main) found exe (after symlink chase) at: %s\n",
4391		  actual_cwrapper_path);
4392  XFREE (tmp_pathspec);
4393
4394  actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
4395  strendzap (actual_cwrapper_path, actual_cwrapper_name);
4396
4397  /* wrapper name transforms */
4398  strendzap (actual_cwrapper_name, ".exe");
4399  tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
4400  XFREE (actual_cwrapper_name);
4401  actual_cwrapper_name = tmp_pathspec;
4402  tmp_pathspec = 0;
4403
4404  /* target_name transforms -- use actual target program name; might have lt- prefix */
4405  target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
4406  strendzap (target_name, ".exe");
4407  tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
4408  XFREE (target_name);
4409  target_name = tmp_pathspec;
4410  tmp_pathspec = 0;
4411
4412  lt_debugprintf (__FILE__, __LINE__,
4413		  "(main) libtool target name: %s\n",
4414		  target_name);
4415EOF
4416
4417	    cat <<EOF
4418  newargz[0] =
4419    XMALLOC (char, (strlen (actual_cwrapper_path) +
4420		    strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
4421  strcpy (newargz[0], actual_cwrapper_path);
4422  strcat (newargz[0], "$objdir");
4423  strcat (newargz[0], "/");
4424EOF
4425
4426	    cat <<"EOF"
4427  /* stop here, and copy so we don't have to do this twice */
4428  tmp_pathspec = xstrdup (newargz[0]);
4429
4430  /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
4431  strcat (newargz[0], actual_cwrapper_name);
4432
4433  /* DO want the lt- prefix here if it exists, so use target_name */
4434  lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
4435  XFREE (tmp_pathspec);
4436  tmp_pathspec = NULL;
4437EOF
4438
4439	    case $host_os in
4440	      mingw*)
4441	    cat <<"EOF"
4442  {
4443    char* p;
4444    while ((p = strchr (newargz[0], '\\')) != NULL)
4445      {
4446	*p = '/';
4447      }
4448    while ((p = strchr (lt_argv_zero, '\\')) != NULL)
4449      {
4450	*p = '/';
4451      }
4452  }
4453EOF
4454	    ;;
4455	    esac
4456
4457	    cat <<"EOF"
4458  XFREE (target_name);
4459  XFREE (actual_cwrapper_path);
4460  XFREE (actual_cwrapper_name);
4461
4462  lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
4463  lt_setenv ("DUALCASE", "1");  /* for MSK sh */
4464  /* Update the DLL searchpath.  EXE_PATH_VALUE ($dllsearchpath) must
4465     be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
4466     because on Windows, both *_VARNAMEs are PATH but uninstalled
4467     libraries must come first. */
4468  lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
4469  lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
4470
4471  lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
4472		  nonnull (lt_argv_zero));
4473  for (i = 0; i < newargc; i++)
4474    {
4475      lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
4476		      i, nonnull (newargz[i]));
4477    }
4478
4479EOF
4480
4481	    case $host_os in
4482	      mingw*)
4483		cat <<"EOF"
4484  /* execv doesn't actually work on mingw as expected on unix */
4485  newargz = prepare_spawn (newargz);
4486  rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
4487  if (rval == -1)
4488    {
4489      /* failed to start process */
4490      lt_debugprintf (__FILE__, __LINE__,
4491		      "(main) failed to launch target \"%s\": %s\n",
4492		      lt_argv_zero, nonnull (strerror (errno)));
4493      return 127;
4494    }
4495  return rval;
4496EOF
4497		;;
4498	      *)
4499		cat <<"EOF"
4500  execv (lt_argv_zero, newargz);
4501  return rval; /* =127, but avoids unused variable warning */
4502EOF
4503		;;
4504	    esac
4505
4506	    cat <<"EOF"
4507}
4508
4509void *
4510xmalloc (size_t num)
4511{
4512  void *p = (void *) malloc (num);
4513  if (!p)
4514    lt_fatal (__FILE__, __LINE__, "memory exhausted");
4515
4516  return p;
4517}
4518
4519char *
4520xstrdup (const char *string)
4521{
4522  return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
4523			  string) : NULL;
4524}
4525
4526const char *
4527base_name (const char *name)
4528{
4529  const char *base;
4530
4531#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4532  /* Skip over the disk name in MSDOS pathnames. */
4533  if (isalpha ((unsigned char) name[0]) && name[1] == ':')
4534    name += 2;
4535#endif
4536
4537  for (base = name; *name; name++)
4538    if (IS_DIR_SEPARATOR (*name))
4539      base = name + 1;
4540  return base;
4541}
4542
4543int
4544check_executable (const char *path)
4545{
4546  struct stat st;
4547
4548  lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
4549                  nonempty (path));
4550  if ((!path) || (!*path))
4551    return 0;
4552
4553  if ((stat (path, &st) >= 0)
4554      && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
4555    return 1;
4556  else
4557    return 0;
4558}
4559
4560int
4561make_executable (const char *path)
4562{
4563  int rval = 0;
4564  struct stat st;
4565
4566  lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
4567                  nonempty (path));
4568  if ((!path) || (!*path))
4569    return 0;
4570
4571  if (stat (path, &st) >= 0)
4572    {
4573      rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
4574    }
4575  return rval;
4576}
4577
4578/* Searches for the full path of the wrapper.  Returns
4579   newly allocated full path name if found, NULL otherwise
4580   Does not chase symlinks, even on platforms that support them.
4581*/
4582char *
4583find_executable (const char *wrapper)
4584{
4585  int has_slash = 0;
4586  const char *p;
4587  const char *p_next;
4588  /* static buffer for getcwd */
4589  char tmp[LT_PATHMAX + 1];
4590  int tmp_len;
4591  char *concat_name;
4592
4593  lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
4594                  nonempty (wrapper));
4595
4596  if ((wrapper == NULL) || (*wrapper == '\0'))
4597    return NULL;
4598
4599  /* Absolute path? */
4600#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4601  if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
4602    {
4603      concat_name = xstrdup (wrapper);
4604      if (check_executable (concat_name))
4605	return concat_name;
4606      XFREE (concat_name);
4607    }
4608  else
4609    {
4610#endif
4611      if (IS_DIR_SEPARATOR (wrapper[0]))
4612	{
4613	  concat_name = xstrdup (wrapper);
4614	  if (check_executable (concat_name))
4615	    return concat_name;
4616	  XFREE (concat_name);
4617	}
4618#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4619    }
4620#endif
4621
4622  for (p = wrapper; *p; p++)
4623    if (*p == '/')
4624      {
4625	has_slash = 1;
4626	break;
4627      }
4628  if (!has_slash)
4629    {
4630      /* no slashes; search PATH */
4631      const char *path = getenv ("PATH");
4632      if (path != NULL)
4633	{
4634	  for (p = path; *p; p = p_next)
4635	    {
4636	      const char *q;
4637	      size_t p_len;
4638	      for (q = p; *q; q++)
4639		if (IS_PATH_SEPARATOR (*q))
4640		  break;
4641	      p_len = q - p;
4642	      p_next = (*q == '\0' ? q : q + 1);
4643	      if (p_len == 0)
4644		{
4645		  /* empty path: current directory */
4646		  if (getcwd (tmp, LT_PATHMAX) == NULL)
4647		    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
4648                              nonnull (strerror (errno)));
4649		  tmp_len = strlen (tmp);
4650		  concat_name =
4651		    XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4652		  memcpy (concat_name, tmp, tmp_len);
4653		  concat_name[tmp_len] = '/';
4654		  strcpy (concat_name + tmp_len + 1, wrapper);
4655		}
4656	      else
4657		{
4658		  concat_name =
4659		    XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
4660		  memcpy (concat_name, p, p_len);
4661		  concat_name[p_len] = '/';
4662		  strcpy (concat_name + p_len + 1, wrapper);
4663		}
4664	      if (check_executable (concat_name))
4665		return concat_name;
4666	      XFREE (concat_name);
4667	    }
4668	}
4669      /* not found in PATH; assume curdir */
4670    }
4671  /* Relative path | not found in path: prepend cwd */
4672  if (getcwd (tmp, LT_PATHMAX) == NULL)
4673    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
4674              nonnull (strerror (errno)));
4675  tmp_len = strlen (tmp);
4676  concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4677  memcpy (concat_name, tmp, tmp_len);
4678  concat_name[tmp_len] = '/';
4679  strcpy (concat_name + tmp_len + 1, wrapper);
4680
4681  if (check_executable (concat_name))
4682    return concat_name;
4683  XFREE (concat_name);
4684  return NULL;
4685}
4686
4687char *
4688chase_symlinks (const char *pathspec)
4689{
4690#ifndef S_ISLNK
4691  return xstrdup (pathspec);
4692#else
4693  char buf[LT_PATHMAX];
4694  struct stat s;
4695  char *tmp_pathspec = xstrdup (pathspec);
4696  char *p;
4697  int has_symlinks = 0;
4698  while (strlen (tmp_pathspec) && !has_symlinks)
4699    {
4700      lt_debugprintf (__FILE__, __LINE__,
4701		      "checking path component for symlinks: %s\n",
4702		      tmp_pathspec);
4703      if (lstat (tmp_pathspec, &s) == 0)
4704	{
4705	  if (S_ISLNK (s.st_mode) != 0)
4706	    {
4707	      has_symlinks = 1;
4708	      break;
4709	    }
4710
4711	  /* search backwards for last DIR_SEPARATOR */
4712	  p = tmp_pathspec + strlen (tmp_pathspec) - 1;
4713	  while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4714	    p--;
4715	  if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4716	    {
4717	      /* no more DIR_SEPARATORS left */
4718	      break;
4719	    }
4720	  *p = '\0';
4721	}
4722      else
4723	{
4724	  lt_fatal (__FILE__, __LINE__,
4725		    "error accessing file \"%s\": %s",
4726		    tmp_pathspec, nonnull (strerror (errno)));
4727	}
4728    }
4729  XFREE (tmp_pathspec);
4730
4731  if (!has_symlinks)
4732    {
4733      return xstrdup (pathspec);
4734    }
4735
4736  tmp_pathspec = realpath (pathspec, buf);
4737  if (tmp_pathspec == 0)
4738    {
4739      lt_fatal (__FILE__, __LINE__,
4740		"could not follow symlinks for %s", pathspec);
4741    }
4742  return xstrdup (tmp_pathspec);
4743#endif
4744}
4745
4746char *
4747strendzap (char *str, const char *pat)
4748{
4749  size_t len, patlen;
4750
4751  assert (str != NULL);
4752  assert (pat != NULL);
4753
4754  len = strlen (str);
4755  patlen = strlen (pat);
4756
4757  if (patlen <= len)
4758    {
4759      str += len - patlen;
4760      if (strcmp (str, pat) == 0)
4761	*str = '\0';
4762    }
4763  return str;
4764}
4765
4766void
4767lt_debugprintf (const char *file, int line, const char *fmt, ...)
4768{
4769  va_list args;
4770  if (lt_debug)
4771    {
4772      (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
4773      va_start (args, fmt);
4774      (void) vfprintf (stderr, fmt, args);
4775      va_end (args);
4776    }
4777}
4778
4779static void
4780lt_error_core (int exit_status, const char *file,
4781	       int line, const char *mode,
4782	       const char *message, va_list ap)
4783{
4784  fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
4785  vfprintf (stderr, message, ap);
4786  fprintf (stderr, ".\n");
4787
4788  if (exit_status >= 0)
4789    exit (exit_status);
4790}
4791
4792void
4793lt_fatal (const char *file, int line, const char *message, ...)
4794{
4795  va_list ap;
4796  va_start (ap, message);
4797  lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
4798  va_end (ap);
4799}
4800
4801static const char *
4802nonnull (const char *s)
4803{
4804  return s ? s : "(null)";
4805}
4806
4807static const char *
4808nonempty (const char *s)
4809{
4810  return (s && !*s) ? "(empty)" : nonnull (s);
4811}
4812
4813void
4814lt_setenv (const char *name, const char *value)
4815{
4816  lt_debugprintf (__FILE__, __LINE__,
4817		  "(lt_setenv) setting '%s' to '%s'\n",
4818                  nonnull (name), nonnull (value));
4819  {
4820#ifdef HAVE_SETENV
4821    /* always make a copy, for consistency with !HAVE_SETENV */
4822    char *str = xstrdup (value);
4823    setenv (name, str, 1);
4824#else
4825    int len = strlen (name) + 1 + strlen (value) + 1;
4826    char *str = XMALLOC (char, len);
4827    sprintf (str, "%s=%s", name, value);
4828    if (putenv (str) != EXIT_SUCCESS)
4829      {
4830        XFREE (str);
4831      }
4832#endif
4833  }
4834}
4835
4836char *
4837lt_extend_str (const char *orig_value, const char *add, int to_end)
4838{
4839  char *new_value;
4840  if (orig_value && *orig_value)
4841    {
4842      int orig_value_len = strlen (orig_value);
4843      int add_len = strlen (add);
4844      new_value = XMALLOC (char, add_len + orig_value_len + 1);
4845      if (to_end)
4846        {
4847          strcpy (new_value, orig_value);
4848          strcpy (new_value + orig_value_len, add);
4849        }
4850      else
4851        {
4852          strcpy (new_value, add);
4853          strcpy (new_value + add_len, orig_value);
4854        }
4855    }
4856  else
4857    {
4858      new_value = xstrdup (add);
4859    }
4860  return new_value;
4861}
4862
4863void
4864lt_update_exe_path (const char *name, const char *value)
4865{
4866  lt_debugprintf (__FILE__, __LINE__,
4867		  "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
4868                  nonnull (name), nonnull (value));
4869
4870  if (name && *name && value && *value)
4871    {
4872      char *new_value = lt_extend_str (getenv (name), value, 0);
4873      /* some systems can't cope with a ':'-terminated path #' */
4874      int len = strlen (new_value);
4875      while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
4876        {
4877          new_value[len-1] = '\0';
4878        }
4879      lt_setenv (name, new_value);
4880      XFREE (new_value);
4881    }
4882}
4883
4884void
4885lt_update_lib_path (const char *name, const char *value)
4886{
4887  lt_debugprintf (__FILE__, __LINE__,
4888		  "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4889                  nonnull (name), nonnull (value));
4890
4891  if (name && *name && value && *value)
4892    {
4893      char *new_value = lt_extend_str (getenv (name), value, 0);
4894      lt_setenv (name, new_value);
4895      XFREE (new_value);
4896    }
4897}
4898
4899EOF
4900	    case $host_os in
4901	      mingw*)
4902		cat <<"EOF"
4903
4904/* Prepares an argument vector before calling spawn().
4905   Note that spawn() does not by itself call the command interpreter
4906     (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
4907      ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
4908         GetVersionEx(&v);
4909         v.dwPlatformId == VER_PLATFORM_WIN32_NT;
4910      }) ? "cmd.exe" : "command.com").
4911   Instead it simply concatenates the arguments, separated by ' ', and calls
4912   CreateProcess().  We must quote the arguments since Win32 CreateProcess()
4913   interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
4914   special way:
4915   - Space and tab are interpreted as delimiters. They are not treated as
4916     delimiters if they are surrounded by double quotes: "...".
4917   - Unescaped double quotes are removed from the input. Their only effect is
4918     that within double quotes, space and tab are treated like normal
4919     characters.
4920   - Backslashes not followed by double quotes are not special.
4921   - But 2*n+1 backslashes followed by a double quote become
4922     n backslashes followed by a double quote (n >= 0):
4923       \" -> "
4924       \\\" -> \"
4925       \\\\\" -> \\"
4926 */
4927#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"
4928#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"
4929char **
4930prepare_spawn (char **argv)
4931{
4932  size_t argc;
4933  char **new_argv;
4934  size_t i;
4935
4936  /* Count number of arguments.  */
4937  for (argc = 0; argv[argc] != NULL; argc++)
4938    ;
4939
4940  /* Allocate new argument vector.  */
4941  new_argv = XMALLOC (char *, argc + 1);
4942
4943  /* Put quoted arguments into the new argument vector.  */
4944  for (i = 0; i < argc; i++)
4945    {
4946      const char *string = argv[i];
4947
4948      if (string[0] == '\0')
4949	new_argv[i] = xstrdup ("\"\"");
4950      else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
4951	{
4952	  int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
4953	  size_t length;
4954	  unsigned int backslashes;
4955	  const char *s;
4956	  char *quoted_string;
4957	  char *p;
4958
4959	  length = 0;
4960	  backslashes = 0;
4961	  if (quote_around)
4962	    length++;
4963	  for (s = string; *s != '\0'; s++)
4964	    {
4965	      char c = *s;
4966	      if (c == '"')
4967		length += backslashes + 1;
4968	      length++;
4969	      if (c == '\\')
4970		backslashes++;
4971	      else
4972		backslashes = 0;
4973	    }
4974	  if (quote_around)
4975	    length += backslashes + 1;
4976
4977	  quoted_string = XMALLOC (char, length + 1);
4978
4979	  p = quoted_string;
4980	  backslashes = 0;
4981	  if (quote_around)
4982	    *p++ = '"';
4983	  for (s = string; *s != '\0'; s++)
4984	    {
4985	      char c = *s;
4986	      if (c == '"')
4987		{
4988		  unsigned int j;
4989		  for (j = backslashes + 1; j > 0; j--)
4990		    *p++ = '\\';
4991		}
4992	      *p++ = c;
4993	      if (c == '\\')
4994		backslashes++;
4995	      else
4996		backslashes = 0;
4997	    }
4998	  if (quote_around)
4999	    {
5000	      unsigned int j;
5001	      for (j = backslashes; j > 0; j--)
5002		*p++ = '\\';
5003	      *p++ = '"';
5004	    }
5005	  *p = '\0';
5006
5007	  new_argv[i] = quoted_string;
5008	}
5009      else
5010	new_argv[i] = (char *) string;
5011    }
5012  new_argv[argc] = NULL;
5013
5014  return new_argv;
5015}
5016EOF
5017		;;
5018	    esac
5019
5020            cat <<"EOF"
5021void lt_dump_script (FILE* f)
5022{
5023EOF
5024	    func_emit_wrapper yes |
5025	      $SED -n -e '
5026s/^\(.\{79\}\)\(..*\)/\1\
5027\2/
5028h
5029s/\([\\"]\)/\\\1/g
5030s/$/\\n/
5031s/\([^\n]*\).*/  fputs ("\1", f);/p
5032g
5033D'
5034            cat <<"EOF"
5035}
5036EOF
5037}
5038# end: func_emit_cwrapperexe_src
5039
5040# func_win32_import_lib_p ARG
5041# True if ARG is an import lib, as indicated by $file_magic_cmd
5042func_win32_import_lib_p ()
5043{
5044    $opt_debug
5045    case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
5046    *import*) : ;;
5047    *) false ;;
5048    esac
5049}
5050
5051# func_mode_link arg...
5052func_mode_link ()
5053{
5054    $opt_debug
5055    case $host in
5056    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
5057      # It is impossible to link a dll without this setting, and
5058      # we shouldn't force the makefile maintainer to figure out
5059      # which system we are compiling for in order to pass an extra
5060      # flag for every libtool invocation.
5061      # allow_undefined=no
5062
5063      # FIXME: Unfortunately, there are problems with the above when trying
5064      # to make a dll which has undefined symbols, in which case not
5065      # even a static library is built.  For now, we need to specify
5066      # -no-undefined on the libtool link line when we can be certain
5067      # that all symbols are satisfied, otherwise we get a static library.
5068      allow_undefined=yes
5069      ;;
5070    *)
5071      allow_undefined=yes
5072      ;;
5073    esac
5074    libtool_args=$nonopt
5075    base_compile="$nonopt $@"
5076    compile_command=$nonopt
5077    finalize_command=$nonopt
5078
5079    compile_rpath=
5080    finalize_rpath=
5081    compile_shlibpath=
5082    finalize_shlibpath=
5083    convenience=
5084    old_convenience=
5085    deplibs=
5086    old_deplibs=
5087    compiler_flags=
5088    linker_flags=
5089    dllsearchpath=
5090    lib_search_path=`pwd`
5091    inst_prefix_dir=
5092    new_inherited_linker_flags=
5093
5094    avoid_version=no
5095    bindir=
5096    dlfiles=
5097    dlprefiles=
5098    dlself=no
5099    export_dynamic=no
5100    export_symbols=
5101    export_symbols_regex=
5102    generated=
5103    libobjs=
5104    ltlibs=
5105    module=no
5106    no_install=no
5107    objs=
5108    non_pic_objects=
5109    precious_files_regex=
5110    prefer_static_libs=no
5111    preload=no
5112    prev=
5113    prevarg=
5114    release=
5115    rpath=
5116    xrpath=
5117    perm_rpath=
5118    temp_rpath=
5119    thread_safe=no
5120    vinfo=
5121    vinfo_number=no
5122    weak_libs=
5123    single_module="${wl}-single_module"
5124    func_infer_tag $base_compile
5125
5126    # We need to know -static, to get the right output filenames.
5127    for arg
5128    do
5129      case $arg in
5130      -shared)
5131	test "$build_libtool_libs" != yes && \
5132	  func_fatal_configuration "can not build a shared library"
5133	build_old_libs=no
5134	break
5135	;;
5136      -all-static | -static | -static-libtool-libs)
5137	case $arg in
5138	-all-static)
5139	  if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
5140	    func_warning "complete static linking is impossible in this configuration"
5141	  fi
5142	  if test -n "$link_static_flag"; then
5143	    dlopen_self=$dlopen_self_static
5144	  fi
5145	  prefer_static_libs=yes
5146	  ;;
5147	-static)
5148	  if test -z "$pic_flag" && test -n "$link_static_flag"; then
5149	    dlopen_self=$dlopen_self_static
5150	  fi
5151	  prefer_static_libs=built
5152	  ;;
5153	-static-libtool-libs)
5154	  if test -z "$pic_flag" && test -n "$link_static_flag"; then
5155	    dlopen_self=$dlopen_self_static
5156	  fi
5157	  prefer_static_libs=yes
5158	  ;;
5159	esac
5160	build_libtool_libs=no
5161	build_old_libs=yes
5162	break
5163	;;
5164      esac
5165    done
5166
5167    # See if our shared archives depend on static archives.
5168    test -n "$old_archive_from_new_cmds" && build_old_libs=yes
5169
5170    # Go through the arguments, transforming them on the way.
5171    while test "$#" -gt 0; do
5172      arg="$1"
5173      shift
5174      func_quote_for_eval "$arg"
5175      qarg=$func_quote_for_eval_unquoted_result
5176      func_append libtool_args " $func_quote_for_eval_result"
5177
5178      # If the previous option needs an argument, assign it.
5179      if test -n "$prev"; then
5180	case $prev in
5181	output)
5182	  func_append compile_command " @OUTPUT@"
5183	  func_append finalize_command " @OUTPUT@"
5184	  ;;
5185	esac
5186
5187	case $prev in
5188	bindir)
5189	  bindir="$arg"
5190	  prev=
5191	  continue
5192	  ;;
5193	dlfiles|dlprefiles)
5194	  if test "$preload" = no; then
5195	    # Add the symbol object into the linking commands.
5196	    func_append compile_command " @SYMFILE@"
5197	    func_append finalize_command " @SYMFILE@"
5198	    preload=yes
5199	  fi
5200	  case $arg in
5201	  *.la | *.lo) ;;  # We handle these cases below.
5202	  force)
5203	    if test "$dlself" = no; then
5204	      dlself=needless
5205	      export_dynamic=yes
5206	    fi
5207	    prev=
5208	    continue
5209	    ;;
5210	  self)
5211	    if test "$prev" = dlprefiles; then
5212	      dlself=yes
5213	    elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
5214	      dlself=yes
5215	    else
5216	      dlself=needless
5217	      export_dynamic=yes
5218	    fi
5219	    prev=
5220	    continue
5221	    ;;
5222	  *)
5223	    if test "$prev" = dlfiles; then
5224	      func_append dlfiles " $arg"
5225	    else
5226	      func_append dlprefiles " $arg"
5227	    fi
5228	    prev=
5229	    continue
5230	    ;;
5231	  esac
5232	  ;;
5233	expsyms)
5234	  export_symbols="$arg"
5235	  test -f "$arg" \
5236	    || func_fatal_error "symbol file \`$arg' does not exist"
5237	  prev=
5238	  continue
5239	  ;;
5240	expsyms_regex)
5241	  export_symbols_regex="$arg"
5242	  prev=
5243	  continue
5244	  ;;
5245	framework)
5246	  case $host in
5247	    *-*-darwin*)
5248	      case "$deplibs " in
5249		*" $qarg.ltframework "*) ;;
5250		*) func_append deplibs " $qarg.ltframework" # this is fixed later
5251		   ;;
5252	      esac
5253	      ;;
5254	  esac
5255	  prev=
5256	  continue
5257	  ;;
5258	inst_prefix)
5259	  inst_prefix_dir="$arg"
5260	  prev=
5261	  continue
5262	  ;;
5263	objectlist)
5264	  if test -f "$arg"; then
5265	    save_arg=$arg
5266	    moreargs=
5267	    for fil in `cat "$save_arg"`
5268	    do
5269#	      func_append moreargs " $fil"
5270	      arg=$fil
5271	      # A libtool-controlled object.
5272
5273	      # Check to see that this really is a libtool object.
5274	      if func_lalib_unsafe_p "$arg"; then
5275		pic_object=
5276		non_pic_object=
5277
5278		# Read the .lo file
5279		func_source "$arg"
5280
5281		if test -z "$pic_object" ||
5282		   test -z "$non_pic_object" ||
5283		   test "$pic_object" = none &&
5284		   test "$non_pic_object" = none; then
5285		  func_fatal_error "cannot find name of object for \`$arg'"
5286		fi
5287
5288		# Extract subdirectory from the argument.
5289		func_dirname "$arg" "/" ""
5290		xdir="$func_dirname_result"
5291
5292		if test "$pic_object" != none; then
5293		  # Prepend the subdirectory the object is found in.
5294		  pic_object="$xdir$pic_object"
5295
5296		  if test "$prev" = dlfiles; then
5297		    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5298		      func_append dlfiles " $pic_object"
5299		      prev=
5300		      continue
5301		    else
5302		      # If libtool objects are unsupported, then we need to preload.
5303		      prev=dlprefiles
5304		    fi
5305		  fi
5306
5307		  # CHECK ME:  I think I busted this.  -Ossama
5308		  if test "$prev" = dlprefiles; then
5309		    # Preload the old-style object.
5310		    func_append dlprefiles " $pic_object"
5311		    prev=
5312		  fi
5313
5314		  # A PIC object.
5315		  func_append libobjs " $pic_object"
5316		  arg="$pic_object"
5317		fi
5318
5319		# Non-PIC object.
5320		if test "$non_pic_object" != none; then
5321		  # Prepend the subdirectory the object is found in.
5322		  non_pic_object="$xdir$non_pic_object"
5323
5324		  # A standard non-PIC object
5325		  func_append non_pic_objects " $non_pic_object"
5326		  if test -z "$pic_object" || test "$pic_object" = none ; then
5327		    arg="$non_pic_object"
5328		  fi
5329		else
5330		  # If the PIC object exists, use it instead.
5331		  # $xdir was prepended to $pic_object above.
5332		  non_pic_object="$pic_object"
5333		  func_append non_pic_objects " $non_pic_object"
5334		fi
5335	      else
5336		# Only an error if not doing a dry-run.
5337		if $opt_dry_run; then
5338		  # Extract subdirectory from the argument.
5339		  func_dirname "$arg" "/" ""
5340		  xdir="$func_dirname_result"
5341
5342		  func_lo2o "$arg"
5343		  pic_object=$xdir$objdir/$func_lo2o_result
5344		  non_pic_object=$xdir$func_lo2o_result
5345		  func_append libobjs " $pic_object"
5346		  func_append non_pic_objects " $non_pic_object"
5347	        else
5348		  func_fatal_error "\`$arg' is not a valid libtool object"
5349		fi
5350	      fi
5351	    done
5352	  else
5353	    func_fatal_error "link input file \`$arg' does not exist"
5354	  fi
5355	  arg=$save_arg
5356	  prev=
5357	  continue
5358	  ;;
5359	precious_regex)
5360	  precious_files_regex="$arg"
5361	  prev=
5362	  continue
5363	  ;;
5364	release)
5365	  release="-$arg"
5366	  prev=
5367	  continue
5368	  ;;
5369	rpath | xrpath)
5370	  # We need an absolute path.
5371	  case $arg in
5372	  [\\/]* | [A-Za-z]:[\\/]*) ;;
5373	  *)
5374	    func_fatal_error "only absolute run-paths are allowed"
5375	    ;;
5376	  esac
5377	  if test "$prev" = rpath; then
5378	    case "$rpath " in
5379	    *" $arg "*) ;;
5380	    *) func_append rpath " $arg" ;;
5381	    esac
5382	  else
5383	    case "$xrpath " in
5384	    *" $arg "*) ;;
5385	    *) func_append xrpath " $arg" ;;
5386	    esac
5387	  fi
5388	  prev=
5389	  continue
5390	  ;;
5391	shrext)
5392	  shrext_cmds="$arg"
5393	  prev=
5394	  continue
5395	  ;;
5396	weak)
5397	  func_append weak_libs " $arg"
5398	  prev=
5399	  continue
5400	  ;;
5401	xcclinker)
5402	  func_append linker_flags " $qarg"
5403	  func_append compiler_flags " $qarg"
5404	  prev=
5405	  func_append compile_command " $qarg"
5406	  func_append finalize_command " $qarg"
5407	  continue
5408	  ;;
5409	xcompiler)
5410	  func_append compiler_flags " $qarg"
5411	  prev=
5412	  func_append compile_command " $qarg"
5413	  func_append finalize_command " $qarg"
5414	  continue
5415	  ;;
5416	xlinker)
5417	  func_append linker_flags " $qarg"
5418	  func_append compiler_flags " $wl$qarg"
5419	  prev=
5420	  func_append compile_command " $wl$qarg"
5421	  func_append finalize_command " $wl$qarg"
5422	  continue
5423	  ;;
5424	*)
5425	  eval "$prev=\"\$arg\""
5426	  prev=
5427	  continue
5428	  ;;
5429	esac
5430      fi # test -n "$prev"
5431
5432      prevarg="$arg"
5433
5434      case $arg in
5435      -all-static)
5436	if test -n "$link_static_flag"; then
5437	  # See comment for -static flag below, for more details.
5438	  func_append compile_command " $link_static_flag"
5439	  func_append finalize_command " $link_static_flag"
5440	fi
5441	continue
5442	;;
5443
5444      -allow-undefined)
5445	# FIXME: remove this flag sometime in the future.
5446	func_fatal_error "\`-allow-undefined' must not be used because it is the default"
5447	;;
5448
5449      -avoid-version)
5450	avoid_version=yes
5451	continue
5452	;;
5453
5454      -bindir)
5455	prev=bindir
5456	continue
5457	;;
5458
5459      -dlopen)
5460	prev=dlfiles
5461	continue
5462	;;
5463
5464      -dlpreopen)
5465	prev=dlprefiles
5466	continue
5467	;;
5468
5469      -export-dynamic)
5470	export_dynamic=yes
5471	continue
5472	;;
5473
5474      -export-symbols | -export-symbols-regex)
5475	if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
5476	  func_fatal_error "more than one -exported-symbols argument is not allowed"
5477	fi
5478	if test "X$arg" = "X-export-symbols"; then
5479	  prev=expsyms
5480	else
5481	  prev=expsyms_regex
5482	fi
5483	continue
5484	;;
5485
5486      -framework)
5487	prev=framework
5488	continue
5489	;;
5490
5491      -inst-prefix-dir)
5492	prev=inst_prefix
5493	continue
5494	;;
5495
5496      # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
5497      # so, if we see these flags be careful not to treat them like -L
5498      -L[A-Z][A-Z]*:*)
5499	case $with_gcc/$host in
5500	no/*-*-irix* | /*-*-irix*)
5501	  func_append compile_command " $arg"
5502	  func_append finalize_command " $arg"
5503	  ;;
5504	esac
5505	continue
5506	;;
5507
5508      -L*)
5509	func_stripname "-L" '' "$arg"
5510	if test -z "$func_stripname_result"; then
5511	  if test "$#" -gt 0; then
5512	    func_fatal_error "require no space between \`-L' and \`$1'"
5513	  else
5514	    func_fatal_error "need path for \`-L' option"
5515	  fi
5516	fi
5517	func_resolve_sysroot "$func_stripname_result"
5518	dir=$func_resolve_sysroot_result
5519	# We need an absolute path.
5520	case $dir in
5521	[\\/]* | [A-Za-z]:[\\/]*) ;;
5522	*)
5523	  absdir=`cd "$dir" && pwd`
5524	  test -z "$absdir" && \
5525	    func_fatal_error "cannot determine absolute directory name of \`$dir'"
5526	  dir="$absdir"
5527	  ;;
5528	esac
5529	case "$deplibs " in
5530	*" -L$dir "* | *" $arg "*)
5531	  # Will only happen for absolute or sysroot arguments
5532	  ;;
5533	*)
5534	  # Preserve sysroot, but never include relative directories
5535	  case $dir in
5536	    [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
5537	    *) func_append deplibs " -L$dir" ;;
5538	  esac
5539	  func_append lib_search_path " $dir"
5540	  ;;
5541	esac
5542	case $host in
5543	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
5544	  testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
5545	  case :$dllsearchpath: in
5546	  *":$dir:"*) ;;
5547	  ::) dllsearchpath=$dir;;
5548	  *) func_append dllsearchpath ":$dir";;
5549	  esac
5550	  case :$dllsearchpath: in
5551	  *":$testbindir:"*) ;;
5552	  ::) dllsearchpath=$testbindir;;
5553	  *) func_append dllsearchpath ":$testbindir";;
5554	  esac
5555	  ;;
5556	esac
5557	continue
5558	;;
5559
5560      -l*)
5561	if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
5562	  case $host in
5563	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
5564	    # These systems don't actually have a C or math library (as such)
5565	    continue
5566	    ;;
5567	  *-*-os2*)
5568	    # These systems don't actually have a C library (as such)
5569	    test "X$arg" = "X-lc" && continue
5570	    ;;
5571	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5572	    # Do not include libc due to us having libc/libc_r.
5573	    test "X$arg" = "X-lc" && continue
5574	    ;;
5575	  *-*-rhapsody* | *-*-darwin1.[012])
5576	    # Rhapsody C and math libraries are in the System framework
5577	    func_append deplibs " System.ltframework"
5578	    continue
5579	    ;;
5580	  *-*-sco3.2v5* | *-*-sco5v6*)
5581	    # Causes problems with __ctype
5582	    test "X$arg" = "X-lc" && continue
5583	    ;;
5584	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
5585	    # Compiler inserts libc in the correct place for threads to work
5586	    test "X$arg" = "X-lc" && continue
5587	    ;;
5588	  esac
5589	elif test "X$arg" = "X-lc_r"; then
5590	 case $host in
5591	 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5592	   # Do not include libc_r directly, use -pthread flag.
5593	   continue
5594	   ;;
5595	 esac
5596	fi
5597	func_append deplibs " $arg"
5598	continue
5599	;;
5600
5601      -module)
5602	module=yes
5603	continue
5604	;;
5605
5606      # Tru64 UNIX uses -model [arg] to determine the layout of C++
5607      # classes, name mangling, and exception handling.
5608      # Darwin uses the -arch flag to determine output architecture.
5609      -model|-arch|-isysroot|--sysroot)
5610	func_append compiler_flags " $arg"
5611	func_append compile_command " $arg"
5612	func_append finalize_command " $arg"
5613	prev=xcompiler
5614	continue
5615	;;
5616
5617      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
5618      |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
5619	func_append compiler_flags " $arg"
5620	func_append compile_command " $arg"
5621	func_append finalize_command " $arg"
5622	func_append deplibs " $arg"
5623	case "$new_inherited_linker_flags " in
5624	    *" $arg "*) ;;
5625	    * ) func_append new_inherited_linker_flags " $arg" ;;
5626	esac
5627	continue
5628	;;
5629
5630      -multi_module)
5631	single_module="${wl}-multi_module"
5632	continue
5633	;;
5634
5635      -no-fast-install)
5636	fast_install=no
5637	continue
5638	;;
5639
5640      -no-install)
5641	case $host in
5642	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
5643	  # The PATH hackery in wrapper scripts is required on Windows
5644	  # and Darwin in order for the loader to find any dlls it needs.
5645	  func_warning "\`-no-install' is ignored for $host"
5646	  func_warning "assuming \`-no-fast-install' instead"
5647	  fast_install=no
5648	  ;;
5649	*) no_install=yes ;;
5650	esac
5651	continue
5652	;;
5653
5654      -no-undefined)
5655	allow_undefined=no
5656	continue
5657	;;
5658
5659      -objectlist)
5660	prev=objectlist
5661	continue
5662	;;
5663
5664      -o) prev=output ;;
5665
5666      -precious-files-regex)
5667	prev=precious_regex
5668	continue
5669	;;
5670
5671      -release)
5672	prev=release
5673	continue
5674	;;
5675
5676      -rpath)
5677	prev=rpath
5678	continue
5679	;;
5680
5681      -R)
5682	prev=xrpath
5683	continue
5684	;;
5685
5686      -R*)
5687	func_stripname '-R' '' "$arg"
5688	dir=$func_stripname_result
5689	# We need an absolute path.
5690	case $dir in
5691	[\\/]* | [A-Za-z]:[\\/]*) ;;
5692	=*)
5693	  func_stripname '=' '' "$dir"
5694	  dir=$lt_sysroot$func_stripname_result
5695	  ;;
5696	*)
5697	  func_fatal_error "only absolute run-paths are allowed"
5698	  ;;
5699	esac
5700	case "$xrpath " in
5701	*" $dir "*) ;;
5702	*) func_append xrpath " $dir" ;;
5703	esac
5704	continue
5705	;;
5706
5707      -shared)
5708	# The effects of -shared are defined in a previous loop.
5709	continue
5710	;;
5711
5712      -shrext)
5713	prev=shrext
5714	continue
5715	;;
5716
5717      -static | -static-libtool-libs)
5718	# The effects of -static are defined in a previous loop.
5719	# We used to do the same as -all-static on platforms that
5720	# didn't have a PIC flag, but the assumption that the effects
5721	# would be equivalent was wrong.  It would break on at least
5722	# Digital Unix and AIX.
5723	continue
5724	;;
5725
5726      -thread-safe)
5727	thread_safe=yes
5728	continue
5729	;;
5730
5731      -version-info)
5732	prev=vinfo
5733	continue
5734	;;
5735
5736      -version-number)
5737	prev=vinfo
5738	vinfo_number=yes
5739	continue
5740	;;
5741
5742      -weak)
5743        prev=weak
5744	continue
5745	;;
5746
5747      -Wc,*)
5748	func_stripname '-Wc,' '' "$arg"
5749	args=$func_stripname_result
5750	arg=
5751	save_ifs="$IFS"; IFS=','
5752	for flag in $args; do
5753	  IFS="$save_ifs"
5754          func_quote_for_eval "$flag"
5755	  func_append arg " $func_quote_for_eval_result"
5756	  func_append compiler_flags " $func_quote_for_eval_result"
5757	done
5758	IFS="$save_ifs"
5759	func_stripname ' ' '' "$arg"
5760	arg=$func_stripname_result
5761	;;
5762
5763      -Wl,*)
5764	func_stripname '-Wl,' '' "$arg"
5765	args=$func_stripname_result
5766	arg=
5767	save_ifs="$IFS"; IFS=','
5768	for flag in $args; do
5769	  IFS="$save_ifs"
5770          func_quote_for_eval "$flag"
5771	  func_append arg " $wl$func_quote_for_eval_result"
5772	  func_append compiler_flags " $wl$func_quote_for_eval_result"
5773	  func_append linker_flags " $func_quote_for_eval_result"
5774	done
5775	IFS="$save_ifs"
5776	func_stripname ' ' '' "$arg"
5777	arg=$func_stripname_result
5778	;;
5779
5780      -Xcompiler)
5781	prev=xcompiler
5782	continue
5783	;;
5784
5785      -Xlinker)
5786	prev=xlinker
5787	continue
5788	;;
5789
5790      -XCClinker)
5791	prev=xcclinker
5792	continue
5793	;;
5794
5795      # -msg_* for osf cc
5796      -msg_*)
5797	func_quote_for_eval "$arg"
5798	arg="$func_quote_for_eval_result"
5799	;;
5800
5801      # Flags to be passed through unchanged, with rationale:
5802      # -64, -mips[0-9]      enable 64-bit mode for the SGI compiler
5803      # -r[0-9][0-9]*        specify processor for the SGI compiler
5804      # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
5805      # +DA*, +DD*           enable 64-bit mode for the HP compiler
5806      # -q*                  compiler args for the IBM compiler
5807      # -m*, -t[45]*, -txscale* architecture-specific flags for GCC
5808      # -F/path              path to uninstalled frameworks, gcc on darwin
5809      # -p, -pg, --coverage, -fprofile-*  profiling flags for GCC
5810      # @file                GCC response files
5811      # -tp=*                Portland pgcc target processor selection
5812      # --sysroot=*          for sysroot support
5813      # -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
5814      -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
5815      -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
5816      -O*|-flto*|-fwhopr*|-fuse-linker-plugin|-fstack-protector*)
5817        func_quote_for_eval "$arg"
5818	arg="$func_quote_for_eval_result"
5819        func_append compile_command " $arg"
5820        func_append finalize_command " $arg"
5821        func_append compiler_flags " $arg"
5822        continue
5823        ;;
5824
5825      # Some other compiler flag.
5826      -* | +*)
5827        func_quote_for_eval "$arg"
5828	arg="$func_quote_for_eval_result"
5829	;;
5830
5831      *.$objext)
5832	# A standard object.
5833	func_append objs " $arg"
5834	;;
5835
5836      *.lo)
5837	# A libtool-controlled object.
5838
5839	# Check to see that this really is a libtool object.
5840	if func_lalib_unsafe_p "$arg"; then
5841	  pic_object=
5842	  non_pic_object=
5843
5844	  # Read the .lo file
5845	  func_source "$arg"
5846
5847	  if test -z "$pic_object" ||
5848	     test -z "$non_pic_object" ||
5849	     test "$pic_object" = none &&
5850	     test "$non_pic_object" = none; then
5851	    func_fatal_error "cannot find name of object for \`$arg'"
5852	  fi
5853
5854	  # Extract subdirectory from the argument.
5855	  func_dirname "$arg" "/" ""
5856	  xdir="$func_dirname_result"
5857
5858	  if test "$pic_object" != none; then
5859	    # Prepend the subdirectory the object is found in.
5860	    pic_object="$xdir$pic_object"
5861
5862	    if test "$prev" = dlfiles; then
5863	      if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5864		func_append dlfiles " $pic_object"
5865		prev=
5866		continue
5867	      else
5868		# If libtool objects are unsupported, then we need to preload.
5869		prev=dlprefiles
5870	      fi
5871	    fi
5872
5873	    # CHECK ME:  I think I busted this.  -Ossama
5874	    if test "$prev" = dlprefiles; then
5875	      # Preload the old-style object.
5876	      func_append dlprefiles " $pic_object"
5877	      prev=
5878	    fi
5879
5880	    # A PIC object.
5881	    func_append libobjs " $pic_object"
5882	    arg="$pic_object"
5883	  fi
5884
5885	  # Non-PIC object.
5886	  if test "$non_pic_object" != none; then
5887	    # Prepend the subdirectory the object is found in.
5888	    non_pic_object="$xdir$non_pic_object"
5889
5890	    # A standard non-PIC object
5891	    func_append non_pic_objects " $non_pic_object"
5892	    if test -z "$pic_object" || test "$pic_object" = none ; then
5893	      arg="$non_pic_object"
5894	    fi
5895	  else
5896	    # If the PIC object exists, use it instead.
5897	    # $xdir was prepended to $pic_object above.
5898	    non_pic_object="$pic_object"
5899	    func_append non_pic_objects " $non_pic_object"
5900	  fi
5901	else
5902	  # Only an error if not doing a dry-run.
5903	  if $opt_dry_run; then
5904	    # Extract subdirectory from the argument.
5905	    func_dirname "$arg" "/" ""
5906	    xdir="$func_dirname_result"
5907
5908	    func_lo2o "$arg"
5909	    pic_object=$xdir$objdir/$func_lo2o_result
5910	    non_pic_object=$xdir$func_lo2o_result
5911	    func_append libobjs " $pic_object"
5912	    func_append non_pic_objects " $non_pic_object"
5913	  else
5914	    func_fatal_error "\`$arg' is not a valid libtool object"
5915	  fi
5916	fi
5917	;;
5918
5919      *.$libext)
5920	# An archive.
5921	func_append deplibs " $arg"
5922	func_append old_deplibs " $arg"
5923	continue
5924	;;
5925
5926      *.la)
5927	# A libtool-controlled library.
5928
5929	func_resolve_sysroot "$arg"
5930	if test "$prev" = dlfiles; then
5931	  # This library was specified with -dlopen.
5932	  func_append dlfiles " $func_resolve_sysroot_result"
5933	  prev=
5934	elif test "$prev" = dlprefiles; then
5935	  # The library was specified with -dlpreopen.
5936	  func_append dlprefiles " $func_resolve_sysroot_result"
5937	  prev=
5938	else
5939	  func_append deplibs " $func_resolve_sysroot_result"
5940	fi
5941	continue
5942	;;
5943
5944      # Some other compiler argument.
5945      *)
5946	# Unknown arguments in both finalize_command and compile_command need
5947	# to be aesthetically quoted because they are evaled later.
5948	func_quote_for_eval "$arg"
5949	arg="$func_quote_for_eval_result"
5950	;;
5951      esac # arg
5952
5953      # Now actually substitute the argument into the commands.
5954      if test -n "$arg"; then
5955	func_append compile_command " $arg"
5956	func_append finalize_command " $arg"
5957      fi
5958    done # argument parsing loop
5959
5960    test -n "$prev" && \
5961      func_fatal_help "the \`$prevarg' option requires an argument"
5962
5963    if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
5964      eval arg=\"$export_dynamic_flag_spec\"
5965      func_append compile_command " $arg"
5966      func_append finalize_command " $arg"
5967    fi
5968
5969    oldlibs=
5970    # calculate the name of the file, without its directory
5971    func_basename "$output"
5972    outputname="$func_basename_result"
5973    libobjs_save="$libobjs"
5974
5975    if test -n "$shlibpath_var"; then
5976      # get the directories listed in $shlibpath_var
5977      eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
5978    else
5979      shlib_search_path=
5980    fi
5981    eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
5982    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
5983
5984    func_dirname "$output" "/" ""
5985    output_objdir="$func_dirname_result$objdir"
5986    func_to_tool_file "$output_objdir/"
5987    tool_output_objdir=$func_to_tool_file_result
5988    # Create the object directory.
5989    func_mkdir_p "$output_objdir"
5990
5991    # Determine the type of output
5992    case $output in
5993    "")
5994      func_fatal_help "you must specify an output file"
5995      ;;
5996    *.$libext) linkmode=oldlib ;;
5997    *.lo | *.$objext) linkmode=obj ;;
5998    *.la) linkmode=lib ;;
5999    *) linkmode=prog ;; # Anything else should be a program.
6000    esac
6001
6002    specialdeplibs=
6003
6004    libs=
6005    # Find all interdependent deplibs by searching for libraries
6006    # that are linked more than once (e.g. -la -lb -la)
6007    for deplib in $deplibs; do
6008      if $opt_preserve_dup_deps ; then
6009	case "$libs " in
6010	*" $deplib "*) func_append specialdeplibs " $deplib" ;;
6011	esac
6012      fi
6013      func_append libs " $deplib"
6014    done
6015
6016    if test "$linkmode" = lib; then
6017      libs="$predeps $libs $compiler_lib_search_path $postdeps"
6018
6019      # Compute libraries that are listed more than once in $predeps
6020      # $postdeps and mark them as special (i.e., whose duplicates are
6021      # not to be eliminated).
6022      pre_post_deps=
6023      if $opt_duplicate_compiler_generated_deps; then
6024	for pre_post_dep in $predeps $postdeps; do
6025	  case "$pre_post_deps " in
6026	  *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
6027	  esac
6028	  func_append pre_post_deps " $pre_post_dep"
6029	done
6030      fi
6031      pre_post_deps=
6032    fi
6033
6034    deplibs=
6035    newdependency_libs=
6036    newlib_search_path=
6037    need_relink=no # whether we're linking any uninstalled libtool libraries
6038    notinst_deplibs= # not-installed libtool libraries
6039    notinst_path= # paths that contain not-installed libtool libraries
6040
6041    case $linkmode in
6042    lib)
6043	passes="conv dlpreopen link"
6044	for file in $dlfiles $dlprefiles; do
6045	  case $file in
6046	  *.la) ;;
6047	  *)
6048	    func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
6049	    ;;
6050	  esac
6051	done
6052	;;
6053    prog)
6054	compile_deplibs=
6055	finalize_deplibs=
6056	alldeplibs=no
6057	newdlfiles=
6058	newdlprefiles=
6059	passes="conv scan dlopen dlpreopen link"
6060	;;
6061    *)  passes="conv"
6062	;;
6063    esac
6064
6065    for pass in $passes; do
6066      # The preopen pass in lib mode reverses $deplibs; put it back here
6067      # so that -L comes before libs that need it for instance...
6068      if test "$linkmode,$pass" = "lib,link"; then
6069	## FIXME: Find the place where the list is rebuilt in the wrong
6070	##        order, and fix it there properly
6071        tmp_deplibs=
6072	for deplib in $deplibs; do
6073	  tmp_deplibs="$deplib $tmp_deplibs"
6074	done
6075	deplibs="$tmp_deplibs"
6076      fi
6077
6078      if test "$linkmode,$pass" = "lib,link" ||
6079	 test "$linkmode,$pass" = "prog,scan"; then
6080	libs="$deplibs"
6081	deplibs=
6082      fi
6083      if test "$linkmode" = prog; then
6084	case $pass in
6085	dlopen) libs="$dlfiles" ;;
6086	dlpreopen) libs="$dlprefiles" ;;
6087	link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
6088	esac
6089      fi
6090      if test "$linkmode,$pass" = "lib,dlpreopen"; then
6091	# Collect and forward deplibs of preopened libtool libs
6092	for lib in $dlprefiles; do
6093	  # Ignore non-libtool-libs
6094	  dependency_libs=
6095	  func_resolve_sysroot "$lib"
6096	  case $lib in
6097	  *.la)	func_source "$func_resolve_sysroot_result" ;;
6098	  esac
6099
6100	  # Collect preopened libtool deplibs, except any this library
6101	  # has declared as weak libs
6102	  for deplib in $dependency_libs; do
6103	    func_basename "$deplib"
6104            deplib_base=$func_basename_result
6105	    case " $weak_libs " in
6106	    *" $deplib_base "*) ;;
6107	    *) func_append deplibs " $deplib" ;;
6108	    esac
6109	  done
6110	done
6111	libs="$dlprefiles"
6112      fi
6113      if test "$pass" = dlopen; then
6114	# Collect dlpreopened libraries
6115	save_deplibs="$deplibs"
6116	deplibs=
6117      fi
6118
6119      for deplib in $libs; do
6120	lib=
6121	found=no
6122	case $deplib in
6123	-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
6124        |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
6125	  if test "$linkmode,$pass" = "prog,link"; then
6126	    compile_deplibs="$deplib $compile_deplibs"
6127	    finalize_deplibs="$deplib $finalize_deplibs"
6128	  else
6129	    func_append compiler_flags " $deplib"
6130	    test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
6131	    if test "$linkmode" = lib ; then
6132		case "$new_inherited_linker_flags " in
6133		    *" $deplib "*) ;;
6134		    * ) func_append new_inherited_linker_flags " $deplib" ;;
6135		esac
6136	    fi
6137	  fi
6138	  continue
6139	  ;;
6140	-l*)
6141	  if test "$linkmode" != lib && test "$linkmode" != prog; then
6142	    func_warning "\`-l' is ignored for archives/objects"
6143	    continue
6144	  fi
6145	  func_stripname '-l' '' "$deplib"
6146	  name=$func_stripname_result
6147	  if test "$linkmode" = lib; then
6148	    searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
6149	  else
6150	    searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
6151	  fi
6152	  for searchdir in $searchdirs; do
6153	    for search_ext in .la $std_shrext .so .a; do
6154	      # Search the libtool library
6155	      lib="$searchdir/lib${name}${search_ext}"
6156	      if test -f "$lib"; then
6157		if test "$search_ext" = ".la"; then
6158		  found=yes
6159		else
6160		  found=no
6161		fi
6162		break 2
6163	      fi
6164	    done
6165	  done
6166	  if test "$found" != yes; then
6167	    # deplib doesn't seem to be a libtool library
6168	    if test "$linkmode,$pass" = "prog,link"; then
6169	      compile_deplibs="$deplib $compile_deplibs"
6170	      finalize_deplibs="$deplib $finalize_deplibs"
6171	    else
6172	      deplibs="$deplib $deplibs"
6173	      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
6174	    fi
6175	    continue
6176	  else # deplib is a libtool library
6177	    # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
6178	    # We need to do some special things here, and not later.
6179	    if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6180	      case " $predeps $postdeps " in
6181	      *" $deplib "*)
6182		if func_lalib_p "$lib"; then
6183		  library_names=
6184		  old_library=
6185		  func_source "$lib"
6186		  for l in $old_library $library_names; do
6187		    ll="$l"
6188		  done
6189		  if test "X$ll" = "X$old_library" ; then # only static version available
6190		    found=no
6191		    func_dirname "$lib" "" "."
6192		    ladir="$func_dirname_result"
6193		    lib=$ladir/$old_library
6194		    if test "$linkmode,$pass" = "prog,link"; then
6195		      compile_deplibs="$deplib $compile_deplibs"
6196		      finalize_deplibs="$deplib $finalize_deplibs"
6197		    else
6198		      deplibs="$deplib $deplibs"
6199		      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
6200		    fi
6201		    continue
6202		  fi
6203		fi
6204		;;
6205	      *) ;;
6206	      esac
6207	    fi
6208	  fi
6209	  ;; # -l
6210	*.ltframework)
6211	  if test "$linkmode,$pass" = "prog,link"; then
6212	    compile_deplibs="$deplib $compile_deplibs"
6213	    finalize_deplibs="$deplib $finalize_deplibs"
6214	  else
6215	    deplibs="$deplib $deplibs"
6216	    if test "$linkmode" = lib ; then
6217		case "$new_inherited_linker_flags " in
6218		    *" $deplib "*) ;;
6219		    * ) func_append new_inherited_linker_flags " $deplib" ;;
6220		esac
6221	    fi
6222	  fi
6223	  continue
6224	  ;;
6225	-L*)
6226	  case $linkmode in
6227	  lib)
6228	    deplibs="$deplib $deplibs"
6229	    test "$pass" = conv && continue
6230	    newdependency_libs="$deplib $newdependency_libs"
6231	    func_stripname '-L' '' "$deplib"
6232	    func_resolve_sysroot "$func_stripname_result"
6233	    func_append newlib_search_path " $func_resolve_sysroot_result"
6234	    ;;
6235	  prog)
6236	    if test "$pass" = conv; then
6237	      deplibs="$deplib $deplibs"
6238	      continue
6239	    fi
6240	    if test "$pass" = scan; then
6241	      deplibs="$deplib $deplibs"
6242	    else
6243	      compile_deplibs="$deplib $compile_deplibs"
6244	      finalize_deplibs="$deplib $finalize_deplibs"
6245	    fi
6246	    func_stripname '-L' '' "$deplib"
6247	    func_resolve_sysroot "$func_stripname_result"
6248	    func_append newlib_search_path " $func_resolve_sysroot_result"
6249	    ;;
6250	  *)
6251	    func_warning "\`-L' is ignored for archives/objects"
6252	    ;;
6253	  esac # linkmode
6254	  continue
6255	  ;; # -L
6256	-R*)
6257	  if test "$pass" = link; then
6258	    func_stripname '-R' '' "$deplib"
6259	    func_resolve_sysroot "$func_stripname_result"
6260	    dir=$func_resolve_sysroot_result
6261	    # Make sure the xrpath contains only unique directories.
6262	    case "$xrpath " in
6263	    *" $dir "*) ;;
6264	    *) func_append xrpath " $dir" ;;
6265	    esac
6266	  fi
6267	  deplibs="$deplib $deplibs"
6268	  continue
6269	  ;;
6270	*.la)
6271	  func_resolve_sysroot "$deplib"
6272	  lib=$func_resolve_sysroot_result
6273	  ;;
6274	*.$libext)
6275	  if test "$pass" = conv; then
6276	    deplibs="$deplib $deplibs"
6277	    continue
6278	  fi
6279	  case $linkmode in
6280	  lib)
6281	    # Linking convenience modules into shared libraries is allowed,
6282	    # but linking other static libraries is non-portable.
6283	    case " $dlpreconveniencelibs " in
6284	    *" $deplib "*) ;;
6285	    *)
6286	      valid_a_lib=no
6287	      case $deplibs_check_method in
6288		match_pattern*)
6289		  set dummy $deplibs_check_method; shift
6290		  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6291		  if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
6292		    | $EGREP "$match_pattern_regex" > /dev/null; then
6293		    valid_a_lib=yes
6294		  fi
6295		;;
6296		pass_all)
6297		  valid_a_lib=yes
6298		;;
6299	      esac
6300	      if test "$valid_a_lib" != yes; then
6301		echo
6302		$ECHO "*** Warning: Trying to link with static lib archive $deplib."
6303		echo "*** I have the capability to make that library automatically link in when"
6304		echo "*** you link to this library.  But I can only do this if you have a"
6305		echo "*** shared version of the library, which you do not appear to have"
6306		echo "*** because the file extensions .$libext of this argument makes me believe"
6307		echo "*** that it is just a static archive that I should not use here."
6308	      else
6309		echo
6310		$ECHO "*** Warning: Linking the shared library $output against the"
6311		$ECHO "*** static library $deplib is not portable!"
6312		deplibs="$deplib $deplibs"
6313	      fi
6314	      ;;
6315	    esac
6316	    continue
6317	    ;;
6318	  prog)
6319	    if test "$pass" != link; then
6320	      deplibs="$deplib $deplibs"
6321	    else
6322	      compile_deplibs="$deplib $compile_deplibs"
6323	      finalize_deplibs="$deplib $finalize_deplibs"
6324	    fi
6325	    continue
6326	    ;;
6327	  esac # linkmode
6328	  ;; # *.$libext
6329	*.lo | *.$objext)
6330	  if test "$pass" = conv; then
6331	    deplibs="$deplib $deplibs"
6332	  elif test "$linkmode" = prog; then
6333	    if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
6334	      # If there is no dlopen support or we're linking statically,
6335	      # we need to preload.
6336	      func_append newdlprefiles " $deplib"
6337	      compile_deplibs="$deplib $compile_deplibs"
6338	      finalize_deplibs="$deplib $finalize_deplibs"
6339	    else
6340	      func_append newdlfiles " $deplib"
6341	    fi
6342	  fi
6343	  continue
6344	  ;;
6345	%DEPLIBS%)
6346	  alldeplibs=yes
6347	  continue
6348	  ;;
6349	esac # case $deplib
6350
6351	if test "$found" = yes || test -f "$lib"; then :
6352	else
6353	  func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
6354	fi
6355
6356	# Check to see that this really is a libtool archive.
6357	func_lalib_unsafe_p "$lib" \
6358	  || func_fatal_error "\`$lib' is not a valid libtool archive"
6359
6360	func_dirname "$lib" "" "."
6361	ladir="$func_dirname_result"
6362
6363	dlname=
6364	dlopen=
6365	dlpreopen=
6366	libdir=
6367	library_names=
6368	old_library=
6369	inherited_linker_flags=
6370	# If the library was installed with an old release of libtool,
6371	# it will not redefine variables installed, or shouldnotlink
6372	installed=yes
6373	shouldnotlink=no
6374	avoidtemprpath=
6375
6376
6377	# Read the .la file
6378	func_source "$lib"
6379
6380	# Convert "-framework foo" to "foo.ltframework"
6381	if test -n "$inherited_linker_flags"; then
6382	  tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
6383	  for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
6384	    case " $new_inherited_linker_flags " in
6385	      *" $tmp_inherited_linker_flag "*) ;;
6386	      *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
6387	    esac
6388	  done
6389	fi
6390	dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
6391	if test "$linkmode,$pass" = "lib,link" ||
6392	   test "$linkmode,$pass" = "prog,scan" ||
6393	   { test "$linkmode" != prog && test "$linkmode" != lib; }; then
6394	  test -n "$dlopen" && func_append dlfiles " $dlopen"
6395	  test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
6396	fi
6397
6398	if test "$pass" = conv; then
6399	  # Only check for convenience libraries
6400	  deplibs="$lib $deplibs"
6401	  if test -z "$libdir"; then
6402	    if test -z "$old_library"; then
6403	      func_fatal_error "cannot find name of link library for \`$lib'"
6404	    fi
6405	    # It is a libtool convenience library, so add in its objects.
6406	    func_append convenience " $ladir/$objdir/$old_library"
6407	    func_append old_convenience " $ladir/$objdir/$old_library"
6408	  elif test "$linkmode" != prog && test "$linkmode" != lib; then
6409	    func_fatal_error "\`$lib' is not a convenience library"
6410	  fi
6411	  tmp_libs=
6412	  for deplib in $dependency_libs; do
6413	    deplibs="$deplib $deplibs"
6414	    if $opt_preserve_dup_deps ; then
6415	      case "$tmp_libs " in
6416	      *" $deplib "*) func_append specialdeplibs " $deplib" ;;
6417	      esac
6418	    fi
6419	    func_append tmp_libs " $deplib"
6420	  done
6421	  continue
6422	fi # $pass = conv
6423
6424
6425	# Get the name of the library we link against.
6426	linklib=
6427	if test -n "$old_library" &&
6428	   { test "$prefer_static_libs" = yes ||
6429	     test "$prefer_static_libs,$installed" = "built,no"; }; then
6430	  linklib=$old_library
6431	else
6432	  for l in $old_library $library_names; do
6433	    linklib="$l"
6434	  done
6435	fi
6436	if test -z "$linklib"; then
6437	  func_fatal_error "cannot find name of link library for \`$lib'"
6438	fi
6439
6440	# This library was specified with -dlopen.
6441	if test "$pass" = dlopen; then
6442	  if test -z "$libdir"; then
6443	    func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
6444	  fi
6445	  if test -z "$dlname" ||
6446	     test "$dlopen_support" != yes ||
6447	     test "$build_libtool_libs" = no; then
6448	    # If there is no dlname, no dlopen support or we're linking
6449	    # statically, we need to preload.  We also need to preload any
6450	    # dependent libraries so libltdl's deplib preloader doesn't
6451	    # bomb out in the load deplibs phase.
6452	    func_append dlprefiles " $lib $dependency_libs"
6453	  else
6454	    func_append newdlfiles " $lib"
6455	  fi
6456	  continue
6457	fi # $pass = dlopen
6458
6459	# We need an absolute path.
6460	case $ladir in
6461	[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
6462	*)
6463	  abs_ladir=`cd "$ladir" && pwd`
6464	  if test -z "$abs_ladir"; then
6465	    func_warning "cannot determine absolute directory name of \`$ladir'"
6466	    func_warning "passing it literally to the linker, although it might fail"
6467	    abs_ladir="$ladir"
6468	  fi
6469	  ;;
6470	esac
6471	func_basename "$lib"
6472	laname="$func_basename_result"
6473
6474	# Find the relevant object directory and library name.
6475	if test "X$installed" = Xyes; then
6476	  if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
6477	    func_warning "library \`$lib' was moved."
6478	    dir="$ladir"
6479	    absdir="$abs_ladir"
6480	    libdir="$abs_ladir"
6481	  else
6482	    dir="$lt_sysroot$libdir"
6483	    absdir="$lt_sysroot$libdir"
6484	  fi
6485	  test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
6486	else
6487	  if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
6488	    dir="$ladir"
6489	    absdir="$abs_ladir"
6490	    # Remove this search path later
6491	    func_append notinst_path " $abs_ladir"
6492	  else
6493	    dir="$ladir/$objdir"
6494	    absdir="$abs_ladir/$objdir"
6495	    # Remove this search path later
6496	    func_append notinst_path " $abs_ladir"
6497	  fi
6498	fi # $installed = yes
6499	func_stripname 'lib' '.la' "$laname"
6500	name=$func_stripname_result
6501
6502	# This library was specified with -dlpreopen.
6503	if test "$pass" = dlpreopen; then
6504	  if test -z "$libdir" && test "$linkmode" = prog; then
6505	    func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
6506	  fi
6507	  case "$host" in
6508	    # special handling for platforms with PE-DLLs.
6509	    *cygwin* | *mingw* | *cegcc* )
6510	      # Linker will automatically link against shared library if both
6511	      # static and shared are present.  Therefore, ensure we extract
6512	      # symbols from the import library if a shared library is present
6513	      # (otherwise, the dlopen module name will be incorrect).  We do
6514	      # this by putting the import library name into $newdlprefiles.
6515	      # We recover the dlopen module name by 'saving' the la file
6516	      # name in a special purpose variable, and (later) extracting the
6517	      # dlname from the la file.
6518	      if test -n "$dlname"; then
6519	        func_tr_sh "$dir/$linklib"
6520	        eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
6521	        func_append newdlprefiles " $dir/$linklib"
6522	      else
6523	        func_append newdlprefiles " $dir/$old_library"
6524	        # Keep a list of preopened convenience libraries to check
6525	        # that they are being used correctly in the link pass.
6526	        test -z "$libdir" && \
6527	          func_append dlpreconveniencelibs " $dir/$old_library"
6528	      fi
6529	    ;;
6530	    * )
6531	      # Prefer using a static library (so that no silly _DYNAMIC symbols
6532	      # are required to link).
6533	      if test -n "$old_library"; then
6534	        func_append newdlprefiles " $dir/$old_library"
6535	        # Keep a list of preopened convenience libraries to check
6536	        # that they are being used correctly in the link pass.
6537	        test -z "$libdir" && \
6538	          func_append dlpreconveniencelibs " $dir/$old_library"
6539	      # Otherwise, use the dlname, so that lt_dlopen finds it.
6540	      elif test -n "$dlname"; then
6541	        func_append newdlprefiles " $dir/$dlname"
6542	      else
6543	        func_append newdlprefiles " $dir/$linklib"
6544	      fi
6545	    ;;
6546	  esac
6547	fi # $pass = dlpreopen
6548
6549	if test -z "$libdir"; then
6550	  # Link the convenience library
6551	  if test "$linkmode" = lib; then
6552	    deplibs="$dir/$old_library $deplibs"
6553	  elif test "$linkmode,$pass" = "prog,link"; then
6554	    compile_deplibs="$dir/$old_library $compile_deplibs"
6555	    finalize_deplibs="$dir/$old_library $finalize_deplibs"
6556	  else
6557	    deplibs="$lib $deplibs" # used for prog,scan pass
6558	  fi
6559	  continue
6560	fi
6561
6562
6563	if test "$linkmode" = prog && test "$pass" != link; then
6564	  func_append newlib_search_path " $ladir"
6565	  deplibs="$lib $deplibs"
6566
6567	  linkalldeplibs=no
6568	  if test "$link_all_deplibs" != no || test -z "$library_names" ||
6569	     test "$build_libtool_libs" = no; then
6570	    linkalldeplibs=yes
6571	  fi
6572
6573	  tmp_libs=
6574	  for deplib in $dependency_libs; do
6575	    case $deplib in
6576	    -L*) func_stripname '-L' '' "$deplib"
6577	         func_resolve_sysroot "$func_stripname_result"
6578	         func_append newlib_search_path " $func_resolve_sysroot_result"
6579		 ;;
6580	    esac
6581	    # Need to link against all dependency_libs?
6582	    if test "$linkalldeplibs" = yes; then
6583	      deplibs="$deplib $deplibs"
6584	    else
6585	      # Need to hardcode shared library paths
6586	      # or/and link against static libraries
6587	      newdependency_libs="$deplib $newdependency_libs"
6588	    fi
6589	    if $opt_preserve_dup_deps ; then
6590	      case "$tmp_libs " in
6591	      *" $deplib "*) func_append specialdeplibs " $deplib" ;;
6592	      esac
6593	    fi
6594	    func_append tmp_libs " $deplib"
6595	  done # for deplib
6596	  continue
6597	fi # $linkmode = prog...
6598
6599	if test "$linkmode,$pass" = "prog,link"; then
6600	  if test -n "$library_names" &&
6601	     { { test "$prefer_static_libs" = no ||
6602	         test "$prefer_static_libs,$installed" = "built,yes"; } ||
6603	       test -z "$old_library"; }; then
6604	    # We need to hardcode the library path
6605	    if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
6606	      # Make sure the rpath contains only unique directories.
6607	      case "$temp_rpath:" in
6608	      *"$absdir:"*) ;;
6609	      *) func_append temp_rpath "$absdir:" ;;
6610	      esac
6611	    fi
6612
6613	    # Hardcode the library path.
6614	    # Skip directories that are in the system default run-time
6615	    # search path.
6616	    case " $sys_lib_dlsearch_path " in
6617	    *" $absdir "*) ;;
6618	    *)
6619	      case "$compile_rpath " in
6620	      *" $absdir "*) ;;
6621	      *) func_append compile_rpath " $absdir" ;;
6622	      esac
6623	      ;;
6624	    esac
6625	    case " $sys_lib_dlsearch_path " in
6626	    *" $libdir "*) ;;
6627	    *)
6628	      case "$finalize_rpath " in
6629	      *" $libdir "*) ;;
6630	      *) func_append finalize_rpath " $libdir" ;;
6631	      esac
6632	      ;;
6633	    esac
6634	  fi # $linkmode,$pass = prog,link...
6635
6636	  if test "$alldeplibs" = yes &&
6637	     { test "$deplibs_check_method" = pass_all ||
6638	       { test "$build_libtool_libs" = yes &&
6639		 test -n "$library_names"; }; }; then
6640	    # We only need to search for static libraries
6641	    continue
6642	  fi
6643	fi
6644
6645	link_static=no # Whether the deplib will be linked statically
6646	use_static_libs=$prefer_static_libs
6647	if test "$use_static_libs" = built && test "$installed" = yes; then
6648	  use_static_libs=no
6649	fi
6650	if test -n "$library_names" &&
6651	   { test "$use_static_libs" = no || test -z "$old_library"; }; then
6652	  case $host in
6653	  *cygwin* | *mingw* | *cegcc*)
6654	      # No point in relinking DLLs because paths are not encoded
6655	      func_append notinst_deplibs " $lib"
6656	      need_relink=no
6657	    ;;
6658	  *)
6659	    if test "$installed" = no; then
6660	      func_append notinst_deplibs " $lib"
6661	      test -z "$DESTDIR" && need_relink=yes
6662	    fi
6663	    ;;
6664	  esac
6665	  # This is a shared library
6666
6667	  # Warn about portability, can't link against -module's on some
6668	  # systems (darwin).  Don't bleat about dlopened modules though!
6669	  dlopenmodule=""
6670	  for dlpremoduletest in $dlprefiles; do
6671	    if test "X$dlpremoduletest" = "X$lib"; then
6672	      dlopenmodule="$dlpremoduletest"
6673	      break
6674	    fi
6675	  done
6676	  if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
6677	    echo
6678	    if test "$linkmode" = prog; then
6679	      $ECHO "*** Warning: Linking the executable $output against the loadable module"
6680	    else
6681	      $ECHO "*** Warning: Linking the shared library $output against the loadable module"
6682	    fi
6683	    $ECHO "*** $linklib is not portable!"
6684	  fi
6685	  if test "$linkmode" = lib &&
6686	     test "$hardcode_into_libs" = yes; then
6687	    # Hardcode the library path.
6688	    # Skip directories that are in the system default run-time
6689	    # search path.
6690	    case " $sys_lib_dlsearch_path " in
6691	    *" $absdir "*) ;;
6692	    *)
6693	      case "$compile_rpath " in
6694	      *" $absdir "*) ;;
6695	      *) func_append compile_rpath " $absdir" ;;
6696	      esac
6697	      ;;
6698	    esac
6699	    case " $sys_lib_dlsearch_path " in
6700	    *" $libdir "*) ;;
6701	    *)
6702	      case "$finalize_rpath " in
6703	      *" $libdir "*) ;;
6704	      *) func_append finalize_rpath " $libdir" ;;
6705	      esac
6706	      ;;
6707	    esac
6708	  fi
6709
6710	  if test -n "$old_archive_from_expsyms_cmds"; then
6711	    # figure out the soname
6712	    set dummy $library_names
6713	    shift
6714	    realname="$1"
6715	    shift
6716	    libname=`eval "\\$ECHO \"$libname_spec\""`
6717	    # use dlname if we got it. it's perfectly good, no?
6718	    if test -n "$dlname"; then
6719	      soname="$dlname"
6720	    elif test -n "$soname_spec"; then
6721	      # bleh windows
6722	      case $host in
6723	      *cygwin* | mingw* | *cegcc*)
6724	        func_arith $current - $age
6725		major=$func_arith_result
6726		versuffix="-$major"
6727		;;
6728	      esac
6729	      eval soname=\"$soname_spec\"
6730	    else
6731	      soname="$realname"
6732	    fi
6733
6734	    # Make a new name for the extract_expsyms_cmds to use
6735	    soroot="$soname"
6736	    func_basename "$soroot"
6737	    soname="$func_basename_result"
6738	    func_stripname 'lib' '.dll' "$soname"
6739	    newlib=libimp-$func_stripname_result.a
6740
6741	    # If the library has no export list, then create one now
6742	    if test -f "$output_objdir/$soname-def"; then :
6743	    else
6744	      func_verbose "extracting exported symbol list from \`$soname'"
6745	      func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
6746	    fi
6747
6748	    # Create $newlib
6749	    if test -f "$output_objdir/$newlib"; then :; else
6750	      func_verbose "generating import library for \`$soname'"
6751	      func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
6752	    fi
6753	    # make sure the library variables are pointing to the new library
6754	    dir=$output_objdir
6755	    linklib=$newlib
6756	  fi # test -n "$old_archive_from_expsyms_cmds"
6757
6758	  if test "$linkmode" = prog || test "$opt_mode" != relink; then
6759	    add_shlibpath=
6760	    add_dir=
6761	    add=
6762	    lib_linked=yes
6763	    case $hardcode_action in
6764	    immediate | unsupported)
6765	      if test "$hardcode_direct" = no; then
6766		add="$dir/$linklib"
6767		case $host in
6768		  *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
6769		  *-*-sysv4*uw2*) add_dir="-L$dir" ;;
6770		  *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
6771		    *-*-unixware7*) add_dir="-L$dir" ;;
6772		  *-*-darwin* )
6773		    # if the lib is a (non-dlopened) module then we can not
6774		    # link against it, someone is ignoring the earlier warnings
6775		    if /usr/bin/file -L $add 2> /dev/null |
6776			 $GREP ": [^:]* bundle" >/dev/null ; then
6777		      if test "X$dlopenmodule" != "X$lib"; then
6778			$ECHO "*** Warning: lib $linklib is a module, not a shared library"
6779			if test -z "$old_library" ; then
6780			  echo
6781			  echo "*** And there doesn't seem to be a static archive available"
6782			  echo "*** The link will probably fail, sorry"
6783			else
6784			  add="$dir/$old_library"
6785			fi
6786		      elif test -n "$old_library"; then
6787			add="$dir/$old_library"
6788		      fi
6789		    fi
6790		esac
6791	      elif test "$hardcode_minus_L" = no; then
6792		case $host in
6793		*-*-sunos*) add_shlibpath="$dir" ;;
6794		esac
6795		add_dir="-L$dir"
6796		add="-l$name"
6797	      elif test "$hardcode_shlibpath_var" = no; then
6798		add_shlibpath="$dir"
6799		add="-l$name"
6800	      else
6801		lib_linked=no
6802	      fi
6803	      ;;
6804	    relink)
6805	      if test "$hardcode_direct" = yes &&
6806	         test "$hardcode_direct_absolute" = no; then
6807		add="$dir/$linklib"
6808	      elif test "$hardcode_minus_L" = yes; then
6809		add_dir="-L$absdir"
6810		# Try looking first in the location we're being installed to.
6811		if test -n "$inst_prefix_dir"; then
6812		  case $libdir in
6813		    [\\/]*)
6814		      func_append add_dir " -L$inst_prefix_dir$libdir"
6815		      ;;
6816		  esac
6817		fi
6818		add="-l$name"
6819	      elif test "$hardcode_shlibpath_var" = yes; then
6820		add_shlibpath="$dir"
6821		add="-l$name"
6822	      else
6823		lib_linked=no
6824	      fi
6825	      ;;
6826	    *) lib_linked=no ;;
6827	    esac
6828
6829	    if test "$lib_linked" != yes; then
6830	      func_fatal_configuration "unsupported hardcode properties"
6831	    fi
6832
6833	    if test -n "$add_shlibpath"; then
6834	      case :$compile_shlibpath: in
6835	      *":$add_shlibpath:"*) ;;
6836	      *) func_append compile_shlibpath "$add_shlibpath:" ;;
6837	      esac
6838	    fi
6839	    if test "$linkmode" = prog; then
6840	      test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
6841	      test -n "$add" && compile_deplibs="$add $compile_deplibs"
6842	    else
6843	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
6844	      test -n "$add" && deplibs="$add $deplibs"
6845	      if test "$hardcode_direct" != yes &&
6846		 test "$hardcode_minus_L" != yes &&
6847		 test "$hardcode_shlibpath_var" = yes; then
6848		case :$finalize_shlibpath: in
6849		*":$libdir:"*) ;;
6850		*) func_append finalize_shlibpath "$libdir:" ;;
6851		esac
6852	      fi
6853	    fi
6854	  fi
6855
6856	  if test "$linkmode" = prog || test "$opt_mode" = relink; then
6857	    add_shlibpath=
6858	    add_dir=
6859	    add=
6860	    # Finalize command for both is simple: just hardcode it.
6861	    if test "$hardcode_direct" = yes &&
6862	       test "$hardcode_direct_absolute" = no; then
6863	      add="$libdir/$linklib"
6864	    elif test "$hardcode_minus_L" = yes; then
6865	      add_dir="-L$libdir"
6866	      add="-l$name"
6867	    elif test "$hardcode_shlibpath_var" = yes; then
6868	      case :$finalize_shlibpath: in
6869	      *":$libdir:"*) ;;
6870	      *) func_append finalize_shlibpath "$libdir:" ;;
6871	      esac
6872	      add="-l$name"
6873	    elif test "$hardcode_automatic" = yes; then
6874	      if test -n "$inst_prefix_dir" &&
6875		 test -f "$inst_prefix_dir$libdir/$linklib" ; then
6876		add="$inst_prefix_dir$libdir/$linklib"
6877	      else
6878		add="$libdir/$linklib"
6879	      fi
6880	    else
6881	      # We cannot seem to hardcode it, guess we'll fake it.
6882	      add_dir="-L$libdir"
6883	      # Try looking first in the location we're being installed to.
6884	      if test -n "$inst_prefix_dir"; then
6885		case $libdir in
6886		  [\\/]*)
6887		    func_append add_dir " -L$inst_prefix_dir$libdir"
6888		    ;;
6889		esac
6890	      fi
6891	      add="-l$name"
6892	    fi
6893
6894	    if test "$linkmode" = prog; then
6895	      test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
6896	      test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
6897	    else
6898	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
6899	      test -n "$add" && deplibs="$add $deplibs"
6900	    fi
6901	  fi
6902	elif test "$linkmode" = prog; then
6903	  # Here we assume that one of hardcode_direct or hardcode_minus_L
6904	  # is not unsupported.  This is valid on all known static and
6905	  # shared platforms.
6906	  if test "$hardcode_direct" != unsupported; then
6907	    test -n "$old_library" && linklib="$old_library"
6908	    compile_deplibs="$dir/$linklib $compile_deplibs"
6909	    finalize_deplibs="$dir/$linklib $finalize_deplibs"
6910	  else
6911	    compile_deplibs="-l$name -L$dir $compile_deplibs"
6912	    finalize_deplibs="-l$name -L$dir $finalize_deplibs"
6913	  fi
6914	elif test "$build_libtool_libs" = yes; then
6915	  # Not a shared library
6916	  if test "$deplibs_check_method" != pass_all; then
6917	    # We're trying link a shared library against a static one
6918	    # but the system doesn't support it.
6919
6920	    # Just print a warning and add the library to dependency_libs so
6921	    # that the program can be linked against the static library.
6922	    echo
6923	    $ECHO "*** Warning: This system can not link to static lib archive $lib."
6924	    echo "*** I have the capability to make that library automatically link in when"
6925	    echo "*** you link to this library.  But I can only do this if you have a"
6926	    echo "*** shared version of the library, which you do not appear to have."
6927	    if test "$module" = yes; then
6928	      echo "*** But as you try to build a module library, libtool will still create "
6929	      echo "*** a static module, that should work as long as the dlopening application"
6930	      echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
6931	      if test -z "$global_symbol_pipe"; then
6932		echo
6933		echo "*** However, this would only work if libtool was able to extract symbol"
6934		echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
6935		echo "*** not find such a program.  So, this module is probably useless."
6936		echo "*** \`nm' from GNU binutils and a full rebuild may help."
6937	      fi
6938	      if test "$build_old_libs" = no; then
6939		build_libtool_libs=module
6940		build_old_libs=yes
6941	      else
6942		build_libtool_libs=no
6943	      fi
6944	    fi
6945	  else
6946	    deplibs="$dir/$old_library $deplibs"
6947	    link_static=yes
6948	  fi
6949	fi # link shared/static library?
6950
6951	if test "$linkmode" = lib; then
6952	  if test -n "$dependency_libs" &&
6953	     { test "$hardcode_into_libs" != yes ||
6954	       test "$build_old_libs" = yes ||
6955	       test "$link_static" = yes; }; then
6956	    # Extract -R from dependency_libs
6957	    temp_deplibs=
6958	    for libdir in $dependency_libs; do
6959	      case $libdir in
6960	      -R*) func_stripname '-R' '' "$libdir"
6961	           temp_xrpath=$func_stripname_result
6962		   case " $xrpath " in
6963		   *" $temp_xrpath "*) ;;
6964		   *) func_append xrpath " $temp_xrpath";;
6965		   esac;;
6966	      *) func_append temp_deplibs " $libdir";;
6967	      esac
6968	    done
6969	    dependency_libs="$temp_deplibs"
6970	  fi
6971
6972	  func_append newlib_search_path " $absdir"
6973	  # Link against this library
6974	  test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
6975	  # ... and its dependency_libs
6976	  tmp_libs=
6977	  for deplib in $dependency_libs; do
6978	    newdependency_libs="$deplib $newdependency_libs"
6979	    case $deplib in
6980              -L*) func_stripname '-L' '' "$deplib"
6981                   func_resolve_sysroot "$func_stripname_result";;
6982              *) func_resolve_sysroot "$deplib" ;;
6983            esac
6984	    if $opt_preserve_dup_deps ; then
6985	      case "$tmp_libs " in
6986	      *" $func_resolve_sysroot_result "*)
6987                func_append specialdeplibs " $func_resolve_sysroot_result" ;;
6988	      esac
6989	    fi
6990	    func_append tmp_libs " $func_resolve_sysroot_result"
6991	  done
6992
6993	  if test "$link_all_deplibs" != no; then
6994	    # Add the search paths of all dependency libraries
6995	    for deplib in $dependency_libs; do
6996	      path=
6997	      case $deplib in
6998	      -L*) path="$deplib" ;;
6999	      *.la)
7000	        func_resolve_sysroot "$deplib"
7001	        deplib=$func_resolve_sysroot_result
7002	        func_dirname "$deplib" "" "."
7003		dir=$func_dirname_result
7004		# We need an absolute path.
7005		case $dir in
7006		[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
7007		*)
7008		  absdir=`cd "$dir" && pwd`
7009		  if test -z "$absdir"; then
7010		    func_warning "cannot determine absolute directory name of \`$dir'"
7011		    absdir="$dir"
7012		  fi
7013		  ;;
7014		esac
7015		if $GREP "^installed=no" $deplib > /dev/null; then
7016		case $host in
7017		*-*-darwin*)
7018		  depdepl=
7019		  eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
7020		  if test -n "$deplibrary_names" ; then
7021		    for tmp in $deplibrary_names ; do
7022		      depdepl=$tmp
7023		    done
7024		    if test -f "$absdir/$objdir/$depdepl" ; then
7025		      depdepl="$absdir/$objdir/$depdepl"
7026		      darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
7027                      if test -z "$darwin_install_name"; then
7028                          darwin_install_name=`${OTOOL64} -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
7029                      fi
7030		      func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
7031		      func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"
7032		      path=
7033		    fi
7034		  fi
7035		  ;;
7036		*)
7037		  path="-L$absdir/$objdir"
7038		  ;;
7039		esac
7040		else
7041		  eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
7042		  test -z "$libdir" && \
7043		    func_fatal_error "\`$deplib' is not a valid libtool archive"
7044		  test "$absdir" != "$libdir" && \
7045		    func_warning "\`$deplib' seems to be moved"
7046
7047		  path="-L$absdir"
7048		fi
7049		;;
7050	      esac
7051	      case " $deplibs " in
7052	      *" $path "*) ;;
7053	      *) deplibs="$path $deplibs" ;;
7054	      esac
7055	    done
7056	  fi # link_all_deplibs != no
7057	fi # linkmode = lib
7058      done # for deplib in $libs
7059      if test "$pass" = link; then
7060	if test "$linkmode" = "prog"; then
7061	  compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
7062	  finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
7063	else
7064	  compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7065	fi
7066      fi
7067      dependency_libs="$newdependency_libs"
7068      if test "$pass" = dlpreopen; then
7069	# Link the dlpreopened libraries before other libraries
7070	for deplib in $save_deplibs; do
7071	  deplibs="$deplib $deplibs"
7072	done
7073      fi
7074      if test "$pass" != dlopen; then
7075	if test "$pass" != conv; then
7076	  # Make sure lib_search_path contains only unique directories.
7077	  lib_search_path=
7078	  for dir in $newlib_search_path; do
7079	    case "$lib_search_path " in
7080	    *" $dir "*) ;;
7081	    *) func_append lib_search_path " $dir" ;;
7082	    esac
7083	  done
7084	  newlib_search_path=
7085	fi
7086
7087	if test "$linkmode,$pass" != "prog,link"; then
7088	  vars="deplibs"
7089	else
7090	  vars="compile_deplibs finalize_deplibs"
7091	fi
7092	for var in $vars dependency_libs; do
7093	  # Add libraries to $var in reverse order
7094	  eval tmp_libs=\"\$$var\"
7095	  new_libs=
7096	  for deplib in $tmp_libs; do
7097	    # FIXME: Pedantically, this is the right thing to do, so
7098	    #        that some nasty dependency loop isn't accidentally
7099	    #        broken:
7100	    #new_libs="$deplib $new_libs"
7101	    # Pragmatically, this seems to cause very few problems in
7102	    # practice:
7103	    case $deplib in
7104	    -L*) new_libs="$deplib $new_libs" ;;
7105	    -R*) ;;
7106	    *)
7107	      # And here is the reason: when a library appears more
7108	      # than once as an explicit dependence of a library, or
7109	      # is implicitly linked in more than once by the
7110	      # compiler, it is considered special, and multiple
7111	      # occurrences thereof are not removed.  Compare this
7112	      # with having the same library being listed as a
7113	      # dependency of multiple other libraries: in this case,
7114	      # we know (pedantically, we assume) the library does not
7115	      # need to be listed more than once, so we keep only the
7116	      # last copy.  This is not always right, but it is rare
7117	      # enough that we require users that really mean to play
7118	      # such unportable linking tricks to link the library
7119	      # using -Wl,-lname, so that libtool does not consider it
7120	      # for duplicate removal.
7121	      case " $specialdeplibs " in
7122	      *" $deplib "*) new_libs="$deplib $new_libs" ;;
7123	      *)
7124		case " $new_libs " in
7125		*" $deplib "*) ;;
7126		*) new_libs="$deplib $new_libs" ;;
7127		esac
7128		;;
7129	      esac
7130	      ;;
7131	    esac
7132	  done
7133	  tmp_libs=
7134	  for deplib in $new_libs; do
7135	    case $deplib in
7136	    -L*)
7137	      case " $tmp_libs " in
7138	      *" $deplib "*) ;;
7139	      *) func_append tmp_libs " $deplib" ;;
7140	      esac
7141	      ;;
7142	    *) func_append tmp_libs " $deplib" ;;
7143	    esac
7144	  done
7145	  eval $var=\"$tmp_libs\"
7146	done # for var
7147      fi
7148      # Last step: remove runtime libs from dependency_libs
7149      # (they stay in deplibs)
7150      tmp_libs=
7151      for i in $dependency_libs ; do
7152	case " $predeps $postdeps $compiler_lib_search_path " in
7153	*" $i "*)
7154	  i=""
7155	  ;;
7156	esac
7157	if test -n "$i" ; then
7158	  func_append tmp_libs " $i"
7159	fi
7160      done
7161      dependency_libs=$tmp_libs
7162    done # for pass
7163    if test "$linkmode" = prog; then
7164      dlfiles="$newdlfiles"
7165    fi
7166    if test "$linkmode" = prog || test "$linkmode" = lib; then
7167      dlprefiles="$newdlprefiles"
7168    fi
7169
7170    case $linkmode in
7171    oldlib)
7172      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
7173	func_warning "\`-dlopen' is ignored for archives"
7174      fi
7175
7176      case " $deplibs" in
7177      *\ -l* | *\ -L*)
7178	func_warning "\`-l' and \`-L' are ignored for archives" ;;
7179      esac
7180
7181      test -n "$rpath" && \
7182	func_warning "\`-rpath' is ignored for archives"
7183
7184      test -n "$xrpath" && \
7185	func_warning "\`-R' is ignored for archives"
7186
7187      test -n "$vinfo" && \
7188	func_warning "\`-version-info/-version-number' is ignored for archives"
7189
7190      test -n "$release" && \
7191	func_warning "\`-release' is ignored for archives"
7192
7193      test -n "$export_symbols$export_symbols_regex" && \
7194	func_warning "\`-export-symbols' is ignored for archives"
7195
7196      # Now set the variables for building old libraries.
7197      build_libtool_libs=no
7198      oldlibs="$output"
7199      func_append objs "$old_deplibs"
7200      ;;
7201
7202    lib)
7203      # Make sure we only generate libraries of the form `libNAME.la'.
7204      case $outputname in
7205      lib*)
7206	func_stripname 'lib' '.la' "$outputname"
7207	name=$func_stripname_result
7208	eval shared_ext=\"$shrext_cmds\"
7209	eval libname=\"$libname_spec\"
7210	;;
7211      *)
7212	test "$module" = no && \
7213	  func_fatal_help "libtool library \`$output' must begin with \`lib'"
7214
7215	if test "$need_lib_prefix" != no; then
7216	  # Add the "lib" prefix for modules if required
7217	  func_stripname '' '.la' "$outputname"
7218	  name=$func_stripname_result
7219	  eval shared_ext=\"$shrext_cmds\"
7220	  eval libname=\"$libname_spec\"
7221	else
7222	  func_stripname '' '.la' "$outputname"
7223	  libname=$func_stripname_result
7224	fi
7225	;;
7226      esac
7227
7228      if test -n "$objs"; then
7229	if test "$deplibs_check_method" != pass_all; then
7230	  func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
7231	else
7232	  echo
7233	  $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
7234	  $ECHO "*** objects $objs is not portable!"
7235	  func_append libobjs " $objs"
7236	fi
7237      fi
7238
7239      test "$dlself" != no && \
7240	func_warning "\`-dlopen self' is ignored for libtool libraries"
7241
7242      set dummy $rpath
7243      shift
7244      test "$#" -gt 1 && \
7245	func_warning "ignoring multiple \`-rpath's for a libtool library"
7246
7247      install_libdir="$1"
7248
7249      oldlibs=
7250      if test -z "$rpath"; then
7251	if test "$build_libtool_libs" = yes; then
7252	  # Building a libtool convenience library.
7253	  # Some compilers have problems with a `.al' extension so
7254	  # convenience libraries should have the same extension an
7255	  # archive normally would.
7256	  oldlibs="$output_objdir/$libname.$libext $oldlibs"
7257	  build_libtool_libs=convenience
7258	  build_old_libs=yes
7259	fi
7260
7261	test -n "$vinfo" && \
7262	  func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
7263
7264	test -n "$release" && \
7265	  func_warning "\`-release' is ignored for convenience libraries"
7266      else
7267
7268	# Parse the version information argument.
7269	save_ifs="$IFS"; IFS=':'
7270	set dummy $vinfo 0 0 0
7271	shift
7272	IFS="$save_ifs"
7273
7274	test -n "$7" && \
7275	  func_fatal_help "too many parameters to \`-version-info'"
7276
7277	# convert absolute version numbers to libtool ages
7278	# this retains compatibility with .la files and attempts
7279	# to make the code below a bit more comprehensible
7280
7281	case $vinfo_number in
7282	yes)
7283	  number_major="$1"
7284	  number_minor="$2"
7285	  number_revision="$3"
7286	  #
7287	  # There are really only two kinds -- those that
7288	  # use the current revision as the major version
7289	  # and those that subtract age and use age as
7290	  # a minor version.  But, then there is irix
7291	  # which has an extra 1 added just for fun
7292	  #
7293	  case $version_type in
7294	  # correct linux to gnu/linux during the next big refactor
7295	  darwin|linux|osf|windows|none)
7296	    func_arith $number_major + $number_minor
7297	    current=$func_arith_result
7298	    age="$number_minor"
7299	    revision="$number_revision"
7300	    ;;
7301	  freebsd-aout|freebsd-elf|qnx|sunos)
7302	    current="$number_major"
7303	    revision="$number_minor"
7304	    age="0"
7305	    ;;
7306	  irix|nonstopux)
7307	    func_arith $number_major + $number_minor
7308	    current=$func_arith_result
7309	    age="$number_minor"
7310	    revision="$number_minor"
7311	    lt_irix_increment=no
7312	    ;;
7313	  esac
7314	  ;;
7315	no)
7316	  current="$1"
7317	  revision="$2"
7318	  age="$3"
7319	  ;;
7320	esac
7321
7322	# Check that each of the things are valid numbers.
7323	case $current in
7324	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]) ;;
7325	*)
7326	  func_error "CURRENT \`$current' must be a nonnegative integer"
7327	  func_fatal_error "\`$vinfo' is not valid version information"
7328	  ;;
7329	esac
7330
7331	case $revision in
7332	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]) ;;
7333	*)
7334	  func_error "REVISION \`$revision' must be a nonnegative integer"
7335	  func_fatal_error "\`$vinfo' is not valid version information"
7336	  ;;
7337	esac
7338
7339	case $age in
7340	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]) ;;
7341	*)
7342	  func_error "AGE \`$age' must be a nonnegative integer"
7343	  func_fatal_error "\`$vinfo' is not valid version information"
7344	  ;;
7345	esac
7346
7347	if test "$age" -gt "$current"; then
7348	  func_error "AGE \`$age' is greater than the current interface number \`$current'"
7349	  func_fatal_error "\`$vinfo' is not valid version information"
7350	fi
7351
7352	# Calculate the version variables.
7353	major=
7354	versuffix=
7355	verstring=
7356	case $version_type in
7357	none) ;;
7358
7359	darwin)
7360	  # Like Linux, but with the current version available in
7361	  # verstring for coding it into the library header
7362	  func_arith $current - $age
7363	  major=.$func_arith_result
7364	  versuffix="$major.$age.$revision"
7365	  # Darwin ld doesn't like 0 for these options...
7366	  func_arith $current + 1
7367	  minor_current=$func_arith_result
7368	  xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
7369	  verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
7370	  ;;
7371
7372	freebsd-aout)
7373	  major=".$current"
7374	  versuffix=".$current.$revision";
7375	  ;;
7376
7377	freebsd-elf)
7378	  major=".$current"
7379	  versuffix=".$current"
7380	  ;;
7381
7382	irix | nonstopux)
7383	  if test "X$lt_irix_increment" = "Xno"; then
7384	    func_arith $current - $age
7385	  else
7386	    func_arith $current - $age + 1
7387	  fi
7388	  major=$func_arith_result
7389
7390	  case $version_type in
7391	    nonstopux) verstring_prefix=nonstopux ;;
7392	    *)         verstring_prefix=sgi ;;
7393	  esac
7394	  verstring="$verstring_prefix$major.$revision"
7395
7396	  # Add in all the interfaces that we are compatible with.
7397	  loop=$revision
7398	  while test "$loop" -ne 0; do
7399	    func_arith $revision - $loop
7400	    iface=$func_arith_result
7401	    func_arith $loop - 1
7402	    loop=$func_arith_result
7403	    verstring="$verstring_prefix$major.$iface:$verstring"
7404	  done
7405
7406	  # Before this point, $major must not contain `.'.
7407	  major=.$major
7408	  versuffix="$major.$revision"
7409	  ;;
7410
7411	linux) # correct to gnu/linux during the next big refactor
7412	  func_arith $current - $age
7413	  major=.$func_arith_result
7414	  versuffix="$major.$age.$revision"
7415	  ;;
7416
7417	osf)
7418	  func_arith $current - $age
7419	  major=.$func_arith_result
7420	  versuffix=".$current.$age.$revision"
7421	  verstring="$current.$age.$revision"
7422
7423	  # Add in all the interfaces that we are compatible with.
7424	  loop=$age
7425	  while test "$loop" -ne 0; do
7426	    func_arith $current - $loop
7427	    iface=$func_arith_result
7428	    func_arith $loop - 1
7429	    loop=$func_arith_result
7430	    verstring="$verstring:${iface}.0"
7431	  done
7432
7433	  # Make executables depend on our current version.
7434	  func_append verstring ":${current}.0"
7435	  ;;
7436
7437	qnx)
7438	  major=".$current"
7439	  versuffix=".$current"
7440	  ;;
7441
7442	sunos)
7443	  major=".$current"
7444	  versuffix=".$current.$revision"
7445	  ;;
7446
7447	windows)
7448	  # Use '-' rather than '.', since we only want one
7449	  # extension on DOS 8.3 filesystems.
7450	  func_arith $current - $age
7451	  major=$func_arith_result
7452	  versuffix="-$major"
7453	  ;;
7454
7455	*)
7456	  func_fatal_configuration "unknown library version type \`$version_type'"
7457	  ;;
7458	esac
7459
7460	# Clear the version info if we defaulted, and they specified a release.
7461	if test -z "$vinfo" && test -n "$release"; then
7462	  major=
7463	  case $version_type in
7464	  darwin)
7465	    # we can't check for "0.0" in archive_cmds due to quoting
7466	    # problems, so we reset it completely
7467	    verstring=
7468	    ;;
7469	  *)
7470	    verstring="0.0"
7471	    ;;
7472	  esac
7473	  if test "$need_version" = no; then
7474	    versuffix=
7475	  else
7476	    versuffix=".0.0"
7477	  fi
7478	fi
7479
7480	# Remove version info from name if versioning should be avoided
7481	if test "$avoid_version" = yes && test "$need_version" = no; then
7482	  major=
7483	  versuffix=
7484	  verstring=""
7485	else
7486	  # XXX
7487	  tmp=`echo $libname|sed -e 's,+,_,g' -e 's,-,_,g' -e 's,\.,_,g'`
7488	  eval tmp2=\$${tmp}_ltversion
7489	  if ! test -z "${SHARED_LIBS_LOG}"; then
7490		  if ! test -f ${SHARED_LIBS_LOG}; then
7491			  echo "# SHARED_LIBS+=	<libname>      <obsd version> # <orig version>" >${SHARED_LIBS_LOG}
7492		  fi
7493		  tmp4=`echo $libname|sed -e 's/^lib//'`
7494		  printf "SHARED_LIBS +=\t%-20s %-8s # %s\n" "$tmp4" "$tmp2" "$versuffix" >>${SHARED_LIBS_LOG}
7495	  fi
7496	  if test -n "$versuffix" && test -n "$tmp2"; then
7497	    versuffix=".$tmp2"
7498	  fi
7499	fi
7500
7501	# Check to see if the archive will have undefined symbols.
7502	if test "$allow_undefined" = yes; then
7503	  if test "$allow_undefined_flag" = unsupported; then
7504	    func_warning "undefined symbols not allowed in $host shared libraries"
7505	    build_libtool_libs=no
7506	    build_old_libs=yes
7507	  fi
7508	else
7509	  # Don't allow undefined symbols.
7510	  allow_undefined_flag="$no_undefined_flag"
7511	fi
7512
7513      fi
7514
7515      func_generate_dlsyms "$libname" "$libname" "yes"
7516      func_append libobjs " $symfileobj"
7517      test "X$libobjs" = "X " && libobjs=
7518
7519      if test "$opt_mode" != relink; then
7520	# Remove our outputs, but don't remove object files since they
7521	# may have been created when compiling PIC objects.
7522	removelist=
7523	tempremovelist=`$ECHO "$output_objdir/*"`
7524	for p in $tempremovelist; do
7525	  case $p in
7526	    *.$objext | *.gcno)
7527	       ;;
7528	    $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
7529	       if test "X$precious_files_regex" != "X"; then
7530		 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
7531		 then
7532		   continue
7533		 fi
7534	       fi
7535	       func_append removelist " $p"
7536	       ;;
7537	    *) ;;
7538	  esac
7539	done
7540	test -n "$removelist" && \
7541	  func_show_eval "${RM}r \$removelist"
7542      fi
7543
7544      # Now set the variables for building old libraries.
7545      if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
7546	func_append oldlibs " $output_objdir/$libname.$libext"
7547
7548	# Transform .lo files to .o files.
7549	oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
7550      fi
7551
7552      # Eliminate all temporary directories.
7553      #for path in $notinst_path; do
7554      #	lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
7555      #	deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
7556      #	dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
7557      #done
7558
7559      if test -n "$xrpath"; then
7560	# If the user specified any rpath flags, then add them.
7561	temp_xrpath=
7562	for libdir in $xrpath; do
7563	  func_replace_sysroot "$libdir"
7564	  func_append temp_xrpath " -R$func_replace_sysroot_result"
7565	  case "$finalize_rpath " in
7566	  *" $libdir "*) ;;
7567	  *) func_append finalize_rpath " $libdir" ;;
7568	  esac
7569	done
7570	if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
7571	  dependency_libs="$temp_xrpath $dependency_libs"
7572	fi
7573      fi
7574
7575      # Make sure dlfiles contains only unique files that won't be dlpreopened
7576      old_dlfiles="$dlfiles"
7577      dlfiles=
7578      for lib in $old_dlfiles; do
7579	case " $dlprefiles $dlfiles " in
7580	*" $lib "*) ;;
7581	*) func_append dlfiles " $lib" ;;
7582	esac
7583      done
7584
7585      # Make sure dlprefiles contains only unique files
7586      old_dlprefiles="$dlprefiles"
7587      dlprefiles=
7588      for lib in $old_dlprefiles; do
7589	case "$dlprefiles " in
7590	*" $lib "*) ;;
7591	*) func_append dlprefiles " $lib" ;;
7592	esac
7593      done
7594
7595      if test "$build_libtool_libs" = yes; then
7596	if test -n "$rpath"; then
7597	  case $host in
7598	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
7599	    # these systems don't actually have a c library (as such)!
7600	    ;;
7601	  *-*-rhapsody* | *-*-darwin1.[012])
7602	    # Rhapsody C library is in the System framework
7603	    func_append deplibs " System.ltframework"
7604	    ;;
7605	  *-*-netbsd*)
7606	    # Don't link with libc until the a.out ld.so is fixed.
7607	    ;;
7608	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
7609	    # Do not include libc due to us having libc/libc_r.
7610	    ;;
7611	  *-*-sco3.2v5* | *-*-sco5v6*)
7612	    # Causes problems with __ctype
7613	    ;;
7614	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
7615	    # Compiler inserts libc in the correct place for threads to work
7616	    ;;
7617	  *)
7618	    # Add libc to deplibs on all other systems if necessary.
7619	    if test "$build_libtool_need_lc" = "yes"; then
7620	      func_append deplibs " -lc"
7621	    fi
7622	    ;;
7623	  esac
7624	fi
7625
7626	# Transform deplibs into only deplibs that can be linked in shared.
7627	name_save=$name
7628	libname_save=$libname
7629	release_save=$release
7630	versuffix_save=$versuffix
7631	major_save=$major
7632	# I'm not sure if I'm treating the release correctly.  I think
7633	# release should show up in the -l (ie -lgmp5) so we don't want to
7634	# add it in twice.  Is that correct?
7635	release=""
7636	versuffix=""
7637	major=""
7638	newdeplibs=
7639	droppeddeps=no
7640	case $deplibs_check_method in
7641	pass_all)
7642	  # Don't check for shared/static.  Everything works.
7643	  # This might be a little naive.  We might want to check
7644	  # whether the library exists or not.  But this is on
7645	  # osf3 & osf4 and I'm not really sure... Just
7646	  # implementing what was already the behavior.
7647	  newdeplibs=$deplibs
7648	  ;;
7649	test_compile)
7650	  # This code stresses the "libraries are programs" paradigm to its
7651	  # limits. Maybe even breaks it.  We compile a program, linking it
7652	  # against the deplibs as a proxy for the library.  Then we can check
7653	  # whether they linked in statically or dynamically with ldd.
7654	  $opt_dry_run || $RM conftest.c
7655	  cat > conftest.c <<EOF
7656	  int main() { return 0; }
7657EOF
7658	  $opt_dry_run || $RM conftest
7659	  if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
7660	    ldd_output=`ldd conftest`
7661	    for i in $deplibs; do
7662	      case $i in
7663	      -l*)
7664		func_stripname -l '' "$i"
7665		name=$func_stripname_result
7666		if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7667		  case " $predeps $postdeps " in
7668		  *" $i "*)
7669		    func_append newdeplibs " $i"
7670		    i=""
7671		    ;;
7672		  esac
7673		fi
7674		if test -n "$i" ; then
7675		  libname=`eval "\\$ECHO \"$libname_spec\""`
7676		  deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7677		  set dummy $deplib_matches; shift
7678		  deplib_match=$1
7679		  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7680		    func_append newdeplibs " $i"
7681		  else
7682		    droppeddeps=yes
7683		    echo
7684		    $ECHO "*** Warning: dynamic linker does not accept needed library $i."
7685		    echo "*** I have the capability to make that library automatically link in when"
7686		    echo "*** you link to this library.  But I can only do this if you have a"
7687		    echo "*** shared version of the library, which I believe you do not have"
7688		    echo "*** because a test_compile did reveal that the linker did not use it for"
7689		    echo "*** its dynamic dependency list that programs get resolved with at runtime."
7690		  fi
7691		fi
7692		;;
7693	      *)
7694		func_append newdeplibs " $i"
7695		;;
7696	      esac
7697	    done
7698	  else
7699	    # Error occurred in the first compile.  Let's try to salvage
7700	    # the situation: Compile a separate program for each library.
7701	    for i in $deplibs; do
7702	      case $i in
7703	      -l*)
7704		func_stripname -l '' "$i"
7705		name=$func_stripname_result
7706		$opt_dry_run || $RM conftest
7707		if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
7708		  ldd_output=`ldd conftest`
7709		  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7710		    case " $predeps $postdeps " in
7711		    *" $i "*)
7712		      func_append newdeplibs " $i"
7713		      i=""
7714		      ;;
7715		    esac
7716		  fi
7717		  if test -n "$i" ; then
7718		    libname=`eval "\\$ECHO \"$libname_spec\""`
7719		    deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7720		    set dummy $deplib_matches; shift
7721		    deplib_match=$1
7722		    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7723		      func_append newdeplibs " $i"
7724		    else
7725		      droppeddeps=yes
7726		      echo
7727		      $ECHO "*** Warning: dynamic linker does not accept needed library $i."
7728		      echo "*** I have the capability to make that library automatically link in when"
7729		      echo "*** you link to this library.  But I can only do this if you have a"
7730		      echo "*** shared version of the library, which you do not appear to have"
7731		      echo "*** because a test_compile did reveal that the linker did not use this one"
7732		      echo "*** as a dynamic dependency that programs can get resolved with at runtime."
7733		    fi
7734		  fi
7735		else
7736		  droppeddeps=yes
7737		  echo
7738		  $ECHO "*** Warning!  Library $i is needed by this library but I was not able to"
7739		  echo "*** make it link in!  You will probably need to install it or some"
7740		  echo "*** library that it depends on before this library will be fully"
7741		  echo "*** functional.  Installing it before continuing would be even better."
7742		fi
7743		;;
7744	      *)
7745		func_append newdeplibs " $i"
7746		;;
7747	      esac
7748	    done
7749	  fi
7750	  ;;
7751	file_magic*)
7752	  set dummy $deplibs_check_method; shift
7753	  file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7754	  for a_deplib in $deplibs; do
7755	    case $a_deplib in
7756	    -l*)
7757	      func_stripname -l '' "$a_deplib"
7758	      name=$func_stripname_result
7759	      if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7760		case " $predeps $postdeps " in
7761		*" $a_deplib "*)
7762		  func_append newdeplibs " $a_deplib"
7763		  a_deplib=""
7764		  ;;
7765		esac
7766	      fi
7767	      if test -n "$a_deplib" ; then
7768		libname=`eval "\\$ECHO \"$libname_spec\""`
7769		if test -n "$file_magic_glob"; then
7770		  libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
7771		else
7772		  libnameglob=$libname
7773		fi
7774		test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`
7775		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7776		  if test "$want_nocaseglob" = yes; then
7777		    shopt -s nocaseglob
7778		    potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
7779		    $nocaseglob
7780		  else
7781		    potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
7782		  fi
7783		  for potent_lib in $potential_libs; do
7784		      # Follow soft links.
7785		      if ls -lLd "$potent_lib" 2>/dev/null |
7786			 $GREP " -> " >/dev/null; then
7787			continue
7788		      fi
7789		      # The statement above tries to avoid entering an
7790		      # endless loop below, in case of cyclic links.
7791		      # We might still enter an endless loop, since a link
7792		      # loop can be closed while we follow links,
7793		      # but so what?
7794		      potlib="$potent_lib"
7795		      while test -h "$potlib" 2>/dev/null; do
7796			potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
7797			case $potliblink in
7798			[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
7799			*) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
7800			esac
7801		      done
7802		      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
7803			 $SED -e 10q |
7804			 $EGREP "$file_magic_regex" > /dev/null; then
7805			func_append newdeplibs " $a_deplib"
7806			a_deplib=""
7807			break 2
7808		      fi
7809		  done
7810		done
7811	      fi
7812	      if test -n "$a_deplib" ; then
7813		droppeddeps=yes
7814		echo
7815		$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7816		echo "*** I have the capability to make that library automatically link in when"
7817		echo "*** you link to this library.  But I can only do this if you have a"
7818		echo "*** shared version of the library, which you do not appear to have"
7819		echo "*** because I did check the linker path looking for a file starting"
7820		if test -z "$potlib" ; then
7821		  $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
7822		else
7823		  $ECHO "*** with $libname and none of the candidates passed a file format test"
7824		  $ECHO "*** using a file magic. Last file checked: $potlib"
7825		fi
7826	      fi
7827	      ;;
7828	    *)
7829	      # Add a -L argument.
7830	      func_append newdeplibs " $a_deplib"
7831	      ;;
7832	    esac
7833	  done # Gone through all deplibs.
7834	  ;;
7835	match_pattern*)
7836	  set dummy $deplibs_check_method; shift
7837	  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7838	  for a_deplib in $deplibs; do
7839	    case $a_deplib in
7840	    -l*)
7841	      func_stripname -l '' "$a_deplib"
7842	      name=$func_stripname_result
7843	      if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7844		case " $predeps $postdeps " in
7845		*" $a_deplib "*)
7846		  func_append newdeplibs " $a_deplib"
7847		  a_deplib=""
7848		  ;;
7849		esac
7850	      fi
7851	      if test -n "$a_deplib" ; then
7852		libname=`eval "\\$ECHO \"$libname_spec\""`
7853		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7854		  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
7855		  for potent_lib in $potential_libs; do
7856		    potlib="$potent_lib" # see symlink-check above in file_magic test
7857		    if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
7858		       $EGREP "$match_pattern_regex" > /dev/null; then
7859		      func_append newdeplibs " $a_deplib"
7860		      a_deplib=""
7861		      break 2
7862		    fi
7863		  done
7864		done
7865	      fi
7866	      if test -n "$a_deplib" ; then
7867		droppeddeps=yes
7868		echo
7869		$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7870		echo "*** I have the capability to make that library automatically link in when"
7871		echo "*** you link to this library.  But I can only do this if you have a"
7872		echo "*** shared version of the library, which you do not appear to have"
7873		echo "*** because I did check the linker path looking for a file starting"
7874		if test -z "$potlib" ; then
7875		  $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
7876		else
7877		  $ECHO "*** with $libname and none of the candidates passed a file format test"
7878		  $ECHO "*** using a regex pattern. Last file checked: $potlib"
7879		fi
7880	      fi
7881	      ;;
7882	    *)
7883	      # Add a -L argument.
7884	      func_append newdeplibs " $a_deplib"
7885	      ;;
7886	    esac
7887	  done # Gone through all deplibs.
7888	  ;;
7889	none | unknown | *)
7890	  newdeplibs=""
7891	  tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
7892	  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7893	    for i in $predeps $postdeps ; do
7894	      # can't use Xsed below, because $i might contain '/'
7895	      tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
7896	    done
7897	  fi
7898	  case $tmp_deplibs in
7899	  *[!\	\ ]*)
7900	    echo
7901	    if test "X$deplibs_check_method" = "Xnone"; then
7902	      echo "*** Warning: inter-library dependencies are not supported in this platform."
7903	    else
7904	      echo "*** Warning: inter-library dependencies are not known to be supported."
7905	    fi
7906	    echo "*** All declared inter-library dependencies are being dropped."
7907	    droppeddeps=yes
7908	    ;;
7909	  esac
7910	  ;;
7911	esac
7912	versuffix=$versuffix_save
7913	major=$major_save
7914	release=$release_save
7915	libname=$libname_save
7916	name=$name_save
7917
7918	case $host in
7919	*-*-rhapsody* | *-*-darwin1.[012])
7920	  # On Rhapsody replace the C library with the System framework
7921	  newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
7922	  ;;
7923	esac
7924
7925	if test "$droppeddeps" = yes; then
7926	  if test "$module" = yes; then
7927	    echo
7928	    echo "*** Warning: libtool could not satisfy all declared inter-library"
7929	    $ECHO "*** dependencies of module $libname.  Therefore, libtool will create"
7930	    echo "*** a static module, that should work as long as the dlopening"
7931	    echo "*** application is linked with the -dlopen flag."
7932	    if test -z "$global_symbol_pipe"; then
7933	      echo
7934	      echo "*** However, this would only work if libtool was able to extract symbol"
7935	      echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
7936	      echo "*** not find such a program.  So, this module is probably useless."
7937	      echo "*** \`nm' from GNU binutils and a full rebuild may help."
7938	    fi
7939	    if test "$build_old_libs" = no; then
7940	      oldlibs="$output_objdir/$libname.$libext"
7941	      build_libtool_libs=module
7942	      build_old_libs=yes
7943	    else
7944	      build_libtool_libs=no
7945	    fi
7946	  else
7947	    echo "*** The inter-library dependencies that have been dropped here will be"
7948	    echo "*** automatically added whenever a program is linked with this library"
7949	    echo "*** or is declared to -dlopen it."
7950
7951	    if test "$allow_undefined" = no; then
7952	      echo
7953	      echo "*** Since this library must not contain undefined symbols,"
7954	      echo "*** because either the platform does not support them or"
7955	      echo "*** it was explicitly requested with -no-undefined,"
7956	      echo "*** libtool will only create a static version of it."
7957	      if test "$build_old_libs" = no; then
7958		oldlibs="$output_objdir/$libname.$libext"
7959		build_libtool_libs=module
7960		build_old_libs=yes
7961	      else
7962		build_libtool_libs=no
7963	      fi
7964	    fi
7965	  fi
7966	fi
7967	# Done checking deplibs!
7968	deplibs=$newdeplibs
7969      fi
7970      # Time to change all our "foo.ltframework" stuff back to "-framework foo"
7971      case $host in
7972	*-*-darwin*)
7973	  newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7974	  new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7975	  deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7976	  ;;
7977      esac
7978
7979      # move library search paths that coincide with paths to not yet
7980      # installed libraries to the beginning of the library search list
7981      new_libs=
7982      for path in $notinst_path; do
7983	case " $new_libs " in
7984	*" -L$path/$objdir "*) ;;
7985	*)
7986	  case " $deplibs " in
7987	  *" -L$path/$objdir "*)
7988	    func_append new_libs " -L$path/$objdir" ;;
7989	  esac
7990	  ;;
7991	esac
7992      done
7993      for deplib in $deplibs; do
7994	case $deplib in
7995	-L*)
7996	  case " $new_libs " in
7997	  *" $deplib "*) ;;
7998	  *) func_append new_libs " $deplib" ;;
7999	  esac
8000	  ;;
8001	*) func_append new_libs " $deplib" ;;
8002	esac
8003      done
8004      deplibs="$new_libs"
8005
8006      # All the library-specific variables (install_libdir is set above).
8007      library_names=
8008      old_library=
8009      dlname=
8010
8011      # Test again, we may have decided not to build it any more
8012      if test "$build_libtool_libs" = yes; then
8013	# Remove ${wl} instances when linking with ld.
8014	# FIXME: should test the right _cmds variable.
8015	case $archive_cmds in
8016	  *\$LD\ *) wl= ;;
8017        esac
8018	if test "$hardcode_into_libs" = yes; then
8019	  # Hardcode the library paths
8020	  hardcode_libdirs=
8021	  dep_rpath=
8022	  rpath="$finalize_rpath"
8023	  test "$opt_mode" != relink && rpath="$compile_rpath$rpath"
8024	  for libdir in $rpath; do
8025	    if test -n "$hardcode_libdir_flag_spec"; then
8026	      if test -n "$hardcode_libdir_separator"; then
8027		func_replace_sysroot "$libdir"
8028		libdir=$func_replace_sysroot_result
8029		if test -z "$hardcode_libdirs"; then
8030		  hardcode_libdirs="$libdir"
8031		else
8032		  # Just accumulate the unique libdirs.
8033		  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8034		  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8035		    ;;
8036		  *)
8037		    func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8038		    ;;
8039		  esac
8040		fi
8041	      else
8042		eval flag=\"$hardcode_libdir_flag_spec\"
8043		func_append dep_rpath " $flag"
8044	      fi
8045	    elif test -n "$runpath_var"; then
8046	      case "$perm_rpath " in
8047	      *" $libdir "*) ;;
8048	      *) func_append perm_rpath " $libdir" ;;
8049	      esac
8050	    fi
8051	  done
8052	  # Substitute the hardcoded libdirs into the rpath.
8053	  if test -n "$hardcode_libdir_separator" &&
8054	     test -n "$hardcode_libdirs"; then
8055	    libdir="$hardcode_libdirs"
8056	    eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
8057	  fi
8058	  if test -n "$runpath_var" && test -n "$perm_rpath"; then
8059	    # We should set the runpath_var.
8060	    rpath=
8061	    for dir in $perm_rpath; do
8062	      func_append rpath "$dir:"
8063	    done
8064	    eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
8065	  fi
8066	  test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
8067	fi
8068
8069	shlibpath="$finalize_shlibpath"
8070	test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
8071	if test -n "$shlibpath"; then
8072	  eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
8073	fi
8074
8075	# Get the real and link names of the library.
8076	eval shared_ext=\"$shrext_cmds\"
8077	eval library_names=\"$library_names_spec\"
8078	set dummy $library_names
8079	shift
8080	realname="$1"
8081	shift
8082
8083	if test -n "$soname_spec"; then
8084	  eval soname=\"$soname_spec\"
8085	else
8086	  soname="$realname"
8087	fi
8088	if test -z "$dlname"; then
8089	  dlname=$soname
8090	fi
8091
8092	lib="$output_objdir/$realname"
8093	linknames=
8094	for link
8095	do
8096	  func_append linknames " $link"
8097	done
8098
8099	# Use standard objects if they are pic
8100	test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
8101	test "X$libobjs" = "X " && libobjs=
8102
8103	delfiles=
8104	if test -n "$export_symbols" && test -n "$include_expsyms"; then
8105	  $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
8106	  export_symbols="$output_objdir/$libname.uexp"
8107	  func_append delfiles " $export_symbols"
8108	fi
8109
8110	orig_export_symbols=
8111	case $host_os in
8112	cygwin* | mingw* | cegcc*)
8113	  if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
8114	    # exporting using user supplied symfile
8115	    if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
8116	      # and it's NOT already a .def file. Must figure out
8117	      # which of the given symbols are data symbols and tag
8118	      # them as such. So, trigger use of export_symbols_cmds.
8119	      # export_symbols gets reassigned inside the "prepare
8120	      # the list of exported symbols" if statement, so the
8121	      # include_expsyms logic still works.
8122	      orig_export_symbols="$export_symbols"
8123	      export_symbols=
8124	      always_export_symbols=yes
8125	    fi
8126	  fi
8127	  ;;
8128	esac
8129
8130	# Prepare the list of exported symbols
8131	if test -z "$export_symbols"; then
8132	  if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
8133	    func_verbose "generating symbol list for \`$libname.la'"
8134	    export_symbols="$output_objdir/$libname.exp"
8135	    $opt_dry_run || $RM $export_symbols
8136	    cmds=$export_symbols_cmds
8137	    save_ifs="$IFS"; IFS='~'
8138	    for cmd1 in $cmds; do
8139	      IFS="$save_ifs"
8140	      # Take the normal branch if the nm_file_list_spec branch
8141	      # doesn't work or if tool conversion is not needed.
8142	      case $nm_file_list_spec~$to_tool_file_cmd in
8143		*~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
8144		  try_normal_branch=yes
8145		  eval cmd=\"$cmd1\"
8146		  func_len " $cmd"
8147		  len=$func_len_result
8148		  ;;
8149		*)
8150		  try_normal_branch=no
8151		  ;;
8152	      esac
8153	      if test "$try_normal_branch" = yes \
8154		 && { test "$len" -lt "$max_cmd_len" \
8155		      || test "$max_cmd_len" -le -1; }
8156	      then
8157		func_show_eval "$cmd" 'exit $?'
8158		skipped_export=false
8159	      elif test -n "$nm_file_list_spec"; then
8160		func_basename "$output"
8161		output_la=$func_basename_result
8162		save_libobjs=$libobjs
8163		save_output=$output
8164		output=${output_objdir}/${output_la}.nm
8165		func_to_tool_file "$output"
8166		libobjs=$nm_file_list_spec$func_to_tool_file_result
8167		func_append delfiles " $output"
8168		func_verbose "creating $NM input file list: $output"
8169		for obj in $save_libobjs; do
8170		  func_to_tool_file "$obj"
8171		  $ECHO "$func_to_tool_file_result"
8172		done > "$output"
8173		eval cmd=\"$cmd1\"
8174		func_show_eval "$cmd" 'exit $?'
8175		output=$save_output
8176		libobjs=$save_libobjs
8177		skipped_export=false
8178	      else
8179		# The command line is too long to execute in one step.
8180		func_verbose "using reloadable object file for export list..."
8181		skipped_export=:
8182		# Break out early, otherwise skipped_export may be
8183		# set to false by a later but shorter cmd.
8184		break
8185	      fi
8186	    done
8187	    IFS="$save_ifs"
8188	    if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
8189	      func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
8190	      func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
8191	    fi
8192	  fi
8193	fi
8194
8195	if test -n "$export_symbols" && test -n "$include_expsyms"; then
8196	  tmp_export_symbols="$export_symbols"
8197	  test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
8198	  $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
8199	fi
8200
8201	if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
8202	  # The given exports_symbols file has to be filtered, so filter it.
8203	  func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
8204	  # FIXME: $output_objdir/$libname.filter potentially contains lots of
8205	  # 's' commands which not all seds can handle. GNU sed should be fine
8206	  # though. Also, the filter scales superlinearly with the number of
8207	  # global variables. join(1) would be nice here, but unfortunately
8208	  # isn't a blessed tool.
8209	  $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
8210	  func_append delfiles " $export_symbols $output_objdir/$libname.filter"
8211	  export_symbols=$output_objdir/$libname.def
8212	  $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
8213	fi
8214
8215	tmp_deplibs=
8216	for test_deplib in $deplibs; do
8217	  case " $convenience " in
8218	  *" $test_deplib "*) ;;
8219	  *)
8220	    func_append tmp_deplibs " $test_deplib"
8221	    ;;
8222	  esac
8223	done
8224	deplibs="$tmp_deplibs"
8225
8226	if test -n "$convenience"; then
8227	  if test -n "$whole_archive_flag_spec" &&
8228	    test "$compiler_needs_object" = yes &&
8229	    test -z "$libobjs"; then
8230	    # extract the archives, so we have objects to list.
8231	    # TODO: could optimize this to just extract one archive.
8232	    whole_archive_flag_spec=
8233	  fi
8234	  if test -n "$whole_archive_flag_spec"; then
8235	    save_libobjs=$libobjs
8236	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
8237	    test "X$libobjs" = "X " && libobjs=
8238	  else
8239	    gentop="$output_objdir/${outputname}x"
8240	    func_append generated " $gentop"
8241
8242	    func_extract_archives $gentop $convenience
8243	    func_append libobjs " $func_extract_archives_result"
8244	    test "X$libobjs" = "X " && libobjs=
8245	  fi
8246	fi
8247
8248	if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
8249	  eval flag=\"$thread_safe_flag_spec\"
8250	  func_append linker_flags " $flag"
8251	fi
8252
8253	# Make a backup of the uninstalled library when relinking
8254	if test "$opt_mode" = relink; then
8255	  $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
8256	fi
8257
8258	# Do each of the archive commands.
8259	if test "$module" = yes && test -n "$module_cmds" ; then
8260	  if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
8261	    eval test_cmds=\"$module_expsym_cmds\"
8262	    cmds=$module_expsym_cmds
8263	  else
8264	    eval test_cmds=\"$module_cmds\"
8265	    cmds=$module_cmds
8266	  fi
8267	else
8268	  if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
8269	    eval test_cmds=\"$archive_expsym_cmds\"
8270	    cmds=$archive_expsym_cmds
8271	  else
8272	    eval test_cmds=\"$archive_cmds\"
8273	    cmds=$archive_cmds
8274	  fi
8275	fi
8276
8277	if test "X$skipped_export" != "X:" &&
8278	   func_len " $test_cmds" &&
8279	   len=$func_len_result &&
8280	   test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
8281	  :
8282	else
8283	  # The command line is too long to link in one step, link piecewise
8284	  # or, if using GNU ld and skipped_export is not :, use a linker
8285	  # script.
8286
8287	  # Save the value of $output and $libobjs because we want to
8288	  # use them later.  If we have whole_archive_flag_spec, we
8289	  # want to use save_libobjs as it was before
8290	  # whole_archive_flag_spec was expanded, because we can't
8291	  # assume the linker understands whole_archive_flag_spec.
8292	  # This may have to be revisited, in case too many
8293	  # convenience libraries get linked in and end up exceeding
8294	  # the spec.
8295	  if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
8296	    save_libobjs=$libobjs
8297	  fi
8298	  save_output=$output
8299	  func_basename "$output"
8300	  output_la=$func_basename_result
8301
8302	  # Clear the reloadable object creation command queue and
8303	  # initialize k to one.
8304	  test_cmds=
8305	  concat_cmds=
8306	  objlist=
8307	  last_robj=
8308	  k=1
8309
8310	  if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
8311	    output=${output_objdir}/${output_la}.lnkscript
8312	    func_verbose "creating GNU ld script: $output"
8313	    echo 'INPUT (' > $output
8314	    for obj in $save_libobjs
8315	    do
8316	      func_to_tool_file "$obj"
8317	      $ECHO "$func_to_tool_file_result" >> $output
8318	    done
8319	    echo ')' >> $output
8320	    func_append delfiles " $output"
8321	    func_to_tool_file "$output"
8322	    output=$func_to_tool_file_result
8323	  elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
8324	    output=${output_objdir}/${output_la}.lnk
8325	    func_verbose "creating linker input file list: $output"
8326	    : > $output
8327	    set x $save_libobjs
8328	    shift
8329	    firstobj=
8330	    if test "$compiler_needs_object" = yes; then
8331	      firstobj="$1 "
8332	      shift
8333	    fi
8334	    for obj
8335	    do
8336	      func_to_tool_file "$obj"
8337	      $ECHO "$func_to_tool_file_result" >> $output
8338	    done
8339	    func_append delfiles " $output"
8340	    func_to_tool_file "$output"
8341	    output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
8342	  else
8343	    if test -n "$save_libobjs"; then
8344	      func_verbose "creating reloadable object files..."
8345	      output=$output_objdir/$output_la-${k}.$objext
8346	      eval test_cmds=\"$reload_cmds\"
8347	      func_len " $test_cmds"
8348	      len0=$func_len_result
8349	      len=$len0
8350
8351	      # Loop over the list of objects to be linked.
8352	      for obj in $save_libobjs
8353	      do
8354		func_len " $obj"
8355		func_arith $len + $func_len_result
8356		len=$func_arith_result
8357		if test "X$objlist" = X ||
8358		   test "$len" -lt "$max_cmd_len"; then
8359		  func_append objlist " $obj"
8360		else
8361		  # The command $test_cmds is almost too long, add a
8362		  # command to the queue.
8363		  if test "$k" -eq 1 ; then
8364		    # The first file doesn't have a previous command to add.
8365		    reload_objs=$objlist
8366		    eval concat_cmds=\"$reload_cmds\"
8367		  else
8368		    # All subsequent reloadable object files will link in
8369		    # the last one created.
8370		    reload_objs="$objlist $last_robj"
8371		    eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
8372		  fi
8373		  last_robj=$output_objdir/$output_la-${k}.$objext
8374		  func_arith $k + 1
8375		  k=$func_arith_result
8376		  output=$output_objdir/$output_la-${k}.$objext
8377		  objlist=" $obj"
8378		  func_len " $last_robj"
8379		  func_arith $len0 + $func_len_result
8380		  len=$func_arith_result
8381		fi
8382	      done
8383	      # Handle the remaining objects by creating one last
8384	      # reloadable object file.  All subsequent reloadable object
8385	      # files will link in the last one created.
8386	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8387	      reload_objs="$objlist $last_robj"
8388	      eval concat_cmds=\"\${concat_cmds}$reload_cmds\"
8389	      if test -n "$last_robj"; then
8390	        eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
8391	      fi
8392	      func_append delfiles " $output"
8393
8394	    else
8395	      output=
8396	    fi
8397
8398	    if ${skipped_export-false}; then
8399	      func_verbose "generating symbol list for \`$libname.la'"
8400	      export_symbols="$output_objdir/$libname.exp"
8401	      $opt_dry_run || $RM $export_symbols
8402	      libobjs=$output
8403	      # Append the command to create the export file.
8404	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8405	      eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
8406	      if test -n "$last_robj"; then
8407		eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
8408	      fi
8409	    fi
8410
8411	    test -n "$save_libobjs" &&
8412	      func_verbose "creating a temporary reloadable object file: $output"
8413
8414	    # Loop through the commands generated above and execute them.
8415	    save_ifs="$IFS"; IFS='~'
8416	    for cmd in $concat_cmds; do
8417	      IFS="$save_ifs"
8418	      $opt_silent || {
8419		  func_quote_for_expand "$cmd"
8420		  eval "func_echo $func_quote_for_expand_result"
8421	      }
8422	      $opt_dry_run || eval "$cmd" || {
8423		lt_exit=$?
8424
8425		# Restore the uninstalled library and exit
8426		if test "$opt_mode" = relink; then
8427		  ( cd "$output_objdir" && \
8428		    $RM "${realname}T" && \
8429		    $MV "${realname}U" "$realname" )
8430		fi
8431
8432		exit $lt_exit
8433	      }
8434	    done
8435	    IFS="$save_ifs"
8436
8437	    if test -n "$export_symbols_regex" && ${skipped_export-false}; then
8438	      func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
8439	      func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
8440	    fi
8441	  fi
8442
8443          if ${skipped_export-false}; then
8444	    if test -n "$export_symbols" && test -n "$include_expsyms"; then
8445	      tmp_export_symbols="$export_symbols"
8446	      test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
8447	      $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
8448	    fi
8449
8450	    if test -n "$orig_export_symbols"; then
8451	      # The given exports_symbols file has to be filtered, so filter it.
8452	      func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
8453	      # FIXME: $output_objdir/$libname.filter potentially contains lots of
8454	      # 's' commands which not all seds can handle. GNU sed should be fine
8455	      # though. Also, the filter scales superlinearly with the number of
8456	      # global variables. join(1) would be nice here, but unfortunately
8457	      # isn't a blessed tool.
8458	      $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
8459	      func_append delfiles " $export_symbols $output_objdir/$libname.filter"
8460	      export_symbols=$output_objdir/$libname.def
8461	      $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
8462	    fi
8463	  fi
8464
8465	  libobjs=$output
8466	  # Restore the value of output.
8467	  output=$save_output
8468
8469	  if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
8470	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
8471	    test "X$libobjs" = "X " && libobjs=
8472	  fi
8473	  # Expand the library linking commands again to reset the
8474	  # value of $libobjs for piecewise linking.
8475
8476	  # Do each of the archive commands.
8477	  if test "$module" = yes && test -n "$module_cmds" ; then
8478	    if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
8479	      cmds=$module_expsym_cmds
8480	    else
8481	      cmds=$module_cmds
8482	    fi
8483	  else
8484	    if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
8485	      cmds=$archive_expsym_cmds
8486	    else
8487	      cmds=$archive_cmds
8488	    fi
8489	  fi
8490	fi
8491
8492	if test -n "$delfiles"; then
8493	  # Append the command to remove temporary files to $cmds.
8494	  eval cmds=\"\$cmds~\$RM $delfiles\"
8495	fi
8496
8497	# Add any objects from preloaded convenience libraries
8498	if test -n "$dlprefiles"; then
8499	  gentop="$output_objdir/${outputname}x"
8500	  func_append generated " $gentop"
8501
8502	  func_extract_archives $gentop $dlprefiles
8503	  func_append libobjs " $func_extract_archives_result"
8504	  test "X$libobjs" = "X " && libobjs=
8505	fi
8506
8507	save_ifs="$IFS"; IFS='~'
8508	for cmd in $cmds; do
8509	  IFS="$save_ifs"
8510	  eval cmd=\"$cmd\"
8511	  $opt_silent || {
8512	    func_quote_for_expand "$cmd"
8513	    eval "func_echo $func_quote_for_expand_result"
8514	  }
8515	  $opt_dry_run || eval "$cmd" || {
8516	    lt_exit=$?
8517
8518	    # Restore the uninstalled library and exit
8519	    if test "$opt_mode" = relink; then
8520	      ( cd "$output_objdir" && \
8521	        $RM "${realname}T" && \
8522		$MV "${realname}U" "$realname" )
8523	    fi
8524
8525	    exit $lt_exit
8526	  }
8527	done
8528	IFS="$save_ifs"
8529
8530	# Restore the uninstalled library and exit
8531	if test "$opt_mode" = relink; then
8532	  $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
8533
8534	  if test -n "$convenience"; then
8535	    if test -z "$whole_archive_flag_spec"; then
8536	      func_show_eval '${RM}r "$gentop"'
8537	    fi
8538	  fi
8539
8540	  exit $EXIT_SUCCESS
8541	fi
8542
8543	# Create links to the real library.
8544	for linkname in $linknames; do
8545	  if test "$realname" != "$linkname"; then
8546	    func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
8547	  fi
8548	done
8549
8550	# If -module or -export-dynamic was specified, set the dlname.
8551	if test "$module" = yes || test "$export_dynamic" = yes; then
8552	  # On all known operating systems, these are identical.
8553	  dlname="$soname"
8554	fi
8555      fi
8556      ;;
8557
8558    obj)
8559      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
8560	func_warning "\`-dlopen' is ignored for objects"
8561      fi
8562
8563      case " $deplibs" in
8564      *\ -l* | *\ -L*)
8565	func_warning "\`-l' and \`-L' are ignored for objects" ;;
8566      esac
8567
8568      test -n "$rpath" && \
8569	func_warning "\`-rpath' is ignored for objects"
8570
8571      test -n "$xrpath" && \
8572	func_warning "\`-R' is ignored for objects"
8573
8574      test -n "$vinfo" && \
8575	func_warning "\`-version-info' is ignored for objects"
8576
8577      test -n "$release" && \
8578	func_warning "\`-release' is ignored for objects"
8579
8580      case $output in
8581      *.lo)
8582	test -n "$objs$old_deplibs" && \
8583	  func_fatal_error "cannot build library object \`$output' from non-libtool objects"
8584
8585	libobj=$output
8586	func_lo2o "$libobj"
8587	obj=$func_lo2o_result
8588	;;
8589      *)
8590	libobj=
8591	obj="$output"
8592	;;
8593      esac
8594
8595      # Delete the old objects.
8596      $opt_dry_run || $RM $obj $libobj
8597
8598      # Objects from convenience libraries.  This assumes
8599      # single-version convenience libraries.  Whenever we create
8600      # different ones for PIC/non-PIC, this we'll have to duplicate
8601      # the extraction.
8602      reload_conv_objs=
8603      gentop=
8604      # reload_cmds runs $LD directly, so let us get rid of
8605      # -Wl from whole_archive_flag_spec and hope we can get by with
8606      # turning comma into space..
8607      wl=
8608
8609      if test -n "$convenience"; then
8610	if test -n "$whole_archive_flag_spec"; then
8611	  eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
8612	  reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
8613	else
8614	  gentop="$output_objdir/${obj}x"
8615	  func_append generated " $gentop"
8616
8617	  func_extract_archives $gentop $convenience
8618	  reload_conv_objs="$reload_objs $func_extract_archives_result"
8619	fi
8620      fi
8621
8622      # If we're not building shared, we need to use non_pic_objs
8623      test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"
8624
8625      # Create the old-style object.
8626      reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
8627
8628      output="$obj"
8629      func_execute_cmds "$reload_cmds" 'exit $?'
8630
8631      # Exit if we aren't doing a library object file.
8632      if test -z "$libobj"; then
8633	if test -n "$gentop"; then
8634	  func_show_eval '${RM}r "$gentop"'
8635	fi
8636
8637	exit $EXIT_SUCCESS
8638      fi
8639
8640      if test "$build_libtool_libs" != yes; then
8641	if test -n "$gentop"; then
8642	  func_show_eval '${RM}r "$gentop"'
8643	fi
8644
8645	# Create an invalid libtool object if no PIC, so that we don't
8646	# accidentally link it into a program.
8647	# $show "echo timestamp > $libobj"
8648	# $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
8649	exit $EXIT_SUCCESS
8650      fi
8651
8652      if test -n "$pic_flag" || test "$pic_mode" != default; then
8653	# Only do commands if we really have different PIC objects.
8654	reload_objs="$libobjs $reload_conv_objs"
8655	output="$libobj"
8656	func_execute_cmds "$reload_cmds" 'exit $?'
8657      fi
8658
8659      if test -n "$gentop"; then
8660	func_show_eval '${RM}r "$gentop"'
8661      fi
8662
8663      exit $EXIT_SUCCESS
8664      ;;
8665
8666    prog)
8667      case $host in
8668	*cygwin*) func_stripname '' '.exe' "$output"
8669	          output=$func_stripname_result.exe;;
8670      esac
8671      test -n "$vinfo" && \
8672	func_warning "\`-version-info' is ignored for programs"
8673
8674      test -n "$release" && \
8675	func_warning "\`-release' is ignored for programs"
8676
8677      test "$preload" = yes \
8678        && test "$dlopen_support" = unknown \
8679	&& test "$dlopen_self" = unknown \
8680	&& test "$dlopen_self_static" = unknown && \
8681	  func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
8682
8683      case $host in
8684      *-*-rhapsody* | *-*-darwin1.[012])
8685	# On Rhapsody replace the C library is the System framework
8686	compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
8687	finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
8688	;;
8689      esac
8690
8691      case $host in
8692      *-*-darwin*)
8693	# Don't allow lazy linking, it breaks C++ global constructors
8694	# But is supposedly fixed on 10.4 or later (yay!).
8695	if test "$tagname" = CXX ; then
8696	  case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
8697	    10.[0123])
8698	      func_append compile_command " ${wl}-bind_at_load"
8699	      func_append finalize_command " ${wl}-bind_at_load"
8700	    ;;
8701	  esac
8702	fi
8703	# Time to change all our "foo.ltframework" stuff back to "-framework foo"
8704	compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8705	finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8706	;;
8707      esac
8708
8709
8710      # move library search paths that coincide with paths to not yet
8711      # installed libraries to the beginning of the library search list
8712      new_libs=
8713      for path in $notinst_path; do
8714	case " $new_libs " in
8715	*" -L$path/$objdir "*) ;;
8716	*)
8717	  case " $compile_deplibs " in
8718	  *" -L$path/$objdir "*)
8719	    func_append new_libs " -L$path/$objdir" ;;
8720	  esac
8721	  ;;
8722	esac
8723      done
8724      for deplib in $compile_deplibs; do
8725	case $deplib in
8726	-L*)
8727	  case " $new_libs " in
8728	  *" $deplib "*) ;;
8729	  *) func_append new_libs " $deplib" ;;
8730	  esac
8731	  ;;
8732	*) func_append new_libs " $deplib" ;;
8733	esac
8734      done
8735      compile_deplibs="$new_libs"
8736
8737
8738      func_append compile_command " $compile_deplibs"
8739      func_append finalize_command " $finalize_deplibs"
8740
8741      if test -n "$rpath$xrpath"; then
8742	# If the user specified any rpath flags, then add them.
8743	for libdir in $rpath $xrpath; do
8744	  # This is the magic to use -rpath.
8745	  case "$finalize_rpath " in
8746	  *" $libdir "*) ;;
8747	  *) func_append finalize_rpath " $libdir" ;;
8748	  esac
8749	done
8750      fi
8751
8752      # Now hardcode the library paths
8753      rpath=
8754      hardcode_libdirs=
8755      for libdir in $compile_rpath $finalize_rpath; do
8756	if test -n "$hardcode_libdir_flag_spec"; then
8757	  if test -n "$hardcode_libdir_separator"; then
8758	    if test -z "$hardcode_libdirs"; then
8759	      hardcode_libdirs="$libdir"
8760	    else
8761	      # Just accumulate the unique libdirs.
8762	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8763	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8764		;;
8765	      *)
8766		func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8767		;;
8768	      esac
8769	    fi
8770	  else
8771	    eval flag=\"$hardcode_libdir_flag_spec\"
8772	    func_append rpath " $flag"
8773	  fi
8774	elif test -n "$runpath_var"; then
8775	  case "$perm_rpath " in
8776	  *" $libdir "*) ;;
8777	  *) func_append perm_rpath " $libdir" ;;
8778	  esac
8779	fi
8780	case $host in
8781	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
8782	  testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
8783	  case :$dllsearchpath: in
8784	  *":$libdir:"*) ;;
8785	  ::) dllsearchpath=$libdir;;
8786	  *) func_append dllsearchpath ":$libdir";;
8787	  esac
8788	  case :$dllsearchpath: in
8789	  *":$testbindir:"*) ;;
8790	  ::) dllsearchpath=$testbindir;;
8791	  *) func_append dllsearchpath ":$testbindir";;
8792	  esac
8793	  ;;
8794	esac
8795      done
8796      # Substitute the hardcoded libdirs into the rpath.
8797      if test -n "$hardcode_libdir_separator" &&
8798	 test -n "$hardcode_libdirs"; then
8799	libdir="$hardcode_libdirs"
8800	eval rpath=\" $hardcode_libdir_flag_spec\"
8801      fi
8802      compile_rpath="$rpath"
8803
8804      rpath=
8805      hardcode_libdirs=
8806      for libdir in $finalize_rpath; do
8807	if test -n "$hardcode_libdir_flag_spec"; then
8808	  if test -n "$hardcode_libdir_separator"; then
8809	    if test -z "$hardcode_libdirs"; then
8810	      hardcode_libdirs="$libdir"
8811	    else
8812	      # Just accumulate the unique libdirs.
8813	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8814	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8815		;;
8816	      *)
8817		func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8818		;;
8819	      esac
8820	    fi
8821	  else
8822	    eval flag=\"$hardcode_libdir_flag_spec\"
8823	    func_append rpath " $flag"
8824	  fi
8825	elif test -n "$runpath_var"; then
8826	  case "$finalize_perm_rpath " in
8827	  *" $libdir "*) ;;
8828	  *) func_append finalize_perm_rpath " $libdir" ;;
8829	  esac
8830	fi
8831      done
8832      # Substitute the hardcoded libdirs into the rpath.
8833      if test -n "$hardcode_libdir_separator" &&
8834	 test -n "$hardcode_libdirs"; then
8835	libdir="$hardcode_libdirs"
8836	eval rpath=\" $hardcode_libdir_flag_spec\"
8837      fi
8838      finalize_rpath="$rpath"
8839
8840      if test -n "$libobjs" && test "$build_old_libs" = yes; then
8841	# Transform all the library objects into standard objects.
8842	compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
8843	finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
8844      fi
8845
8846      func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
8847
8848      # template prelinking step
8849      if test -n "$prelink_cmds"; then
8850	func_execute_cmds "$prelink_cmds" 'exit $?'
8851      fi
8852
8853      wrappers_required=yes
8854      case $host in
8855      *cegcc* | *mingw32ce*)
8856        # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
8857        wrappers_required=no
8858        ;;
8859      *cygwin* | *mingw* )
8860        if test "$build_libtool_libs" != yes; then
8861          wrappers_required=no
8862        fi
8863        ;;
8864      *)
8865        if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
8866          wrappers_required=no
8867        fi
8868        ;;
8869      esac
8870      if test "$wrappers_required" = no; then
8871	# Replace the output file specification.
8872	compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
8873	link_command="$compile_command$compile_rpath"
8874
8875	# We have no uninstalled library dependencies, so finalize right now.
8876	exit_status=0
8877	func_show_eval "$link_command" 'exit_status=$?'
8878
8879	if test -n "$postlink_cmds"; then
8880	  func_to_tool_file "$output"
8881	  postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8882	  func_execute_cmds "$postlink_cmds" 'exit $?'
8883	fi
8884
8885	# Delete the generated files.
8886	if test -f "$output_objdir/${outputname}S.${objext}"; then
8887	  func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
8888	fi
8889
8890	exit $exit_status
8891      fi
8892
8893      if test -n "$compile_shlibpath$finalize_shlibpath"; then
8894	compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
8895      fi
8896      if test -n "$finalize_shlibpath"; then
8897	finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
8898      fi
8899
8900      compile_var=
8901      finalize_var=
8902      if test -n "$runpath_var"; then
8903	if test -n "$perm_rpath"; then
8904	  # We should set the runpath_var.
8905	  rpath=
8906	  for dir in $perm_rpath; do
8907	    func_append rpath "$dir:"
8908	  done
8909	  compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
8910	fi
8911	if test -n "$finalize_perm_rpath"; then
8912	  # We should set the runpath_var.
8913	  rpath=
8914	  for dir in $finalize_perm_rpath; do
8915	    func_append rpath "$dir:"
8916	  done
8917	  finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
8918	fi
8919      fi
8920
8921      if test "$no_install" = yes; then
8922	# We don't need to create a wrapper script.
8923	link_command="$compile_var$compile_command$compile_rpath"
8924	# Replace the output file specification.
8925	link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
8926	# Delete the old output file.
8927	$opt_dry_run || $RM $output
8928	# Link the executable and exit
8929	func_show_eval "$link_command" 'exit $?'
8930
8931	if test -n "$postlink_cmds"; then
8932	  func_to_tool_file "$output"
8933	  postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8934	  func_execute_cmds "$postlink_cmds" 'exit $?'
8935	fi
8936
8937	exit $EXIT_SUCCESS
8938      fi
8939
8940      if test "$hardcode_action" = relink; then
8941	# Fast installation is not supported
8942	link_command="$compile_var$compile_command$compile_rpath"
8943	relink_command="$finalize_var$finalize_command$finalize_rpath"
8944
8945	func_warning "this platform does not like uninstalled shared libraries"
8946	func_warning "\`$output' will be relinked during installation"
8947      else
8948	if test "$fast_install" != no; then
8949	  link_command="$finalize_var$compile_command$finalize_rpath"
8950	  if test "$fast_install" = yes; then
8951	    relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
8952	  else
8953	    # fast_install is set to needless
8954	    relink_command=
8955	  fi
8956	else
8957	  link_command="$compile_var$compile_command$compile_rpath"
8958	  relink_command="$finalize_var$finalize_command$finalize_rpath"
8959	fi
8960      fi
8961
8962      # Replace the output file specification.
8963      link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
8964
8965      # Delete the old output files.
8966      $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
8967
8968      func_show_eval "$link_command" 'exit $?'
8969
8970      if test -n "$postlink_cmds"; then
8971	func_to_tool_file "$output_objdir/$outputname"
8972	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'`
8973	func_execute_cmds "$postlink_cmds" 'exit $?'
8974      fi
8975
8976      # Now create the wrapper script.
8977      func_verbose "creating $output"
8978
8979      # Quote the relink command for shipping.
8980      if test -n "$relink_command"; then
8981	# Preserve any variables that may affect compiler behavior
8982	for var in $variables_saved_for_relink; do
8983	  if eval test -z \"\${$var+set}\"; then
8984	    relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
8985	  elif eval var_value=\$$var; test -z "$var_value"; then
8986	    relink_command="$var=; export $var; $relink_command"
8987	  else
8988	    func_quote_for_eval "$var_value"
8989	    relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
8990	  fi
8991	done
8992	relink_command="(cd `pwd`; $relink_command)"
8993	relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
8994      fi
8995
8996      # Only actually do things if not in dry run mode.
8997      $opt_dry_run || {
8998	# win32 will think the script is a binary if it has
8999	# a .exe suffix, so we strip it off here.
9000	case $output in
9001	  *.exe) func_stripname '' '.exe' "$output"
9002	         output=$func_stripname_result ;;
9003	esac
9004	# test for cygwin because mv fails w/o .exe extensions
9005	case $host in
9006	  *cygwin*)
9007	    exeext=.exe
9008	    func_stripname '' '.exe' "$outputname"
9009	    outputname=$func_stripname_result ;;
9010	  *) exeext= ;;
9011	esac
9012	case $host in
9013	  *cygwin* | *mingw* )
9014	    func_dirname_and_basename "$output" "" "."
9015	    output_name=$func_basename_result
9016	    output_path=$func_dirname_result
9017	    cwrappersource="$output_path/$objdir/lt-$output_name.c"
9018	    cwrapper="$output_path/$output_name.exe"
9019	    $RM $cwrappersource $cwrapper
9020	    trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
9021
9022	    func_emit_cwrapperexe_src > $cwrappersource
9023
9024	    # The wrapper executable is built using the $host compiler,
9025	    # because it contains $host paths and files. If cross-
9026	    # compiling, it, like the target executable, must be
9027	    # executed on the $host or under an emulation environment.
9028	    $opt_dry_run || {
9029	      $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
9030	      $STRIP $cwrapper
9031	    }
9032
9033	    # Now, create the wrapper script for func_source use:
9034	    func_ltwrapper_scriptname $cwrapper
9035	    $RM $func_ltwrapper_scriptname_result
9036	    trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
9037	    $opt_dry_run || {
9038	      # note: this script will not be executed, so do not chmod.
9039	      if test "x$build" = "x$host" ; then
9040		$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
9041	      else
9042		func_emit_wrapper no > $func_ltwrapper_scriptname_result
9043	      fi
9044	    }
9045	  ;;
9046	  * )
9047	    $RM $output
9048	    trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
9049
9050	    func_emit_wrapper no > $output
9051	    chmod +x $output
9052	  ;;
9053	esac
9054      }
9055      exit $EXIT_SUCCESS
9056      ;;
9057    esac
9058
9059    # See if we need to build an old-fashioned archive.
9060    for oldlib in $oldlibs; do
9061
9062      if test "$build_libtool_libs" = convenience; then
9063	oldobjs="$libobjs_save $symfileobj"
9064	addlibs="$convenience"
9065	build_libtool_libs=no
9066      else
9067	if test "$build_libtool_libs" = module; then
9068	  oldobjs="$libobjs_save"
9069	  build_libtool_libs=no
9070	else
9071	  oldobjs="$old_deplibs $non_pic_objects"
9072	  if test "$preload" = yes && test -f "$symfileobj"; then
9073	    func_append oldobjs " $symfileobj"
9074	  fi
9075	fi
9076	addlibs="$old_convenience"
9077      fi
9078
9079      if test -n "$addlibs"; then
9080	gentop="$output_objdir/${outputname}x"
9081	func_append generated " $gentop"
9082
9083	func_extract_archives $gentop $addlibs
9084	func_append oldobjs " $func_extract_archives_result"
9085      fi
9086
9087      # Do each command in the archive commands.
9088      if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
9089	cmds=$old_archive_from_new_cmds
9090      else
9091
9092	# Add any objects from preloaded convenience libraries
9093	if test -n "$dlprefiles"; then
9094	  gentop="$output_objdir/${outputname}x"
9095	  func_append generated " $gentop"
9096
9097	  func_extract_archives $gentop $dlprefiles
9098	  func_append oldobjs " $func_extract_archives_result"
9099	fi
9100
9101	# POSIX demands no paths to be encoded in archives.  We have
9102	# to avoid creating archives with duplicate basenames if we
9103	# might have to extract them afterwards, e.g., when creating a
9104	# static archive out of a convenience library, or when linking
9105	# the entirety of a libtool archive into another (currently
9106	# not supported by libtool).
9107	if (for obj in $oldobjs
9108	    do
9109	      func_basename "$obj"
9110	      $ECHO "$func_basename_result"
9111	    done | sort | sort -uc >/dev/null 2>&1); then
9112	  :
9113	else
9114	  echo "copying selected object files to avoid basename conflicts..."
9115	  gentop="$output_objdir/${outputname}x"
9116	  func_append generated " $gentop"
9117	  func_mkdir_p "$gentop"
9118	  save_oldobjs=$oldobjs
9119	  oldobjs=
9120	  counter=1
9121	  for obj in $save_oldobjs
9122	  do
9123	    func_basename "$obj"
9124	    objbase="$func_basename_result"
9125	    case " $oldobjs " in
9126	    " ") oldobjs=$obj ;;
9127	    *[\ /]"$objbase "*)
9128	      while :; do
9129		# Make sure we don't pick an alternate name that also
9130		# overlaps.
9131		newobj=lt$counter-$objbase
9132		func_arith $counter + 1
9133		counter=$func_arith_result
9134		case " $oldobjs " in
9135		*[\ /]"$newobj "*) ;;
9136		*) if test ! -f "$gentop/$newobj"; then break; fi ;;
9137		esac
9138	      done
9139	      func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
9140	      func_append oldobjs " $gentop/$newobj"
9141	      ;;
9142	    *) func_append oldobjs " $obj" ;;
9143	    esac
9144	  done
9145	fi
9146	func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
9147	tool_oldlib=$func_to_tool_file_result
9148	eval cmds=\"$old_archive_cmds\"
9149
9150	func_len " $cmds"
9151	len=$func_len_result
9152	if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
9153	  cmds=$old_archive_cmds
9154	elif test -n "$archiver_list_spec"; then
9155	  func_verbose "using command file archive linking..."
9156	  for obj in $oldobjs
9157	  do
9158	    func_to_tool_file "$obj"
9159	    $ECHO "$func_to_tool_file_result"
9160	  done > $output_objdir/$libname.libcmd
9161	  func_to_tool_file "$output_objdir/$libname.libcmd"
9162	  oldobjs=" $archiver_list_spec$func_to_tool_file_result"
9163	  cmds=$old_archive_cmds
9164	else
9165	  # the command line is too long to link in one step, link in parts
9166	  func_verbose "using piecewise archive linking..."
9167	  save_RANLIB=$RANLIB
9168	  RANLIB=:
9169	  objlist=
9170	  concat_cmds=
9171	  save_oldobjs=$oldobjs
9172	  oldobjs=
9173	  # Is there a better way of finding the last object in the list?
9174	  for obj in $save_oldobjs
9175	  do
9176	    last_oldobj=$obj
9177	  done
9178	  eval test_cmds=\"$old_archive_cmds\"
9179	  func_len " $test_cmds"
9180	  len0=$func_len_result
9181	  len=$len0
9182	  for obj in $save_oldobjs
9183	  do
9184	    func_len " $obj"
9185	    func_arith $len + $func_len_result
9186	    len=$func_arith_result
9187	    func_append objlist " $obj"
9188	    if test "$len" -lt "$max_cmd_len"; then
9189	      :
9190	    else
9191	      # the above command should be used before it gets too long
9192	      oldobjs=$objlist
9193	      if test "$obj" = "$last_oldobj" ; then
9194		RANLIB=$save_RANLIB
9195	      fi
9196	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
9197	      eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
9198	      objlist=
9199	      len=$len0
9200	    fi
9201	  done
9202	  RANLIB=$save_RANLIB
9203	  oldobjs=$objlist
9204	  if test "X$oldobjs" = "X" ; then
9205	    eval cmds=\"\$concat_cmds\"
9206	  else
9207	    eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
9208	  fi
9209	fi
9210      fi
9211      func_execute_cmds "$cmds" 'exit $?'
9212    done
9213
9214    test -n "$generated" && \
9215      func_show_eval "${RM}r$generated"
9216
9217    # Now create the libtool archive.
9218    case $output in
9219    *.la)
9220      old_library=
9221      test "$build_old_libs" = yes && old_library="$libname.$libext"
9222      func_verbose "creating $output"
9223
9224      # Preserve any variables that may affect compiler behavior
9225      for var in $variables_saved_for_relink; do
9226	if eval test -z \"\${$var+set}\"; then
9227	  relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
9228	elif eval var_value=\$$var; test -z "$var_value"; then
9229	  relink_command="$var=; export $var; $relink_command"
9230	else
9231	  func_quote_for_eval "$var_value"
9232	  relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
9233	fi
9234      done
9235      # Quote the link command for shipping.
9236      relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
9237      relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
9238      if test "$hardcode_automatic" = yes ; then
9239	relink_command=
9240      fi
9241
9242      # Only create the output if not a dry run.
9243      $opt_dry_run || {
9244	for installed in no yes; do
9245	  if test "$installed" = yes; then
9246	    if test -z "$install_libdir"; then
9247	      break
9248	    fi
9249	    output="$output_objdir/$outputname"i
9250	    # Replace all uninstalled libtool libraries with the installed ones
9251	    newdependency_libs=
9252	    for deplib in $dependency_libs; do
9253	      case $deplib in
9254	      *.la)
9255		func_basename "$deplib"
9256		name="$func_basename_result"
9257		func_resolve_sysroot "$deplib"
9258		eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result`
9259		test -z "$libdir" && \
9260		  func_fatal_error "\`$deplib' is not a valid libtool archive"
9261		func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
9262		;;
9263	      -L*)
9264		func_stripname -L '' "$deplib"
9265		func_replace_sysroot "$func_stripname_result"
9266		func_append newdependency_libs " -L$func_replace_sysroot_result"
9267		;;
9268	      -R*)
9269		func_stripname -R '' "$deplib"
9270		func_replace_sysroot "$func_stripname_result"
9271		func_append newdependency_libs " -R$func_replace_sysroot_result"
9272		;;
9273	      *) func_append newdependency_libs " $deplib" ;;
9274	      esac
9275	    done
9276	    dependency_libs="$newdependency_libs"
9277	    newdlfiles=
9278
9279	    for lib in $dlfiles; do
9280	      case $lib in
9281	      *.la)
9282	        func_basename "$lib"
9283		name="$func_basename_result"
9284		eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
9285		test -z "$libdir" && \
9286		  func_fatal_error "\`$lib' is not a valid libtool archive"
9287		func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
9288		;;
9289	      *) func_append newdlfiles " $lib" ;;
9290	      esac
9291	    done
9292	    dlfiles="$newdlfiles"
9293	    newdlprefiles=
9294	    for lib in $dlprefiles; do
9295	      case $lib in
9296	      *.la)
9297		# Only pass preopened files to the pseudo-archive (for
9298		# eventual linking with the app. that links it) if we
9299		# didn't already link the preopened objects directly into
9300		# the library:
9301		func_basename "$lib"
9302		name="$func_basename_result"
9303		eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
9304		test -z "$libdir" && \
9305		  func_fatal_error "\`$lib' is not a valid libtool archive"
9306		func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
9307		;;
9308	      esac
9309	    done
9310	    dlprefiles="$newdlprefiles"
9311	  else
9312	    newdlfiles=
9313	    for lib in $dlfiles; do
9314	      case $lib in
9315		[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
9316		*) abs=`pwd`"/$lib" ;;
9317	      esac
9318	      func_append newdlfiles " $abs"
9319	    done
9320	    dlfiles="$newdlfiles"
9321	    newdlprefiles=
9322	    for lib in $dlprefiles; do
9323	      case $lib in
9324		[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
9325		*) abs=`pwd`"/$lib" ;;
9326	      esac
9327	      func_append newdlprefiles " $abs"
9328	    done
9329	    dlprefiles="$newdlprefiles"
9330	  fi
9331	  $RM $output
9332	  # place dlname in correct position for cygwin
9333	  # In fact, it would be nice if we could use this code for all target
9334	  # systems that can't hard-code library paths into their executables
9335	  # and that have no shared library path variable independent of PATH,
9336	  # but it turns out we can't easily determine that from inspecting
9337	  # libtool variables, so we have to hard-code the OSs to which it
9338	  # applies here; at the moment, that means platforms that use the PE
9339	  # object format with DLL files.  See the long comment at the top of
9340	  # tests/bindir.at for full details.
9341	  tdlname=$dlname
9342	  case $host,$output,$installed,$module,$dlname in
9343	    *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
9344	      # If a -bindir argument was supplied, place the dll there.
9345	      if test "x$bindir" != x ;
9346	      then
9347		func_relative_path "$install_libdir" "$bindir"
9348		tdlname=$func_relative_path_result$dlname
9349	      else
9350		# Otherwise fall back on heuristic.
9351		tdlname=../bin/$dlname
9352	      fi
9353	      ;;
9354	  esac
9355	  $ECHO > $output "\
9356# $outputname - a libtool library file
9357# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
9358#
9359# Please DO NOT delete this file!
9360# It is necessary for linking the library.
9361
9362# The name that we can dlopen(3).
9363dlname='$tdlname'
9364
9365# Names of this library.
9366library_names='$library_names'
9367
9368# The name of the static archive.
9369old_library='$old_library'
9370
9371# Linker flags that can not go in dependency_libs.
9372inherited_linker_flags='$new_inherited_linker_flags'
9373
9374# Libraries that this one depends upon.
9375dependency_libs='$dependency_libs'
9376
9377# Names of additional weak libraries provided by this library
9378weak_library_names='$weak_libs'
9379
9380# Version information for $libname.
9381current=$current
9382age=$age
9383revision=$revision
9384
9385# Is this an already installed library?
9386installed=$installed
9387
9388# Should we warn about portability when linking against -modules?
9389shouldnotlink=$module
9390
9391# Files to dlopen/dlpreopen
9392dlopen='$dlfiles'
9393dlpreopen='$dlprefiles'
9394
9395# Directory that this library needs to be installed in:
9396libdir='$install_libdir'"
9397	  if test "$installed" = no && test "$need_relink" = yes; then
9398	    $ECHO >> $output "\
9399relink_command=\"$relink_command\""
9400	  fi
9401	done
9402      }
9403
9404      # Do a symbolic link so that the libtool archive can be found in
9405      # LD_LIBRARY_PATH before the program is installed.
9406      func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
9407      ;;
9408    esac
9409    exit $EXIT_SUCCESS
9410}
9411
9412{ test "$opt_mode" = link || test "$opt_mode" = relink; } &&
9413    func_mode_link ${1+"$@"}
9414
9415
9416# func_mode_uninstall arg...
9417func_mode_uninstall ()
9418{
9419    $opt_debug
9420    RM="$nonopt"
9421    files=
9422    rmforce=
9423    exit_status=0
9424
9425    # This variable tells wrapper scripts just to set variables rather
9426    # than running their programs.
9427    libtool_install_magic="$magic"
9428
9429    for arg
9430    do
9431      case $arg in
9432      -f) func_append RM " $arg"; rmforce=yes ;;
9433      -*) func_append RM " $arg" ;;
9434      *) func_append files " $arg" ;;
9435      esac
9436    done
9437
9438    test -z "$RM" && \
9439      func_fatal_help "you must specify an RM program"
9440
9441    rmdirs=
9442
9443    for file in $files; do
9444      func_dirname "$file" "" "."
9445      dir="$func_dirname_result"
9446      if test "X$dir" = X.; then
9447	odir="$objdir"
9448      else
9449	odir="$dir/$objdir"
9450      fi
9451      func_basename "$file"
9452      name="$func_basename_result"
9453      test "$opt_mode" = uninstall && odir="$dir"
9454
9455      # Remember odir for removal later, being careful to avoid duplicates
9456      if test "$opt_mode" = clean; then
9457	case " $rmdirs " in
9458	  *" $odir "*) ;;
9459	  *) func_append rmdirs " $odir" ;;
9460	esac
9461      fi
9462
9463      # Don't error if the file doesn't exist and rm -f was used.
9464      if { test -L "$file"; } >/dev/null 2>&1 ||
9465	 { test -h "$file"; } >/dev/null 2>&1 ||
9466	 test -f "$file"; then
9467	:
9468      elif test -d "$file"; then
9469	exit_status=1
9470	continue
9471      elif test "$rmforce" = yes; then
9472	continue
9473      fi
9474
9475      rmfiles="$file"
9476
9477      case $name in
9478      *.la)
9479	# Possibly a libtool archive, so verify it.
9480	if func_lalib_p "$file"; then
9481	  func_source $dir/$name
9482
9483	  # Delete the libtool libraries and symlinks.
9484	  for n in $library_names; do
9485	    func_append rmfiles " $odir/$n"
9486	  done
9487	  test -n "$old_library" && func_append rmfiles " $odir/$old_library"
9488
9489	  case "$opt_mode" in
9490	  clean)
9491	    case " $library_names " in
9492	    *" $dlname "*) ;;
9493	    *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
9494	    esac
9495	    test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
9496	    ;;
9497	  uninstall)
9498	    if test -n "$library_names"; then
9499	      # Do each command in the postuninstall commands.
9500	      func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
9501	    fi
9502
9503	    if test -n "$old_library"; then
9504	      # Do each command in the old_postuninstall commands.
9505	      func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
9506	    fi
9507	    # FIXME: should reinstall the best remaining shared library.
9508	    ;;
9509	  esac
9510	fi
9511	;;
9512
9513      *.lo)
9514	# Possibly a libtool object, so verify it.
9515	if func_lalib_p "$file"; then
9516
9517	  # Read the .lo file
9518	  func_source $dir/$name
9519
9520	  # Add PIC object to the list of files to remove.
9521	  if test -n "$pic_object" &&
9522	     test "$pic_object" != none; then
9523	    func_append rmfiles " $dir/$pic_object"
9524	  fi
9525
9526	  # Add non-PIC object to the list of files to remove.
9527	  if test -n "$non_pic_object" &&
9528	     test "$non_pic_object" != none; then
9529	    func_append rmfiles " $dir/$non_pic_object"
9530	  fi
9531	fi
9532	;;
9533
9534      *)
9535	if test "$opt_mode" = clean ; then
9536	  noexename=$name
9537	  case $file in
9538	  *.exe)
9539	    func_stripname '' '.exe' "$file"
9540	    file=$func_stripname_result
9541	    func_stripname '' '.exe' "$name"
9542	    noexename=$func_stripname_result
9543	    # $file with .exe has already been added to rmfiles,
9544	    # add $file without .exe
9545	    func_append rmfiles " $file"
9546	    ;;
9547	  esac
9548	  # Do a test to see if this is a libtool program.
9549	  if func_ltwrapper_p "$file"; then
9550	    if func_ltwrapper_executable_p "$file"; then
9551	      func_ltwrapper_scriptname "$file"
9552	      relink_command=
9553	      func_source $func_ltwrapper_scriptname_result
9554	      func_append rmfiles " $func_ltwrapper_scriptname_result"
9555	    else
9556	      relink_command=
9557	      func_source $dir/$noexename
9558	    fi
9559
9560	    # note $name still contains .exe if it was in $file originally
9561	    # as does the version of $file that was added into $rmfiles
9562	    func_append rmfiles " $odir/$name $odir/${name}S.${objext}"
9563	    if test "$fast_install" = yes && test -n "$relink_command"; then
9564	      func_append rmfiles " $odir/lt-$name"
9565	    fi
9566	    if test "X$noexename" != "X$name" ; then
9567	      func_append rmfiles " $odir/lt-${noexename}.c"
9568	    fi
9569	  fi
9570	fi
9571	;;
9572      esac
9573      func_show_eval "$RM $rmfiles" 'exit_status=1'
9574    done
9575
9576    # Try to remove the ${objdir}s in the directories where we deleted files
9577    for dir in $rmdirs; do
9578      if test -d "$dir"; then
9579	func_show_eval "rmdir $dir >/dev/null 2>&1"
9580      fi
9581    done
9582
9583    exit $exit_status
9584}
9585
9586{ test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&
9587    func_mode_uninstall ${1+"$@"}
9588
9589test -z "$opt_mode" && {
9590  help="$generic_help"
9591  func_fatal_help "you must specify a MODE"
9592}
9593
9594test -z "$exec_cmd" && \
9595  func_fatal_help "invalid operation mode \`$opt_mode'"
9596
9597if test -n "$exec_cmd"; then
9598  eval exec "$exec_cmd"
9599  exit $EXIT_FAILURE
9600fi
9601
9602exit $exit_status
9603
9604
9605# The TAGs below are defined such that we never get into a situation
9606# in which we disable both kinds of libraries.  Given conflicting
9607# choices, we go for a static library, that is the most portable,
9608# since we can't tell whether shared libraries were disabled because
9609# the user asked for that or because the platform doesn't support
9610# them.  This is particularly important on AIX, because we don't
9611# support having both static and shared libraries enabled at the same
9612# time on that platform, so we default to a shared-only configuration.
9613# If a disable-shared tag is given, we'll fallback to a static-only
9614# configuration.  But we'll never go from static-only to shared-only.
9615
9616# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
9617build_libtool_libs=no
9618build_old_libs=yes
9619# ### END LIBTOOL TAG CONFIG: disable-shared
9620
9621# ### BEGIN LIBTOOL TAG CONFIG: disable-static
9622build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
9623# ### END LIBTOOL TAG CONFIG: disable-static
9624
9625# Local Variables:
9626# mode:shell-script
9627# sh-indentation:2
9628# End:
9629# vi:sw=2
9630
9631