source: mod_gnutls/config/ltmain.sh @ 180e49f

debian/masterdebian/stretch-backportsjessie-backportsupstream upstream/0.5.10
Last change on this file since 180e49f was 180e49f, checked in by Daniel Kahn Gillmor <dkg@…>, 7 years ago

Imported Upstream version 0.5.10

  • Property mode set to 100755
File size: 247.2 KB
Line 
1# Generated from ltmain.m4sh.
2
3# libtool (GNU libtool) 2.2.10
4# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
5
6# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
7# 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
8# This is free software; see the source for copying conditions.  There is NO
9# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
10
11# GNU Libtool is free software; you can redistribute it and/or modify
12# it under the terms of the GNU General Public License as published by
13# the Free Software Foundation; either version 2 of the License, or
14# (at your option) any later version.
15#
16# As a special exception to the GNU General Public License,
17# if you distribute this file as part of a program or library that
18# is built using GNU Libtool, you may include this file under the
19# same distribution terms that you use for the rest of that program.
20#
21# GNU Libtool is distributed in the hope that it will be useful, but
22# WITHOUT ANY WARRANTY; without even the implied warranty of
23# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24# General Public License for more details.
25#
26# You should have received a copy of the GNU General Public License
27# along with GNU Libtool; see the file COPYING.  If not, a copy
28# can be downloaded from http://www.gnu.org/licenses/gpl.html,
29# or obtained by writing to the Free Software Foundation, Inc.,
30# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
31
32# Usage: $progname [OPTION]... [MODE-ARG]...
33#
34# Provide generalized library-building support services.
35#
36#       --config             show all configuration variables
37#       --debug              enable verbose shell tracing
38#   -n, --dry-run            display commands without modifying any files
39#       --features           display basic configuration information and exit
40#       --mode=MODE          use operation mode MODE
41#       --preserve-dup-deps  don't remove duplicate dependency libraries
42#       --quiet, --silent    don't print informational messages
43#       --no-quiet, --no-silent
44#                            print informational messages (default)
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.2.10
74#         automake:     $automake_version
75#         autoconf:     $autoconf_version
76#
77# Report bugs to <bug-libtool@gnu.org>.
78
79PROGRAM=libtool
80PACKAGE=libtool
81VERSION=2.2.10
82TIMESTAMP=""
83package_revision=1.3175
84
85# Be Bourne compatible
86if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
87  emulate sh
88  NULLCMD=:
89  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
90  # is contrary to our usage.  Disable this feature.
91  alias -g '${1+"$@"}'='"$@"'
92  setopt NO_GLOB_SUBST
93else
94  case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
95fi
96BIN_SH=xpg4; export BIN_SH # for Tru64
97DUALCASE=1; export DUALCASE # for MKS sh
98
99# A function that is used when there is no print builtin or printf.
100func_fallback_echo ()
101{
102  eval 'cat <<_LTECHO_EOF
103$1
104_LTECHO_EOF'
105}
106
107# NLS nuisances: We save the old values to restore during execute mode.
108lt_user_locale=
109lt_safe_locale=
110for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
111do
112  eval "if test \"\${$lt_var+set}\" = set; then
113          save_$lt_var=\$$lt_var
114          $lt_var=C
115          export $lt_var
116          lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
117          lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
118        fi"
119done
120LC_ALL=C
121LANGUAGE=C
122export LANGUAGE LC_ALL
123
124$lt_unset CDPATH
125
126
127# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
128# is ksh but when the shell is invoked as "sh" and the current value of
129# the _XPG environment variable is not equal to 1 (one), the special
130# positional parameter $0, within a function call, is the name of the
131# function.
132progpath="$0"
133
134
135
136: ${CP="cp -f"}
137test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
138: ${EGREP="/bin/grep -E"}
139: ${FGREP="/bin/grep -F"}
140: ${GREP="/bin/grep"}
141: ${LN_S="ln -s"}
142: ${MAKE="make"}
143: ${MKDIR="mkdir"}
144: ${MV="mv -f"}
145: ${RM="rm -f"}
146: ${SED="/bin/sed"}
147: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
148: ${Xsed="$SED -e 1s/^X//"}
149
150# Global variables:
151EXIT_SUCCESS=0
152EXIT_FAILURE=1
153EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.
154EXIT_SKIP=77      # $? = 77 is used to indicate a skipped test to automake.
155
156exit_status=$EXIT_SUCCESS
157
158# Make sure IFS has a sensible default
159lt_nl='
160'
161IFS="   $lt_nl"
162
163dirname="s,/[^/]*$,,"
164basename="s,^.*/,,"
165
166# func_dirname_and_basename file append nondir_replacement
167# perform func_basename and func_dirname in a single function
168# call:
169#   dirname:  Compute the dirname of FILE.  If nonempty,
170#             add APPEND to the result, otherwise set result
171#             to NONDIR_REPLACEMENT.
172#             value returned in "$func_dirname_result"
173#   basename: Compute filename of FILE.
174#             value retuned in "$func_basename_result"
175# Implementation must be kept synchronized with func_dirname
176# and func_basename. For efficiency, we do not delegate to
177# those functions but instead duplicate the functionality here.
178func_dirname_and_basename ()
179{
180  # Extract subdirectory from the argument.
181  func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
182  if test "X$func_dirname_result" = "X${1}"; then
183    func_dirname_result="${3}"
184  else
185    func_dirname_result="$func_dirname_result${2}"
186  fi
187  func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
188}
189
190# Generated shell functions inserted here.
191
192# These SED scripts presuppose an absolute path with a trailing slash.
193pathcar='s,^/\([^/]*\).*$,\1,'
194pathcdr='s,^/[^/]*,,'
195removedotparts=':dotsl
196                s@/\./@/@g
197                t dotsl
198                s,/\.$,/,'
199collapseslashes='s@/\{1,\}@/@g'
200finalslash='s,/*$,/,'
201
202# func_normal_abspath PATH
203# Remove doubled-up and trailing slashes, "." path components,
204# and cancel out any ".." path components in PATH after making
205# it an absolute path.
206#             value returned in "$func_normal_abspath_result"
207func_normal_abspath ()
208{
209  # Start from root dir and reassemble the path.
210  func_normal_abspath_result=
211  func_normal_abspath_tpath=$1
212  func_normal_abspath_altnamespace=
213  case $func_normal_abspath_tpath in
214    "")
215      # Empty path, that just means $cwd.
216      func_stripname '' '/' "`pwd`"
217      func_normal_abspath_result=$func_stripname_result
218      return
219    ;;
220    # The next three entries are used to spot a run of precisely
221    # two leading slashes without using negated character classes;
222    # we take advantage of case's first-match behaviour.
223    ///*)
224      # Unusual form of absolute path, do nothing.
225    ;;
226    //*)
227      # Not necessarily an ordinary path; POSIX reserves leading '//'
228      # and for example Cygwin uses it to access remote file shares
229      # over CIFS/SMB, so we conserve a leading double slash if found.
230      func_normal_abspath_altnamespace=/
231    ;;
232    /*)
233      # Absolute path, do nothing.
234    ;;
235    *)
236      # Relative path, prepend $cwd.
237      func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
238    ;;
239  esac
240  # Cancel out all the simple stuff to save iterations.  We also want
241  # the path to end with a slash for ease of parsing, so make sure
242  # there is one (and only one) here.
243  func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
244        -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
245  while :; do
246    # Processed it all yet?
247    if test "$func_normal_abspath_tpath" = / ; then
248      # If we ascended to the root using ".." the result may be empty now.
249      if test -z "$func_normal_abspath_result" ; then
250        func_normal_abspath_result=/
251      fi
252      break
253    fi
254    func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
255        -e "$pathcar"`
256    func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
257        -e "$pathcdr"`
258    # Figure out what to do with it
259    case $func_normal_abspath_tcomponent in
260      "")
261        # Trailing empty path component, ignore it.
262      ;;
263      ..)
264        # Parent dir; strip last assembled component from result.
265        func_dirname "$func_normal_abspath_result"
266        func_normal_abspath_result=$func_dirname_result
267      ;;
268      *)
269        # Actual path component, append it.
270        func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
271      ;;
272    esac
273  done
274  # Restore leading double-slash if one was found on entry.
275  func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
276}
277
278# func_relative_path SRCDIR DSTDIR
279# generates a relative path from SRCDIR to DSTDIR, with a trailing
280# slash if non-empty, suitable for immediately appending a filename
281# without needing to append a separator.
282#             value returned in "$func_relative_path_result"
283func_relative_path ()
284{
285  func_relative_path_result=
286  func_normal_abspath "$1"
287  func_relative_path_tlibdir=$func_normal_abspath_result
288  func_normal_abspath "$2"
289  func_relative_path_tbindir=$func_normal_abspath_result
290
291  # Ascend the tree starting from libdir
292  while :; do
293    # check if we have found a prefix of bindir
294    case $func_relative_path_tbindir in
295      $func_relative_path_tlibdir)
296        # found an exact match
297        func_relative_path_tcancelled=
298        break
299        ;;
300      $func_relative_path_tlibdir*)
301        # found a matching prefix
302        func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
303        func_relative_path_tcancelled=$func_stripname_result
304        if test -z "$func_relative_path_result"; then
305          func_relative_path_result=.
306        fi
307        break
308        ;;
309      *)
310        func_dirname $func_relative_path_tlibdir
311        func_relative_path_tlibdir=${func_dirname_result}
312        if test "x$func_relative_path_tlibdir" = x ; then
313          # Have to descend all the way to the root!
314          func_relative_path_result=../$func_relative_path_result
315          func_relative_path_tcancelled=$func_relative_path_tbindir
316          break
317        fi
318        func_relative_path_result=../$func_relative_path_result
319        ;;
320    esac
321  done
322
323  # Now calculate path; take care to avoid doubling-up slashes.
324  func_stripname '' '/' "$func_relative_path_result"
325  func_relative_path_result=$func_stripname_result
326  func_stripname '/' '/' "$func_relative_path_tcancelled"
327  if test "x$func_stripname_result" != x ; then
328    func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
329  fi
330
331  # Normalisation. If bindir is libdir, return empty string,
332  # else relative path ending with a slash; either way, target
333  # file name can be directly appended.
334  if test ! -z "$func_relative_path_result"; then
335    func_stripname './' '' "$func_relative_path_result/"
336    func_relative_path_result=$func_stripname_result
337  fi
338}
339
340# The name of this program:
341func_dirname_and_basename "$progpath"
342progname=$func_basename_result
343
344# Make sure we have an absolute path for reexecution:
345case $progpath in
346  [\\/]*|[A-Za-z]:\\*) ;;
347  *[\\/]*)
348     progdir=$func_dirname_result
349     progdir=`cd "$progdir" && pwd`
350     progpath="$progdir/$progname"
351     ;;
352  *)
353     save_IFS="$IFS"
354     IFS=:
355     for progdir in $PATH; do
356       IFS="$save_IFS"
357       test -x "$progdir/$progname" && break
358     done
359     IFS="$save_IFS"
360     test -n "$progdir" || progdir=`pwd`
361     progpath="$progdir/$progname"
362     ;;
363esac
364
365# Sed substitution that helps us do robust quoting.  It backslashifies
366# metacharacters that are still active within double-quoted strings.
367Xsed="${SED}"' -e 1s/^X//'
368sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
369
370# Same as above, but do not quote variable references.
371double_quote_subst='s/\(["`\\]\)/\\\1/g'
372
373# Re-`\' parameter expansions in output of double_quote_subst that were
374# `\'-ed in input to the same.  If an odd number of `\' preceded a '$'
375# in input to double_quote_subst, that '$' was protected from expansion.
376# Since each input `\' is now two `\'s, look for any number of runs of
377# four `\'s followed by two `\'s and then a '$'.  `\' that '$'.
378bs='\\'
379bs2='\\\\'
380bs4='\\\\\\\\'
381dollar='\$'
382sed_double_backslash="\
383  s/$bs4/&\\
384/g
385  s/^$bs2$dollar/$bs&/
386  s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
387  s/\n//g"
388
389# Standard options:
390opt_dry_run=false
391opt_help=false
392opt_quiet=false
393opt_verbose=false
394opt_warning=:
395
396# func_echo arg...
397# Echo program name prefixed message, along with the current mode
398# name if it has been set yet.
399func_echo ()
400{
401    $ECHO "$progname${mode+: }$mode: $*"
402}
403
404# func_verbose arg...
405# Echo program name prefixed message in verbose mode only.
406func_verbose ()
407{
408    $opt_verbose && func_echo ${1+"$@"}
409
410    # A bug in bash halts the script if the last line of a function
411    # fails when set -e is in force, so we need another command to
412    # work around that:
413    :
414}
415
416# func_echo_all arg...
417# Invoke $ECHO with all args, space-separated.
418func_echo_all ()
419{
420    $ECHO "$*"
421}
422
423# func_error arg...
424# Echo program name prefixed message to standard error.
425func_error ()
426{
427    $ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
428}
429
430# func_warning arg...
431# Echo program name prefixed warning message to standard error.
432func_warning ()
433{
434    $opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
435
436    # bash bug again:
437    :
438}
439
440# func_fatal_error arg...
441# Echo program name prefixed message to standard error, and exit.
442func_fatal_error ()
443{
444    func_error ${1+"$@"}
445    exit $EXIT_FAILURE
446}
447
448# func_fatal_help arg...
449# Echo program name prefixed message to standard error, followed by
450# a help hint, and exit.
451func_fatal_help ()
452{
453    func_error ${1+"$@"}
454    func_fatal_error "$help"
455}
456help="Try \`$progname --help' for more information."  ## default
457
458
459# func_grep expression filename
460# Check whether EXPRESSION matches any line of FILENAME, without output.
461func_grep ()
462{
463    $GREP "$1" "$2" >/dev/null 2>&1
464}
465
466
467# func_mkdir_p directory-path
468# Make sure the entire path to DIRECTORY-PATH is available.
469func_mkdir_p ()
470{
471    my_directory_path="$1"
472    my_dir_list=
473
474    if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
475
476      # Protect directory names starting with `-'
477      case $my_directory_path in
478        -*) my_directory_path="./$my_directory_path" ;;
479      esac
480
481      # While some portion of DIR does not yet exist...
482      while test ! -d "$my_directory_path"; do
483        # ...make a list in topmost first order.  Use a colon delimited
484        # list incase some portion of path contains whitespace.
485        my_dir_list="$my_directory_path:$my_dir_list"
486
487        # If the last portion added has no slash in it, the list is done
488        case $my_directory_path in */*) ;; *) break ;; esac
489
490        # ...otherwise throw away the child directory and loop
491        my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
492      done
493      my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
494
495      save_mkdir_p_IFS="$IFS"; IFS=':'
496      for my_dir in $my_dir_list; do
497        IFS="$save_mkdir_p_IFS"
498        # mkdir can fail with a `File exist' error if two processes
499        # try to create one of the directories concurrently.  Don't
500        # stop in that case!
501        $MKDIR "$my_dir" 2>/dev/null || :
502      done
503      IFS="$save_mkdir_p_IFS"
504
505      # Bail out if we (or some other process) failed to create a directory.
506      test -d "$my_directory_path" || \
507        func_fatal_error "Failed to create \`$1'"
508    fi
509}
510
511
512# func_mktempdir [string]
513# Make a temporary directory that won't clash with other running
514# libtool processes, and avoids race conditions if possible.  If
515# given, STRING is the basename for that directory.
516func_mktempdir ()
517{
518    my_template="${TMPDIR-/tmp}/${1-$progname}"
519
520    if test "$opt_dry_run" = ":"; then
521      # Return a directory name, but don't create it in dry-run mode
522      my_tmpdir="${my_template}-$$"
523    else
524
525      # If mktemp works, use that first and foremost
526      my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
527
528      if test ! -d "$my_tmpdir"; then
529        # Failing that, at least try and use $RANDOM to avoid a race
530        my_tmpdir="${my_template}-${RANDOM-0}$$"
531
532        save_mktempdir_umask=`umask`
533        umask 0077
534        $MKDIR "$my_tmpdir"
535        umask $save_mktempdir_umask
536      fi
537
538      # If we're not in dry-run mode, bomb out on failure
539      test -d "$my_tmpdir" || \
540        func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
541    fi
542
543    $ECHO "$my_tmpdir"
544}
545
546
547# func_quote_for_eval arg
548# Aesthetically quote ARG to be evaled later.
549# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
550# is double-quoted, suitable for a subsequent eval, whereas
551# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
552# which are still active within double quotes backslashified.
553func_quote_for_eval ()
554{
555    case $1 in
556      *[\\\`\"\$]*)
557        func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
558      *)
559        func_quote_for_eval_unquoted_result="$1" ;;
560    esac
561
562    case $func_quote_for_eval_unquoted_result in
563      # Double-quote args containing shell metacharacters to delay
564      # word splitting, command substitution and and variable
565      # expansion for a subsequent eval.
566      # Many Bourne shells cannot handle close brackets correctly
567      # in scan sets, so we specify it separately.
568      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
569        func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
570        ;;
571      *)
572        func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
573    esac
574}
575
576
577# func_quote_for_expand arg
578# Aesthetically quote ARG to be evaled later; same as above,
579# but do not quote variable references.
580func_quote_for_expand ()
581{
582    case $1 in
583      *[\\\`\"]*)
584        my_arg=`$ECHO "$1" | $SED \
585            -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
586      *)
587        my_arg="$1" ;;
588    esac
589
590    case $my_arg in
591      # Double-quote args containing shell metacharacters to delay
592      # word splitting and command substitution for a subsequent eval.
593      # Many Bourne shells cannot handle close brackets correctly
594      # in scan sets, so we specify it separately.
595      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
596        my_arg="\"$my_arg\""
597        ;;
598    esac
599
600    func_quote_for_expand_result="$my_arg"
601}
602
603
604# func_show_eval cmd [fail_exp]
605# Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
606# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
607# is given, then evaluate it.
608func_show_eval ()
609{
610    my_cmd="$1"
611    my_fail_exp="${2-:}"
612
613    ${opt_silent-false} || {
614      func_quote_for_expand "$my_cmd"
615      eval "func_echo $func_quote_for_expand_result"
616    }
617
618    if ${opt_dry_run-false}; then :; else
619      eval "$my_cmd"
620      my_status=$?
621      if test "$my_status" -eq 0; then :; else
622        eval "(exit $my_status); $my_fail_exp"
623      fi
624    fi
625}
626
627
628# func_show_eval_locale cmd [fail_exp]
629# Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
630# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
631# is given, then evaluate it.  Use the saved locale for evaluation.
632func_show_eval_locale ()
633{
634    my_cmd="$1"
635    my_fail_exp="${2-:}"
636
637    ${opt_silent-false} || {
638      func_quote_for_expand "$my_cmd"
639      eval "func_echo $func_quote_for_expand_result"
640    }
641
642    if ${opt_dry_run-false}; then :; else
643      eval "$lt_user_locale
644            $my_cmd"
645      my_status=$?
646      eval "$lt_safe_locale"
647      if test "$my_status" -eq 0; then :; else
648        eval "(exit $my_status); $my_fail_exp"
649      fi
650    fi
651}
652
653
654# func_version
655# Echo version message to standard output and exit.
656func_version ()
657{
658    $SED -n '/(C)/!b go
659        :more
660        /\./!{
661          N
662          s/\n# / /
663          b more
664        }
665        :go
666        /^# '$PROGRAM' (GNU /,/# warranty; / {
667        s/^# //
668        s/^# *$//
669        s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
670        p
671     }' < "$progpath"
672     exit $?
673}
674
675# func_usage
676# Echo short help message to standard output and exit.
677func_usage ()
678{
679    $SED -n '/^# Usage:/,/^#  *.*--help/ {
680        s/^# //
681        s/^# *$//
682        s/\$progname/'$progname'/
683        p
684    }' < "$progpath"
685    echo
686    $ECHO "run \`$progname --help | more' for full usage"
687    exit $?
688}
689
690# func_help [NOEXIT]
691# Echo long help message to standard output and exit,
692# unless 'noexit' is passed as argument.
693func_help ()
694{
695    $SED -n '/^# Usage:/,/# Report bugs to/ {
696        s/^# //
697        s/^# *$//
698        s*\$progname*'$progname'*
699        s*\$host*'"$host"'*
700        s*\$SHELL*'"$SHELL"'*
701        s*\$LTCC*'"$LTCC"'*
702        s*\$LTCFLAGS*'"$LTCFLAGS"'*
703        s*\$LD*'"$LD"'*
704        s/\$with_gnu_ld/'"$with_gnu_ld"'/
705        s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
706        s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
707        p
708     }' < "$progpath"
709    ret=$?
710    if test -z "$1"; then
711      exit $ret
712    fi
713}
714
715# func_missing_arg argname
716# Echo program name prefixed message to standard error and set global
717# exit_cmd.
718func_missing_arg ()
719{
720    func_error "missing argument for $1."
721    exit_cmd=exit
722}
723
724exit_cmd=:
725
726
727
728
729
730
731magic="%%%MAGIC variable%%%"
732magic_exe="%%%MAGIC EXE variable%%%"
733
734# Global variables.
735# $mode is unset
736nonopt=
737execute_dlfiles=
738preserve_args=
739lo2o="s/\\.lo\$/.${objext}/"
740o2lo="s/\\.${objext}\$/.lo/"
741extracted_archives=
742extracted_serial=0
743
744opt_dry_run=false
745opt_duplicate_deps=false
746opt_silent=false
747opt_debug=:
748
749# If this variable is set in any of the actions, the command in it
750# will be execed at the end.  This prevents here-documents from being
751# left over by shells.
752exec_cmd=
753
754# func_fatal_configuration arg...
755# Echo program name prefixed message to standard error, followed by
756# a configuration failure hint, and exit.
757func_fatal_configuration ()
758{
759    func_error ${1+"$@"}
760    func_error "See the $PACKAGE documentation for more information."
761    func_fatal_error "Fatal configuration error."
762}
763
764
765# func_config
766# Display the configuration for all the tags in this script.
767func_config ()
768{
769    re_begincf='^# ### BEGIN LIBTOOL'
770    re_endcf='^# ### END LIBTOOL'
771
772    # Default configuration.
773    $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
774
775    # Now print the configurations for the tags.
776    for tagname in $taglist; do
777      $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
778    done
779
780    exit $?
781}
782
783# func_features
784# Display the features supported by this script.
785func_features ()
786{
787    echo "host: $host"
788    if test "$build_libtool_libs" = yes; then
789      echo "enable shared libraries"
790    else
791      echo "disable shared libraries"
792    fi
793    if test "$build_old_libs" = yes; then
794      echo "enable static libraries"
795    else
796      echo "disable static libraries"
797    fi
798
799    exit $?
800}
801
802# func_enable_tag tagname
803# Verify that TAGNAME is valid, and either flag an error and exit, or
804# enable the TAGNAME tag.  We also add TAGNAME to the global $taglist
805# variable here.
806func_enable_tag ()
807{
808  # Global variable:
809  tagname="$1"
810
811  re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
812  re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
813  sed_extractcf="/$re_begincf/,/$re_endcf/p"
814
815  # Validate tagname.
816  case $tagname in
817    *[!-_A-Za-z0-9,/]*)
818      func_fatal_error "invalid tag name: $tagname"
819      ;;
820  esac
821
822  # Don't test for the "default" C tag, as we know it's
823  # there but not specially marked.
824  case $tagname in
825    CC) ;;
826    *)
827      if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
828        taglist="$taglist $tagname"
829
830        # Evaluate the configuration.  Be careful to quote the path
831        # and the sed script, to avoid splitting on whitespace, but
832        # also don't use non-portable quotes within backquotes within
833        # quotes we have to do it in 2 steps:
834        extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
835        eval "$extractedcf"
836      else
837        func_error "ignoring unknown tag $tagname"
838      fi
839      ;;
840  esac
841}
842
843# Parse options once, thoroughly.  This comes as soon as possible in
844# the script to make things like `libtool --version' happen quickly.
845{
846
847  # Shorthand for --mode=foo, only valid as the first argument
848  case $1 in
849  clean|clea|cle|cl)
850    shift; set dummy --mode clean ${1+"$@"}; shift
851    ;;
852  compile|compil|compi|comp|com|co|c)
853    shift; set dummy --mode compile ${1+"$@"}; shift
854    ;;
855  execute|execut|execu|exec|exe|ex|e)
856    shift; set dummy --mode execute ${1+"$@"}; shift
857    ;;
858  finish|finis|fini|fin|fi|f)
859    shift; set dummy --mode finish ${1+"$@"}; shift
860    ;;
861  install|instal|insta|inst|ins|in|i)
862    shift; set dummy --mode install ${1+"$@"}; shift
863    ;;
864  link|lin|li|l)
865    shift; set dummy --mode link ${1+"$@"}; shift
866    ;;
867  uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
868    shift; set dummy --mode uninstall ${1+"$@"}; shift
869    ;;
870  esac
871
872  # Parse non-mode specific arguments:
873  while test "$#" -gt 0; do
874    opt="$1"
875    shift
876
877    case $opt in
878      --config)         func_config                                     ;;
879
880      --debug)          preserve_args="$preserve_args $opt"
881                        func_echo "enabling shell trace mode"
882                        opt_debug='set -x'
883                        $opt_debug
884                        ;;
885
886      -dlopen)          test "$#" -eq 0 && func_missing_arg "$opt" && break
887                        execute_dlfiles="$execute_dlfiles $1"
888                        shift
889                        ;;
890
891      --dry-run | -n)   opt_dry_run=:                                   ;;
892      --features)       func_features                                   ;;
893      --finish)         mode="finish"                                   ;;
894
895      --mode)           test "$#" -eq 0 && func_missing_arg "$opt" && break
896                        case $1 in
897                          # Valid mode arguments:
898                          clean)        ;;
899                          compile)      ;;
900                          execute)      ;;
901                          finish)       ;;
902                          install)      ;;
903                          link)         ;;
904                          relink)       ;;
905                          uninstall)    ;;
906
907                          # Catch anything else as an error
908                          *) func_error "invalid argument for $opt"
909                             exit_cmd=exit
910                             break
911                             ;;
912                        esac
913
914                        mode="$1"
915                        shift
916                        ;;
917
918      --preserve-dup-deps)
919                        opt_duplicate_deps=:                            ;;
920
921      --quiet|--silent) preserve_args="$preserve_args $opt"
922                        opt_silent=:
923                        opt_verbose=false
924                        ;;
925
926      --no-quiet|--no-silent)
927                        preserve_args="$preserve_args $opt"
928                        opt_silent=false
929                        ;;
930
931      --verbose| -v)    preserve_args="$preserve_args $opt"
932                        opt_silent=false
933                        opt_verbose=:
934                        ;;
935
936      --no-verbose)     preserve_args="$preserve_args $opt"
937                        opt_verbose=false
938                        ;;
939
940      --tag)            test "$#" -eq 0 && func_missing_arg "$opt" && break
941                        preserve_args="$preserve_args $opt $1"
942                        func_enable_tag "$1"    # tagname is set here
943                        shift
944                        ;;
945
946      # Separate optargs to long options:
947      -dlopen=*|--mode=*|--tag=*)
948                        func_opt_split "$opt"
949                        set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}
950                        shift
951                        ;;
952
953      -\?|-h)           func_usage                                      ;;
954      --help)           opt_help=:                                      ;;
955      --help-all)       opt_help=': help-all'                           ;;
956      --version)        func_version                                    ;;
957
958      -*)               func_fatal_help "unrecognized option \`$opt'"   ;;
959
960      *)                nonopt="$opt"
961                        break
962                        ;;
963    esac
964  done
965
966
967  case $host in
968    *cygwin* | *mingw* | *pw32* | *cegcc*)
969      # don't eliminate duplications in $postdeps and $predeps
970      opt_duplicate_compiler_generated_deps=:
971      ;;
972    *)
973      opt_duplicate_compiler_generated_deps=$opt_duplicate_deps
974      ;;
975  esac
976
977  # Having warned about all mis-specified options, bail out if
978  # anything was wrong.
979  $exit_cmd $EXIT_FAILURE
980}
981
982# func_check_version_match
983# Ensure that we are using m4 macros, and libtool script from the same
984# release of libtool.
985func_check_version_match ()
986{
987  if test "$package_revision" != "$macro_revision"; then
988    if test "$VERSION" != "$macro_version"; then
989      if test -z "$macro_version"; then
990        cat >&2 <<_LT_EOF
991$progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
992$progname: definition of this LT_INIT comes from an older release.
993$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
994$progname: and run autoconf again.
995_LT_EOF
996      else
997        cat >&2 <<_LT_EOF
998$progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
999$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
1000$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
1001$progname: and run autoconf again.
1002_LT_EOF
1003      fi
1004    else
1005      cat >&2 <<_LT_EOF
1006$progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,
1007$progname: but the definition of this LT_INIT comes from revision $macro_revision.
1008$progname: You should recreate aclocal.m4 with macros from revision $package_revision
1009$progname: of $PACKAGE $VERSION and run autoconf again.
1010_LT_EOF
1011    fi
1012
1013    exit $EXIT_MISMATCH
1014  fi
1015}
1016
1017
1018## ----------- ##
1019##    Main.    ##
1020## ----------- ##
1021
1022$opt_help || {
1023  # Sanity checks first:
1024  func_check_version_match
1025
1026  if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
1027    func_fatal_configuration "not configured to build any kind of library"
1028  fi
1029
1030  test -z "$mode" && func_fatal_error "error: you must specify a MODE."
1031
1032
1033  # Darwin sucks
1034  eval std_shrext=\"$shrext_cmds\"
1035
1036
1037  # Only execute mode is allowed to have -dlopen flags.
1038  if test -n "$execute_dlfiles" && test "$mode" != execute; then
1039    func_error "unrecognized option \`-dlopen'"
1040    $ECHO "$help" 1>&2
1041    exit $EXIT_FAILURE
1042  fi
1043
1044  # Change the help message to a mode-specific one.
1045  generic_help="$help"
1046  help="Try \`$progname --help --mode=$mode' for more information."
1047}
1048
1049
1050# func_lalib_p file
1051# True iff FILE is a libtool `.la' library or `.lo' object file.
1052# This function is only a basic sanity check; it will hardly flush out
1053# determined imposters.
1054func_lalib_p ()
1055{
1056    test -f "$1" &&
1057      $SED -e 4q "$1" 2>/dev/null \
1058        | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
1059}
1060
1061# func_lalib_unsafe_p file
1062# True iff FILE is a libtool `.la' library or `.lo' object file.
1063# This function implements the same check as func_lalib_p without
1064# resorting to external programs.  To this end, it redirects stdin and
1065# closes it afterwards, without saving the original file descriptor.
1066# As a safety measure, use it only where a negative result would be
1067# fatal anyway.  Works if `file' does not exist.
1068func_lalib_unsafe_p ()
1069{
1070    lalib_p=no
1071    if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
1072        for lalib_p_l in 1 2 3 4
1073        do
1074            read lalib_p_line
1075            case "$lalib_p_line" in
1076                \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
1077            esac
1078        done
1079        exec 0<&5 5<&-
1080    fi
1081    test "$lalib_p" = yes
1082}
1083
1084# func_ltwrapper_script_p file
1085# True iff FILE is a libtool wrapper script
1086# This function is only a basic sanity check; it will hardly flush out
1087# determined imposters.
1088func_ltwrapper_script_p ()
1089{
1090    func_lalib_p "$1"
1091}
1092
1093# func_ltwrapper_executable_p file
1094# True iff FILE is a libtool wrapper executable
1095# This function is only a basic sanity check; it will hardly flush out
1096# determined imposters.
1097func_ltwrapper_executable_p ()
1098{
1099    func_ltwrapper_exec_suffix=
1100    case $1 in
1101    *.exe) ;;
1102    *) func_ltwrapper_exec_suffix=.exe ;;
1103    esac
1104    $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
1105}
1106
1107# func_ltwrapper_scriptname file
1108# Assumes file is an ltwrapper_executable
1109# uses $file to determine the appropriate filename for a
1110# temporary ltwrapper_script.
1111func_ltwrapper_scriptname ()
1112{
1113    func_ltwrapper_scriptname_result=""
1114    if func_ltwrapper_executable_p "$1"; then
1115        func_dirname_and_basename "$1" "" "."
1116        func_stripname '' '.exe' "$func_basename_result"
1117        func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
1118    fi
1119}
1120
1121# func_ltwrapper_p file
1122# True iff FILE is a libtool wrapper script or wrapper executable
1123# This function is only a basic sanity check; it will hardly flush out
1124# determined imposters.
1125func_ltwrapper_p ()
1126{
1127    func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
1128}
1129
1130
1131# func_execute_cmds commands fail_cmd
1132# Execute tilde-delimited COMMANDS.
1133# If FAIL_CMD is given, eval that upon failure.
1134# FAIL_CMD may read-access the current command in variable CMD!
1135func_execute_cmds ()
1136{
1137    $opt_debug
1138    save_ifs=$IFS; IFS='~'
1139    for cmd in $1; do
1140      IFS=$save_ifs
1141      eval cmd=\"$cmd\"
1142      func_show_eval "$cmd" "${2-:}"
1143    done
1144    IFS=$save_ifs
1145}
1146
1147
1148# func_source file
1149# Source FILE, adding directory component if necessary.
1150# Note that it is not necessary on cygwin/mingw to append a dot to
1151# FILE even if both FILE and FILE.exe exist: automatic-append-.exe
1152# behavior happens only for exec(3), not for open(2)!  Also, sourcing
1153# `FILE.' does not work on cygwin managed mounts.
1154func_source ()
1155{
1156    $opt_debug
1157    case $1 in
1158    */* | *\\*) . "$1" ;;
1159    *)          . "./$1" ;;
1160    esac
1161}
1162
1163
1164# func_infer_tag arg
1165# Infer tagged configuration to use if any are available and
1166# if one wasn't chosen via the "--tag" command line option.
1167# Only attempt this if the compiler in the base compile
1168# command doesn't match the default compiler.
1169# arg is usually of the form 'gcc ...'
1170func_infer_tag ()
1171{
1172    $opt_debug
1173    if test -n "$available_tags" && test -z "$tagname"; then
1174      CC_quoted=
1175      for arg in $CC; do
1176        func_quote_for_eval "$arg"
1177        CC_quoted="$CC_quoted $func_quote_for_eval_result"
1178      done
1179      CC_expanded=`func_echo_all $CC`
1180      CC_quoted_expanded=`func_echo_all $CC_quoted`
1181      case $@ in
1182      # Blanks in the command may have been stripped by the calling shell,
1183      # but not from the CC environment variable when configure was run.
1184      " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1185      " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
1186      # Blanks at the start of $base_compile will cause this to fail
1187      # if we don't check for them as well.
1188      *)
1189        for z in $available_tags; do
1190          if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1191            # Evaluate the configuration.
1192            eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1193            CC_quoted=
1194            for arg in $CC; do
1195              # Double-quote args containing other shell metacharacters.
1196              func_quote_for_eval "$arg"
1197              CC_quoted="$CC_quoted $func_quote_for_eval_result"
1198            done
1199            CC_expanded=`func_echo_all $CC`
1200            CC_quoted_expanded=`func_echo_all $CC_quoted`
1201            case "$@ " in
1202            " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1203            " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
1204              # The compiler in the base compile command matches
1205              # the one in the tagged configuration.
1206              # Assume this is the tagged configuration we want.
1207              tagname=$z
1208              break
1209              ;;
1210            esac
1211          fi
1212        done
1213        # If $tagname still isn't set, then no tagged configuration
1214        # was found and let the user know that the "--tag" command
1215        # line option must be used.
1216        if test -z "$tagname"; then
1217          func_echo "unable to infer tagged configuration"
1218          func_fatal_error "specify a tag with \`--tag'"
1219#       else
1220#         func_verbose "using $tagname tagged configuration"
1221        fi
1222        ;;
1223      esac
1224    fi
1225}
1226
1227
1228
1229# func_write_libtool_object output_name pic_name nonpic_name
1230# Create a libtool object file (analogous to a ".la" file),
1231# but don't create it if we're doing a dry run.
1232func_write_libtool_object ()
1233{
1234    write_libobj=${1}
1235    if test "$build_libtool_libs" = yes; then
1236      write_lobj=\'${2}\'
1237    else
1238      write_lobj=none
1239    fi
1240
1241    if test "$build_old_libs" = yes; then
1242      write_oldobj=\'${3}\'
1243    else
1244      write_oldobj=none
1245    fi
1246
1247    $opt_dry_run || {
1248      cat >${write_libobj}T <<EOF
1249# $write_libobj - a libtool object file
1250# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1251#
1252# Please DO NOT delete this file!
1253# It is necessary for linking the library.
1254
1255# Name of the PIC object.
1256pic_object=$write_lobj
1257
1258# Name of the non-PIC object
1259non_pic_object=$write_oldobj
1260
1261EOF
1262      $MV "${write_libobj}T" "${write_libobj}"
1263    }
1264}
1265
1266# func_mode_compile arg...
1267func_mode_compile ()
1268{
1269    $opt_debug
1270    # Get the compilation command and the source file.
1271    base_compile=
1272    srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
1273    suppress_opt=yes
1274    suppress_output=
1275    arg_mode=normal
1276    libobj=
1277    later=
1278    pie_flag=
1279
1280    for arg
1281    do
1282      case $arg_mode in
1283      arg  )
1284        # do not "continue".  Instead, add this to base_compile
1285        lastarg="$arg"
1286        arg_mode=normal
1287        ;;
1288
1289      target )
1290        libobj="$arg"
1291        arg_mode=normal
1292        continue
1293        ;;
1294
1295      normal )
1296        # Accept any command-line options.
1297        case $arg in
1298        -o)
1299          test -n "$libobj" && \
1300            func_fatal_error "you cannot specify \`-o' more than once"
1301          arg_mode=target
1302          continue
1303          ;;
1304
1305        -pie | -fpie | -fPIE)
1306          pie_flag="$pie_flag $arg"
1307          continue
1308          ;;
1309
1310        -shared | -static | -prefer-pic | -prefer-non-pic)
1311          later="$later $arg"
1312          continue
1313          ;;
1314
1315        -no-suppress)
1316          suppress_opt=no
1317          continue
1318          ;;
1319
1320        -Xcompiler)
1321          arg_mode=arg  #  the next one goes into the "base_compile" arg list
1322          continue      #  The current "srcfile" will either be retained or
1323          ;;            #  replaced later.  I would guess that would be a bug.
1324
1325        -Wc,*)
1326          func_stripname '-Wc,' '' "$arg"
1327          args=$func_stripname_result
1328          lastarg=
1329          save_ifs="$IFS"; IFS=','
1330          for arg in $args; do
1331            IFS="$save_ifs"
1332            func_quote_for_eval "$arg"
1333            lastarg="$lastarg $func_quote_for_eval_result"
1334          done
1335          IFS="$save_ifs"
1336          func_stripname ' ' '' "$lastarg"
1337          lastarg=$func_stripname_result
1338
1339          # Add the arguments to base_compile.
1340          base_compile="$base_compile $lastarg"
1341          continue
1342          ;;
1343
1344        *)
1345          # Accept the current argument as the source file.
1346          # The previous "srcfile" becomes the current argument.
1347          #
1348          lastarg="$srcfile"
1349          srcfile="$arg"
1350          ;;
1351        esac  #  case $arg
1352        ;;
1353      esac    #  case $arg_mode
1354
1355      # Aesthetically quote the previous argument.
1356      func_quote_for_eval "$lastarg"
1357      base_compile="$base_compile $func_quote_for_eval_result"
1358    done # for arg
1359
1360    case $arg_mode in
1361    arg)
1362      func_fatal_error "you must specify an argument for -Xcompile"
1363      ;;
1364    target)
1365      func_fatal_error "you must specify a target with \`-o'"
1366      ;;
1367    *)
1368      # Get the name of the library object.
1369      test -z "$libobj" && {
1370        func_basename "$srcfile"
1371        libobj="$func_basename_result"
1372      }
1373      ;;
1374    esac
1375
1376    # Recognize several different file suffixes.
1377    # If the user specifies -o file.o, it is replaced with file.lo
1378    case $libobj in
1379    *.[cCFSifmso] | \
1380    *.ada | *.adb | *.ads | *.asm | \
1381    *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
1382    *.[fF][09]? | *.for | *.java | *.obj | *.sx | *.cu | *.cup)
1383      func_xform "$libobj"
1384      libobj=$func_xform_result
1385      ;;
1386    esac
1387
1388    case $libobj in
1389    *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
1390    *)
1391      func_fatal_error "cannot determine name of library object from \`$libobj'"
1392      ;;
1393    esac
1394
1395    func_infer_tag $base_compile
1396
1397    for arg in $later; do
1398      case $arg in
1399      -shared)
1400        test "$build_libtool_libs" != yes && \
1401          func_fatal_configuration "can not build a shared library"
1402        build_old_libs=no
1403        continue
1404        ;;
1405
1406      -static)
1407        build_libtool_libs=no
1408        build_old_libs=yes
1409        continue
1410        ;;
1411
1412      -prefer-pic)
1413        pic_mode=yes
1414        continue
1415        ;;
1416
1417      -prefer-non-pic)
1418        pic_mode=no
1419        continue
1420        ;;
1421      esac
1422    done
1423
1424    func_quote_for_eval "$libobj"
1425    test "X$libobj" != "X$func_quote_for_eval_result" \
1426      && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'    &()|`$[]' \
1427      && func_warning "libobj name \`$libobj' may not contain shell special characters."
1428    func_dirname_and_basename "$obj" "/" ""
1429    objname="$func_basename_result"
1430    xdir="$func_dirname_result"
1431    lobj=${xdir}$objdir/$objname
1432
1433    test -z "$base_compile" && \
1434      func_fatal_help "you must specify a compilation command"
1435
1436    # Delete any leftover library objects.
1437    if test "$build_old_libs" = yes; then
1438      removelist="$obj $lobj $libobj ${libobj}T"
1439    else
1440      removelist="$lobj $libobj ${libobj}T"
1441    fi
1442
1443    # On Cygwin there's no "real" PIC flag so we must build both object types
1444    case $host_os in
1445    cygwin* | mingw* | pw32* | os2* | cegcc*)
1446      pic_mode=default
1447      ;;
1448    esac
1449    if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
1450      # non-PIC code in shared libraries is not supported
1451      pic_mode=default
1452    fi
1453
1454    # Calculate the filename of the output object if compiler does
1455    # not support -o with -c
1456    if test "$compiler_c_o" = no; then
1457      output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
1458      lockfile="$output_obj.lock"
1459    else
1460      output_obj=
1461      need_locks=no
1462      lockfile=
1463    fi
1464
1465    # Lock this critical section if it is needed
1466    # We use this script file to make the link, it avoids creating a new file
1467    if test "$need_locks" = yes; then
1468      until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
1469        func_echo "Waiting for $lockfile to be removed"
1470        sleep 2
1471      done
1472    elif test "$need_locks" = warn; then
1473      if test -f "$lockfile"; then
1474        $ECHO "\
1475*** ERROR, $lockfile exists and contains:
1476`cat $lockfile 2>/dev/null`
1477
1478This indicates that another process is trying to use the same
1479temporary object file, and libtool could not work around it because
1480your compiler does not support \`-c' and \`-o' together.  If you
1481repeat this compilation, it may succeed, by chance, but you had better
1482avoid parallel builds (make -j) in this platform, or get a better
1483compiler."
1484
1485        $opt_dry_run || $RM $removelist
1486        exit $EXIT_FAILURE
1487      fi
1488      removelist="$removelist $output_obj"
1489      $ECHO "$srcfile" > "$lockfile"
1490    fi
1491
1492    $opt_dry_run || $RM $removelist
1493    removelist="$removelist $lockfile"
1494    trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
1495
1496    if test -n "$fix_srcfile_path"; then
1497      eval srcfile=\"$fix_srcfile_path\"
1498    fi
1499    func_quote_for_eval "$srcfile"
1500    qsrcfile=$func_quote_for_eval_result
1501
1502    # Only build a PIC object if we are building libtool libraries.
1503    if test "$build_libtool_libs" = yes; then
1504      # Without this assignment, base_compile gets emptied.
1505      fbsd_hideous_sh_bug=$base_compile
1506
1507      if test "$pic_mode" != no; then
1508        command="$base_compile $qsrcfile $pic_flag"
1509      else
1510        # Don't build PIC code
1511        command="$base_compile $qsrcfile"
1512      fi
1513
1514      func_mkdir_p "$xdir$objdir"
1515
1516      if test -z "$output_obj"; then
1517        # Place PIC objects in $objdir
1518        command="$command -o $lobj"
1519      fi
1520
1521      func_show_eval_locale "$command"  \
1522          'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
1523
1524      if test "$need_locks" = warn &&
1525         test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1526        $ECHO "\
1527*** ERROR, $lockfile contains:
1528`cat $lockfile 2>/dev/null`
1529
1530but it should contain:
1531$srcfile
1532
1533This indicates that another process is trying to use the same
1534temporary object file, and libtool could not work around it because
1535your compiler does not support \`-c' and \`-o' together.  If you
1536repeat this compilation, it may succeed, by chance, but you had better
1537avoid parallel builds (make -j) in this platform, or get a better
1538compiler."
1539
1540        $opt_dry_run || $RM $removelist
1541        exit $EXIT_FAILURE
1542      fi
1543
1544      # Just move the object if needed, then go on to compile the next one
1545      if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
1546        func_show_eval '$MV "$output_obj" "$lobj"' \
1547          'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1548      fi
1549
1550      # Allow error messages only from the first compilation.
1551      if test "$suppress_opt" = yes; then
1552        suppress_output=' >/dev/null 2>&1'
1553      fi
1554    fi
1555
1556    # Only build a position-dependent object if we build old libraries.
1557    if test "$build_old_libs" = yes; then
1558      if test "$pic_mode" != yes; then
1559        # Don't build PIC code
1560        command="$base_compile $qsrcfile$pie_flag"
1561      else
1562        command="$base_compile $qsrcfile $pic_flag"
1563      fi
1564      if test "$compiler_c_o" = yes; then
1565        command="$command -o $obj"
1566      fi
1567
1568      # Suppress compiler output if we already did a PIC compilation.
1569      command="$command$suppress_output"
1570      func_show_eval_locale "$command" \
1571        '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
1572
1573      if test "$need_locks" = warn &&
1574         test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1575        $ECHO "\
1576*** ERROR, $lockfile contains:
1577`cat $lockfile 2>/dev/null`
1578
1579but it should contain:
1580$srcfile
1581
1582This indicates that another process is trying to use the same
1583temporary object file, and libtool could not work around it because
1584your compiler does not support \`-c' and \`-o' together.  If you
1585repeat this compilation, it may succeed, by chance, but you had better
1586avoid parallel builds (make -j) in this platform, or get a better
1587compiler."
1588
1589        $opt_dry_run || $RM $removelist
1590        exit $EXIT_FAILURE
1591      fi
1592
1593      # Just move the object if needed
1594      if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
1595        func_show_eval '$MV "$output_obj" "$obj"' \
1596          'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1597      fi
1598    fi
1599
1600    $opt_dry_run || {
1601      func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
1602
1603      # Unlock the critical section if it was locked
1604      if test "$need_locks" != no; then
1605        removelist=$lockfile
1606        $RM "$lockfile"
1607      fi
1608    }
1609
1610    exit $EXIT_SUCCESS
1611}
1612
1613$opt_help || {
1614  test "$mode" = compile && func_mode_compile ${1+"$@"}
1615}
1616
1617func_mode_help ()
1618{
1619    # We need to display help for each of the modes.
1620    case $mode in
1621      "")
1622        # Generic help is extracted from the usage comments
1623        # at the start of this file.
1624        func_help
1625        ;;
1626
1627      clean)
1628        $ECHO \
1629"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
1630
1631Remove files from the build directory.
1632
1633RM is the name of the program to use to delete files associated with each FILE
1634(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
1635to RM.
1636
1637If FILE is a libtool library, object or program, all the files associated
1638with it are deleted. Otherwise, only FILE itself is deleted using RM."
1639        ;;
1640
1641      compile)
1642      $ECHO \
1643"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
1644
1645Compile a source file into a libtool library object.
1646
1647This mode accepts the following additional options:
1648
1649  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
1650  -no-suppress      do not suppress compiler output for multiple passes
1651  -prefer-pic       try to build PIC objects only
1652  -prefer-non-pic   try to build non-PIC objects only
1653  -shared           do not build a \`.o' file suitable for static linking
1654  -static           only build a \`.o' file suitable for static linking
1655  -Wc,FLAG          pass FLAG directly to the compiler
1656
1657COMPILE-COMMAND is a command to be used in creating a \`standard' object file
1658from the given SOURCEFILE.
1659
1660The output file name is determined by removing the directory component from
1661SOURCEFILE, then substituting the C source code suffix \`.c' with the
1662library object suffix, \`.lo'."
1663        ;;
1664
1665      execute)
1666        $ECHO \
1667"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
1668
1669Automatically set library path, then run a program.
1670
1671This mode accepts the following additional options:
1672
1673  -dlopen FILE      add the directory containing FILE to the library path
1674
1675This mode sets the library path environment variable according to \`-dlopen'
1676flags.
1677
1678If any of the ARGS are libtool executable wrappers, then they are translated
1679into their corresponding uninstalled binary, and any of their required library
1680directories are added to the library path.
1681
1682Then, COMMAND is executed, with ARGS as arguments."
1683        ;;
1684
1685      finish)
1686        $ECHO \
1687"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
1688
1689Complete the installation of libtool libraries.
1690
1691Each LIBDIR is a directory that contains libtool libraries.
1692
1693The commands that this mode executes may require superuser privileges.  Use
1694the \`--dry-run' option if you just want to see what would be executed."
1695        ;;
1696
1697      install)
1698        $ECHO \
1699"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
1700
1701Install executables or libraries.
1702
1703INSTALL-COMMAND is the installation command.  The first component should be
1704either the \`install' or \`cp' program.
1705
1706The following components of INSTALL-COMMAND are treated specially:
1707
1708  -inst-prefix-dir PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
1709
1710The rest of the components are interpreted as arguments to that command (only
1711BSD-compatible install options are recognized)."
1712        ;;
1713
1714      link)
1715        $ECHO \
1716"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
1717
1718Link object files or libraries together to form another library, or to
1719create an executable program.
1720
1721LINK-COMMAND is a command using the C compiler that you would use to create
1722a program from several object files.
1723
1724The following components of LINK-COMMAND are treated specially:
1725
1726  -all-static       do not do any dynamic linking at all
1727  -avoid-version    do not add a version suffix if possible
1728  -bindir BINDIR    specify path to binaries directory (for systems where
1729                    libraries must be found in the PATH setting at runtime)
1730  -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
1731  -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
1732  -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
1733  -export-symbols SYMFILE
1734                    try to export only the symbols listed in SYMFILE
1735  -export-symbols-regex REGEX
1736                    try to export only the symbols matching REGEX
1737  -LLIBDIR          search LIBDIR for required installed libraries
1738  -lNAME            OUTPUT-FILE requires the installed library libNAME
1739  -module           build a library that can dlopened
1740  -no-fast-install  disable the fast-install mode
1741  -no-install       link a not-installable executable
1742  -no-undefined     declare that a library does not refer to external symbols
1743  -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
1744  -objectlist FILE  Use a list of object files found in FILE to specify objects
1745  -precious-files-regex REGEX
1746                    don't remove output files matching REGEX
1747  -release RELEASE  specify package release information
1748  -rpath LIBDIR     the created library will eventually be installed in LIBDIR
1749  -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
1750  -shared           only do dynamic linking of libtool libraries
1751  -shrext SUFFIX    override the standard shared library file extension
1752  -static           do not do any dynamic linking of uninstalled libtool libraries
1753  -static-libtool-libs
1754                    do not do any dynamic linking of libtool libraries
1755  -version-info CURRENT[:REVISION[:AGE]]
1756                    specify library version info [each variable defaults to 0]
1757  -weak LIBNAME     declare that the target provides the LIBNAME interface
1758  -Wc,FLAG
1759  -Xcompiler FLAG   pass linker-specific FLAG directly to the compiler
1760  -Wl,FLAG
1761  -Xlinker FLAG     pass linker-specific FLAG directly to the linker
1762  -XCClinker FLAG   pass link-specific FLAG to the compiler driver (CC)
1763
1764All other options (arguments beginning with \`-') are ignored.
1765
1766Every other argument is treated as a filename.  Files ending in \`.la' are
1767treated as uninstalled libtool libraries, other files are standard or library
1768object files.
1769
1770If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
1771only library objects (\`.lo' files) may be specified, and \`-rpath' is
1772required, except when creating a convenience library.
1773
1774If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
1775using \`ar' and \`ranlib', or on Windows using \`lib'.
1776
1777If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
1778is created, otherwise an executable program is created."
1779        ;;
1780
1781      uninstall)
1782        $ECHO \
1783"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
1784
1785Remove libraries from an installation directory.
1786
1787RM is the name of the program to use to delete files associated with each FILE
1788(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
1789to RM.
1790
1791If FILE is a libtool library, all the files associated with it are deleted.
1792Otherwise, only FILE itself is deleted using RM."
1793        ;;
1794
1795      *)
1796        func_fatal_help "invalid operation mode \`$mode'"
1797        ;;
1798    esac
1799
1800    echo
1801    $ECHO "Try \`$progname --help' for more information about other modes."
1802}
1803
1804# Now that we've collected a possible --mode arg, show help if necessary
1805if $opt_help; then
1806  if test "$opt_help" = :; then
1807    func_mode_help
1808  else
1809    {
1810      func_help noexit
1811      for mode in compile link execute install finish uninstall clean; do
1812        func_mode_help
1813      done
1814    } | sed -n '1p; 2,$s/^Usage:/  or: /p'
1815    {
1816      func_help noexit
1817      for mode in compile link execute install finish uninstall clean; do
1818        echo
1819        func_mode_help
1820      done
1821    } |
1822    sed '1d
1823      /^When reporting/,/^Report/{
1824        H
1825        d
1826      }
1827      $x
1828      /information about other modes/d
1829      /more detailed .*MODE/d
1830      s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
1831  fi
1832  exit $?
1833fi
1834
1835
1836# func_mode_execute arg...
1837func_mode_execute ()
1838{
1839    $opt_debug
1840    # The first argument is the command name.
1841    cmd="$nonopt"
1842    test -z "$cmd" && \
1843      func_fatal_help "you must specify a COMMAND"
1844
1845    # Handle -dlopen flags immediately.
1846    for file in $execute_dlfiles; do
1847      test -f "$file" \
1848        || func_fatal_help "\`$file' is not a file"
1849
1850      dir=
1851      case $file in
1852      *.la)
1853        # Check to see that this really is a libtool archive.
1854        func_lalib_unsafe_p "$file" \
1855          || func_fatal_help "\`$lib' is not a valid libtool archive"
1856
1857        # Read the libtool library.
1858        dlname=
1859        library_names=
1860        func_source "$file"
1861
1862        # Skip this library if it cannot be dlopened.
1863        if test -z "$dlname"; then
1864          # Warn if it was a shared library.
1865          test -n "$library_names" && \
1866            func_warning "\`$file' was not linked with \`-export-dynamic'"
1867          continue
1868        fi
1869
1870        func_dirname "$file" "" "."
1871        dir="$func_dirname_result"
1872
1873        if test -f "$dir/$objdir/$dlname"; then
1874          dir="$dir/$objdir"
1875        else
1876          if test ! -f "$dir/$dlname"; then
1877            func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
1878          fi
1879        fi
1880        ;;
1881
1882      *.lo)
1883        # Just add the directory containing the .lo file.
1884        func_dirname "$file" "" "."
1885        dir="$func_dirname_result"
1886        ;;
1887
1888      *)
1889        func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
1890        continue
1891        ;;
1892      esac
1893
1894      # Get the absolute pathname.
1895      absdir=`cd "$dir" && pwd`
1896      test -n "$absdir" && dir="$absdir"
1897
1898      # Now add the directory to shlibpath_var.
1899      if eval "test -z \"\$$shlibpath_var\""; then
1900        eval "$shlibpath_var=\"\$dir\""
1901      else
1902        eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
1903      fi
1904    done
1905
1906    # This variable tells wrapper scripts just to set shlibpath_var
1907    # rather than running their programs.
1908    libtool_execute_magic="$magic"
1909
1910    # Check if any of the arguments is a wrapper script.
1911    args=
1912    for file
1913    do
1914      case $file in
1915      -* | *.la | *.lo ) ;;
1916      *)
1917        # Do a test to see if this is really a libtool program.
1918        if func_ltwrapper_script_p "$file"; then
1919          func_source "$file"
1920          # Transform arg to wrapped name.
1921          file="$progdir/$program"
1922        elif func_ltwrapper_executable_p "$file"; then
1923          func_ltwrapper_scriptname "$file"
1924          func_source "$func_ltwrapper_scriptname_result"
1925          # Transform arg to wrapped name.
1926          file="$progdir/$program"
1927        fi
1928        ;;
1929      esac
1930      # Quote arguments (to preserve shell metacharacters).
1931      func_quote_for_eval "$file"
1932      args="$args $func_quote_for_eval_result"
1933    done
1934
1935    if test "X$opt_dry_run" = Xfalse; then
1936      if test -n "$shlibpath_var"; then
1937        # Export the shlibpath_var.
1938        eval "export $shlibpath_var"
1939      fi
1940
1941      # Restore saved environment variables
1942      for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
1943      do
1944        eval "if test \"\${save_$lt_var+set}\" = set; then
1945                $lt_var=\$save_$lt_var; export $lt_var
1946              else
1947                $lt_unset $lt_var
1948              fi"
1949      done
1950
1951      # Now prepare to actually exec the command.
1952      exec_cmd="\$cmd$args"
1953    else
1954      # Display what would be done.
1955      if test -n "$shlibpath_var"; then
1956        eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
1957        echo "export $shlibpath_var"
1958      fi
1959      $ECHO "$cmd$args"
1960      exit $EXIT_SUCCESS
1961    fi
1962}
1963
1964test "$mode" = execute && func_mode_execute ${1+"$@"}
1965
1966
1967# func_mode_finish arg...
1968func_mode_finish ()
1969{
1970    $opt_debug
1971    libdirs="$nonopt"
1972    admincmds=
1973
1974    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
1975      for dir
1976      do
1977        libdirs="$libdirs $dir"
1978      done
1979
1980      for libdir in $libdirs; do
1981        if test -n "$finish_cmds"; then
1982          # Do each command in the finish commands.
1983          func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
1984'"$cmd"'"'
1985        fi
1986        if test -n "$finish_eval"; then
1987          # Do the single finish_eval.
1988          eval cmds=\"$finish_eval\"
1989          $opt_dry_run || eval "$cmds" || admincmds="$admincmds
1990       $cmds"
1991        fi
1992      done
1993    fi
1994
1995    # Exit here if they wanted silent mode.
1996    $opt_silent && exit $EXIT_SUCCESS
1997
1998    echo "----------------------------------------------------------------------"
1999    echo "Libraries have been installed in:"
2000    for libdir in $libdirs; do
2001      $ECHO "   $libdir"
2002    done
2003    echo
2004    echo "If you ever happen to want to link against installed libraries"
2005    echo "in a given directory, LIBDIR, you must either use libtool, and"
2006    echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
2007    echo "flag during linking and do at least one of the following:"
2008    if test -n "$shlibpath_var"; then
2009      echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
2010      echo "     during execution"
2011    fi
2012    if test -n "$runpath_var"; then
2013      echo "   - add LIBDIR to the \`$runpath_var' environment variable"
2014      echo "     during linking"
2015    fi
2016    if test -n "$hardcode_libdir_flag_spec"; then
2017      libdir=LIBDIR
2018      eval flag=\"$hardcode_libdir_flag_spec\"
2019
2020      $ECHO "   - use the \`$flag' linker flag"
2021    fi
2022    if test -n "$admincmds"; then
2023      $ECHO "   - have your system administrator run these commands:$admincmds"
2024    fi
2025    if test -f /etc/ld.so.conf; then
2026      echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
2027    fi
2028    echo
2029
2030    echo "See any operating system documentation about shared libraries for"
2031    case $host in
2032      solaris2.[6789]|solaris2.1[0-9])
2033        echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
2034        echo "pages."
2035        ;;
2036      *)
2037        echo "more information, such as the ld(1) and ld.so(8) manual pages."
2038        ;;
2039    esac
2040    echo "----------------------------------------------------------------------"
2041    exit $EXIT_SUCCESS
2042}
2043
2044test "$mode" = finish && func_mode_finish ${1+"$@"}
2045
2046
2047# func_mode_install arg...
2048func_mode_install ()
2049{
2050    $opt_debug
2051    # There may be an optional sh(1) argument at the beginning of
2052    # install_prog (especially on Windows NT).
2053    if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
2054       # Allow the use of GNU shtool's install command.
2055       case $nonopt in *shtool*) :;; *) false;; esac; then
2056      # Aesthetically quote it.
2057      func_quote_for_eval "$nonopt"
2058      install_prog="$func_quote_for_eval_result "
2059      arg=$1
2060      shift
2061    else
2062      install_prog=
2063      arg=$nonopt
2064    fi
2065
2066    # The real first argument should be the name of the installation program.
2067    # Aesthetically quote it.
2068    func_quote_for_eval "$arg"
2069    install_prog="$install_prog$func_quote_for_eval_result"
2070    install_shared_prog=$install_prog
2071    case " $install_prog " in
2072      *[\\\ /]cp\ *) install_cp=: ;;
2073      *) install_cp=false ;;
2074    esac
2075
2076    # We need to accept at least all the BSD install flags.
2077    dest=
2078    files=
2079    opts=
2080    prev=
2081    install_type=
2082    isdir=no
2083    stripme=
2084    no_mode=:
2085    for arg
2086    do
2087      arg2=
2088      if test -n "$dest"; then
2089        files="$files $dest"
2090        dest=$arg
2091        continue
2092      fi
2093
2094      case $arg in
2095      -d) isdir=yes ;;
2096      -f)
2097        if $install_cp; then :; else
2098          prev=$arg
2099        fi
2100        ;;
2101      -g | -m | -o)
2102        prev=$arg
2103        ;;
2104      -s)
2105        stripme=" -s"
2106        continue
2107        ;;
2108      -*)
2109        ;;
2110      *)
2111        # If the previous option needed an argument, then skip it.
2112        if test -n "$prev"; then
2113          if test "x$prev" = x-m && test -n "$install_override_mode"; then
2114            arg2=$install_override_mode
2115            no_mode=false
2116          fi
2117          prev=
2118        else
2119          dest=$arg
2120          continue
2121        fi
2122        ;;
2123      esac
2124
2125      # Aesthetically quote the argument.
2126      func_quote_for_eval "$arg"
2127      install_prog="$install_prog $func_quote_for_eval_result"
2128      if test -n "$arg2"; then
2129        func_quote_for_eval "$arg2"
2130      fi
2131      install_shared_prog="$install_shared_prog $func_quote_for_eval_result"
2132    done
2133
2134    test -z "$install_prog" && \
2135      func_fatal_help "you must specify an install program"
2136
2137    test -n "$prev" && \
2138      func_fatal_help "the \`$prev' option requires an argument"
2139
2140    if test -n "$install_override_mode" && $no_mode; then
2141      if $install_cp; then :; else
2142        func_quote_for_eval "$install_override_mode"
2143        install_shared_prog="$install_shared_prog -m $func_quote_for_eval_result"
2144      fi
2145    fi
2146
2147    if test -z "$files"; then
2148      if test -z "$dest"; then
2149        func_fatal_help "no file or destination specified"
2150      else
2151        func_fatal_help "you must specify a destination"
2152      fi
2153    fi
2154
2155    # Strip any trailing slash from the destination.
2156    func_stripname '' '/' "$dest"
2157    dest=$func_stripname_result
2158
2159    # Check to see that the destination is a directory.
2160    test -d "$dest" && isdir=yes
2161    if test "$isdir" = yes; then
2162      destdir="$dest"
2163      destname=
2164    else
2165      func_dirname_and_basename "$dest" "" "."
2166      destdir="$func_dirname_result"
2167      destname="$func_basename_result"
2168
2169      # Not a directory, so check to see that there is only one file specified.
2170      set dummy $files; shift
2171      test "$#" -gt 1 && \
2172        func_fatal_help "\`$dest' is not a directory"
2173    fi
2174    case $destdir in
2175    [\\/]* | [A-Za-z]:[\\/]*) ;;
2176    *)
2177      for file in $files; do
2178        case $file in
2179        *.lo) ;;
2180        *)
2181          func_fatal_help "\`$destdir' must be an absolute directory name"
2182          ;;
2183        esac
2184      done
2185      ;;
2186    esac
2187
2188    # This variable tells wrapper scripts just to set variables rather
2189    # than running their programs.
2190    libtool_install_magic="$magic"
2191
2192    staticlibs=
2193    future_libdirs=
2194    current_libdirs=
2195    for file in $files; do
2196
2197      # Do each installation.
2198      case $file in
2199      *.$libext)
2200        # Do the static libraries later.
2201        staticlibs="$staticlibs $file"
2202        ;;
2203
2204      *.la)
2205        # Check to see that this really is a libtool archive.
2206        func_lalib_unsafe_p "$file" \
2207          || func_fatal_help "\`$file' is not a valid libtool archive"
2208
2209        library_names=
2210        old_library=
2211        relink_command=
2212        func_source "$file"
2213
2214        # Add the libdir to current_libdirs if it is the destination.
2215        if test "X$destdir" = "X$libdir"; then
2216          case "$current_libdirs " in
2217          *" $libdir "*) ;;
2218          *) current_libdirs="$current_libdirs $libdir" ;;
2219          esac
2220        else
2221          # Note the libdir as a future libdir.
2222          case "$future_libdirs " in
2223          *" $libdir "*) ;;
2224          *) future_libdirs="$future_libdirs $libdir" ;;
2225          esac
2226        fi
2227
2228        func_dirname "$file" "/" ""
2229        dir="$func_dirname_result"
2230        dir="$dir$objdir"
2231
2232        if test -n "$relink_command"; then
2233          # Determine the prefix the user has applied to our future dir.
2234          inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
2235
2236          # Don't allow the user to place us outside of our expected
2237          # location b/c this prevents finding dependent libraries that
2238          # are installed to the same prefix.
2239          # At present, this check doesn't affect windows .dll's that
2240          # are installed into $libdir/../bin (currently, that works fine)
2241          # but it's something to keep an eye on.
2242          test "$inst_prefix_dir" = "$destdir" && \
2243            func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2244
2245          if test -n "$inst_prefix_dir"; then
2246            # Stick the inst_prefix_dir data into the link command.
2247            relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2248          else
2249            relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
2250          fi
2251
2252          func_warning "relinking \`$file'"
2253          func_show_eval "$relink_command" \
2254            'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2255        fi
2256
2257        # See the names of the shared library.
2258        set dummy $library_names; shift
2259        if test -n "$1"; then
2260          realname="$1"
2261          shift
2262
2263          srcname="$realname"
2264          test -n "$relink_command" && srcname="$realname"T
2265
2266          # Install the shared library and build the symlinks.
2267          func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
2268              'exit $?'
2269          tstripme="$stripme"
2270          case $host_os in
2271          cygwin* | mingw* | pw32* | cegcc*)
2272            case $realname in
2273            *.dll.a)
2274              tstripme=""
2275              ;;
2276            esac
2277            ;;
2278          esac
2279          if test -n "$tstripme" && test -n "$striplib"; then
2280            func_show_eval "$striplib $destdir/$realname" 'exit $?'
2281          fi
2282
2283          if test "$#" -gt 0; then
2284            # Delete the old symlinks, and create new ones.
2285            # Try `ln -sf' first, because the `ln' binary might depend on
2286            # the symlink we replace!  Solaris /bin/ln does not understand -f,
2287            # so we also need to try rm && ln -s.
2288            for linkname
2289            do
2290              test "$linkname" != "$realname" \
2291                && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
2292            done
2293          fi
2294
2295          # Do each command in the postinstall commands.
2296          lib="$destdir/$realname"
2297          func_execute_cmds "$postinstall_cmds" 'exit $?'
2298        fi
2299
2300        # Install the pseudo-library for information purposes.
2301        func_basename "$file"
2302        name="$func_basename_result"
2303        instname="$dir/$name"i
2304        func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
2305
2306        # Maybe install the static library, too.
2307        test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
2308        ;;
2309
2310      *.lo)
2311        # Install (i.e. copy) a libtool object.
2312
2313        # Figure out destination file name, if it wasn't already specified.
2314        if test -n "$destname"; then
2315          destfile="$destdir/$destname"
2316        else
2317          func_basename "$file"
2318          destfile="$func_basename_result"
2319          destfile="$destdir/$destfile"
2320        fi
2321
2322        # Deduce the name of the destination old-style object file.
2323        case $destfile in
2324        *.lo)
2325          func_lo2o "$destfile"
2326          staticdest=$func_lo2o_result
2327          ;;
2328        *.$objext)
2329          staticdest="$destfile"
2330          destfile=
2331          ;;
2332        *)
2333          func_fatal_help "cannot copy a libtool object to \`$destfile'"
2334          ;;
2335        esac
2336
2337        # Install the libtool object if requested.
2338        test -n "$destfile" && \
2339          func_show_eval "$install_prog $file $destfile" 'exit $?'
2340
2341        # Install the old object if enabled.
2342        if test "$build_old_libs" = yes; then
2343          # Deduce the name of the old-style object file.
2344          func_lo2o "$file"
2345          staticobj=$func_lo2o_result
2346          func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
2347        fi
2348        exit $EXIT_SUCCESS
2349        ;;
2350
2351      *)
2352        # Figure out destination file name, if it wasn't already specified.
2353        if test -n "$destname"; then
2354          destfile="$destdir/$destname"
2355        else
2356          func_basename "$file"
2357          destfile="$func_basename_result"
2358          destfile="$destdir/$destfile"
2359        fi
2360
2361        # If the file is missing, and there is a .exe on the end, strip it
2362        # because it is most likely a libtool script we actually want to
2363        # install
2364        stripped_ext=""
2365        case $file in
2366          *.exe)
2367            if test ! -f "$file"; then
2368              func_stripname '' '.exe' "$file"
2369              file=$func_stripname_result
2370              stripped_ext=".exe"
2371            fi
2372            ;;
2373        esac
2374
2375        # Do a test to see if this is really a libtool program.
2376        case $host in
2377        *cygwin* | *mingw*)
2378            if func_ltwrapper_executable_p "$file"; then
2379              func_ltwrapper_scriptname "$file"
2380              wrapper=$func_ltwrapper_scriptname_result
2381            else
2382              func_stripname '' '.exe' "$file"
2383              wrapper=$func_stripname_result
2384            fi
2385            ;;
2386        *)
2387            wrapper=$file
2388            ;;
2389        esac
2390        if func_ltwrapper_script_p "$wrapper"; then
2391          notinst_deplibs=
2392          relink_command=
2393
2394          func_source "$wrapper"
2395
2396          # Check the variables that should have been set.
2397          test -z "$generated_by_libtool_version" && \
2398            func_fatal_error "invalid libtool wrapper script \`$wrapper'"
2399
2400          finalize=yes
2401          for lib in $notinst_deplibs; do
2402            # Check to see that each library is installed.
2403            libdir=
2404            if test -f "$lib"; then
2405              func_source "$lib"
2406            fi
2407            libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
2408            if test -n "$libdir" && test ! -f "$libfile"; then
2409              func_warning "\`$lib' has not been installed in \`$libdir'"
2410              finalize=no
2411            fi
2412          done
2413
2414          relink_command=
2415          func_source "$wrapper"
2416
2417          outputname=
2418          if test "$fast_install" = no && test -n "$relink_command"; then
2419            $opt_dry_run || {
2420              if test "$finalize" = yes; then
2421                tmpdir=`func_mktempdir`
2422                func_basename "$file$stripped_ext"
2423                file="$func_basename_result"
2424                outputname="$tmpdir/$file"
2425                # Replace the output file specification.
2426                relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
2427
2428                $opt_silent || {
2429                  func_quote_for_expand "$relink_command"
2430                  eval "func_echo $func_quote_for_expand_result"
2431                }
2432                if eval "$relink_command"; then :
2433                  else
2434                  func_error "error: relink \`$file' with the above command before installing it"
2435                  $opt_dry_run || ${RM}r "$tmpdir"
2436                  continue
2437                fi
2438                file="$outputname"
2439              else
2440                func_warning "cannot relink \`$file'"
2441              fi
2442            }
2443          else
2444            # Install the binary that we compiled earlier.
2445            file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
2446          fi
2447        fi
2448
2449        # remove .exe since cygwin /usr/bin/install will append another
2450        # one anyway
2451        case $install_prog,$host in
2452        */usr/bin/install*,*cygwin*)
2453          case $file:$destfile in
2454          *.exe:*.exe)
2455            # this is ok
2456            ;;
2457          *.exe:*)
2458            destfile=$destfile.exe
2459            ;;
2460          *:*.exe)
2461            func_stripname '' '.exe' "$destfile"
2462            destfile=$func_stripname_result
2463            ;;
2464          esac
2465          ;;
2466        esac
2467        func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
2468        $opt_dry_run || if test -n "$outputname"; then
2469          ${RM}r "$tmpdir"
2470        fi
2471        ;;
2472      esac
2473    done
2474
2475    for file in $staticlibs; do
2476      func_basename "$file"
2477      name="$func_basename_result"
2478
2479      # Set up the ranlib parameters.
2480      oldlib="$destdir/$name"
2481
2482      func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
2483
2484      if test -n "$stripme" && test -n "$old_striplib"; then
2485        func_show_eval "$old_striplib $oldlib" 'exit $?'
2486      fi
2487
2488      # Do each command in the postinstall commands.
2489      func_execute_cmds "$old_postinstall_cmds" 'exit $?'
2490    done
2491
2492    test -n "$future_libdirs" && \
2493      func_warning "remember to run \`$progname --finish$future_libdirs'"
2494
2495    if test -n "$current_libdirs"; then
2496      # Maybe just do a dry run.
2497      $opt_dry_run && current_libdirs=" -n$current_libdirs"
2498      exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
2499    else
2500      exit $EXIT_SUCCESS
2501    fi
2502}
2503
2504test "$mode" = install && func_mode_install ${1+"$@"}
2505
2506
2507# func_generate_dlsyms outputname originator pic_p
2508# Extract symbols from dlprefiles and create ${outputname}S.o with
2509# a dlpreopen symbol table.
2510func_generate_dlsyms ()
2511{
2512    $opt_debug
2513    my_outputname="$1"
2514    my_originator="$2"
2515    my_pic_p="${3-no}"
2516    my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
2517    my_dlsyms=
2518
2519    if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2520      if test -n "$NM" && test -n "$global_symbol_pipe"; then
2521        my_dlsyms="${my_outputname}S.c"
2522      else
2523        func_error "not configured to extract global symbols from dlpreopened files"
2524      fi
2525    fi
2526
2527    if test -n "$my_dlsyms"; then
2528      case $my_dlsyms in
2529      "") ;;
2530      *.c)
2531        # Discover the nlist of each of the dlfiles.
2532        nlist="$output_objdir/${my_outputname}.nm"
2533
2534        func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
2535
2536        # Parse the name list into a source file.
2537        func_verbose "creating $output_objdir/$my_dlsyms"
2538
2539        $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
2540/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
2541/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
2542
2543#ifdef __cplusplus
2544extern \"C\" {
2545#endif
2546
2547#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
2548#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
2549#endif
2550
2551/* External symbol declarations for the compiler. */\
2552"
2553
2554        if test "$dlself" = yes; then
2555          func_verbose "generating symbol list for \`$output'"
2556
2557          $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
2558
2559          # Add our own program objects to the symbol list.
2560          progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
2561          for progfile in $progfiles; do
2562            func_verbose "extracting global C symbols from \`$progfile'"
2563            $opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
2564          done
2565
2566          if test -n "$exclude_expsyms"; then
2567            $opt_dry_run || {
2568              eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
2569              eval '$MV "$nlist"T "$nlist"'
2570            }
2571          fi
2572
2573          if test -n "$export_symbols_regex"; then
2574            $opt_dry_run || {
2575              eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
2576              eval '$MV "$nlist"T "$nlist"'
2577            }
2578          fi
2579
2580          # Prepare the list of exported symbols
2581          if test -z "$export_symbols"; then
2582            export_symbols="$output_objdir/$outputname.exp"
2583            $opt_dry_run || {
2584              $RM $export_symbols
2585              eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
2586              case $host in
2587              *cygwin* | *mingw* | *cegcc* )
2588                eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2589                eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
2590                ;;
2591              esac
2592            }
2593          else
2594            $opt_dry_run || {
2595              eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
2596              eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
2597              eval '$MV "$nlist"T "$nlist"'
2598              case $host in
2599                *cygwin* | *mingw* | *cegcc* )
2600                  eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2601                  eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
2602                  ;;
2603              esac
2604            }
2605          fi
2606        fi
2607
2608        for dlprefile in $dlprefiles; do
2609          func_verbose "extracting global C symbols from \`$dlprefile'"
2610          func_basename "$dlprefile"
2611          name="$func_basename_result"
2612          $opt_dry_run || {
2613            eval '$ECHO ": $name " >> "$nlist"'
2614            eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
2615          }
2616        done
2617
2618        $opt_dry_run || {
2619          # Make sure we have at least an empty file.
2620          test -f "$nlist" || : > "$nlist"
2621
2622          if test -n "$exclude_expsyms"; then
2623            $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
2624            $MV "$nlist"T "$nlist"
2625          fi
2626
2627          # Try sorting and uniquifying the output.
2628          if $GREP -v "^: " < "$nlist" |
2629              if sort -k 3 </dev/null >/dev/null 2>&1; then
2630                sort -k 3
2631              else
2632                sort +2
2633              fi |
2634              uniq > "$nlist"S; then
2635            :
2636          else
2637            $GREP -v "^: " < "$nlist" > "$nlist"S
2638          fi
2639
2640          if test -f "$nlist"S; then
2641            eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
2642          else
2643            echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
2644          fi
2645
2646          echo >> "$output_objdir/$my_dlsyms" "\
2647
2648/* The mapping between symbol names and symbols.  */
2649typedef struct {
2650  const char *name;
2651  void *address;
2652} lt_dlsymlist;
2653"
2654          case $host in
2655          *cygwin* | *mingw* | *cegcc* )
2656            echo >> "$output_objdir/$my_dlsyms" "\
2657/* DATA imports from DLLs on WIN32 con't be const, because
2658   runtime relocations are performed -- see ld's documentation
2659   on pseudo-relocs.  */"
2660            lt_dlsym_const= ;;
2661          *osf5*)
2662            echo >> "$output_objdir/$my_dlsyms" "\
2663/* This system does not cope well with relocations in const data */"
2664            lt_dlsym_const= ;;
2665          *)
2666            lt_dlsym_const=const ;;
2667          esac
2668
2669          echo >> "$output_objdir/$my_dlsyms" "\
2670extern $lt_dlsym_const lt_dlsymlist
2671lt_${my_prefix}_LTX_preloaded_symbols[];
2672$lt_dlsym_const lt_dlsymlist
2673lt_${my_prefix}_LTX_preloaded_symbols[] =
2674{\
2675  { \"$my_originator\", (void *) 0 },"
2676
2677          case $need_lib_prefix in
2678          no)
2679            eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
2680            ;;
2681          *)
2682            eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
2683            ;;
2684          esac
2685          echo >> "$output_objdir/$my_dlsyms" "\
2686  {0, (void *) 0}
2687};
2688
2689/* This works around a problem in FreeBSD linker */
2690#ifdef FREEBSD_WORKAROUND
2691static const void *lt_preloaded_setup() {
2692  return lt_${my_prefix}_LTX_preloaded_symbols;
2693}
2694#endif
2695
2696#ifdef __cplusplus
2697}
2698#endif\
2699"
2700        } # !$opt_dry_run
2701
2702        pic_flag_for_symtable=
2703        case "$compile_command " in
2704        *" -static "*) ;;
2705        *)
2706          case $host in
2707          # compiling the symbol table file with pic_flag works around
2708          # a FreeBSD bug that causes programs to crash when -lm is
2709          # linked before any other PIC object.  But we must not use
2710          # pic_flag when linking with -static.  The problem exists in
2711          # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
2712          *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
2713            pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
2714          *-*-hpux*)
2715            pic_flag_for_symtable=" $pic_flag"  ;;
2716          *)
2717            if test "X$my_pic_p" != Xno; then
2718              pic_flag_for_symtable=" $pic_flag"
2719            fi
2720            ;;
2721          esac
2722          ;;
2723        esac
2724        symtab_cflags=
2725        for arg in $LTCFLAGS; do
2726          case $arg in
2727          -pie | -fpie | -fPIE) ;;
2728          *) symtab_cflags="$symtab_cflags $arg" ;;
2729          esac
2730        done
2731
2732        # Now compile the dynamic symbol file.
2733        func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
2734
2735        # Clean up the generated files.
2736        func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
2737
2738        # Transform the symbol file into the correct name.
2739        symfileobj="$output_objdir/${my_outputname}S.$objext"
2740        case $host in
2741        *cygwin* | *mingw* | *cegcc* )
2742          if test -f "$output_objdir/$my_outputname.def"; then
2743            compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2744            finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2745          else
2746            compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
2747            finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
2748          fi
2749          ;;
2750        *)
2751          compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
2752          finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
2753          ;;
2754        esac
2755        ;;
2756      *)
2757        func_fatal_error "unknown suffix for \`$my_dlsyms'"
2758        ;;
2759      esac
2760    else
2761      # We keep going just in case the user didn't refer to
2762      # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
2763      # really was required.
2764
2765      # Nullify the symbol file.
2766      compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
2767      finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
2768    fi
2769}
2770
2771# func_win32_libid arg
2772# return the library type of file 'arg'
2773#
2774# Need a lot of goo to handle *both* DLLs and import libs
2775# Has to be a shell function in order to 'eat' the argument
2776# that is supplied when $file_magic_command is called.
2777# Despite the name, also deal with 64 bit binaries.
2778func_win32_libid ()
2779{
2780  $opt_debug
2781  win32_libid_type="unknown"
2782  win32_fileres=`file -L $1 2>/dev/null`
2783  case $win32_fileres in
2784  *ar\ archive\ import\ library*) # definitely import
2785    win32_libid_type="x86 archive import"
2786    ;;
2787  *ar\ archive*) # could be an import, or static
2788    # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
2789    if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
2790       $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
2791      win32_nmres=`eval $NM -f posix -A $1 |
2792        $SED -n -e '
2793            1,100{
2794                / I /{
2795                    s,.*,import,
2796                    p
2797                    q
2798                }
2799            }'`
2800      case $win32_nmres in
2801      import*)  win32_libid_type="x86 archive import";;
2802      *)        win32_libid_type="x86 archive static";;
2803      esac
2804    fi
2805    ;;
2806  *DLL*)
2807    win32_libid_type="x86 DLL"
2808    ;;
2809  *executable*) # but shell scripts are "executable" too...
2810    case $win32_fileres in
2811    *MS\ Windows\ PE\ Intel*)
2812      win32_libid_type="x86 DLL"
2813      ;;
2814    esac
2815    ;;
2816  esac
2817  $ECHO "$win32_libid_type"
2818}
2819
2820
2821
2822# func_extract_an_archive dir oldlib
2823func_extract_an_archive ()
2824{
2825    $opt_debug
2826    f_ex_an_ar_dir="$1"; shift
2827    f_ex_an_ar_oldlib="$1"
2828    if test "$lock_old_archive_extraction" = yes; then
2829      lockfile=$f_ex_an_ar_oldlib.lock
2830      until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
2831        func_echo "Waiting for $lockfile to be removed"
2832        sleep 2
2833      done
2834    fi
2835    func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
2836                   'stat=$?; rm -f "$lockfile"; exit $stat'
2837    if test "$lock_old_archive_extraction" = yes; then
2838      $opt_dry_run || rm -f "$lockfile"
2839    fi
2840    if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
2841     :
2842    else
2843      func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
2844    fi
2845}
2846
2847
2848# func_extract_archives gentop oldlib ...
2849func_extract_archives ()
2850{
2851    $opt_debug
2852    my_gentop="$1"; shift
2853    my_oldlibs=${1+"$@"}
2854    my_oldobjs=""
2855    my_xlib=""
2856    my_xabs=""
2857    my_xdir=""
2858
2859    for my_xlib in $my_oldlibs; do
2860      # Extract the objects.
2861      case $my_xlib in
2862        [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
2863        *) my_xabs=`pwd`"/$my_xlib" ;;
2864      esac
2865      func_basename "$my_xlib"
2866      my_xlib="$func_basename_result"
2867      my_xlib_u=$my_xlib
2868      while :; do
2869        case " $extracted_archives " in
2870        *" $my_xlib_u "*)
2871          func_arith $extracted_serial + 1
2872          extracted_serial=$func_arith_result
2873          my_xlib_u=lt$extracted_serial-$my_xlib ;;
2874        *) break ;;
2875        esac
2876      done
2877      extracted_archives="$extracted_archives $my_xlib_u"
2878      my_xdir="$my_gentop/$my_xlib_u"
2879
2880      func_mkdir_p "$my_xdir"
2881
2882      case $host in
2883      *-darwin*)
2884        func_verbose "Extracting $my_xabs"
2885        # Do not bother doing anything if just a dry run
2886        $opt_dry_run || {
2887          darwin_orig_dir=`pwd`
2888          cd $my_xdir || exit $?
2889          darwin_archive=$my_xabs
2890          darwin_curdir=`pwd`
2891          darwin_base_archive=`basename "$darwin_archive"`
2892          darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
2893          if test -n "$darwin_arches"; then
2894            darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
2895            darwin_arch=
2896            func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
2897            for darwin_arch in  $darwin_arches ; do
2898              func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2899              $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
2900              cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2901              func_extract_an_archive "`pwd`" "${darwin_base_archive}"
2902              cd "$darwin_curdir"
2903              $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
2904            done # $darwin_arches
2905            ## Okay now we've a bunch of thin objects, gotta fatten them up :)
2906            darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
2907            darwin_file=
2908            darwin_files=
2909            for darwin_file in $darwin_filelist; do
2910              darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
2911              $LIPO -create -output "$darwin_file" $darwin_files
2912            done # $darwin_filelist
2913            $RM -rf unfat-$$
2914            cd "$darwin_orig_dir"
2915          else
2916            cd $darwin_orig_dir
2917            func_extract_an_archive "$my_xdir" "$my_xabs"
2918          fi # $darwin_arches
2919        } # !$opt_dry_run
2920        ;;
2921      *)
2922        func_extract_an_archive "$my_xdir" "$my_xabs"
2923        ;;
2924      esac
2925      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
2926    done
2927
2928    func_extract_archives_result="$my_oldobjs"
2929}
2930
2931
2932# func_emit_wrapper [arg=no]
2933#
2934# Emit a libtool wrapper script on stdout.
2935# Don't directly open a file because we may want to
2936# incorporate the script contents within a cygwin/mingw
2937# wrapper executable.  Must ONLY be called from within
2938# func_mode_link because it depends on a number of variables
2939# set therein.
2940#
2941# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
2942# variable will take.  If 'yes', then the emitted script
2943# will assume that the directory in which it is stored is
2944# the $objdir directory.  This is a cygwin/mingw-specific
2945# behavior.
2946func_emit_wrapper ()
2947{
2948        func_emit_wrapper_arg1=${1-no}
2949
2950        $ECHO "\
2951#! $SHELL
2952
2953# $output - temporary wrapper script for $objdir/$outputname
2954# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
2955#
2956# The $output program cannot be directly executed until all the libtool
2957# libraries that it depends on are installed.
2958#
2959# This wrapper script should never be moved out of the build directory.
2960# If it is, it will not operate correctly.
2961
2962# Sed substitution that helps us do robust quoting.  It backslashifies
2963# metacharacters that are still active within double-quoted strings.
2964sed_quote_subst='$sed_quote_subst'
2965
2966# Be Bourne compatible
2967if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
2968  emulate sh
2969  NULLCMD=:
2970  # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
2971  # is contrary to our usage.  Disable this feature.
2972  alias -g '\${1+\"\$@\"}'='\"\$@\"'
2973  setopt NO_GLOB_SUBST
2974else
2975  case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
2976fi
2977BIN_SH=xpg4; export BIN_SH # for Tru64
2978DUALCASE=1; export DUALCASE # for MKS sh
2979
2980# The HP-UX ksh and POSIX shell print the target directory to stdout
2981# if CDPATH is set.
2982(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
2983
2984relink_command=\"$relink_command\"
2985
2986# This environment variable determines our operation mode.
2987if test \"\$libtool_install_magic\" = \"$magic\"; then
2988  # install mode needs the following variables:
2989  generated_by_libtool_version='$macro_version'
2990  notinst_deplibs='$notinst_deplibs'
2991else
2992  # When we are sourced in execute mode, \$file and \$ECHO are already set.
2993  if test \"\$libtool_execute_magic\" != \"$magic\"; then
2994    file=\"\$0\""
2995
2996    qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
2997    $ECHO "\
2998
2999# A function that is used when there is no print builtin or printf.
3000func_fallback_echo ()
3001{
3002  eval 'cat <<_LTECHO_EOF
3003\$1
3004_LTECHO_EOF'
3005}
3006    ECHO=\"$qECHO\"
3007  fi
3008
3009# Very basic option parsing. These options are (a) specific to
3010# the libtool wrapper, (b) are identical between the wrapper
3011# /script/ and the wrapper /executable/ which is used only on
3012# windows platforms, and (c) all begin with the string "--lt-"
3013# (application programs are unlikely to have options which match
3014# this pattern).
3015#
3016# There are only two supported options: --lt-debug and
3017# --lt-dump-script. There is, deliberately, no --lt-help.
3018#
3019# The first argument to this parsing function should be the
3020# script's $0 value, followed by "$@".
3021lt_option_debug=
3022func_parse_lt_options ()
3023{
3024  lt_script_arg0=\$0
3025  shift
3026  for lt_opt
3027  do
3028    case \"\$lt_opt\" in
3029    --lt-debug) lt_option_debug=1 ;;
3030    --lt-dump-script)
3031        lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
3032        test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
3033        lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
3034        cat \"\$lt_dump_D/\$lt_dump_F\"
3035        exit 0
3036      ;;
3037    --lt-*)
3038        \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
3039        exit 1
3040      ;;
3041    esac
3042  done
3043
3044  # Print the debug banner immediately:
3045  if test -n \"\$lt_option_debug\"; then
3046    echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
3047  fi
3048}
3049
3050# Used when --lt-debug. Prints its arguments to stdout
3051# (redirection is the responsibility of the caller)
3052func_lt_dump_args ()
3053{
3054  lt_dump_args_N=1;
3055  for lt_arg
3056  do
3057    \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
3058    lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
3059  done
3060}
3061
3062# Core function for launching the target application
3063func_exec_program_core ()
3064{
3065"
3066  case $host in
3067  # Backslashes separate directories on plain windows
3068  *-*-mingw | *-*-os2* | *-cegcc*)
3069    $ECHO "\
3070      if test -n \"\$lt_option_debug\"; then
3071        \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
3072        func_lt_dump_args \${1+\"\$@\"} 1>&2
3073      fi
3074      exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
3075"
3076    ;;
3077
3078  *)
3079    $ECHO "\
3080      if test -n \"\$lt_option_debug\"; then
3081        \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
3082        func_lt_dump_args \${1+\"\$@\"} 1>&2
3083      fi
3084      exec \"\$progdir/\$program\" \${1+\"\$@\"}
3085"
3086    ;;
3087  esac
3088  $ECHO "\
3089      \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
3090      exit 1
3091}
3092
3093# A function to encapsulate launching the target application
3094# Strips options in the --lt-* namespace from \$@ and
3095# launches target application with the remaining arguments.
3096func_exec_program ()
3097{
3098  for lt_wr_arg
3099  do
3100    case \$lt_wr_arg in
3101    --lt-*) ;;
3102    *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
3103    esac
3104    shift
3105  done
3106  func_exec_program_core \${1+\"\$@\"}
3107}
3108
3109  # Parse options
3110  func_parse_lt_options \"\$0\" \${1+\"\$@\"}
3111
3112  # Find the directory that this script lives in.
3113  thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
3114  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
3115
3116  # Follow symbolic links until we get to the real thisdir.
3117  file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
3118  while test -n \"\$file\"; do
3119    destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
3120
3121    # If there was a directory component, then change thisdir.
3122    if test \"x\$destdir\" != \"x\$file\"; then
3123      case \"\$destdir\" in
3124      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
3125      *) thisdir=\"\$thisdir/\$destdir\" ;;
3126      esac
3127    fi
3128
3129    file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
3130    file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
3131  done
3132
3133  # Usually 'no', except on cygwin/mingw when embedded into
3134  # the cwrapper.
3135  WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
3136  if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
3137    # special case for '.'
3138    if test \"\$thisdir\" = \".\"; then
3139      thisdir=\`pwd\`
3140    fi
3141    # remove .libs from thisdir
3142    case \"\$thisdir\" in
3143    *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
3144    $objdir )   thisdir=. ;;
3145    esac
3146  fi
3147
3148  # Try to get the absolute directory name.
3149  absdir=\`cd \"\$thisdir\" && pwd\`
3150  test -n \"\$absdir\" && thisdir=\"\$absdir\"
3151"
3152
3153        if test "$fast_install" = yes; then
3154          $ECHO "\
3155  program=lt-'$outputname'$exeext
3156  progdir=\"\$thisdir/$objdir\"
3157
3158  if test ! -f \"\$progdir/\$program\" ||
3159     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
3160       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
3161
3162    file=\"\$\$-\$program\"
3163
3164    if test ! -d \"\$progdir\"; then
3165      $MKDIR \"\$progdir\"
3166    else
3167      $RM \"\$progdir/\$file\"
3168    fi"
3169
3170          $ECHO "\
3171
3172    # relink executable if necessary
3173    if test -n \"\$relink_command\"; then
3174      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
3175      else
3176        $ECHO \"\$relink_command_output\" >&2
3177        $RM \"\$progdir/\$file\"
3178        exit 1
3179      fi
3180    fi
3181
3182    $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
3183    { $RM \"\$progdir/\$program\";
3184      $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
3185    $RM \"\$progdir/\$file\"
3186  fi"
3187        else
3188          $ECHO "\
3189  program='$outputname'
3190  progdir=\"\$thisdir/$objdir\"
3191"
3192        fi
3193
3194        $ECHO "\
3195
3196  if test -f \"\$progdir/\$program\"; then"
3197
3198        # Export our shlibpath_var if we have one.
3199        if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3200          $ECHO "\
3201    # Add our own library path to $shlibpath_var
3202    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
3203
3204    # Some systems cannot cope with colon-terminated $shlibpath_var
3205    # The second colon is a workaround for a bug in BeOS R4 sed
3206    $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
3207
3208    export $shlibpath_var
3209"
3210        fi
3211
3212        # fixup the dll searchpath if we need to.
3213        if test -n "$dllsearchpath"; then
3214          $ECHO "\
3215    # Add the dll search path components to the executable PATH
3216    PATH=$dllsearchpath:\$PATH
3217"
3218        fi
3219
3220        $ECHO "\
3221    if test \"\$libtool_execute_magic\" != \"$magic\"; then
3222      # Run the actual program with our arguments.
3223      func_exec_program \${1+\"\$@\"}
3224    fi
3225  else
3226    # The program doesn't exist.
3227    \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
3228    \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
3229    \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
3230    exit 1
3231  fi
3232fi\
3233"
3234}
3235
3236
3237# func_to_host_path arg
3238#
3239# Convert paths to host format when used with build tools.
3240# Intended for use with "native" mingw (where libtool itself
3241# is running under the msys shell), or in the following cross-
3242# build environments:
3243#    $build          $host
3244#    mingw (msys)    mingw  [e.g. native]
3245#    cygwin          mingw
3246#    *nix + wine     mingw
3247# where wine is equipped with the `winepath' executable.
3248# In the native mingw case, the (msys) shell automatically
3249# converts paths for any non-msys applications it launches,
3250# but that facility isn't available from inside the cwrapper.
3251# Similar accommodations are necessary for $host mingw and
3252# $build cygwin.  Calling this function does no harm for other
3253# $host/$build combinations not listed above.
3254#
3255# ARG is the path (on $build) that should be converted to
3256# the proper representation for $host. The result is stored
3257# in $func_to_host_path_result.
3258func_to_host_path ()
3259{
3260  func_to_host_path_result="$1"
3261  if test -n "$1"; then
3262    case $host in
3263      *mingw* )
3264        lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
3265        case $build in
3266          *mingw* ) # actually, msys
3267            # awkward: cmd appends spaces to result
3268            func_to_host_path_result=`( cmd //c echo "$1" ) 2>/dev/null |
3269              $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
3270            ;;
3271          *cygwin* )
3272            func_to_host_path_result=`cygpath -w "$1" |
3273              $SED -e "$lt_sed_naive_backslashify"`
3274            ;;
3275          * )
3276            # Unfortunately, winepath does not exit with a non-zero
3277            # error code, so we are forced to check the contents of
3278            # stdout. On the other hand, if the command is not
3279            # found, the shell will set an exit code of 127 and print
3280            # *an error message* to stdout. So we must check for both
3281            # error code of zero AND non-empty stdout, which explains
3282            # the odd construction:
3283            func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null`
3284            if test "$?" -eq 0 && test -n "${func_to_host_path_tmp1}"; then
3285              func_to_host_path_result=`$ECHO "$func_to_host_path_tmp1" |
3286                $SED -e "$lt_sed_naive_backslashify"`
3287            else
3288              # Allow warning below.
3289              func_to_host_path_result=
3290            fi
3291            ;;
3292        esac
3293        if test -z "$func_to_host_path_result" ; then
3294          func_error "Could not determine host path corresponding to"
3295          func_error "  \`$1'"
3296          func_error "Continuing, but uninstalled executables may not work."
3297          # Fallback:
3298          func_to_host_path_result="$1"
3299        fi
3300        ;;
3301    esac
3302  fi
3303}
3304# end: func_to_host_path
3305
3306# func_to_host_pathlist arg
3307#
3308# Convert pathlists to host format when used with build tools.
3309# See func_to_host_path(), above. This function supports the
3310# following $build/$host combinations (but does no harm for
3311# combinations not listed here):
3312#    $build          $host
3313#    mingw (msys)    mingw  [e.g. native]
3314#    cygwin          mingw
3315#    *nix + wine     mingw
3316#
3317# Path separators are also converted from $build format to
3318# $host format. If ARG begins or ends with a path separator
3319# character, it is preserved (but converted to $host format)
3320# on output.
3321#
3322# ARG is a pathlist (on $build) that should be converted to
3323# the proper representation on $host. The result is stored
3324# in $func_to_host_pathlist_result.
3325func_to_host_pathlist ()
3326{
3327  func_to_host_pathlist_result="$1"
3328  if test -n "$1"; then
3329    case $host in
3330      *mingw* )
3331        lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
3332        # Remove leading and trailing path separator characters from
3333        # ARG. msys behavior is inconsistent here, cygpath turns them
3334        # into '.;' and ';.', and winepath ignores them completely.
3335        func_stripname : : "$1"
3336        func_to_host_pathlist_tmp1=$func_stripname_result
3337        case $build in
3338          *mingw* ) # Actually, msys.
3339            # Awkward: cmd appends spaces to result.
3340            func_to_host_pathlist_result=`
3341              ( cmd //c echo "$func_to_host_pathlist_tmp1" ) 2>/dev/null |
3342              $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
3343            ;;
3344          *cygwin* )
3345            func_to_host_pathlist_result=`cygpath -w -p "$func_to_host_pathlist_tmp1" |
3346              $SED -e "$lt_sed_naive_backslashify"`
3347            ;;
3348          * )
3349            # unfortunately, winepath doesn't convert pathlists
3350            func_to_host_pathlist_result=""
3351            func_to_host_pathlist_oldIFS=$IFS
3352            IFS=:
3353            for func_to_host_pathlist_f in $func_to_host_pathlist_tmp1 ; do
3354              IFS=$func_to_host_pathlist_oldIFS
3355              if test -n "$func_to_host_pathlist_f" ; then
3356                func_to_host_path "$func_to_host_pathlist_f"
3357                if test -n "$func_to_host_path_result" ; then
3358                  if test -z "$func_to_host_pathlist_result" ; then
3359                    func_to_host_pathlist_result="$func_to_host_path_result"
3360                  else
3361                    func_append func_to_host_pathlist_result ";$func_to_host_path_result"
3362                  fi
3363                fi
3364              fi
3365            done
3366            IFS=$func_to_host_pathlist_oldIFS
3367            ;;
3368        esac
3369        if test -z "$func_to_host_pathlist_result"; then
3370          func_error "Could not determine the host path(s) corresponding to"
3371          func_error "  \`$1'"
3372          func_error "Continuing, but uninstalled executables may not work."
3373          # Fallback. This may break if $1 contains DOS-style drive
3374          # specifications. The fix is not to complicate the expression
3375          # below, but for the user to provide a working wine installation
3376          # with winepath so that path translation in the cross-to-mingw
3377          # case works properly.
3378          lt_replace_pathsep_nix_to_dos="s|:|;|g"
3379          func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp1" |\
3380            $SED -e "$lt_replace_pathsep_nix_to_dos"`
3381        fi
3382        # Now, add the leading and trailing path separators back
3383        case "$1" in
3384          :* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result"
3385            ;;
3386        esac
3387        case "$1" in
3388          *: ) func_append func_to_host_pathlist_result ";"
3389            ;;
3390        esac
3391        ;;
3392    esac
3393  fi
3394}
3395# end: func_to_host_pathlist
3396
3397# func_emit_cwrapperexe_src
3398# emit the source code for a wrapper executable on stdout
3399# Must ONLY be called from within func_mode_link because
3400# it depends on a number of variable set therein.
3401func_emit_cwrapperexe_src ()
3402{
3403        cat <<EOF
3404
3405/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
3406   Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3407
3408   The $output program cannot be directly executed until all the libtool
3409   libraries that it depends on are installed.
3410
3411   This wrapper executable should never be moved out of the build directory.
3412   If it is, it will not operate correctly.
3413*/
3414EOF
3415            cat <<"EOF"
3416#ifdef _MSC_VER
3417# define _CRT_SECURE_NO_DEPRECATE 1
3418#endif
3419#include <stdio.h>
3420#include <stdlib.h>
3421#ifdef _MSC_VER
3422# include <direct.h>
3423# include <process.h>
3424# include <io.h>
3425#else
3426# include <unistd.h>
3427# include <stdint.h>
3428# ifdef __CYGWIN__
3429#  include <io.h>
3430# endif
3431#endif
3432#include <malloc.h>
3433#include <stdarg.h>
3434#include <assert.h>
3435#include <string.h>
3436#include <ctype.h>
3437#include <errno.h>
3438#include <fcntl.h>
3439#include <sys/stat.h>
3440
3441/* declarations of non-ANSI functions */
3442#if defined(__MINGW32__)
3443# ifdef __STRICT_ANSI__
3444int _putenv (const char *);
3445# endif
3446#elif defined(__CYGWIN__)
3447# ifdef __STRICT_ANSI__
3448char *realpath (const char *, char *);
3449int putenv (char *);
3450int setenv (const char *, const char *, int);
3451# endif
3452/* #elif defined (other platforms) ... */
3453#endif
3454
3455/* portability defines, excluding path handling macros */
3456#if defined(_MSC_VER)
3457# define setmode _setmode
3458# define stat    _stat
3459# define chmod   _chmod
3460# define getcwd  _getcwd
3461# define putenv  _putenv
3462# define S_IXUSR _S_IEXEC
3463# ifndef _INTPTR_T_DEFINED
3464#  define _INTPTR_T_DEFINED
3465#  define intptr_t int
3466# endif
3467#elif defined(__MINGW32__)
3468# define setmode _setmode
3469# define stat    _stat
3470# define chmod   _chmod
3471# define getcwd  _getcwd
3472# define putenv  _putenv
3473#elif defined(__CYGWIN__)
3474# define HAVE_SETENV
3475# define FOPEN_WB "wb"
3476/* #elif defined (other platforms) ... */
3477#endif
3478
3479#if defined(PATH_MAX)
3480# define LT_PATHMAX PATH_MAX
3481#elif defined(MAXPATHLEN)
3482# define LT_PATHMAX MAXPATHLEN
3483#else
3484# define LT_PATHMAX 1024
3485#endif
3486
3487#ifndef S_IXOTH
3488# define S_IXOTH 0
3489#endif
3490#ifndef S_IXGRP
3491# define S_IXGRP 0
3492#endif
3493
3494/* path handling portability macros */
3495#ifndef DIR_SEPARATOR
3496# define DIR_SEPARATOR '/'
3497# define PATH_SEPARATOR ':'
3498#endif
3499
3500#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
3501  defined (__OS2__)
3502# define HAVE_DOS_BASED_FILE_SYSTEM
3503# define FOPEN_WB "wb"
3504# ifndef DIR_SEPARATOR_2
3505#  define DIR_SEPARATOR_2 '\\'
3506# endif
3507# ifndef PATH_SEPARATOR_2
3508#  define PATH_SEPARATOR_2 ';'
3509# endif
3510#endif
3511
3512#ifndef DIR_SEPARATOR_2
3513# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
3514#else /* DIR_SEPARATOR_2 */
3515# define IS_DIR_SEPARATOR(ch) \
3516        (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
3517#endif /* DIR_SEPARATOR_2 */
3518
3519#ifndef PATH_SEPARATOR_2
3520# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
3521#else /* PATH_SEPARATOR_2 */
3522# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
3523#endif /* PATH_SEPARATOR_2 */
3524
3525#ifndef FOPEN_WB
3526# define FOPEN_WB "w"
3527#endif
3528#ifndef _O_BINARY
3529# define _O_BINARY 0
3530#endif
3531
3532#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
3533#define XFREE(stale) do { \
3534  if (stale) { free ((void *) stale); stale = 0; } \
3535} while (0)
3536
3537#if defined(LT_DEBUGWRAPPER)
3538static int lt_debug = 1;
3539#else
3540static int lt_debug = 0;
3541#endif
3542
3543const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
3544
3545void *xmalloc (size_t num);
3546char *xstrdup (const char *string);
3547const char *base_name (const char *name);
3548char *find_executable (const char *wrapper);
3549char *chase_symlinks (const char *pathspec);
3550int make_executable (const char *path);
3551int check_executable (const char *path);
3552char *strendzap (char *str, const char *pat);
3553void lt_debugprintf (const char *file, int line, const char *fmt, ...);
3554void lt_fatal (const char *file, int line, const char *message, ...);
3555static const char *nonnull (const char *s);
3556static const char *nonempty (const char *s);
3557void lt_setenv (const char *name, const char *value);
3558char *lt_extend_str (const char *orig_value, const char *add, int to_end);
3559void lt_update_exe_path (const char *name, const char *value);
3560void lt_update_lib_path (const char *name, const char *value);
3561char **prepare_spawn (char **argv);
3562void lt_dump_script (FILE *f);
3563EOF
3564
3565            cat <<EOF
3566const char * MAGIC_EXE = "$magic_exe";
3567const char * LIB_PATH_VARNAME = "$shlibpath_var";
3568EOF
3569
3570            if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3571              func_to_host_pathlist "$temp_rpath"
3572              cat <<EOF
3573const char * LIB_PATH_VALUE   = "$func_to_host_pathlist_result";
3574EOF
3575            else
3576              cat <<"EOF"
3577const char * LIB_PATH_VALUE   = "";
3578EOF
3579            fi
3580
3581            if test -n "$dllsearchpath"; then
3582              func_to_host_pathlist "$dllsearchpath:"
3583              cat <<EOF
3584const char * EXE_PATH_VARNAME = "PATH";
3585const char * EXE_PATH_VALUE   = "$func_to_host_pathlist_result";
3586EOF
3587            else
3588              cat <<"EOF"
3589const char * EXE_PATH_VARNAME = "";
3590const char * EXE_PATH_VALUE   = "";
3591EOF
3592            fi
3593
3594            if test "$fast_install" = yes; then
3595              cat <<EOF
3596const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
3597EOF
3598            else
3599              cat <<EOF
3600const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
3601EOF
3602            fi
3603
3604
3605            cat <<"EOF"
3606
3607#define LTWRAPPER_OPTION_PREFIX         "--lt-"
3608
3609static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
3610static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
3611static const char *debug_opt            = LTWRAPPER_OPTION_PREFIX "debug";
3612
3613int
3614main (int argc, char *argv[])
3615{
3616  char **newargz;
3617  int  newargc;
3618  char *tmp_pathspec;
3619  char *actual_cwrapper_path;
3620  char *actual_cwrapper_name;
3621  char *target_name;
3622  char *lt_argv_zero;
3623  intptr_t rval = 127;
3624
3625  int i;
3626
3627  program_name = (char *) xstrdup (base_name (argv[0]));
3628  newargz = XMALLOC (char *, argc + 1);
3629
3630  /* very simple arg parsing; don't want to rely on getopt
3631   * also, copy all non cwrapper options to newargz, except
3632   * argz[0], which is handled differently
3633   */
3634  newargc=0;
3635  for (i = 1; i < argc; i++)
3636    {
3637      if (strcmp (argv[i], dumpscript_opt) == 0)
3638        {
3639EOF
3640            case "$host" in
3641              *mingw* | *cygwin* )
3642                # make stdout use "unix" line endings
3643                echo "          setmode(1,_O_BINARY);"
3644                ;;
3645              esac
3646
3647            cat <<"EOF"
3648          lt_dump_script (stdout);
3649          return 0;
3650        }
3651      if (strcmp (argv[i], debug_opt) == 0)
3652        {
3653          lt_debug = 1;
3654          continue;
3655        }
3656      if (strcmp (argv[i], ltwrapper_option_prefix) == 0)
3657        {
3658          /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
3659             namespace, but it is not one of the ones we know about and
3660             have already dealt with, above (inluding dump-script), then
3661             report an error. Otherwise, targets might begin to believe
3662             they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
3663             namespace. The first time any user complains about this, we'll
3664             need to make LTWRAPPER_OPTION_PREFIX a configure-time option
3665             or a configure.ac-settable value.
3666           */
3667          lt_fatal (__FILE__, __LINE__,
3668                    "unrecognized %s option: '%s'",
3669                    ltwrapper_option_prefix, argv[i]);
3670        }
3671      /* otherwise ... */
3672      newargz[++newargc] = xstrdup (argv[i]);
3673    }
3674  newargz[++newargc] = NULL;
3675
3676EOF
3677            cat <<EOF
3678  /* The GNU banner must be the first non-error debug message */
3679  lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");
3680EOF
3681            cat <<"EOF"
3682  lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
3683  lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
3684
3685  tmp_pathspec = find_executable (argv[0]);
3686  if (tmp_pathspec == NULL)
3687    lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
3688  lt_debugprintf (__FILE__, __LINE__,
3689                  "(main) found exe (before symlink chase) at: %s\n",
3690                  tmp_pathspec);
3691
3692  actual_cwrapper_path = chase_symlinks (tmp_pathspec);
3693  lt_debugprintf (__FILE__, __LINE__,
3694                  "(main) found exe (after symlink chase) at: %s\n",
3695                  actual_cwrapper_path);
3696  XFREE (tmp_pathspec);
3697
3698  actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
3699  strendzap (actual_cwrapper_path, actual_cwrapper_name);
3700
3701  /* wrapper name transforms */
3702  strendzap (actual_cwrapper_name, ".exe");
3703  tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
3704  XFREE (actual_cwrapper_name);
3705  actual_cwrapper_name = tmp_pathspec;
3706  tmp_pathspec = 0;
3707
3708  /* target_name transforms -- use actual target program name; might have lt- prefix */
3709  target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
3710  strendzap (target_name, ".exe");
3711  tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
3712  XFREE (target_name);
3713  target_name = tmp_pathspec;
3714  tmp_pathspec = 0;
3715
3716  lt_debugprintf (__FILE__, __LINE__,
3717                  "(main) libtool target name: %s\n",
3718                  target_name);
3719EOF
3720
3721            cat <<EOF
3722  newargz[0] =
3723    XMALLOC (char, (strlen (actual_cwrapper_path) +
3724                    strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
3725  strcpy (newargz[0], actual_cwrapper_path);
3726  strcat (newargz[0], "$objdir");
3727  strcat (newargz[0], "/");
3728EOF
3729
3730            cat <<"EOF"
3731  /* stop here, and copy so we don't have to do this twice */
3732  tmp_pathspec = xstrdup (newargz[0]);
3733
3734  /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
3735  strcat (newargz[0], actual_cwrapper_name);
3736
3737  /* DO want the lt- prefix here if it exists, so use target_name */
3738  lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
3739  XFREE (tmp_pathspec);
3740  tmp_pathspec = NULL;
3741EOF
3742
3743            case $host_os in
3744              mingw*)
3745            cat <<"EOF"
3746  {
3747    char* p;
3748    while ((p = strchr (newargz[0], '\\')) != NULL)
3749      {
3750        *p = '/';
3751      }
3752    while ((p = strchr (lt_argv_zero, '\\')) != NULL)
3753      {
3754        *p = '/';
3755      }
3756  }
3757EOF
3758            ;;
3759            esac
3760
3761            cat <<"EOF"
3762  XFREE (target_name);
3763  XFREE (actual_cwrapper_path);
3764  XFREE (actual_cwrapper_name);
3765
3766  lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
3767  lt_setenv ("DUALCASE", "1");  /* for MSK sh */
3768  lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
3769  lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
3770
3771  lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
3772                  nonnull (lt_argv_zero));
3773  for (i = 0; i < newargc; i++)
3774    {
3775      lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
3776                      i, nonnull (newargz[i]));
3777    }
3778
3779EOF
3780
3781            case $host_os in
3782              mingw*)
3783                cat <<"EOF"
3784  /* execv doesn't actually work on mingw as expected on unix */
3785  newargz = prepare_spawn (newargz);
3786  rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
3787  if (rval == -1)
3788    {
3789      /* failed to start process */
3790      lt_debugprintf (__FILE__, __LINE__,
3791                      "(main) failed to launch target \"%s\": %s\n",
3792                      lt_argv_zero, nonnull (strerror (errno)));
3793      return 127;
3794    }
3795  return rval;
3796EOF
3797                ;;
3798              *)
3799                cat <<"EOF"
3800  execv (lt_argv_zero, newargz);
3801  return rval; /* =127, but avoids unused variable warning */
3802EOF
3803                ;;
3804            esac
3805
3806            cat <<"EOF"
3807}
3808
3809void *
3810xmalloc (size_t num)
3811{
3812  void *p = (void *) malloc (num);
3813  if (!p)
3814    lt_fatal (__FILE__, __LINE__, "memory exhausted");
3815
3816  return p;
3817}
3818
3819char *
3820xstrdup (const char *string)
3821{
3822  return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
3823                          string) : NULL;
3824}
3825
3826const char *
3827base_name (const char *name)
3828{
3829  const char *base;
3830
3831#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3832  /* Skip over the disk name in MSDOS pathnames. */
3833  if (isalpha ((unsigned char) name[0]) && name[1] == ':')
3834    name += 2;
3835#endif
3836
3837  for (base = name; *name; name++)
3838    if (IS_DIR_SEPARATOR (*name))
3839      base = name + 1;
3840  return base;
3841}
3842
3843int
3844check_executable (const char *path)
3845{
3846  struct stat st;
3847
3848  lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
3849                  nonempty (path));
3850  if ((!path) || (!*path))
3851    return 0;
3852
3853  if ((stat (path, &st) >= 0)
3854      && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
3855    return 1;
3856  else
3857    return 0;
3858}
3859
3860int
3861make_executable (const char *path)
3862{
3863  int rval = 0;
3864  struct stat st;
3865
3866  lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
3867                  nonempty (path));
3868  if ((!path) || (!*path))
3869    return 0;
3870
3871  if (stat (path, &st) >= 0)
3872    {
3873      rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
3874    }
3875  return rval;
3876}
3877
3878/* Searches for the full path of the wrapper.  Returns
3879   newly allocated full path name if found, NULL otherwise
3880   Does not chase symlinks, even on platforms that support them.
3881*/
3882char *
3883find_executable (const char *wrapper)
3884{
3885  int has_slash = 0;
3886  const char *p;
3887  const char *p_next;
3888  /* static buffer for getcwd */
3889  char tmp[LT_PATHMAX + 1];
3890  int tmp_len;
3891  char *concat_name;
3892
3893  lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
3894                  nonempty (wrapper));
3895
3896  if ((wrapper == NULL) || (*wrapper == '\0'))
3897    return NULL;
3898
3899  /* Absolute path? */
3900#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3901  if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
3902    {
3903      concat_name = xstrdup (wrapper);
3904      if (check_executable (concat_name))
3905        return concat_name;
3906      XFREE (concat_name);
3907    }
3908  else
3909    {
3910#endif
3911      if (IS_DIR_SEPARATOR (wrapper[0]))
3912        {
3913          concat_name = xstrdup (wrapper);
3914          if (check_executable (concat_name))
3915            return concat_name;
3916          XFREE (concat_name);
3917        }
3918#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3919    }
3920#endif
3921
3922  for (p = wrapper; *p; p++)
3923    if (*p == '/')
3924      {
3925        has_slash = 1;
3926        break;
3927      }
3928  if (!has_slash)
3929    {
3930      /* no slashes; search PATH */
3931      const char *path = getenv ("PATH");
3932      if (path != NULL)
3933        {
3934          for (p = path; *p; p = p_next)
3935            {
3936              const char *q;
3937              size_t p_len;
3938              for (q = p; *q; q++)
3939                if (IS_PATH_SEPARATOR (*q))
3940                  break;
3941              p_len = q - p;
3942              p_next = (*q == '\0' ? q : q + 1);
3943              if (p_len == 0)
3944                {
3945                  /* empty path: current directory */
3946                  if (getcwd (tmp, LT_PATHMAX) == NULL)
3947                    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
3948                              nonnull (strerror (errno)));
3949                  tmp_len = strlen (tmp);
3950                  concat_name =
3951                    XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3952                  memcpy (concat_name, tmp, tmp_len);
3953                  concat_name[tmp_len] = '/';
3954                  strcpy (concat_name + tmp_len + 1, wrapper);
3955                }
3956              else
3957                {
3958                  concat_name =
3959                    XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
3960                  memcpy (concat_name, p, p_len);
3961                  concat_name[p_len] = '/';
3962                  strcpy (concat_name + p_len + 1, wrapper);
3963                }
3964              if (check_executable (concat_name))
3965                return concat_name;
3966              XFREE (concat_name);
3967            }
3968        }
3969      /* not found in PATH; assume curdir */
3970    }
3971  /* Relative path | not found in path: prepend cwd */
3972  if (getcwd (tmp, LT_PATHMAX) == NULL)
3973    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
3974              nonnull (strerror (errno)));
3975  tmp_len = strlen (tmp);
3976  concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3977  memcpy (concat_name, tmp, tmp_len);
3978  concat_name[tmp_len] = '/';
3979  strcpy (concat_name + tmp_len + 1, wrapper);
3980
3981  if (check_executable (concat_name))
3982    return concat_name;
3983  XFREE (concat_name);
3984  return NULL;
3985}
3986
3987char *
3988chase_symlinks (const char *pathspec)
3989{
3990#ifndef S_ISLNK
3991  return xstrdup (pathspec);
3992#else
3993  char buf[LT_PATHMAX];
3994  struct stat s;
3995  char *tmp_pathspec = xstrdup (pathspec);
3996  char *p;
3997  int has_symlinks = 0;
3998  while (strlen (tmp_pathspec) && !has_symlinks)
3999    {
4000      lt_debugprintf (__FILE__, __LINE__,
4001                      "checking path component for symlinks: %s\n",
4002                      tmp_pathspec);
4003      if (lstat (tmp_pathspec, &s) == 0)
4004        {
4005          if (S_ISLNK (s.st_mode) != 0)
4006            {
4007              has_symlinks = 1;
4008              break;
4009            }
4010
4011          /* search backwards for last DIR_SEPARATOR */
4012          p = tmp_pathspec + strlen (tmp_pathspec) - 1;
4013          while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4014            p--;
4015          if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4016            {
4017              /* no more DIR_SEPARATORS left */
4018              break;
4019            }
4020          *p = '\0';
4021        }
4022      else
4023        {
4024          lt_fatal (__FILE__, __LINE__,
4025                    "error accessing file \"%s\": %s",
4026                    tmp_pathspec, nonnull (strerror (errno)));
4027        }
4028    }
4029  XFREE (tmp_pathspec);
4030
4031  if (!has_symlinks)
4032    {
4033      return xstrdup (pathspec);
4034    }
4035
4036  tmp_pathspec = realpath (pathspec, buf);
4037  if (tmp_pathspec == 0)
4038    {
4039      lt_fatal (__FILE__, __LINE__,
4040                "could not follow symlinks for %s", pathspec);
4041    }
4042  return xstrdup (tmp_pathspec);
4043#endif
4044}
4045
4046char *
4047strendzap (char *str, const char *pat)
4048{
4049  size_t len, patlen;
4050
4051  assert (str != NULL);
4052  assert (pat != NULL);
4053
4054  len = strlen (str);
4055  patlen = strlen (pat);
4056
4057  if (patlen <= len)
4058    {
4059      str += len - patlen;
4060      if (strcmp (str, pat) == 0)
4061        *str = '\0';
4062    }
4063  return str;
4064}
4065
4066void
4067lt_debugprintf (const char *file, int line, const char *fmt, ...)
4068{
4069  va_list args;
4070  if (lt_debug)
4071    {
4072      (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
4073      va_start (args, fmt);
4074      (void) vfprintf (stderr, fmt, args);
4075      va_end (args);
4076    }
4077}
4078
4079static void
4080lt_error_core (int exit_status, const char *file,
4081               int line, const char *mode,
4082               const char *message, va_list ap)
4083{
4084  fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
4085  vfprintf (stderr, message, ap);
4086  fprintf (stderr, ".\n");
4087
4088  if (exit_status >= 0)
4089    exit (exit_status);
4090}
4091
4092void
4093lt_fatal (const char *file, int line, const char *message, ...)
4094{
4095  va_list ap;
4096  va_start (ap, message);
4097  lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
4098  va_end (ap);
4099}
4100
4101static const char *
4102nonnull (const char *s)
4103{
4104  return s ? s : "(null)";
4105}
4106
4107static const char *
4108nonempty (const char *s)
4109{
4110  return (s && !*s) ? "(empty)" : nonnull (s);
4111}
4112
4113void
4114lt_setenv (const char *name, const char *value)
4115{
4116  lt_debugprintf (__FILE__, __LINE__,
4117                  "(lt_setenv) setting '%s' to '%s'\n",
4118                  nonnull (name), nonnull (value));
4119  {
4120#ifdef HAVE_SETENV
4121    /* always make a copy, for consistency with !HAVE_SETENV */
4122    char *str = xstrdup (value);
4123    setenv (name, str, 1);
4124#else
4125    int len = strlen (name) + 1 + strlen (value) + 1;
4126    char *str = XMALLOC (char, len);
4127    sprintf (str, "%s=%s", name, value);
4128    if (putenv (str) != EXIT_SUCCESS)
4129      {
4130        XFREE (str);
4131      }
4132#endif
4133  }
4134}
4135
4136char *
4137lt_extend_str (const char *orig_value, const char *add, int to_end)
4138{
4139  char *new_value;
4140  if (orig_value && *orig_value)
4141    {
4142      int orig_value_len = strlen (orig_value);
4143      int add_len = strlen (add);
4144      new_value = XMALLOC (char, add_len + orig_value_len + 1);
4145      if (to_end)
4146        {
4147          strcpy (new_value, orig_value);
4148          strcpy (new_value + orig_value_len, add);
4149        }
4150      else
4151        {
4152          strcpy (new_value, add);
4153          strcpy (new_value + add_len, orig_value);
4154        }
4155    }
4156  else
4157    {
4158      new_value = xstrdup (add);
4159    }
4160  return new_value;
4161}
4162
4163void
4164lt_update_exe_path (const char *name, const char *value)
4165{
4166  lt_debugprintf (__FILE__, __LINE__,
4167                  "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
4168                  nonnull (name), nonnull (value));
4169
4170  if (name && *name && value && *value)
4171    {
4172      char *new_value = lt_extend_str (getenv (name), value, 0);
4173      /* some systems can't cope with a ':'-terminated path #' */
4174      int len = strlen (new_value);
4175      while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
4176        {
4177          new_value[len-1] = '\0';
4178        }
4179      lt_setenv (name, new_value);
4180      XFREE (new_value);
4181    }
4182}
4183
4184void
4185lt_update_lib_path (const char *name, const char *value)
4186{
4187  lt_debugprintf (__FILE__, __LINE__,
4188                  "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4189                  nonnull (name), nonnull (value));
4190
4191  if (name && *name && value && *value)
4192    {
4193      char *new_value = lt_extend_str (getenv (name), value, 0);
4194      lt_setenv (name, new_value);
4195      XFREE (new_value);
4196    }
4197}
4198
4199EOF
4200            case $host_os in
4201              mingw*)
4202                cat <<"EOF"
4203
4204/* Prepares an argument vector before calling spawn().
4205   Note that spawn() does not by itself call the command interpreter
4206     (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
4207      ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
4208         GetVersionEx(&v);
4209         v.dwPlatformId == VER_PLATFORM_WIN32_NT;
4210      }) ? "cmd.exe" : "command.com").
4211   Instead it simply concatenates the arguments, separated by ' ', and calls
4212   CreateProcess().  We must quote the arguments since Win32 CreateProcess()
4213   interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
4214   special way:
4215   - Space and tab are interpreted as delimiters. They are not treated as
4216     delimiters if they are surrounded by double quotes: "...".
4217   - Unescaped double quotes are removed from the input. Their only effect is
4218     that within double quotes, space and tab are treated like normal
4219     characters.
4220   - Backslashes not followed by double quotes are not special.
4221   - But 2*n+1 backslashes followed by a double quote become
4222     n backslashes followed by a double quote (n >= 0):
4223       \" -> "
4224       \\\" -> \"
4225       \\\\\" -> \\"
4226 */
4227#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"
4228#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"
4229char **
4230prepare_spawn (char **argv)
4231{
4232  size_t argc;
4233  char **new_argv;
4234  size_t i;
4235
4236  /* Count number of arguments.  */
4237  for (argc = 0; argv[argc] != NULL; argc++)
4238    ;
4239
4240  /* Allocate new argument vector.  */
4241  new_argv = XMALLOC (char *, argc + 1);
4242
4243  /* Put quoted arguments into the new argument vector.  */
4244  for (i = 0; i < argc; i++)
4245    {
4246      const char *string = argv[i];
4247
4248      if (string[0] == '\0')
4249        new_argv[i] = xstrdup ("\"\"");
4250      else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
4251        {
4252          int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
4253          size_t length;
4254          unsigned int backslashes;
4255          const char *s;
4256          char *quoted_string;
4257          char *p;
4258
4259          length = 0;
4260          backslashes = 0;
4261          if (quote_around)
4262            length++;
4263          for (s = string; *s != '\0'; s++)
4264            {
4265              char c = *s;
4266              if (c == '"')
4267                length += backslashes + 1;
4268              length++;
4269              if (c == '\\')
4270                backslashes++;
4271              else
4272                backslashes = 0;
4273            }
4274          if (quote_around)
4275            length += backslashes + 1;
4276
4277          quoted_string = XMALLOC (char, length + 1);
4278
4279          p = quoted_string;
4280          backslashes = 0;
4281          if (quote_around)
4282            *p++ = '"';
4283          for (s = string; *s != '\0'; s++)
4284            {
4285              char c = *s;
4286              if (c == '"')
4287                {
4288                  unsigned int j;
4289                  for (j = backslashes + 1; j > 0; j--)
4290                    *p++ = '\\';
4291                }
4292              *p++ = c;
4293              if (c == '\\')
4294                backslashes++;
4295              else
4296                backslashes = 0;
4297            }
4298          if (quote_around)
4299            {
4300              unsigned int j;
4301              for (j = backslashes; j > 0; j--)
4302                *p++ = '\\';
4303              *p++ = '"';
4304            }
4305          *p = '\0';
4306
4307          new_argv[i] = quoted_string;
4308        }
4309      else
4310        new_argv[i] = (char *) string;
4311    }
4312  new_argv[argc] = NULL;
4313
4314  return new_argv;
4315}
4316EOF
4317                ;;
4318            esac
4319
4320            cat <<"EOF"
4321void lt_dump_script (FILE* f)
4322{
4323EOF
4324            func_emit_wrapper yes |
4325              $SED -e 's/\([\\"]\)/\\\1/g' \
4326                   -e 's/^/  fputs ("/' -e 's/$/\\n", f);/'
4327
4328            cat <<"EOF"
4329}
4330EOF
4331}
4332# end: func_emit_cwrapperexe_src
4333
4334# func_win32_import_lib_p ARG
4335# True if ARG is an import lib, as indicated by $file_magic_cmd
4336func_win32_import_lib_p ()
4337{
4338    $opt_debug
4339    case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
4340    *import*) : ;;
4341    *) false ;;
4342    esac
4343}
4344
4345# func_mode_link arg...
4346func_mode_link ()
4347{
4348    $opt_debug
4349    case $host in
4350    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4351      # It is impossible to link a dll without this setting, and
4352      # we shouldn't force the makefile maintainer to figure out
4353      # which system we are compiling for in order to pass an extra
4354      # flag for every libtool invocation.
4355      # allow_undefined=no
4356
4357      # FIXME: Unfortunately, there are problems with the above when trying
4358      # to make a dll which has undefined symbols, in which case not
4359      # even a static library is built.  For now, we need to specify
4360      # -no-undefined on the libtool link line when we can be certain
4361      # that all symbols are satisfied, otherwise we get a static library.
4362      allow_undefined=yes
4363      ;;
4364    *)
4365      allow_undefined=yes
4366      ;;
4367    esac
4368    libtool_args=$nonopt
4369    base_compile="$nonopt $@"
4370    compile_command=$nonopt
4371    finalize_command=$nonopt
4372
4373    compile_rpath=
4374    finalize_rpath=
4375    compile_shlibpath=
4376    finalize_shlibpath=
4377    convenience=
4378    old_convenience=
4379    deplibs=
4380    old_deplibs=
4381    compiler_flags=
4382    linker_flags=
4383    dllsearchpath=
4384    lib_search_path=`pwd`
4385    inst_prefix_dir=
4386    new_inherited_linker_flags=
4387
4388    avoid_version=no
4389    bindir=
4390    dlfiles=
4391    dlprefiles=
4392    dlself=no
4393    export_dynamic=no
4394    export_symbols=
4395    export_symbols_regex=
4396    generated=
4397    libobjs=
4398    ltlibs=
4399    module=no
4400    no_install=no
4401    objs=
4402    non_pic_objects=
4403    precious_files_regex=
4404    prefer_static_libs=no
4405    preload=no
4406    prev=
4407    prevarg=
4408    release=
4409    rpath=
4410    xrpath=
4411    perm_rpath=
4412    temp_rpath=
4413    thread_safe=no
4414    vinfo=
4415    vinfo_number=no
4416    weak_libs=
4417    single_module="${wl}-single_module"
4418    func_infer_tag $base_compile
4419
4420    # We need to know -static, to get the right output filenames.
4421    for arg
4422    do
4423      case $arg in
4424      -shared)
4425        test "$build_libtool_libs" != yes && \
4426          func_fatal_configuration "can not build a shared library"
4427        build_old_libs=no
4428        break
4429        ;;
4430      -all-static | -static | -static-libtool-libs)
4431        case $arg in
4432        -all-static)
4433          if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
4434            func_warning "complete static linking is impossible in this configuration"
4435          fi
4436          if test -n "$link_static_flag"; then
4437            dlopen_self=$dlopen_self_static
4438          fi
4439          prefer_static_libs=yes
4440          ;;
4441        -static)
4442          if test -z "$pic_flag" && test -n "$link_static_flag"; then
4443            dlopen_self=$dlopen_self_static
4444          fi
4445          prefer_static_libs=built
4446          ;;
4447        -static-libtool-libs)
4448          if test -z "$pic_flag" && test -n "$link_static_flag"; then
4449            dlopen_self=$dlopen_self_static
4450          fi
4451          prefer_static_libs=yes
4452          ;;
4453        esac
4454        build_libtool_libs=no
4455        build_old_libs=yes
4456        break
4457        ;;
4458      esac
4459    done
4460
4461    # See if our shared archives depend on static archives.
4462    test -n "$old_archive_from_new_cmds" && build_old_libs=yes
4463
4464    # Go through the arguments, transforming them on the way.
4465    while test "$#" -gt 0; do
4466      arg="$1"
4467      shift
4468      func_quote_for_eval "$arg"
4469      qarg=$func_quote_for_eval_unquoted_result
4470      func_append libtool_args " $func_quote_for_eval_result"
4471
4472      # If the previous option needs an argument, assign it.
4473      if test -n "$prev"; then
4474        case $prev in
4475        output)
4476          func_append compile_command " @OUTPUT@"
4477          func_append finalize_command " @OUTPUT@"
4478          ;;
4479        esac
4480
4481        case $prev in
4482        bindir)
4483          bindir="$arg"
4484          prev=
4485          continue
4486          ;;
4487        dlfiles|dlprefiles)
4488          if test "$preload" = no; then
4489            # Add the symbol object into the linking commands.
4490            func_append compile_command " @SYMFILE@"
4491            func_append finalize_command " @SYMFILE@"
4492            preload=yes
4493          fi
4494          case $arg in
4495          *.la | *.lo) ;;  # We handle these cases below.
4496          force)
4497            if test "$dlself" = no; then
4498              dlself=needless
4499              export_dynamic=yes
4500            fi
4501            prev=
4502            continue
4503            ;;
4504          self)
4505            if test "$prev" = dlprefiles; then
4506              dlself=yes
4507            elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
4508              dlself=yes
4509            else
4510              dlself=needless
4511              export_dynamic=yes
4512            fi
4513            prev=
4514            continue
4515            ;;
4516          *)
4517            if test "$prev" = dlfiles; then
4518              dlfiles="$dlfiles $arg"
4519            else
4520              dlprefiles="$dlprefiles $arg"
4521            fi
4522            prev=
4523            continue
4524            ;;
4525          esac
4526          ;;
4527        expsyms)
4528          export_symbols="$arg"
4529          test -f "$arg" \
4530            || func_fatal_error "symbol file \`$arg' does not exist"
4531          prev=
4532          continue
4533          ;;
4534        expsyms_regex)
4535          export_symbols_regex="$arg"
4536          prev=
4537          continue
4538          ;;
4539        framework)
4540          case $host in
4541            *-*-darwin*)
4542              case "$deplibs " in
4543                *" $qarg.ltframework "*) ;;
4544                *) deplibs="$deplibs $qarg.ltframework" # this is fixed later
4545                   ;;
4546              esac
4547              ;;
4548          esac
4549          prev=
4550          continue
4551          ;;
4552        inst_prefix)
4553          inst_prefix_dir="$arg"
4554          prev=
4555          continue
4556          ;;
4557        objectlist)
4558          if test -f "$arg"; then
4559            save_arg=$arg
4560            moreargs=
4561            for fil in `cat "$save_arg"`
4562            do
4563#             moreargs="$moreargs $fil"
4564              arg=$fil
4565              # A libtool-controlled object.
4566
4567              # Check to see that this really is a libtool object.
4568              if func_lalib_unsafe_p "$arg"; then
4569                pic_object=
4570                non_pic_object=
4571
4572                # Read the .lo file
4573                func_source "$arg"
4574
4575                if test -z "$pic_object" ||
4576                   test -z "$non_pic_object" ||
4577                   test "$pic_object" = none &&
4578                   test "$non_pic_object" = none; then
4579                  func_fatal_error "cannot find name of object for \`$arg'"
4580                fi
4581
4582                # Extract subdirectory from the argument.
4583                func_dirname "$arg" "/" ""
4584                xdir="$func_dirname_result"
4585
4586                if test "$pic_object" != none; then
4587                  # Prepend the subdirectory the object is found in.
4588                  pic_object="$xdir$pic_object"
4589
4590                  if test "$prev" = dlfiles; then
4591                    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
4592                      dlfiles="$dlfiles $pic_object"
4593                      prev=
4594                      continue
4595                    else
4596                      # If libtool objects are unsupported, then we need to preload.
4597                      prev=dlprefiles
4598                    fi
4599                  fi
4600
4601                  # CHECK ME:  I think I busted this.  -Ossama
4602                  if test "$prev" = dlprefiles; then
4603                    # Preload the old-style object.
4604                    dlprefiles="$dlprefiles $pic_object"
4605                    prev=
4606                  fi
4607
4608                  # A PIC object.
4609                  func_append libobjs " $pic_object"
4610                  arg="$pic_object"
4611                fi
4612
4613                # Non-PIC object.
4614                if test "$non_pic_object" != none; then
4615                  # Prepend the subdirectory the object is found in.
4616                  non_pic_object="$xdir$non_pic_object"
4617
4618                  # A standard non-PIC object
4619                  func_append non_pic_objects " $non_pic_object"
4620                  if test -z "$pic_object" || test "$pic_object" = none ; then
4621                    arg="$non_pic_object"
4622                  fi
4623                else
4624                  # If the PIC object exists, use it instead.
4625                  # $xdir was prepended to $pic_object above.
4626                  non_pic_object="$pic_object"
4627                  func_append non_pic_objects " $non_pic_object"
4628                fi
4629              else
4630                # Only an error if not doing a dry-run.
4631                if $opt_dry_run; then
4632                  # Extract subdirectory from the argument.
4633                  func_dirname "$arg" "/" ""
4634                  xdir="$func_dirname_result"
4635
4636                  func_lo2o "$arg"
4637                  pic_object=$xdir$objdir/$func_lo2o_result
4638                  non_pic_object=$xdir$func_lo2o_result
4639                  func_append libobjs " $pic_object"
4640                  func_append non_pic_objects " $non_pic_object"
4641                else
4642                  func_fatal_error "\`$arg' is not a valid libtool object"
4643                fi
4644              fi
4645            done
4646          else
4647            func_fatal_error "link input file \`$arg' does not exist"
4648          fi
4649          arg=$save_arg
4650          prev=
4651          continue
4652          ;;
4653        precious_regex)
4654          precious_files_regex="$arg"
4655          prev=
4656          continue
4657          ;;
4658        release)
4659          release="-$arg"
4660          prev=
4661          continue
4662          ;;
4663        rpath | xrpath)
4664          # We need an absolute path.
4665          case $arg in
4666          [\\/]* | [A-Za-z]:[\\/]*) ;;
4667          *)
4668            func_fatal_error "only absolute run-paths are allowed"
4669            ;;
4670          esac
4671          if test "$prev" = rpath; then
4672            case "$rpath " in
4673            *" $arg "*) ;;
4674            *) rpath="$rpath $arg" ;;
4675            esac
4676          else
4677            case "$xrpath " in
4678            *" $arg "*) ;;
4679            *) xrpath="$xrpath $arg" ;;
4680            esac
4681          fi
4682          prev=
4683          continue
4684          ;;
4685        shrext)
4686          shrext_cmds="$arg"
4687          prev=
4688          continue
4689          ;;
4690        weak)
4691          weak_libs="$weak_libs $arg"
4692          prev=
4693          continue
4694          ;;
4695        xcclinker)
4696          linker_flags="$linker_flags $qarg"
4697          compiler_flags="$compiler_flags $qarg"
4698          prev=
4699          func_append compile_command " $qarg"
4700          func_append finalize_command " $qarg"
4701          continue
4702          ;;
4703        xcompiler)
4704          compiler_flags="$compiler_flags $qarg"
4705          prev=
4706          func_append compile_command " $qarg"
4707          func_append finalize_command " $qarg"
4708          continue
4709          ;;
4710        xlinker)
4711          linker_flags="$linker_flags $qarg"
4712          compiler_flags="$compiler_flags $wl$qarg"
4713          prev=
4714          func_append compile_command " $wl$qarg"
4715          func_append finalize_command " $wl$qarg"
4716          continue
4717          ;;
4718        *)
4719          eval "$prev=\"\$arg\""
4720          prev=
4721          continue
4722          ;;
4723        esac
4724      fi # test -n "$prev"
4725
4726      prevarg="$arg"
4727
4728      case $arg in
4729      -all-static)
4730        if test -n "$link_static_flag"; then
4731          # See comment for -static flag below, for more details.
4732          func_append compile_command " $link_static_flag"
4733          func_append finalize_command " $link_static_flag"
4734        fi
4735        continue
4736        ;;
4737
4738      -allow-undefined)
4739        # FIXME: remove this flag sometime in the future.
4740        func_fatal_error "\`-allow-undefined' must not be used because it is the default"
4741        ;;
4742
4743      -avoid-version)
4744        avoid_version=yes
4745        continue
4746        ;;
4747
4748      -bindir)
4749        prev=bindir
4750        continue
4751        ;;
4752
4753      -dlopen)
4754        prev=dlfiles
4755        continue
4756        ;;
4757
4758      -dlpreopen)
4759        prev=dlprefiles
4760        continue
4761        ;;
4762
4763      -export-dynamic)
4764        export_dynamic=yes
4765        continue
4766        ;;
4767
4768      -export-symbols | -export-symbols-regex)
4769        if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
4770          func_fatal_error "more than one -exported-symbols argument is not allowed"
4771        fi
4772        if test "X$arg" = "X-export-symbols"; then
4773          prev=expsyms
4774        else
4775          prev=expsyms_regex
4776        fi
4777        continue
4778        ;;
4779
4780      -framework)
4781        prev=framework
4782        continue
4783        ;;
4784
4785      -inst-prefix-dir)
4786        prev=inst_prefix
4787        continue
4788        ;;
4789
4790      # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
4791      # so, if we see these flags be careful not to treat them like -L
4792      -L[A-Z][A-Z]*:*)
4793        case $with_gcc/$host in
4794        no/*-*-irix* | /*-*-irix*)
4795          func_append compile_command " $arg"
4796          func_append finalize_command " $arg"
4797          ;;
4798        esac
4799        continue
4800        ;;
4801
4802      -L*)
4803        func_stripname '-L' '' "$arg"
4804        dir=$func_stripname_result
4805        if test -z "$dir"; then
4806          if test "$#" -gt 0; then
4807            func_fatal_error "require no space between \`-L' and \`$1'"
4808          else
4809            func_fatal_error "need path for \`-L' option"
4810          fi
4811        fi
4812        # We need an absolute path.
4813        case $dir in
4814        [\\/]* | [A-Za-z]:[\\/]*) ;;
4815        *)
4816          absdir=`cd "$dir" && pwd`
4817          test -z "$absdir" && \
4818            func_fatal_error "cannot determine absolute directory name of \`$dir'"
4819          dir="$absdir"
4820          ;;
4821        esac
4822        case "$deplibs " in
4823        *" -L$dir "*) ;;
4824        *)
4825          deplibs="$deplibs -L$dir"
4826          lib_search_path="$lib_search_path $dir"
4827          ;;
4828        esac
4829        case $host in
4830        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4831          testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
4832          case :$dllsearchpath: in
4833          *":$dir:"*) ;;
4834          ::) dllsearchpath=$dir;;
4835          *) dllsearchpath="$dllsearchpath:$dir";;
4836          esac
4837          case :$dllsearchpath: in
4838          *":$testbindir:"*) ;;
4839          ::) dllsearchpath=$testbindir;;
4840          *) dllsearchpath="$dllsearchpath:$testbindir";;
4841          esac
4842          ;;
4843        esac
4844        continue
4845        ;;
4846
4847      -l*)
4848        if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
4849          case $host in
4850          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
4851            # These systems don't actually have a C or math library (as such)
4852            continue
4853            ;;
4854          *-*-os2*)
4855            # These systems don't actually have a C library (as such)
4856            test "X$arg" = "X-lc" && continue
4857            ;;
4858          *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
4859            # Do not include libc due to us having libc/libc_r.
4860            test "X$arg" = "X-lc" && continue
4861            ;;
4862          *-*-rhapsody* | *-*-darwin1.[012])
4863            # Rhapsody C and math libraries are in the System framework
4864            deplibs="$deplibs System.ltframework"
4865            continue
4866            ;;
4867          *-*-sco3.2v5* | *-*-sco5v6*)
4868            # Causes problems with __ctype
4869            test "X$arg" = "X-lc" && continue
4870            ;;
4871          *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
4872            # Compiler inserts libc in the correct place for threads to work
4873            test "X$arg" = "X-lc" && continue
4874            ;;
4875          esac
4876        elif test "X$arg" = "X-lc_r"; then
4877         case $host in
4878         *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
4879           # Do not include libc_r directly, use -pthread flag.
4880           continue
4881           ;;
4882         esac
4883        fi
4884        deplibs="$deplibs $arg"
4885        continue
4886        ;;
4887
4888      -module)
4889        module=yes
4890        continue
4891        ;;
4892
4893      # Tru64 UNIX uses -model [arg] to determine the layout of C++
4894      # classes, name mangling, and exception handling.
4895      # Darwin uses the -arch flag to determine output architecture.
4896      -model|-arch|-isysroot)
4897        compiler_flags="$compiler_flags $arg"
4898        func_append compile_command " $arg"
4899        func_append finalize_command " $arg"
4900        prev=xcompiler
4901        continue
4902        ;;
4903
4904      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
4905        compiler_flags="$compiler_flags $arg"
4906        func_append compile_command " $arg"
4907        func_append finalize_command " $arg"
4908        case "$new_inherited_linker_flags " in
4909            *" $arg "*) ;;
4910            * ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
4911        esac
4912        continue
4913        ;;
4914
4915      -multi_module)
4916        single_module="${wl}-multi_module"
4917        continue
4918        ;;
4919
4920      -no-fast-install)
4921        fast_install=no
4922        continue
4923        ;;
4924
4925      -no-install)
4926        case $host in
4927        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
4928          # The PATH hackery in wrapper scripts is required on Windows
4929          # and Darwin in order for the loader to find any dlls it needs.
4930          func_warning "\`-no-install' is ignored for $host"
4931          func_warning "assuming \`-no-fast-install' instead"
4932          fast_install=no
4933          ;;
4934        *) no_install=yes ;;
4935        esac
4936        continue
4937        ;;
4938
4939      -no-undefined)
4940        allow_undefined=no
4941        continue
4942        ;;
4943
4944      -objectlist)
4945        prev=objectlist
4946        continue
4947        ;;
4948
4949      -o) prev=output ;;
4950
4951      -precious-files-regex)
4952        prev=precious_regex
4953        continue
4954        ;;
4955
4956      -release)
4957        prev=release
4958        continue
4959        ;;
4960
4961      -rpath)
4962        prev=rpath
4963        continue
4964        ;;
4965
4966      -R)
4967        prev=xrpath
4968        continue
4969        ;;
4970
4971      -R*)
4972        func_stripname '-R' '' "$arg"
4973        dir=$func_stripname_result
4974        # We need an absolute path.
4975        case $dir in
4976        [\\/]* | [A-Za-z]:[\\/]*) ;;
4977        *)
4978          func_fatal_error "only absolute run-paths are allowed"
4979          ;;
4980        esac
4981        case "$xrpath " in
4982        *" $dir "*) ;;
4983        *) xrpath="$xrpath $dir" ;;
4984        esac
4985        continue
4986        ;;
4987
4988      -shared)
4989        # The effects of -shared are defined in a previous loop.
4990        continue
4991        ;;
4992
4993      -shrext)
4994        prev=shrext
4995        continue
4996        ;;
4997
4998      -static | -static-libtool-libs)
4999        # The effects of -static are defined in a previous loop.
5000        # We used to do the same as -all-static on platforms that
5001        # didn't have a PIC flag, but the assumption that the effects
5002        # would be equivalent was wrong.  It would break on at least
5003        # Digital Unix and AIX.
5004        continue
5005        ;;
5006
5007      -thread-safe)
5008        thread_safe=yes
5009        continue
5010        ;;
5011
5012      -version-info)
5013        prev=vinfo
5014        continue
5015        ;;
5016
5017      -version-number)
5018        prev=vinfo
5019        vinfo_number=yes
5020        continue
5021        ;;
5022
5023      -weak)
5024        prev=weak
5025        continue
5026        ;;
5027
5028      -Wc,*)
5029        func_stripname '-Wc,' '' "$arg"
5030        args=$func_stripname_result
5031        arg=
5032        save_ifs="$IFS"; IFS=','
5033        for flag in $args; do
5034          IFS="$save_ifs"
5035          func_quote_for_eval "$flag"
5036          arg="$arg $func_quote_for_eval_result"
5037          compiler_flags="$compiler_flags $func_quote_for_eval_result"
5038        done
5039        IFS="$save_ifs"
5040        func_stripname ' ' '' "$arg"
5041        arg=$func_stripname_result
5042        ;;
5043
5044      -Wl,*)
5045        func_stripname '-Wl,' '' "$arg"
5046        args=$func_stripname_result
5047        arg=
5048        save_ifs="$IFS"; IFS=','
5049        for flag in $args; do
5050          IFS="$save_ifs"
5051          func_quote_for_eval "$flag"
5052          arg="$arg $wl$func_quote_for_eval_result"
5053          compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"
5054          linker_flags="$linker_flags $func_quote_for_eval_result"
5055        done
5056        IFS="$save_ifs"
5057        func_stripname ' ' '' "$arg"
5058        arg=$func_stripname_result
5059        ;;
5060
5061      -Xcompiler)
5062        prev=xcompiler
5063        continue
5064        ;;
5065
5066      -Xlinker)
5067        prev=xlinker
5068        continue
5069        ;;
5070
5071      -XCClinker)
5072        prev=xcclinker
5073        continue
5074        ;;
5075
5076      # -msg_* for osf cc
5077      -msg_*)
5078        func_quote_for_eval "$arg"
5079        arg="$func_quote_for_eval_result"
5080        ;;
5081
5082      # Flags to be passed through unchanged, with rationale:
5083      # -64, -mips[0-9]      enable 64-bit mode for the SGI compiler
5084      # -r[0-9][0-9]*        specify processor for the SGI compiler
5085      # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
5086      # +DA*, +DD*           enable 64-bit mode for the HP compiler
5087      # -q*                  compiler args for the IBM compiler
5088      # -m*, -t[45]*, -txscale* architecture-specific flags for GCC
5089      # -F/path              path to uninstalled frameworks, gcc on darwin
5090      # -p, -pg, --coverage, -fprofile-*  profiling flags for GCC
5091      # @file                GCC response files
5092      # -tp=*                Portland pgcc target processor selection
5093      -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
5094      -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*)
5095        func_quote_for_eval "$arg"
5096        arg="$func_quote_for_eval_result"
5097        func_append compile_command " $arg"
5098        func_append finalize_command " $arg"
5099        compiler_flags="$compiler_flags $arg"
5100        continue
5101        ;;
5102
5103      # Some other compiler flag.
5104      -* | +*)
5105        func_quote_for_eval "$arg"
5106        arg="$func_quote_for_eval_result"
5107        ;;
5108
5109      *.$objext)
5110        # A standard object.
5111        objs="$objs $arg"
5112        ;;
5113
5114      *.lo)
5115        # A libtool-controlled object.
5116
5117        # Check to see that this really is a libtool object.
5118        if func_lalib_unsafe_p "$arg"; then
5119          pic_object=
5120          non_pic_object=
5121
5122          # Read the .lo file
5123          func_source "$arg"
5124
5125          if test -z "$pic_object" ||
5126             test -z "$non_pic_object" ||
5127             test "$pic_object" = none &&
5128             test "$non_pic_object" = none; then
5129            func_fatal_error "cannot find name of object for \`$arg'"
5130          fi
5131
5132          # Extract subdirectory from the argument.
5133          func_dirname "$arg" "/" ""
5134          xdir="$func_dirname_result"
5135
5136          if test "$pic_object" != none; then
5137            # Prepend the subdirectory the object is found in.
5138            pic_object="$xdir$pic_object"
5139
5140            if test "$prev" = dlfiles; then
5141              if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5142                dlfiles="$dlfiles $pic_object"
5143                prev=
5144                continue
5145              else
5146                # If libtool objects are unsupported, then we need to preload.
5147                prev=dlprefiles
5148              fi
5149            fi
5150
5151            # CHECK ME:  I think I busted this.  -Ossama
5152            if test "$prev" = dlprefiles; then
5153              # Preload the old-style object.
5154              dlprefiles="$dlprefiles $pic_object"
5155              prev=
5156            fi
5157
5158            # A PIC object.
5159            func_append libobjs " $pic_object"
5160            arg="$pic_object"
5161          fi
5162
5163          # Non-PIC object.
5164          if test "$non_pic_object" != none; then
5165            # Prepend the subdirectory the object is found in.
5166            non_pic_object="$xdir$non_pic_object"
5167
5168            # A standard non-PIC object
5169            func_append non_pic_objects " $non_pic_object"
5170            if test -z "$pic_object" || test "$pic_object" = none ; then
5171              arg="$non_pic_object"
5172            fi
5173          else
5174            # If the PIC object exists, use it instead.
5175            # $xdir was prepended to $pic_object above.
5176            non_pic_object="$pic_object"
5177            func_append non_pic_objects " $non_pic_object"
5178          fi
5179        else
5180          # Only an error if not doing a dry-run.
5181          if $opt_dry_run; then
5182            # Extract subdirectory from the argument.
5183            func_dirname "$arg" "/" ""
5184            xdir="$func_dirname_result"
5185
5186            func_lo2o "$arg"
5187            pic_object=$xdir$objdir/$func_lo2o_result
5188            non_pic_object=$xdir$func_lo2o_result
5189            func_append libobjs " $pic_object"
5190            func_append non_pic_objects " $non_pic_object"
5191          else
5192            func_fatal_error "\`$arg' is not a valid libtool object"
5193          fi
5194        fi
5195        ;;
5196
5197      *.$libext)
5198        # An archive.
5199        deplibs="$deplibs $arg"
5200        old_deplibs="$old_deplibs $arg"
5201        continue
5202        ;;
5203
5204      *.la)
5205        # A libtool-controlled library.
5206
5207        if test "$prev" = dlfiles; then
5208          # This library was specified with -dlopen.
5209          dlfiles="$dlfiles $arg"
5210          prev=
5211        elif test "$prev" = dlprefiles; then
5212          # The library was specified with -dlpreopen.
5213          dlprefiles="$dlprefiles $arg"
5214          prev=
5215        else
5216          deplibs="$deplibs $arg"
5217        fi
5218        continue
5219        ;;
5220
5221      # Some other compiler argument.
5222      *)
5223        # Unknown arguments in both finalize_command and compile_command need
5224        # to be aesthetically quoted because they are evaled later.
5225        func_quote_for_eval "$arg"
5226        arg="$func_quote_for_eval_result"
5227        ;;
5228      esac # arg
5229
5230      # Now actually substitute the argument into the commands.
5231      if test -n "$arg"; then
5232        func_append compile_command " $arg"
5233        func_append finalize_command " $arg"
5234      fi
5235    done # argument parsing loop
5236
5237    test -n "$prev" && \
5238      func_fatal_help "the \`$prevarg' option requires an argument"
5239
5240    if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
5241      eval arg=\"$export_dynamic_flag_spec\"
5242      func_append compile_command " $arg"
5243      func_append finalize_command " $arg"
5244    fi
5245
5246    oldlibs=
5247    # calculate the name of the file, without its directory
5248    func_basename "$output"
5249    outputname="$func_basename_result"
5250    libobjs_save="$libobjs"
5251
5252    if test -n "$shlibpath_var"; then
5253      # get the directories listed in $shlibpath_var
5254      eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
5255    else
5256      shlib_search_path=
5257    fi
5258    eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
5259    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
5260
5261    func_dirname "$output" "/" ""
5262    output_objdir="$func_dirname_result$objdir"
5263    # Create the object directory.
5264    func_mkdir_p "$output_objdir"
5265
5266    # Determine the type of output
5267    case $output in
5268    "")
5269      func_fatal_help "you must specify an output file"
5270      ;;
5271    *.$libext) linkmode=oldlib ;;
5272    *.lo | *.$objext) linkmode=obj ;;
5273    *.la) linkmode=lib ;;
5274    *) linkmode=prog ;; # Anything else should be a program.
5275    esac
5276
5277    specialdeplibs=
5278
5279    libs=
5280    # Find all interdependent deplibs by searching for libraries
5281    # that are linked more than once (e.g. -la -lb -la)
5282    for deplib in $deplibs; do
5283      if $opt_duplicate_deps ; then
5284        case "$libs " in
5285        *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5286        esac
5287      fi
5288      libs="$libs $deplib"
5289    done
5290
5291    if test "$linkmode" = lib; then
5292      libs="$predeps $libs $compiler_lib_search_path $postdeps"
5293
5294      # Compute libraries that are listed more than once in $predeps
5295      # $postdeps and mark them as special (i.e., whose duplicates are
5296      # not to be eliminated).
5297      pre_post_deps=
5298      if $opt_duplicate_compiler_generated_deps; then
5299        for pre_post_dep in $predeps $postdeps; do
5300          case "$pre_post_deps " in
5301          *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
5302          esac
5303          pre_post_deps="$pre_post_deps $pre_post_dep"
5304        done
5305      fi
5306      pre_post_deps=
5307    fi
5308
5309    deplibs=
5310    newdependency_libs=
5311    newlib_search_path=
5312    need_relink=no # whether we're linking any uninstalled libtool libraries
5313    notinst_deplibs= # not-installed libtool libraries
5314    notinst_path= # paths that contain not-installed libtool libraries
5315
5316    case $linkmode in
5317    lib)
5318        passes="conv dlpreopen link"
5319        for file in $dlfiles $dlprefiles; do
5320          case $file in
5321          *.la) ;;
5322          *)
5323            func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
5324            ;;
5325          esac
5326        done
5327        ;;
5328    prog)
5329        compile_deplibs=
5330        finalize_deplibs=
5331        alldeplibs=no
5332        newdlfiles=
5333        newdlprefiles=
5334        passes="conv scan dlopen dlpreopen link"
5335        ;;
5336    *)  passes="conv"
5337        ;;
5338    esac
5339
5340    for pass in $passes; do
5341      # The preopen pass in lib mode reverses $deplibs; put it back here
5342      # so that -L comes before libs that need it for instance...
5343      if test "$linkmode,$pass" = "lib,link"; then
5344        ## FIXME: Find the place where the list is rebuilt in the wrong
5345        ##        order, and fix it there properly
5346        tmp_deplibs=
5347        for deplib in $deplibs; do
5348          tmp_deplibs="$deplib $tmp_deplibs"
5349        done
5350        deplibs="$tmp_deplibs"
5351      fi
5352
5353      if test "$linkmode,$pass" = "lib,link" ||
5354         test "$linkmode,$pass" = "prog,scan"; then
5355        libs="$deplibs"
5356        deplibs=
5357      fi
5358      if test "$linkmode" = prog; then
5359        case $pass in
5360        dlopen) libs="$dlfiles" ;;
5361        dlpreopen) libs="$dlprefiles" ;;
5362        link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
5363        esac
5364      fi
5365      if test "$linkmode,$pass" = "lib,dlpreopen"; then
5366        # Collect and forward deplibs of preopened libtool libs
5367        for lib in $dlprefiles; do
5368          # Ignore non-libtool-libs
5369          dependency_libs=
5370          case $lib in
5371          *.la) func_source "$lib" ;;
5372          esac
5373
5374          # Collect preopened libtool deplibs, except any this library
5375          # has declared as weak libs
5376          for deplib in $dependency_libs; do
5377            func_basename "$deplib"
5378            deplib_base=$func_basename_result
5379            case " $weak_libs " in
5380            *" $deplib_base "*) ;;
5381            *) deplibs="$deplibs $deplib" ;;
5382            esac
5383          done
5384        done
5385        libs="$dlprefiles"
5386      fi
5387      if test "$pass" = dlopen; then
5388        # Collect dlpreopened libraries
5389        save_deplibs="$deplibs"
5390        deplibs=
5391      fi
5392
5393      for deplib in $libs; do
5394        lib=
5395        found=no
5396        case $deplib in
5397        -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
5398          if test "$linkmode,$pass" = "prog,link"; then
5399            compile_deplibs="$deplib $compile_deplibs"
5400            finalize_deplibs="$deplib $finalize_deplibs"
5401          else
5402            compiler_flags="$compiler_flags $deplib"
5403            if test "$linkmode" = lib ; then
5404                case "$new_inherited_linker_flags " in
5405                    *" $deplib "*) ;;
5406                    * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5407                esac
5408            fi
5409          fi
5410          continue
5411          ;;
5412        -l*)
5413          if test "$linkmode" != lib && test "$linkmode" != prog; then
5414            func_warning "\`-l' is ignored for archives/objects"
5415            continue
5416          fi
5417          func_stripname '-l' '' "$deplib"
5418          name=$func_stripname_result
5419          if test "$linkmode" = lib; then
5420            searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
5421          else
5422            searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
5423          fi
5424          for searchdir in $searchdirs; do
5425            for search_ext in .la $std_shrext .so .a; do
5426              # Search the libtool library
5427              lib="$searchdir/lib${name}${search_ext}"
5428              if test -f "$lib"; then
5429                if test "$search_ext" = ".la"; then
5430                  found=yes
5431                else
5432                  found=no
5433                fi
5434                break 2
5435              fi
5436            done
5437          done
5438          if test "$found" != yes; then
5439            # deplib doesn't seem to be a libtool library
5440            if test "$linkmode,$pass" = "prog,link"; then
5441              compile_deplibs="$deplib $compile_deplibs"
5442              finalize_deplibs="$deplib $finalize_deplibs"
5443            else
5444              deplibs="$deplib $deplibs"
5445              test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
5446            fi
5447            continue
5448          else # deplib is a libtool library
5449            # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
5450            # We need to do some special things here, and not later.
5451            if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
5452              case " $predeps $postdeps " in
5453              *" $deplib "*)
5454                if func_lalib_p "$lib"; then
5455                  library_names=
5456                  old_library=
5457                  func_source "$lib"
5458                  for l in $old_library $library_names; do
5459                    ll="$l"
5460                  done
5461                  if test "X$ll" = "X$old_library" ; then # only static version available
5462                    found=no
5463                    func_dirname "$lib" "" "."
5464                    ladir="$func_dirname_result"
5465                    lib=$ladir/$old_library
5466                    if test "$linkmode,$pass" = "prog,link"; then
5467                      compile_deplibs="$deplib $compile_deplibs"
5468                      finalize_deplibs="$deplib $finalize_deplibs"
5469                    else
5470                      deplibs="$deplib $deplibs"
5471                      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
5472                    fi
5473                    continue
5474                  fi
5475                fi
5476                ;;
5477              *) ;;
5478              esac
5479            fi
5480          fi
5481          ;; # -l
5482        *.ltframework)
5483          if test "$linkmode,$pass" = "prog,link"; then
5484            compile_deplibs="$deplib $compile_deplibs"
5485            finalize_deplibs="$deplib $finalize_deplibs"
5486          else
5487            deplibs="$deplib $deplibs"
5488            if test "$linkmode" = lib ; then
5489                case "$new_inherited_linker_flags " in
5490                    *" $deplib "*) ;;
5491                    * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5492                esac
5493            fi
5494          fi
5495          continue
5496          ;;
5497        -L*)
5498          case $linkmode in
5499          lib)
5500            deplibs="$deplib $deplibs"
5501            test "$pass" = conv && continue
5502            newdependency_libs="$deplib $newdependency_libs"
5503            func_stripname '-L' '' "$deplib"
5504            newlib_search_path="$newlib_search_path $func_stripname_result"
5505            ;;
5506          prog)
5507            if test "$pass" = conv; then
5508              deplibs="$deplib $deplibs"
5509              continue
5510            fi
5511            if test "$pass" = scan; then
5512              deplibs="$deplib $deplibs"
5513            else
5514              compile_deplibs="$deplib $compile_deplibs"
5515              finalize_deplibs="$deplib $finalize_deplibs"
5516            fi
5517            func_stripname '-L' '' "$deplib"
5518            newlib_search_path="$newlib_search_path $func_stripname_result"
5519            ;;
5520          *)
5521            func_warning "\`-L' is ignored for archives/objects"
5522            ;;
5523          esac # linkmode
5524          continue
5525          ;; # -L
5526        -R*)
5527          if test "$pass" = link; then
5528            func_stripname '-R' '' "$deplib"
5529            dir=$func_stripname_result
5530            # Make sure the xrpath contains only unique directories.
5531            case "$xrpath " in
5532            *" $dir "*) ;;
5533            *) xrpath="$xrpath $dir" ;;
5534            esac
5535          fi
5536          deplibs="$deplib $deplibs"
5537          continue
5538          ;;
5539        *.la) lib="$deplib" ;;
5540        *.$libext)
5541          if test "$pass" = conv; then
5542            deplibs="$deplib $deplibs"
5543            continue
5544          fi
5545          case $linkmode in
5546          lib)
5547            # Linking convenience modules into shared libraries is allowed,
5548            # but linking other static libraries is non-portable.
5549            case " $dlpreconveniencelibs " in
5550            *" $deplib "*) ;;
5551            *)
5552              valid_a_lib=no
5553              case $deplibs_check_method in
5554                match_pattern*)
5555                  set dummy $deplibs_check_method; shift
5556                  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
5557                  if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
5558                    | $EGREP "$match_pattern_regex" > /dev/null; then
5559                    valid_a_lib=yes
5560                  fi
5561                ;;
5562                pass_all)
5563                  valid_a_lib=yes
5564                ;;
5565              esac
5566              if test "$valid_a_lib" != yes; then
5567                echo
5568                $ECHO "*** Warning: Trying to link with static lib archive $deplib."
5569                echo "*** I have the capability to make that library automatically link in when"
5570                echo "*** you link to this library.  But I can only do this if you have a"
5571                echo "*** shared version of the library, which you do not appear to have"
5572                echo "*** because the file extensions .$libext of this argument makes me believe"
5573                echo "*** that it is just a static archive that I should not use here."
5574              else
5575                echo
5576                $ECHO "*** Warning: Linking the shared library $output against the"
5577                $ECHO "*** static library $deplib is not portable!"
5578                deplibs="$deplib $deplibs"
5579              fi
5580              ;;
5581            esac
5582            continue
5583            ;;
5584          prog)
5585            if test "$pass" != link; then
5586              deplibs="$deplib $deplibs"
5587            else
5588              compile_deplibs="$deplib $compile_deplibs"
5589              finalize_deplibs="$deplib $finalize_deplibs"
5590            fi
5591            continue
5592            ;;
5593          esac # linkmode
5594          ;; # *.$libext
5595        *.lo | *.$objext)
5596          if test "$pass" = conv; then
5597            deplibs="$deplib $deplibs"
5598          elif test "$linkmode" = prog; then
5599            if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
5600              # If there is no dlopen support or we're linking statically,
5601              # we need to preload.
5602              newdlprefiles="$newdlprefiles $deplib"
5603              compile_deplibs="$deplib $compile_deplibs"
5604              finalize_deplibs="$deplib $finalize_deplibs"
5605            else
5606              newdlfiles="$newdlfiles $deplib"
5607            fi
5608          fi
5609          continue
5610          ;;
5611        %DEPLIBS%)
5612          alldeplibs=yes
5613          continue
5614          ;;
5615        esac # case $deplib
5616
5617        if test "$found" = yes || test -f "$lib"; then :
5618        else
5619          func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
5620        fi
5621
5622        # Check to see that this really is a libtool archive.
5623        func_lalib_unsafe_p "$lib" \
5624          || func_fatal_error "\`$lib' is not a valid libtool archive"
5625
5626        func_dirname "$lib" "" "."
5627        ladir="$func_dirname_result"
5628
5629        dlname=
5630        dlopen=
5631        dlpreopen=
5632        libdir=
5633        library_names=
5634        old_library=
5635        inherited_linker_flags=
5636        # If the library was installed with an old release of libtool,
5637        # it will not redefine variables installed, or shouldnotlink
5638        installed=yes
5639        shouldnotlink=no
5640        avoidtemprpath=
5641
5642
5643        # Read the .la file
5644        func_source "$lib"
5645
5646        # Convert "-framework foo" to "foo.ltframework"
5647        if test -n "$inherited_linker_flags"; then
5648          tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
5649          for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
5650            case " $new_inherited_linker_flags " in
5651              *" $tmp_inherited_linker_flag "*) ;;
5652              *) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
5653            esac
5654          done
5655        fi
5656        dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
5657        if test "$linkmode,$pass" = "lib,link" ||
5658           test "$linkmode,$pass" = "prog,scan" ||
5659           { test "$linkmode" != prog && test "$linkmode" != lib; }; then
5660          test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
5661          test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
5662        fi
5663
5664        if test "$pass" = conv; then
5665          # Only check for convenience libraries
5666          deplibs="$lib $deplibs"
5667          if test -z "$libdir"; then
5668            if test -z "$old_library"; then
5669              func_fatal_error "cannot find name of link library for \`$lib'"
5670            fi
5671            # It is a libtool convenience library, so add in its objects.
5672            convenience="$convenience $ladir/$objdir/$old_library"
5673            old_convenience="$old_convenience $ladir/$objdir/$old_library"
5674          elif test "$linkmode" != prog && test "$linkmode" != lib; then
5675            func_fatal_error "\`$lib' is not a convenience library"
5676          fi
5677          tmp_libs=
5678          for deplib in $dependency_libs; do
5679            deplibs="$deplib $deplibs"
5680            if $opt_duplicate_deps ; then
5681              case "$tmp_libs " in
5682              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5683              esac
5684            fi
5685            tmp_libs="$tmp_libs $deplib"
5686          done
5687          continue
5688        fi # $pass = conv
5689
5690
5691        # Get the name of the library we link against.
5692        linklib=
5693        for l in $old_library $library_names; do
5694          linklib="$l"
5695        done
5696        if test -z "$linklib"; then
5697          func_fatal_error "cannot find name of link library for \`$lib'"
5698        fi
5699
5700        # This library was specified with -dlopen.
5701        if test "$pass" = dlopen; then
5702          if test -z "$libdir"; then
5703            func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
5704          fi
5705          if test -z "$dlname" ||
5706             test "$dlopen_support" != yes ||
5707             test "$build_libtool_libs" = no; then
5708            # If there is no dlname, no dlopen support or we're linking
5709            # statically, we need to preload.  We also need to preload any
5710            # dependent libraries so libltdl's deplib preloader doesn't
5711            # bomb out in the load deplibs phase.
5712            dlprefiles="$dlprefiles $lib $dependency_libs"
5713          else
5714            newdlfiles="$newdlfiles $lib"
5715          fi
5716          continue
5717        fi # $pass = dlopen
5718
5719        # We need an absolute path.
5720        case $ladir in
5721        [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
5722        *)
5723          abs_ladir=`cd "$ladir" && pwd`
5724          if test -z "$abs_ladir"; then
5725            func_warning "cannot determine absolute directory name of \`$ladir'"
5726            func_warning "passing it literally to the linker, although it might fail"
5727            abs_ladir="$ladir"
5728          fi
5729          ;;
5730        esac
5731        func_basename "$lib"
5732        laname="$func_basename_result"
5733
5734        # Find the relevant object directory and library name.
5735        if test "X$installed" = Xyes; then
5736          if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5737            func_warning "library \`$lib' was moved."
5738            dir="$ladir"
5739            absdir="$abs_ladir"
5740            libdir="$abs_ladir"
5741          else
5742            dir="$libdir"
5743            absdir="$libdir"
5744          fi
5745          test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
5746        else
5747          if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5748            dir="$ladir"
5749            absdir="$abs_ladir"
5750            # Remove this search path later
5751            notinst_path="$notinst_path $abs_ladir"
5752          else
5753            dir="$ladir/$objdir"
5754            absdir="$abs_ladir/$objdir"
5755            # Remove this search path later
5756            notinst_path="$notinst_path $abs_ladir"
5757          fi
5758        fi # $installed = yes
5759        func_stripname 'lib' '.la' "$laname"
5760        name=$func_stripname_result
5761
5762        # This library was specified with -dlpreopen.
5763        if test "$pass" = dlpreopen; then
5764          if test -z "$libdir" && test "$linkmode" = prog; then
5765            func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
5766          fi
5767          # Prefer using a static library (so that no silly _DYNAMIC symbols
5768          # are required to link).
5769          if test -n "$old_library"; then
5770            newdlprefiles="$newdlprefiles $dir/$old_library"
5771            # Keep a list of preopened convenience libraries to check
5772            # that they are being used correctly in the link pass.
5773            test -z "$libdir" && \
5774                dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"
5775          # Otherwise, use the dlname, so that lt_dlopen finds it.
5776          elif test -n "$dlname"; then
5777            newdlprefiles="$newdlprefiles $dir/$dlname"
5778          else
5779            newdlprefiles="$newdlprefiles $dir/$linklib"
5780          fi
5781        fi # $pass = dlpreopen
5782
5783        if test -z "$libdir"; then
5784          # Link the convenience library
5785          if test "$linkmode" = lib; then
5786            deplibs="$dir/$old_library $deplibs"
5787          elif test "$linkmode,$pass" = "prog,link"; then
5788            compile_deplibs="$dir/$old_library $compile_deplibs"
5789            finalize_deplibs="$dir/$old_library $finalize_deplibs"
5790          else
5791            deplibs="$lib $deplibs" # used for prog,scan pass
5792          fi
5793          continue
5794        fi
5795
5796
5797        if test "$linkmode" = prog && test "$pass" != link; then
5798          newlib_search_path="$newlib_search_path $ladir"
5799          deplibs="$lib $deplibs"
5800
5801          linkalldeplibs=no
5802          if test "$link_all_deplibs" != no || test -z "$library_names" ||
5803             test "$build_libtool_libs" = no; then
5804            linkalldeplibs=yes
5805          fi
5806
5807          tmp_libs=
5808          for deplib in $dependency_libs; do
5809            case $deplib in
5810            -L*) func_stripname '-L' '' "$deplib"
5811                 newlib_search_path="$newlib_search_path $func_stripname_result"
5812                 ;;
5813            esac
5814            # Need to link against all dependency_libs?
5815            if test "$linkalldeplibs" = yes; then
5816              deplibs="$deplib $deplibs"
5817            else
5818              # Need to hardcode shared library paths
5819              # or/and link against static libraries
5820              newdependency_libs="$deplib $newdependency_libs"
5821            fi
5822            if $opt_duplicate_deps ; then
5823              case "$tmp_libs " in
5824              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5825              esac
5826            fi
5827            tmp_libs="$tmp_libs $deplib"
5828          done # for deplib
5829          continue
5830        fi # $linkmode = prog...
5831
5832        if test "$linkmode,$pass" = "prog,link"; then
5833          if test -n "$library_names" &&
5834             { { test "$prefer_static_libs" = no ||
5835                 test "$prefer_static_libs,$installed" = "built,yes"; } ||
5836               test -z "$old_library"; }; then
5837            # We need to hardcode the library path
5838            if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
5839              # Make sure the rpath contains only unique directories.
5840              case "$temp_rpath:" in
5841              *"$absdir:"*) ;;
5842              *) temp_rpath="$temp_rpath$absdir:" ;;
5843              esac
5844            fi
5845
5846            # Hardcode the library path.
5847            # Skip directories that are in the system default run-time
5848            # search path.
5849            case " $sys_lib_dlsearch_path " in
5850            *" $absdir "*) ;;
5851            *)
5852              case "$compile_rpath " in
5853              *" $absdir "*) ;;
5854              *) compile_rpath="$compile_rpath $absdir"
5855              esac
5856              ;;
5857            esac
5858            case " $sys_lib_dlsearch_path " in
5859            *" $libdir "*) ;;
5860            *)
5861              case "$finalize_rpath " in
5862              *" $libdir "*) ;;
5863              *) finalize_rpath="$finalize_rpath $libdir"
5864              esac
5865              ;;
5866            esac
5867          fi # $linkmode,$pass = prog,link...
5868
5869          if test "$alldeplibs" = yes &&
5870             { test "$deplibs_check_method" = pass_all ||
5871               { test "$build_libtool_libs" = yes &&
5872                 test -n "$library_names"; }; }; then
5873            # We only need to search for static libraries
5874            continue
5875          fi
5876        fi
5877
5878        link_static=no # Whether the deplib will be linked statically
5879        use_static_libs=$prefer_static_libs
5880        if test "$use_static_libs" = built && test "$installed" = yes; then
5881          use_static_libs=no
5882        fi
5883        if test -n "$library_names" &&
5884           { test "$use_static_libs" = no || test -z "$old_library"; }; then
5885          case $host in
5886          *cygwin* | *mingw* | *cegcc*)
5887              # No point in relinking DLLs because paths are not encoded
5888              notinst_deplibs="$notinst_deplibs $lib"
5889              need_relink=no
5890            ;;
5891          *)
5892            if test "$installed" = no; then
5893              notinst_deplibs="$notinst_deplibs $lib"
5894              need_relink=yes
5895            fi
5896            ;;
5897          esac
5898          # This is a shared library
5899
5900          # Warn about portability, can't link against -module's on some
5901          # systems (darwin).  Don't bleat about dlopened modules though!
5902          dlopenmodule=""
5903          for dlpremoduletest in $dlprefiles; do
5904            if test "X$dlpremoduletest" = "X$lib"; then
5905              dlopenmodule="$dlpremoduletest"
5906              break
5907            fi
5908          done
5909          if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
5910            echo
5911            if test "$linkmode" = prog; then
5912              $ECHO "*** Warning: Linking the executable $output against the loadable module"
5913            else
5914              $ECHO "*** Warning: Linking the shared library $output against the loadable module"
5915            fi
5916            $ECHO "*** $linklib is not portable!"
5917          fi
5918          if test "$linkmode" = lib &&
5919             test "$hardcode_into_libs" = yes; then
5920            # Hardcode the library path.
5921            # Skip directories that are in the system default run-time
5922            # search path.
5923            case " $sys_lib_dlsearch_path " in
5924            *" $absdir "*) ;;
5925            *)
5926              case "$compile_rpath " in
5927              *" $absdir "*) ;;
5928              *) compile_rpath="$compile_rpath $absdir"
5929              esac
5930              ;;
5931            esac
5932            case " $sys_lib_dlsearch_path " in
5933            *" $libdir "*) ;;
5934            *)
5935              case "$finalize_rpath " in
5936              *" $libdir "*) ;;
5937              *) finalize_rpath="$finalize_rpath $libdir"
5938              esac
5939              ;;
5940            esac
5941          fi
5942
5943          if test -n "$old_archive_from_expsyms_cmds"; then
5944            # figure out the soname
5945            set dummy $library_names
5946            shift
5947            realname="$1"
5948            shift
5949            libname=`eval "\\$ECHO \"$libname_spec\""`
5950            # use dlname if we got it. it's perfectly good, no?
5951            if test -n "$dlname"; then
5952              soname="$dlname"
5953            elif test -n "$soname_spec"; then
5954              # bleh windows
5955              case $host in
5956              *cygwin* | mingw* | *cegcc*)
5957                func_arith $current - $age
5958                major=$func_arith_result
5959                versuffix="-$major"
5960                ;;
5961              esac
5962              eval soname=\"$soname_spec\"
5963            else
5964              soname="$realname"
5965            fi
5966
5967            # Make a new name for the extract_expsyms_cmds to use
5968            soroot="$soname"
5969            func_basename "$soroot"
5970            soname="$func_basename_result"
5971            func_stripname 'lib' '.dll' "$soname"
5972            newlib=libimp-$func_stripname_result.a
5973
5974            # If the library has no export list, then create one now
5975            if test -f "$output_objdir/$soname-def"; then :
5976            else
5977              func_verbose "extracting exported symbol list from \`$soname'"
5978              func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
5979            fi
5980
5981            # Create $newlib
5982            if test -f "$output_objdir/$newlib"; then :; else
5983              func_verbose "generating import library for \`$soname'"
5984              func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
5985            fi
5986            # make sure the library variables are pointing to the new library
5987            dir=$output_objdir
5988            linklib=$newlib
5989          fi # test -n "$old_archive_from_expsyms_cmds"
5990
5991          if test "$linkmode" = prog || test "$mode" != relink; then
5992            add_shlibpath=
5993            add_dir=
5994            add=
5995            lib_linked=yes
5996            case $hardcode_action in
5997            immediate | unsupported)
5998              if test "$hardcode_direct" = no; then
5999                add="$dir/$linklib"
6000                case $host in
6001                  *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
6002                  *-*-sysv4*uw2*) add_dir="-L$dir" ;;
6003                  *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
6004                    *-*-unixware7*) add_dir="-L$dir" ;;
6005                  *-*-darwin* )
6006                    # if the lib is a (non-dlopened) module then we can not
6007                    # link against it, someone is ignoring the earlier warnings
6008                    if /usr/bin/file -L $add 2> /dev/null |
6009                         $GREP ": [^:]* bundle" >/dev/null ; then
6010                      if test "X$dlopenmodule" != "X$lib"; then
6011                        $ECHO "*** Warning: lib $linklib is a module, not a shared library"
6012                        if test -z "$old_library" ; then
6013                          echo
6014                          echo "*** And there doesn't seem to be a static archive available"
6015                          echo "*** The link will probably fail, sorry"
6016                        else
6017                          add="$dir/$old_library"
6018                        fi
6019                      elif test -n "$old_library"; then
6020                        add="$dir/$old_library"
6021                      fi
6022                    fi
6023                esac
6024              elif test "$hardcode_minus_L" = no; then
6025                case $host in
6026                *-*-sunos*) add_shlibpath="$dir" ;;
6027                esac
6028                add_dir="-L$dir"
6029                add="-l$name"
6030              elif test "$hardcode_shlibpath_var" = no; then
6031                add_shlibpath="$dir"
6032                add="-l$name"
6033              else
6034                lib_linked=no
6035              fi
6036              ;;
6037            relink)
6038              if test "$hardcode_direct" = yes &&
6039                 test "$hardcode_direct_absolute" = no; then
6040                add="$dir/$linklib"
6041              elif test "$hardcode_minus_L" = yes; then
6042                add_dir="-L$dir"
6043                # Try looking first in the location we're being installed to.
6044                if test -n "$inst_prefix_dir"; then
6045                  case $libdir in
6046                    [\\/]*)
6047                      add_dir="$add_dir -L$inst_prefix_dir$libdir"
6048                      ;;
6049                  esac
6050                fi
6051                add="-l$name"
6052              elif test "$hardcode_shlibpath_var" = yes; then
6053                add_shlibpath="$dir"
6054                add="-l$name"
6055              else
6056                lib_linked=no
6057              fi
6058              ;;
6059            *) lib_linked=no ;;
6060            esac
6061
6062            if test "$lib_linked" != yes; then
6063              func_fatal_configuration "unsupported hardcode properties"
6064            fi
6065
6066            if test -n "$add_shlibpath"; then
6067              case :$compile_shlibpath: in
6068              *":$add_shlibpath:"*) ;;
6069              *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
6070              esac
6071            fi
6072            if test "$linkmode" = prog; then
6073              test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
6074              test -n "$add" && compile_deplibs="$add $compile_deplibs"
6075            else
6076              test -n "$add_dir" && deplibs="$add_dir $deplibs"
6077              test -n "$add" && deplibs="$add $deplibs"
6078              if test "$hardcode_direct" != yes &&
6079                 test "$hardcode_minus_L" != yes &&
6080                 test "$hardcode_shlibpath_var" = yes; then
6081                case :$finalize_shlibpath: in
6082                *":$libdir:"*) ;;
6083                *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
6084                esac
6085              fi
6086            fi
6087          fi
6088
6089          if test "$linkmode" = prog || test "$mode" = relink; then
6090            add_shlibpath=
6091            add_dir=
6092            add=
6093            # Finalize command for both is simple: just hardcode it.
6094            if test "$hardcode_direct" = yes &&
6095               test "$hardcode_direct_absolute" = no; then
6096              add="$libdir/$linklib"
6097            elif test "$hardcode_minus_L" = yes; then
6098              add_dir="-L$libdir"
6099              add="-l$name"
6100            elif test "$hardcode_shlibpath_var" = yes; then
6101              case :$finalize_shlibpath: in
6102              *":$libdir:"*) ;;
6103              *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
6104              esac
6105              add="-l$name"
6106            elif test "$hardcode_automatic" = yes; then
6107              if test -n "$inst_prefix_dir" &&
6108                 test -f "$inst_prefix_dir$libdir/$linklib" ; then
6109                add="$inst_prefix_dir$libdir/$linklib"
6110              else
6111                add="$libdir/$linklib"
6112              fi
6113            else
6114              # We cannot seem to hardcode it, guess we'll fake it.
6115              add_dir="-L$libdir"
6116              # Try looking first in the location we're being installed to.
6117              if test -n "$inst_prefix_dir"; then
6118                case $libdir in
6119                  [\\/]*)
6120                    add_dir="$add_dir -L$inst_prefix_dir$libdir"
6121                    ;;
6122                esac
6123              fi
6124              add="-l$name"
6125            fi
6126
6127            if test "$linkmode" = prog; then
6128              test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
6129              test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
6130            else
6131              test -n "$add_dir" && deplibs="$add_dir $deplibs"
6132              test -n "$add" && deplibs="$add $deplibs"
6133            fi
6134          fi
6135        elif test "$linkmode" = prog; then
6136          # Here we assume that one of hardcode_direct or hardcode_minus_L
6137          # is not unsupported.  This is valid on all known static and
6138          # shared platforms.
6139          if test "$hardcode_direct" != unsupported; then
6140            test -n "$old_library" && linklib="$old_library"
6141            compile_deplibs="$dir/$linklib $compile_deplibs"
6142            finalize_deplibs="$dir/$linklib $finalize_deplibs"
6143          else
6144            compile_deplibs="-l$name -L$dir $compile_deplibs"
6145            finalize_deplibs="-l$name -L$dir $finalize_deplibs"
6146          fi
6147        elif test "$build_libtool_libs" = yes; then
6148          # Not a shared library
6149          if test "$deplibs_check_method" != pass_all; then
6150            # We're trying link a shared library against a static one
6151            # but the system doesn't support it.
6152
6153            # Just print a warning and add the library to dependency_libs so
6154            # that the program can be linked against the static library.
6155            echo
6156            $ECHO "*** Warning: This system can not link to static lib archive $lib."
6157            echo "*** I have the capability to make that library automatically link in when"
6158            echo "*** you link to this library.  But I can only do this if you have a"
6159            echo "*** shared version of the library, which you do not appear to have."
6160            if test "$module" = yes; then
6161              echo "*** But as you try to build a module library, libtool will still create "
6162              echo "*** a static module, that should work as long as the dlopening application"
6163              echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
6164              if test -z "$global_symbol_pipe"; then
6165                echo
6166                echo "*** However, this would only work if libtool was able to extract symbol"
6167                echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
6168                echo "*** not find such a program.  So, this module is probably useless."
6169                echo "*** \`nm' from GNU binutils and a full rebuild may help."
6170              fi
6171              if test "$build_old_libs" = no; then
6172                build_libtool_libs=module
6173                build_old_libs=yes
6174              else
6175                build_libtool_libs=no
6176              fi
6177            fi
6178          else
6179            deplibs="$dir/$old_library $deplibs"
6180            link_static=yes
6181          fi
6182        fi # link shared/static library?
6183
6184        if test "$linkmode" = lib; then
6185          if test -n "$dependency_libs" &&
6186             { test "$hardcode_into_libs" != yes ||
6187               test "$build_old_libs" = yes ||
6188               test "$link_static" = yes; }; then
6189            # Extract -R from dependency_libs
6190            temp_deplibs=
6191            for libdir in $dependency_libs; do
6192              case $libdir in
6193              -R*) func_stripname '-R' '' "$libdir"
6194                   temp_xrpath=$func_stripname_result
6195                   case " $xrpath " in
6196                   *" $temp_xrpath "*) ;;
6197                   *) xrpath="$xrpath $temp_xrpath";;
6198                   esac;;
6199              *) temp_deplibs="$temp_deplibs $libdir";;
6200              esac
6201            done
6202            dependency_libs="$temp_deplibs"
6203          fi
6204
6205          newlib_search_path="$newlib_search_path $absdir"
6206          # Link against this library
6207          test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
6208          # ... and its dependency_libs
6209          tmp_libs=
6210          for deplib in $dependency_libs; do
6211            newdependency_libs="$deplib $newdependency_libs"
6212            if $opt_duplicate_deps ; then
6213              case "$tmp_libs " in
6214              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
6215              esac
6216            fi
6217            tmp_libs="$tmp_libs $deplib"
6218          done
6219
6220          if test "$link_all_deplibs" != no; then
6221            # Add the search paths of all dependency libraries
6222            for deplib in $dependency_libs; do
6223              path=
6224              case $deplib in
6225              -L*) path="$deplib" ;;
6226              *.la)
6227                func_dirname "$deplib" "" "."
6228                dir="$func_dirname_result"
6229                # We need an absolute path.
6230                case $dir in
6231                [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
6232                *)
6233                  absdir=`cd "$dir" && pwd`
6234                  if test -z "$absdir"; then
6235                    func_warning "cannot determine absolute directory name of \`$dir'"
6236                    absdir="$dir"
6237                  fi
6238                  ;;
6239                esac
6240                if $GREP "^installed=no" $deplib > /dev/null; then
6241                case $host in
6242                *-*-darwin*)
6243                  depdepl=
6244                  eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
6245                  if test -n "$deplibrary_names" ; then
6246                    for tmp in $deplibrary_names ; do
6247                      depdepl=$tmp
6248                    done
6249                    if test -f "$absdir/$objdir/$depdepl" ; then
6250                      depdepl="$absdir/$objdir/$depdepl"
6251                      darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
6252                      if test -z "$darwin_install_name"; then
6253                          darwin_install_name=`${OTOOL64} -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
6254                      fi
6255                      compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
6256                      linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
6257                      path=
6258                    fi
6259                  fi
6260                  ;;
6261                *)
6262                  path="-L$absdir/$objdir"
6263                  ;;
6264                esac
6265                else
6266                  eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
6267                  test -z "$libdir" && \
6268                    func_fatal_error "\`$deplib' is not a valid libtool archive"
6269                  test "$absdir" != "$libdir" && \
6270                    func_warning "\`$deplib' seems to be moved"
6271
6272                  path="-L$absdir"
6273                fi
6274                ;;
6275              esac
6276              case " $deplibs " in
6277              *" $path "*) ;;
6278              *) deplibs="$path $deplibs" ;;
6279              esac
6280            done
6281          fi # link_all_deplibs != no
6282        fi # linkmode = lib
6283      done # for deplib in $libs
6284      if test "$pass" = link; then
6285        if test "$linkmode" = "prog"; then
6286          compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
6287          finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
6288        else
6289          compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
6290        fi
6291      fi
6292      dependency_libs="$newdependency_libs"
6293      if test "$pass" = dlpreopen; then
6294        # Link the dlpreopened libraries before other libraries
6295        for deplib in $save_deplibs; do
6296          deplibs="$deplib $deplibs"
6297        done
6298      fi
6299      if test "$pass" != dlopen; then
6300        if test "$pass" != conv; then
6301          # Make sure lib_search_path contains only unique directories.
6302          lib_search_path=
6303          for dir in $newlib_search_path; do
6304            case "$lib_search_path " in
6305            *" $dir "*) ;;
6306            *) lib_search_path="$lib_search_path $dir" ;;
6307            esac
6308          done
6309          newlib_search_path=
6310        fi
6311
6312        if test "$linkmode,$pass" != "prog,link"; then
6313          vars="deplibs"
6314        else
6315          vars="compile_deplibs finalize_deplibs"
6316        fi
6317        for var in $vars dependency_libs; do
6318          # Add libraries to $var in reverse order
6319          eval tmp_libs=\"\$$var\"
6320          new_libs=
6321          for deplib in $tmp_libs; do
6322            # FIXME: Pedantically, this is the right thing to do, so
6323            #        that some nasty dependency loop isn't accidentally
6324            #        broken:
6325            #new_libs="$deplib $new_libs"
6326            # Pragmatically, this seems to cause very few problems in
6327            # practice:
6328            case $deplib in
6329            -L*) new_libs="$deplib $new_libs" ;;
6330            -R*) ;;
6331            *)
6332              # And here is the reason: when a library appears more
6333              # than once as an explicit dependence of a library, or
6334              # is implicitly linked in more than once by the
6335              # compiler, it is considered special, and multiple
6336              # occurrences thereof are not removed.  Compare this
6337              # with having the same library being listed as a
6338              # dependency of multiple other libraries: in this case,
6339              # we know (pedantically, we assume) the library does not
6340              # need to be listed more than once, so we keep only the
6341              # last copy.  This is not always right, but it is rare
6342              # enough that we require users that really mean to play
6343              # such unportable linking tricks to link the library
6344              # using -Wl,-lname, so that libtool does not consider it
6345              # for duplicate removal.
6346              case " $specialdeplibs " in
6347              *" $deplib "*) new_libs="$deplib $new_libs" ;;
6348              *)
6349                case " $new_libs " in
6350                *" $deplib "*) ;;
6351                *) new_libs="$deplib $new_libs" ;;
6352                esac
6353                ;;
6354              esac
6355              ;;
6356            esac
6357          done
6358          tmp_libs=
6359          for deplib in $new_libs; do
6360            case $deplib in
6361            -L*)
6362              case " $tmp_libs " in
6363              *" $deplib "*) ;;
6364              *) tmp_libs="$tmp_libs $deplib" ;;
6365              esac
6366              ;;
6367            *) tmp_libs="$tmp_libs $deplib" ;;
6368            esac
6369          done
6370          eval $var=\"$tmp_libs\"
6371        done # for var
6372      fi
6373      # Last step: remove runtime libs from dependency_libs
6374      # (they stay in deplibs)
6375      tmp_libs=
6376      for i in $dependency_libs ; do
6377        case " $predeps $postdeps $compiler_lib_search_path " in
6378        *" $i "*)
6379          i=""
6380          ;;
6381        esac
6382        if test -n "$i" ; then
6383          tmp_libs="$tmp_libs $i"
6384