source: mod_gnutls/config/ltmain.sh @ 4ecf14f

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

Imported Upstream version 0.5.4

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