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
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
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="/usr/bin/grep -E"}
120: ${FGREP="/usr/bin/grep -F"}
121: ${GREP="/usr/bin/grep"}
122: ${LN_S="ln -s"}
123: ${MAKE="make"}
124: ${MKDIR="mkdir"}
125: ${MV="mv -f"}
126: ${RM="rm -f"}
127: ${SED="/opt/local/bin/gsed"}
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) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
4510	esac
4511      fi
4512      if test "$linkmode,$pass" = "lib,dlpreopen"; then
4513	# Collect and forward deplibs of preopened libtool libs
4514	for lib in $dlprefiles; do
4515	  # Ignore non-libtool-libs
4516	  dependency_libs=
4517	  case $lib in
4518	  *.la)	func_source "$lib" ;;
4519	  esac
4520
4521	  # Collect preopened libtool deplibs, except any this library
4522	  # has declared as weak libs
4523	  for deplib in $dependency_libs; do
4524            deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`
4525	    case " $weak_libs " in
4526	    *" $deplib_base "*) ;;
4527	    *) deplibs="$deplibs $deplib" ;;
4528	    esac
4529	  done
4530	done
4531	libs="$dlprefiles"
4532      fi
4533      if test "$pass" = dlopen; then
4534	# Collect dlpreopened libraries
4535	save_deplibs="$deplibs"
4536	deplibs=
4537      fi
4538
4539      for deplib in $libs; do
4540	lib=
4541	found=no
4542	case $deplib in
4543	-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
4544	  if test "$linkmode,$pass" = "prog,link"; then
4545	    compile_deplibs="$deplib $compile_deplibs"
4546	    finalize_deplibs="$deplib $finalize_deplibs"
4547	  else
4548	    compiler_flags="$compiler_flags $deplib"
4549	    if test "$linkmode" = lib ; then
4550		case "$new_inherited_linker_flags " in
4551		    *" $deplib "*) ;;
4552		    * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
4553		esac
4554	    fi
4555	  fi
4556	  continue
4557	  ;;
4558	-l*)
4559	  if test "$linkmode" != lib && test "$linkmode" != prog; then
4560	    func_warning "\`-l' is ignored for archives/objects"
4561	    continue
4562	  fi
4563	  func_stripname '-l' '' "$deplib"
4564	  name=$func_stripname_result
4565	  if test "$linkmode" = lib; then
4566	    searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
4567	  else
4568	    searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
4569	  fi
4570	  for searchdir in $searchdirs; do
4571	    for search_ext in .la $std_shrext .so .a; do
4572	      # Search the libtool library
4573	      lib="$searchdir/lib${name}${search_ext}"
4574	      if test -f "$lib"; then
4575		if test "$search_ext" = ".la"; then
4576		  found=yes
4577		else
4578		  found=no
4579		fi
4580		break 2
4581	      fi
4582	    done
4583	  done
4584	  if test "$found" != yes; then
4585	    # deplib doesn't seem to be a libtool library
4586	    if test "$linkmode,$pass" = "prog,link"; then
4587	      compile_deplibs="$deplib $compile_deplibs"
4588	      finalize_deplibs="$deplib $finalize_deplibs"
4589	    else
4590	      deplibs="$deplib $deplibs"
4591	      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
4592	    fi
4593	    continue
4594	  else # deplib is a libtool library
4595	    # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
4596	    # We need to do some special things here, and not later.
4597	    if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
4598	      case " $predeps $postdeps " in
4599	      *" $deplib "*)
4600		if func_lalib_p "$lib"; then
4601		  library_names=
4602		  old_library=
4603		  func_source "$lib"
4604		  for l in $old_library $library_names; do
4605		    ll="$l"
4606		  done
4607		  if test "X$ll" = "X$old_library" ; then # only static version available
4608		    found=no
4609		    func_dirname "$lib" "" "."
4610		    ladir="$func_dirname_result"
4611		    lib=$ladir/$old_library
4612		    if test "$linkmode,$pass" = "prog,link"; then
4613		      compile_deplibs="$deplib $compile_deplibs"
4614		      finalize_deplibs="$deplib $finalize_deplibs"
4615		    else
4616		      deplibs="$deplib $deplibs"
4617		      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
4618		    fi
4619		    continue
4620		  fi
4621		fi
4622		;;
4623	      *) ;;
4624	      esac
4625	    fi
4626	  fi
4627	  ;; # -l
4628	*.ltframework)
4629	  if test "$linkmode,$pass" = "prog,link"; then
4630	    compile_deplibs="$deplib $compile_deplibs"
4631	    finalize_deplibs="$deplib $finalize_deplibs"
4632	  else
4633	    deplibs="$deplib $deplibs"
4634	    if test "$linkmode" = lib ; then
4635		case "$new_inherited_linker_flags " in
4636		    *" $deplib "*) ;;
4637		    * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
4638		esac
4639	    fi
4640	  fi
4641	  continue
4642	  ;;
4643	-L*)
4644	  case $linkmode in
4645	  lib)
4646	    deplibs="$deplib $deplibs"
4647	    test "$pass" = conv && continue
4648	    newdependency_libs="$deplib $newdependency_libs"
4649	    func_stripname '-L' '' "$deplib"
4650	    newlib_search_path="$newlib_search_path $func_stripname_result"
4651	    ;;
4652	  prog)
4653	    if test "$pass" = conv; then
4654	      deplibs="$deplib $deplibs"
4655	      continue
4656	    fi
4657	    if test "$pass" = scan; then
4658	      deplibs="$deplib $deplibs"
4659	    else
4660	      compile_deplibs="$deplib $compile_deplibs"
4661	      finalize_deplibs="$deplib $finalize_deplibs"
4662	    fi
4663	    func_stripname '-L' '' "$deplib"
4664	    newlib_search_path="$newlib_search_path $func_stripname_result"
4665	    ;;
4666	  *)
4667	    func_warning "\`-L' is ignored for archives/objects"
4668	    ;;
4669	  esac # linkmode
4670	  continue
4671	  ;; # -L
4672	-R*)
4673	  if test "$pass" = link; then
4674	    func_stripname '-R' '' "$deplib"
4675	    dir=$func_stripname_result
4676	    # Make sure the xrpath contains only unique directories.
4677	    case "$xrpath " in
4678	    *" $dir "*) ;;
4679	    *) xrpath="$xrpath $dir" ;;
4680	    esac
4681	  fi
4682	  deplibs="$deplib $deplibs"
4683	  continue
4684	  ;;
4685	*.la) lib="$deplib" ;;
4686	*.$libext)
4687	  if test "$pass" = conv; then
4688	    deplibs="$deplib $deplibs"
4689	    continue
4690	  fi
4691	  case $linkmode in
4692	  lib)
4693	    # Linking convenience modules into shared libraries is allowed,
4694	    # but linking other static libraries is non-portable.
4695	    case " $dlpreconveniencelibs " in
4696	    *" $deplib "*) ;;
4697	    *)
4698	      valid_a_lib=no
4699	      case $deplibs_check_method in
4700		match_pattern*)
4701		  set dummy $deplibs_check_method; shift
4702		  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
4703		  if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \
4704		    | $EGREP "$match_pattern_regex" > /dev/null; then
4705		    valid_a_lib=yes
4706		  fi
4707		;;
4708		pass_all)
4709		  valid_a_lib=yes
4710		;;
4711	      esac
4712	      if test "$valid_a_lib" != yes; then
4713		$ECHO
4714		$ECHO "*** Warning: Trying to link with static lib archive $deplib."
4715		$ECHO "*** I have the capability to make that library automatically link in when"
4716		$ECHO "*** you link to this library.  But I can only do this if you have a"
4717		$ECHO "*** shared version of the library, which you do not appear to have"
4718		$ECHO "*** because the file extensions .$libext of this argument makes me believe"
4719		$ECHO "*** that it is just a static archive that I should not use here."
4720	      else
4721		$ECHO
4722		$ECHO "*** Warning: Linking the shared library $output against the"
4723		$ECHO "*** static library $deplib is not portable!"
4724		deplibs="$deplib $deplibs"
4725	      fi
4726	      ;;
4727	    esac
4728	    continue
4729	    ;;
4730	  prog)
4731	    if test "$pass" != link; then
4732	      deplibs="$deplib $deplibs"
4733	    else
4734	      compile_deplibs="$deplib $compile_deplibs"
4735	      finalize_deplibs="$deplib $finalize_deplibs"
4736	    fi
4737	    continue
4738	    ;;
4739	  esac # linkmode
4740	  ;; # *.$libext
4741	*.lo | *.$objext)
4742	  if test "$pass" = conv; then
4743	    deplibs="$deplib $deplibs"
4744	  elif test "$linkmode" = prog; then
4745	    if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
4746	      # If there is no dlopen support or we're linking statically,
4747	      # we need to preload.
4748	      newdlprefiles="$newdlprefiles $deplib"
4749	      compile_deplibs="$deplib $compile_deplibs"
4750	      finalize_deplibs="$deplib $finalize_deplibs"
4751	    else
4752	      newdlfiles="$newdlfiles $deplib"
4753	    fi
4754	  fi
4755	  continue
4756	  ;;
4757	%DEPLIBS%)
4758	  alldeplibs=yes
4759	  continue
4760	  ;;
4761	esac # case $deplib
4762
4763	if test "$found" = yes || test -f "$lib"; then :
4764	else
4765	  func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
4766	fi
4767
4768	# Check to see that this really is a libtool archive.
4769	func_lalib_unsafe_p "$lib" \
4770	  || func_fatal_error "\`$lib' is not a valid libtool archive"
4771
4772	func_dirname "$lib" "" "."
4773	ladir="$func_dirname_result"
4774
4775	dlname=
4776	dlopen=
4777	dlpreopen=
4778	libdir=
4779	library_names=
4780	old_library=
4781	inherited_linker_flags=
4782	# If the library was installed with an old release of libtool,
4783	# it will not redefine variables installed, or shouldnotlink
4784	installed=yes
4785	shouldnotlink=no
4786	avoidtemprpath=
4787
4788
4789	# Read the .la file
4790	func_source "$lib"
4791
4792	# Convert "-framework foo" to "foo.ltframework"
4793	if test -n "$inherited_linker_flags"; then
4794	  tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework \([^ $]*\)/\1.ltframework/g'`
4795	  for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
4796	    case " $new_inherited_linker_flags " in
4797	      *" $tmp_inherited_linker_flag "*) ;;
4798	      *) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
4799	    esac
4800	  done
4801	fi
4802	dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
4803	if test "$linkmode,$pass" = "lib,link" ||
4804	   test "$linkmode,$pass" = "prog,scan" ||
4805	   { test "$linkmode" != prog && test "$linkmode" != lib; }; then
4806	  test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
4807	  test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
4808	fi
4809
4810	if test "$pass" = conv; then
4811	  # Only check for convenience libraries
4812	  deplibs="$lib $deplibs"
4813	  if test -z "$libdir"; then
4814	    if test -z "$old_library"; then
4815	      func_fatal_error "cannot find name of link library for \`$lib'"
4816	    fi
4817	    # It is a libtool convenience library, so add in its objects.
4818	    convenience="$convenience $ladir/$objdir/$old_library"
4819	    old_convenience="$old_convenience $ladir/$objdir/$old_library"
4820	  elif test "$linkmode" != prog && test "$linkmode" != lib; then
4821	    func_fatal_error "\`$lib' is not a convenience library"
4822	  fi
4823	  tmp_libs=
4824	  for deplib in $dependency_libs; do
4825	    deplibs="$deplib $deplibs"
4826	    if $opt_duplicate_deps ; then
4827	      case "$tmp_libs " in
4828	      *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
4829	      esac
4830	    fi
4831	    tmp_libs="$tmp_libs $deplib"
4832	  done
4833	  continue
4834	fi # $pass = conv
4835
4836
4837	# Get the name of the library we link against.
4838	linklib=
4839	for l in $old_library $library_names; do
4840	  linklib="$l"
4841	done
4842	if test -z "$linklib"; then
4843	  func_fatal_error "cannot find name of link library for \`$lib'"
4844	fi
4845
4846	# This library was specified with -dlopen.
4847	if test "$pass" = dlopen; then
4848	  if test -z "$libdir"; then
4849	    func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
4850	  fi
4851	  if test -z "$dlname" ||
4852	     test "$dlopen_support" != yes ||
4853	     test "$build_libtool_libs" = no; then
4854	    # If there is no dlname, no dlopen support or we're linking
4855	    # statically, we need to preload.  We also need to preload any
4856	    # dependent libraries so libltdl's deplib preloader doesn't
4857	    # bomb out in the load deplibs phase.
4858	    dlprefiles="$dlprefiles $lib $dependency_libs"
4859	  else
4860	    newdlfiles="$newdlfiles $lib"
4861	  fi
4862	  continue
4863	fi # $pass = dlopen
4864
4865	# We need an absolute path.
4866	case $ladir in
4867	[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
4868	*)
4869	  abs_ladir=`cd "$ladir" && pwd`
4870	  if test -z "$abs_ladir"; then
4871	    func_warning "cannot determine absolute directory name of \`$ladir'"
4872	    func_warning "passing it literally to the linker, although it might fail"
4873	    abs_ladir="$ladir"
4874	  fi
4875	  ;;
4876	esac
4877	func_basename "$lib"
4878	laname="$func_basename_result"
4879
4880	# Find the relevant object directory and library name.
4881	if test "X$installed" = Xyes; then
4882	  if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
4883	    func_warning "library \`$lib' was moved."
4884	    dir="$ladir"
4885	    absdir="$abs_ladir"
4886	    libdir="$abs_ladir"
4887	  else
4888	    dir="$libdir"
4889	    absdir="$libdir"
4890	  fi
4891	  test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
4892	else
4893	  if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
4894	    dir="$ladir"
4895	    absdir="$abs_ladir"
4896	    # Remove this search path later
4897	    notinst_path="$notinst_path $abs_ladir"
4898	  else
4899	    dir="$ladir/$objdir"
4900	    absdir="$abs_ladir/$objdir"
4901	    # Remove this search path later
4902	    notinst_path="$notinst_path $abs_ladir"
4903	  fi
4904	fi # $installed = yes
4905	func_stripname 'lib' '.la' "$laname"
4906	name=$func_stripname_result
4907
4908	# This library was specified with -dlpreopen.
4909	if test "$pass" = dlpreopen; then
4910	  if test -z "$libdir" && test "$linkmode" = prog; then
4911	    func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
4912	  fi
4913	  # Prefer using a static library (so that no silly _DYNAMIC symbols
4914	  # are required to link).
4915	  if test -n "$old_library"; then
4916	    newdlprefiles="$newdlprefiles $dir/$old_library"
4917	    # Keep a list of preopened convenience libraries to check
4918	    # that they are being used correctly in the link pass.
4919	    test -z "$libdir" && \
4920		dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"
4921	  # Otherwise, use the dlname, so that lt_dlopen finds it.
4922	  elif test -n "$dlname"; then
4923	    newdlprefiles="$newdlprefiles $dir/$dlname"
4924	  else
4925	    newdlprefiles="$newdlprefiles $dir/$linklib"
4926	  fi
4927	fi # $pass = dlpreopen
4928
4929	if test -z "$libdir"; then
4930	  # Link the convenience library
4931	  if test "$linkmode" = lib; then
4932	    deplibs="$dir/$old_library $deplibs"
4933	  elif test "$linkmode,$pass" = "prog,link"; then
4934	    compile_deplibs="$dir/$old_library $compile_deplibs"
4935	    finalize_deplibs="$dir/$old_library $finalize_deplibs"
4936	  else
4937	    deplibs="$lib $deplibs" # used for prog,scan pass
4938	  fi
4939	  continue
4940	fi
4941
4942
4943	if test "$linkmode" = prog && test "$pass" != link; then
4944	  newlib_search_path="$newlib_search_path $ladir"
4945	  deplibs="$lib $deplibs"
4946
4947	  linkalldeplibs=no
4948	  if test "$link_all_deplibs" != no || test -z "$library_names" ||
4949	     test "$build_libtool_libs" = no; then
4950	    linkalldeplibs=yes
4951	  fi
4952
4953	  tmp_libs=
4954	  for deplib in $dependency_libs; do
4955	    case $deplib in
4956	    -L*) func_stripname '-L' '' "$deplib"
4957	         newlib_search_path="$newlib_search_path $func_stripname_result"
4958		 ;;
4959	    esac
4960	    # Need to link against all dependency_libs?
4961	    if test "$linkalldeplibs" = yes; then
4962	      deplibs="$deplib $deplibs"
4963	    else
4964	      # Need to hardcode shared library paths
4965	      # or/and link against static libraries
4966	      newdependency_libs="$deplib $newdependency_libs"
4967	    fi
4968	    if $opt_duplicate_deps ; then
4969	      case "$tmp_libs " in
4970	      *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
4971	      esac
4972	    fi
4973	    tmp_libs="$tmp_libs $deplib"
4974	  done # for deplib
4975	  continue
4976	fi # $linkmode = prog...
4977
4978	if test "$linkmode,$pass" = "prog,link"; then
4979	  if test -n "$library_names" &&
4980	     { { test "$prefer_static_libs" = no ||
4981	         test "$prefer_static_libs,$installed" = "built,yes"; } ||
4982	       test -z "$old_library"; }; then
4983	    # We need to hardcode the library path
4984	    if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
4985	      # Make sure the rpath contains only unique directories.
4986	      case "$temp_rpath:" in
4987	      *"$absdir:"*) ;;
4988	      *) temp_rpath="$temp_rpath$absdir:" ;;
4989	      esac
4990	    fi
4991
4992	    # Hardcode the library path.
4993	    # Skip directories that are in the system default run-time
4994	    # search path.
4995	    case " $sys_lib_dlsearch_path " in
4996	    *" $absdir "*) ;;
4997	    *)
4998	      case "$compile_rpath " in
4999	      *" $absdir "*) ;;
5000	      *) compile_rpath="$compile_rpath $absdir"
5001	      esac
5002	      ;;
5003	    esac
5004	    case " $sys_lib_dlsearch_path " in
5005	    *" $libdir "*) ;;
5006	    *)
5007	      case "$finalize_rpath " in
5008	      *" $libdir "*) ;;
5009	      *) finalize_rpath="$finalize_rpath $libdir"
5010	      esac
5011	      ;;
5012	    esac
5013	  fi # $linkmode,$pass = prog,link...
5014
5015	  if test "$alldeplibs" = yes &&
5016	     { test "$deplibs_check_method" = pass_all ||
5017	       { test "$build_libtool_libs" = yes &&
5018		 test -n "$library_names"; }; }; then
5019	    # We only need to search for static libraries
5020	    continue
5021	  fi
5022	fi
5023
5024	link_static=no # Whether the deplib will be linked statically
5025	use_static_libs=$prefer_static_libs
5026	if test "$use_static_libs" = built && test "$installed" = yes; then
5027	  use_static_libs=no
5028	fi
5029	if test -n "$library_names" &&
5030	   { test "$use_static_libs" = no || test -z "$old_library"; }; then
5031	  case $host in
5032	  *cygwin* | *mingw*)
5033	      # No point in relinking DLLs because paths are not encoded
5034	      notinst_deplibs="$notinst_deplibs $lib"
5035	      need_relink=no
5036	    ;;
5037	  *)
5038	    if test "$installed" = no; then
5039	      notinst_deplibs="$notinst_deplibs $lib"
5040	      need_relink=yes
5041	    fi
5042	    ;;
5043	  esac
5044	  # This is a shared library
5045
5046	  # Warn about portability, can't link against -module's on some
5047	  # systems (darwin).  Don't bleat about dlopened modules though!
5048	  dlopenmodule=""
5049	  for dlpremoduletest in $dlprefiles; do
5050	    if test "X$dlpremoduletest" = "X$lib"; then
5051	      dlopenmodule="$dlpremoduletest"
5052	      break
5053	    fi
5054	  done
5055	  if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
5056	    $ECHO
5057	    if test "$linkmode" = prog; then
5058	      $ECHO "*** Warning: Linking the executable $output against the loadable module"
5059	    else
5060	      $ECHO "*** Warning: Linking the shared library $output against the loadable module"
5061	    fi
5062	    $ECHO "*** $linklib is not portable!"
5063	  fi
5064	  if test "$linkmode" = lib &&
5065	     test "$hardcode_into_libs" = yes; then
5066	    # Hardcode the library path.
5067	    # Skip directories that are in the system default run-time
5068	    # search path.
5069	    case " $sys_lib_dlsearch_path " in
5070	    *" $absdir "*) ;;
5071	    *)
5072	      case "$compile_rpath " in
5073	      *" $absdir "*) ;;
5074	      *) compile_rpath="$compile_rpath $absdir"
5075	      esac
5076	      ;;
5077	    esac
5078	    case " $sys_lib_dlsearch_path " in
5079	    *" $libdir "*) ;;
5080	    *)
5081	      case "$finalize_rpath " in
5082	      *" $libdir "*) ;;
5083	      *) finalize_rpath="$finalize_rpath $libdir"
5084	      esac
5085	      ;;
5086	    esac
5087	  fi
5088
5089	  if test -n "$old_archive_from_expsyms_cmds"; then
5090	    # figure out the soname
5091	    set dummy $library_names
5092	    shift
5093	    realname="$1"
5094	    shift
5095	    libname=`eval "\\$ECHO \"$libname_spec\""`
5096	    # use dlname if we got it. it's perfectly good, no?
5097	    if test -n "$dlname"; then
5098	      soname="$dlname"
5099	    elif test -n "$soname_spec"; then
5100	      # bleh windows
5101	      case $host in
5102	      *cygwin* | mingw*)
5103	        func_arith $current - $age
5104		major=$func_arith_result
5105		versuffix="-$major"
5106		;;
5107	      esac
5108	      eval soname=\"$soname_spec\"
5109	    else
5110	      soname="$realname"
5111	    fi
5112
5113	    # Make a new name for the extract_expsyms_cmds to use
5114	    soroot="$soname"
5115	    func_basename "$soroot"
5116	    soname="$func_basename_result"
5117	    func_stripname 'lib' '.dll' "$soname"
5118	    newlib=libimp-$func_stripname_result.a
5119
5120	    # If the library has no export list, then create one now
5121	    if test -f "$output_objdir/$soname-def"; then :
5122	    else
5123	      func_verbose "extracting exported symbol list from \`$soname'"
5124	      func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
5125	    fi
5126
5127	    # Create $newlib
5128	    if test -f "$output_objdir/$newlib"; then :; else
5129	      func_verbose "generating import library for \`$soname'"
5130	      func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
5131	    fi
5132	    # make sure the library variables are pointing to the new library
5133	    dir=$output_objdir
5134	    linklib=$newlib
5135	  fi # test -n "$old_archive_from_expsyms_cmds"
5136
5137	  if test "$linkmode" = prog || test "$mode" != relink; then
5138	    add_shlibpath=
5139	    add_dir=
5140	    add=
5141	    lib_linked=yes
5142	    case $hardcode_action in
5143	    immediate | unsupported)
5144	      if test "$hardcode_direct" = no; then
5145		add="$dir/$linklib"
5146		case $host in
5147		  *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
5148		  *-*-sysv4*uw2*) add_dir="-L$dir" ;;
5149		  *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
5150		    *-*-unixware7*) add_dir="-L$dir" ;;
5151		  *-*-darwin* )
5152		    # if the lib is a (non-dlopened) module then we can not
5153		    # link against it, someone is ignoring the earlier warnings
5154		    if /usr/bin/file -L $add 2> /dev/null |
5155			 $GREP ": [^:]* bundle" >/dev/null ; then
5156		      if test "X$dlopenmodule" != "X$lib"; then
5157			$ECHO "*** Warning: lib $linklib is a module, not a shared library"
5158			if test -z "$old_library" ; then
5159			  $ECHO
5160			  $ECHO "*** And there doesn't seem to be a static archive available"
5161			  $ECHO "*** The link will probably fail, sorry"
5162			else
5163			  add="$dir/$old_library"
5164			fi
5165		      elif test -n "$old_library"; then
5166			add="$dir/$old_library"
5167		      fi
5168		    fi
5169		esac
5170	      elif test "$hardcode_minus_L" = no; then
5171		case $host in
5172		*-*-sunos*) add_shlibpath="$dir" ;;
5173		esac
5174		add_dir="-L$dir"
5175		add="-l$name"
5176	      elif test "$hardcode_shlibpath_var" = no; then
5177		add_shlibpath="$dir"
5178		add="-l$name"
5179	      else
5180		lib_linked=no
5181	      fi
5182	      ;;
5183	    relink)
5184	      if test "$hardcode_direct" = yes &&
5185	         test "$hardcode_direct_absolute" = no; then
5186		add="$dir/$linklib"
5187	      elif test "$hardcode_minus_L" = yes; then
5188		add_dir="-L$dir"
5189		# Try looking first in the location we're being installed to.
5190		if test -n "$inst_prefix_dir"; then
5191		  case $libdir in
5192		    [\\/]*)
5193		      add_dir="$add_dir -L$inst_prefix_dir$libdir"
5194		      ;;
5195		  esac
5196		fi
5197		add="-l$name"
5198	      elif test "$hardcode_shlibpath_var" = yes; then
5199		add_shlibpath="$dir"
5200		add="-l$name"
5201	      else
5202		lib_linked=no
5203	      fi
5204	      ;;
5205	    *) lib_linked=no ;;
5206	    esac
5207
5208	    if test "$lib_linked" != yes; then
5209	      func_fatal_configuration "unsupported hardcode properties"
5210	    fi
5211
5212	    if test -n "$add_shlibpath"; then
5213	      case :$compile_shlibpath: in
5214	      *":$add_shlibpath:"*) ;;
5215	      *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
5216	      esac
5217	    fi
5218	    if test "$linkmode" = prog; then
5219	      test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
5220	      test -n "$add" && compile_deplibs="$add $compile_deplibs"
5221	    else
5222	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
5223	      test -n "$add" && deplibs="$add $deplibs"
5224	      if test "$hardcode_direct" != yes &&
5225		 test "$hardcode_minus_L" != yes &&
5226		 test "$hardcode_shlibpath_var" = yes; then
5227		case :$finalize_shlibpath: in
5228		*":$libdir:"*) ;;
5229		*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
5230		esac
5231	      fi
5232	    fi
5233	  fi
5234
5235	  if test "$linkmode" = prog || test "$mode" = relink; then
5236	    add_shlibpath=
5237	    add_dir=
5238	    add=
5239	    # Finalize command for both is simple: just hardcode it.
5240	    if test "$hardcode_direct" = yes &&
5241	       test "$hardcode_direct_absolute" = no; then
5242	      add="$libdir/$linklib"
5243	    elif test "$hardcode_minus_L" = yes; then
5244	      add_dir="-L$libdir"
5245	      add="-l$name"
5246	    elif test "$hardcode_shlibpath_var" = yes; then
5247	      case :$finalize_shlibpath: in
5248	      *":$libdir:"*) ;;
5249	      *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
5250	      esac
5251	      add="-l$name"
5252	    elif test "$hardcode_automatic" = yes; then
5253	      if test -n "$inst_prefix_dir" &&
5254		 test -f "$inst_prefix_dir$libdir/$linklib" ; then
5255		add="$inst_prefix_dir$libdir/$linklib"
5256	      else
5257		add="$libdir/$linklib"
5258	      fi
5259	    else
5260	      # We cannot seem to hardcode it, guess we'll fake it.
5261	      add_dir="-L$libdir"
5262	      # Try looking first in the location we're being installed to.
5263	      if test -n "$inst_prefix_dir"; then
5264		case $libdir in
5265		  [\\/]*)
5266		    add_dir="$add_dir -L$inst_prefix_dir$libdir"
5267		    ;;
5268		esac
5269	      fi
5270	      add="-l$name"
5271	    fi
5272
5273	    if test "$linkmode" = prog; then
5274	      test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
5275	      test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
5276	    else
5277	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
5278	      test -n "$add" && deplibs="$add $deplibs"
5279	    fi
5280	  fi
5281	elif test "$linkmode" = prog; then
5282	  # Here we assume that one of hardcode_direct or hardcode_minus_L
5283	  # is not unsupported.  This is valid on all known static and
5284	  # shared platforms.
5285	  if test "$hardcode_direct" != unsupported; then
5286	    test -n "$old_library" && linklib="$old_library"
5287	    compile_deplibs="$dir/$linklib $compile_deplibs"
5288	    finalize_deplibs="$dir/$linklib $finalize_deplibs"
5289	  else
5290	    compile_deplibs="-l$name -L$dir $compile_deplibs"
5291	    finalize_deplibs="-l$name -L$dir $finalize_deplibs"
5292	  fi
5293	elif test "$build_libtool_libs" = yes; then
5294	  # Not a shared library
5295	  if test "$deplibs_check_method" != pass_all; then
5296	    # We're trying link a shared library against a static one
5297	    # but the system doesn't support it.
5298
5299	    # Just print a warning and add the library to dependency_libs so
5300	    # that the program can be linked against the static library.
5301	    $ECHO
5302	    $ECHO "*** Warning: This system can not link to static lib archive $lib."
5303	    $ECHO "*** I have the capability to make that library automatically link in when"
5304	    $ECHO "*** you link to this library.  But I can only do this if you have a"
5305	    $ECHO "*** shared version of the library, which you do not appear to have."
5306	    if test "$module" = yes; then
5307	      $ECHO "*** But as you try to build a module library, libtool will still create "
5308	      $ECHO "*** a static module, that should work as long as the dlopening application"
5309	      $ECHO "*** is linked with the -dlopen flag to resolve symbols at runtime."
5310	      if test -z "$global_symbol_pipe"; then
5311		$ECHO
5312		$ECHO "*** However, this would only work if libtool was able to extract symbol"
5313		$ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
5314		$ECHO "*** not find such a program.  So, this module is probably useless."
5315		$ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
5316	      fi
5317	      if test "$build_old_libs" = no; then
5318		build_libtool_libs=module
5319		build_old_libs=yes
5320	      else
5321		build_libtool_libs=no
5322	      fi
5323	    fi
5324	  else
5325	    deplibs="$dir/$old_library $deplibs"
5326	    link_static=yes
5327	  fi
5328	fi # link shared/static library?
5329
5330	if test "$linkmode" = lib; then
5331	  if test -n "$dependency_libs" &&
5332	     { test "$hardcode_into_libs" != yes ||
5333	       test "$build_old_libs" = yes ||
5334	       test "$link_static" = yes; }; then
5335	    # Extract -R from dependency_libs
5336	    temp_deplibs=
5337	    for libdir in $dependency_libs; do
5338	      case $libdir in
5339	      -R*) func_stripname '-R' '' "$libdir"
5340	           temp_xrpath=$func_stripname_result
5341		   case " $xrpath " in
5342		   *" $temp_xrpath "*) ;;
5343		   *) xrpath="$xrpath $temp_xrpath";;
5344		   esac;;
5345	      *) temp_deplibs="$temp_deplibs $libdir";;
5346	      esac
5347	    done
5348	    dependency_libs="$temp_deplibs"
5349	  fi
5350
5351	  newlib_search_path="$newlib_search_path $absdir"
5352	  # Link against this library
5353	  test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
5354	  # ... and its dependency_libs
5355	  tmp_libs=
5356	  for deplib in $dependency_libs; do
5357	    newdependency_libs="$deplib $newdependency_libs"
5358	    if $opt_duplicate_deps ; then
5359	      case "$tmp_libs " in
5360	      *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5361	      esac
5362	    fi
5363	    tmp_libs="$tmp_libs $deplib"
5364	  done
5365
5366	  if test "$link_all_deplibs" != no; then
5367	    # Add the search paths of all dependency libraries
5368	    for deplib in $dependency_libs; do
5369	      case $deplib in
5370	      -L*) path="$deplib" ;;
5371	      *.la)
5372	        func_dirname "$deplib" "" "."
5373		dir="$func_dirname_result"
5374		# We need an absolute path.
5375		case $dir in
5376		[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
5377		*)
5378		  absdir=`cd "$dir" && pwd`
5379		  if test -z "$absdir"; then
5380		    func_warning "cannot determine absolute directory name of \`$dir'"
5381		    absdir="$dir"
5382		  fi
5383		  ;;
5384		esac
5385		if $GREP "^installed=no" $deplib > /dev/null; then
5386		case $host in
5387		*-*-darwin*)
5388		  depdepl=
5389		  eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
5390		  if test -n "$deplibrary_names" ; then
5391		    for tmp in $deplibrary_names ; do
5392		      depdepl=$tmp
5393		    done
5394		    if test -f "$absdir/$objdir/$depdepl" ; then
5395		      depdepl="$absdir/$objdir/$depdepl"
5396		      darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
5397                      if test -z "$darwin_install_name"; then
5398                          darwin_install_name=`${OTOOL64} -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
5399                      fi
5400		      compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
5401		      linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
5402		      path=
5403		    fi
5404		  fi
5405		  ;;
5406		*)
5407		  path="-L$absdir/$objdir"
5408		  ;;
5409		esac
5410		else
5411		  eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
5412		  test -z "$libdir" && \
5413		    func_fatal_error "\`$deplib' is not a valid libtool archive"
5414		  test "$absdir" != "$libdir" && \
5415		    func_warning "\`$deplib' seems to be moved"
5416
5417		  path="-L$absdir"
5418		fi
5419		;;
5420	      esac
5421	      case " $deplibs " in
5422	      *" $path "*) ;;
5423	      *) deplibs="$path $deplibs" ;;
5424	      esac
5425	    done
5426	  fi # link_all_deplibs != no
5427	fi # linkmode = lib
5428      done # for deplib in $libs
5429      if test "$pass" = link; then
5430	if test "$linkmode" = "prog"; then
5431	  compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
5432	  finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
5433	else
5434	  compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
5435	fi
5436      fi
5437      dependency_libs="$newdependency_libs"
5438      if test "$pass" = dlpreopen; then
5439	# Link the dlpreopened libraries before other libraries
5440	for deplib in $save_deplibs; do
5441	  deplibs="$deplib $deplibs"
5442	done
5443      fi
5444      if test "$pass" != dlopen; then
5445	if test "$pass" != conv; then
5446	  # Make sure lib_search_path contains only unique directories.
5447	  lib_search_path=
5448	  for dir in $newlib_search_path; do
5449	    case "$lib_search_path " in
5450	    *" $dir "*) ;;
5451	    *) lib_search_path="$lib_search_path $dir" ;;
5452	    esac
5453	  done
5454	  newlib_search_path=
5455	fi
5456
5457	if test "$linkmode,$pass" != "prog,link"; then
5458	  vars="deplibs"
5459	else
5460	  vars="compile_deplibs finalize_deplibs"
5461	fi
5462	for var in $vars dependency_libs; do
5463	  # Add libraries to $var in reverse order
5464	  eval tmp_libs=\"\$$var\"
5465	  new_libs=
5466	  for deplib in $tmp_libs; do
5467	    # FIXME: Pedantically, this is the right thing to do, so
5468	    #        that some nasty dependency loop isn't accidentally
5469	    #        broken:
5470	    #new_libs="$deplib $new_libs"
5471	    # Pragmatically, this seems to cause very few problems in
5472	    # practice:
5473	    case $deplib in
5474	    -L*) new_libs="$deplib $new_libs" ;;
5475	    -R*) ;;
5476	    *)
5477	      # And here is the reason: when a library appears more
5478	      # than once as an explicit dependence of a library, or
5479	      # is implicitly linked in more than once by the
5480	      # compiler, it is considered special, and multiple
5481	      # occurrences thereof are not removed.  Compare this
5482	      # with having the same library being listed as a
5483	      # dependency of multiple other libraries: in this case,
5484	      # we know (pedantically, we assume) the library does not
5485	      # need to be listed more than once, so we keep only the
5486	      # last copy.  This is not always right, but it is rare
5487	      # enough that we require users that really mean to play
5488	      # such unportable linking tricks to link the library
5489	      # using -Wl,-lname, so that libtool does not consider it
5490	      # for duplicate removal.
5491	      case " $specialdeplibs " in
5492	      *" $deplib "*) new_libs="$deplib $new_libs" ;;
5493	      *)
5494		case " $new_libs " in
5495		*" $deplib "*) ;;
5496		*) new_libs="$deplib $new_libs" ;;
5497		esac
5498		;;
5499	      esac
5500	      ;;
5501	    esac
5502	  done
5503	  tmp_libs=
5504	  for deplib in $new_libs; do
5505	    case $deplib in
5506	    -L*)
5507	      case " $tmp_libs " in
5508	      *" $deplib "*) ;;
5509	      *) tmp_libs="$tmp_libs $deplib" ;;
5510	      esac
5511	      ;;
5512	    *) tmp_libs="$tmp_libs $deplib" ;;
5513	    esac
5514	  done
5515	  eval $var=\"$tmp_libs\"
5516	done # for var
5517      fi
5518      # Last step: remove runtime libs from dependency_libs
5519      # (they stay in deplibs)
5520      tmp_libs=
5521      for i in $dependency_libs ; do
5522	case " $predeps $postdeps $compiler_lib_search_path " in
5523	*" $i "*)
5524	  i=""
5525	  ;;
5526	esac
5527	if test -n "$i" ; then
5528	  tmp_libs="$tmp_libs $i"
5529	fi
5530      done
5531      dependency_libs=$tmp_libs
5532    done # for pass
5533    if test "$linkmode" = prog; then
5534      dlfiles="$newdlfiles"
5535    fi
5536    if test "$linkmode" = prog || test "$linkmode" = lib; then
5537      dlprefiles="$newdlprefiles"
5538    fi
5539
5540    case $linkmode in
5541    oldlib)
5542      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
5543	func_warning "\`-dlopen' is ignored for archives"
5544      fi
5545
5546      case " $deplibs" in
5547      *\ -l* | *\ -L*)
5548	func_warning "\`-l' and \`-L' are ignored for archives" ;;
5549      esac
5550
5551      test -n "$rpath" && \
5552	func_warning "\`-rpath' is ignored for archives"
5553
5554      test -n "$xrpath" && \
5555	func_warning "\`-R' is ignored for archives"
5556
5557      test -n "$vinfo" && \
5558	func_warning "\`-version-info/-version-number' is ignored for archives"
5559
5560      test -n "$release" && \
5561	func_warning "\`-release' is ignored for archives"
5562
5563      test -n "$export_symbols$export_symbols_regex" && \
5564	func_warning "\`-export-symbols' is ignored for archives"
5565
5566      # Now set the variables for building old libraries.
5567      build_libtool_libs=no
5568      oldlibs="$output"
5569      objs="$objs$old_deplibs"
5570      ;;
5571
5572    lib)
5573      # Make sure we only generate libraries of the form `libNAME.la'.
5574      case $outputname in
5575      lib*)
5576	func_stripname 'lib' '.la' "$outputname"
5577	name=$func_stripname_result
5578	eval shared_ext=\"$shrext_cmds\"
5579	eval libname=\"$libname_spec\"
5580	;;
5581      *)
5582	test "$module" = no && \
5583	  func_fatal_help "libtool library \`$output' must begin with \`lib'"
5584
5585	if test "$need_lib_prefix" != no; then
5586	  # Add the "lib" prefix for modules if required
5587	  func_stripname '' '.la' "$outputname"
5588	  name=$func_stripname_result
5589	  eval shared_ext=\"$shrext_cmds\"
5590	  eval libname=\"$libname_spec\"
5591	else
5592	  func_stripname '' '.la' "$outputname"
5593	  libname=$func_stripname_result
5594	fi
5595	;;
5596      esac
5597
5598      if test -n "$objs"; then
5599	if test "$deplibs_check_method" != pass_all; then
5600	  func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
5601	else
5602	  $ECHO
5603	  $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
5604	  $ECHO "*** objects $objs is not portable!"
5605	  libobjs="$libobjs $objs"
5606	fi
5607      fi
5608
5609      test "$dlself" != no && \
5610	func_warning "\`-dlopen self' is ignored for libtool libraries"
5611
5612      set dummy $rpath
5613      shift
5614      test "$#" -gt 1 && \
5615	func_warning "ignoring multiple \`-rpath's for a libtool library"
5616
5617      install_libdir="$1"
5618
5619      oldlibs=
5620      if test -z "$rpath"; then
5621	if test "$build_libtool_libs" = yes; then
5622	  # Building a libtool convenience library.
5623	  # Some compilers have problems with a `.al' extension so
5624	  # convenience libraries should have the same extension an
5625	  # archive normally would.
5626	  oldlibs="$output_objdir/$libname.$libext $oldlibs"
5627	  build_libtool_libs=convenience
5628	  build_old_libs=yes
5629	fi
5630
5631	test -n "$vinfo" && \
5632	  func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
5633
5634	test -n "$release" && \
5635	  func_warning "\`-release' is ignored for convenience libraries"
5636      else
5637
5638	# Parse the version information argument.
5639	save_ifs="$IFS"; IFS=':'
5640	set dummy $vinfo 0 0 0
5641	shift
5642	IFS="$save_ifs"
5643
5644	test -n "$7" && \
5645	  func_fatal_help "too many parameters to \`-version-info'"
5646
5647	# convert absolute version numbers to libtool ages
5648	# this retains compatibility with .la files and attempts
5649	# to make the code below a bit more comprehensible
5650
5651	case $vinfo_number in
5652	yes)
5653	  number_major="$1"
5654	  number_minor="$2"
5655	  number_revision="$3"
5656	  #
5657	  # There are really only two kinds -- those that
5658	  # use the current revision as the major version
5659	  # and those that subtract age and use age as
5660	  # a minor version.  But, then there is irix
5661	  # which has an extra 1 added just for fun
5662	  #
5663	  case $version_type in
5664	  darwin|linux|osf|windows|none)
5665	    func_arith $number_major + $number_minor
5666	    current=$func_arith_result
5667	    age="$number_minor"
5668	    revision="$number_revision"
5669	    ;;
5670	  freebsd-aout|freebsd-elf|sunos)
5671	    current="$number_major"
5672	    revision="$number_minor"
5673	    age="0"
5674	    ;;
5675	  irix|nonstopux)
5676	    func_arith $number_major + $number_minor
5677	    current=$func_arith_result
5678	    age="$number_minor"
5679	    revision="$number_minor"
5680	    lt_irix_increment=no
5681	    ;;
5682	  esac
5683	  ;;
5684	no)
5685	  current="$1"
5686	  revision="$2"
5687	  age="$3"
5688	  ;;
5689	esac
5690
5691	# Check that each of the things are valid numbers.
5692	case $current in
5693	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]) ;;
5694	*)
5695	  func_error "CURRENT \`$current' must be a nonnegative integer"
5696	  func_fatal_error "\`$vinfo' is not valid version information"
5697	  ;;
5698	esac
5699
5700	case $revision in
5701	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]) ;;
5702	*)
5703	  func_error "REVISION \`$revision' must be a nonnegative integer"
5704	  func_fatal_error "\`$vinfo' is not valid version information"
5705	  ;;
5706	esac
5707
5708	case $age in
5709	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]) ;;
5710	*)
5711	  func_error "AGE \`$age' must be a nonnegative integer"
5712	  func_fatal_error "\`$vinfo' is not valid version information"
5713	  ;;
5714	esac
5715
5716	if test "$age" -gt "$current"; then
5717	  func_error "AGE \`$age' is greater than the current interface number \`$current'"
5718	  func_fatal_error "\`$vinfo' is not valid version information"
5719	fi
5720
5721	# Calculate the version variables.
5722	major=
5723	versuffix=
5724	verstring=
5725	case $version_type in
5726	none) ;;
5727
5728	darwin)
5729	  # Like Linux, but with the current version available in
5730	  # verstring for coding it into the library header
5731	  func_arith $current - $age
5732	  major=.$func_arith_result
5733	  versuffix="$major.$age.$revision"
5734	  # Darwin ld doesn't like 0 for these options...
5735	  func_arith $current + 1
5736	  minor_current=$func_arith_result
5737	  xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
5738	  verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
5739	  ;;
5740
5741	freebsd-aout)
5742	  major=".$current"
5743	  versuffix=".$current.$revision";
5744	  ;;
5745
5746	freebsd-elf)
5747	  major=".$current"
5748	  versuffix=".$current"
5749	  ;;
5750
5751	irix | nonstopux)
5752	  if test "X$lt_irix_increment" = "Xno"; then
5753	    func_arith $current - $age
5754	  else
5755	    func_arith $current - $age + 1
5756	  fi
5757	  major=$func_arith_result
5758
5759	  case $version_type in
5760	    nonstopux) verstring_prefix=nonstopux ;;
5761	    *)         verstring_prefix=sgi ;;
5762	  esac
5763	  verstring="$verstring_prefix$major.$revision"
5764
5765	  # Add in all the interfaces that we are compatible with.
5766	  loop=$revision
5767	  while test "$loop" -ne 0; do
5768	    func_arith $revision - $loop
5769	    iface=$func_arith_result
5770	    func_arith $loop - 1
5771	    loop=$func_arith_result
5772	    verstring="$verstring_prefix$major.$iface:$verstring"
5773	  done
5774
5775	  # Before this point, $major must not contain `.'.
5776	  major=.$major
5777	  versuffix="$major.$revision"
5778	  ;;
5779
5780	linux)
5781	  func_arith $current - $age
5782	  major=.$func_arith_result
5783	  versuffix="$major.$age.$revision"
5784	  ;;
5785
5786	osf)
5787	  func_arith $current - $age
5788	  major=.$func_arith_result
5789	  versuffix=".$current.$age.$revision"
5790	  verstring="$current.$age.$revision"
5791
5792	  # Add in all the interfaces that we are compatible with.
5793	  loop=$age
5794	  while test "$loop" -ne 0; do
5795	    func_arith $current - $loop
5796	    iface=$func_arith_result
5797	    func_arith $loop - 1
5798	    loop=$func_arith_result
5799	    verstring="$verstring:${iface}.0"
5800	  done
5801
5802	  # Make executables depend on our current version.
5803	  verstring="$verstring:${current}.0"
5804	  ;;
5805
5806	qnx)
5807	  major=".$current"
5808	  versuffix=".$current"
5809	  ;;
5810
5811	sunos)
5812	  major=".$current"
5813	  versuffix=".$current.$revision"
5814	  ;;
5815
5816	windows)
5817	  # Use '-' rather than '.', since we only want one
5818	  # extension on DOS 8.3 filesystems.
5819	  func_arith $current - $age
5820	  major=$func_arith_result
5821	  versuffix="-$major"
5822	  ;;
5823
5824	*)
5825	  func_fatal_configuration "unknown library version type \`$version_type'"
5826	  ;;
5827	esac
5828
5829	# Clear the version info if we defaulted, and they specified a release.
5830	if test -z "$vinfo" && test -n "$release"; then
5831	  major=
5832	  case $version_type in
5833	  darwin)
5834	    # we can't check for "0.0" in archive_cmds due to quoting
5835	    # problems, so we reset it completely
5836	    verstring=
5837	    ;;
5838	  *)
5839	    verstring="0.0"
5840	    ;;
5841	  esac
5842	  if test "$need_version" = no; then
5843	    versuffix=
5844	  else
5845	    versuffix=".0.0"
5846	  fi
5847	fi
5848
5849	# Remove version info from name if versioning should be avoided
5850	if test "$avoid_version" = yes && test "$need_version" = no; then
5851	  major=
5852	  versuffix=
5853	  verstring=""
5854	fi
5855
5856	# Check to see if the archive will have undefined symbols.
5857	if test "$allow_undefined" = yes; then
5858	  if test "$allow_undefined_flag" = unsupported; then
5859	    func_warning "undefined symbols not allowed in $host shared libraries"
5860	    build_libtool_libs=no
5861	    build_old_libs=yes
5862	  fi
5863	else
5864	  # Don't allow undefined symbols.
5865	  allow_undefined_flag="$no_undefined_flag"
5866	fi
5867
5868      fi
5869
5870      func_generate_dlsyms "$libname" "$libname" "yes"
5871      libobjs="$libobjs $symfileobj"
5872      test "X$libobjs" = "X " && libobjs=
5873
5874      if test "$mode" != relink; then
5875	# Remove our outputs, but don't remove object files since they
5876	# may have been created when compiling PIC objects.
5877	removelist=
5878	tempremovelist=`$ECHO "$output_objdir/*"`
5879	for p in $tempremovelist; do
5880	  case $p in
5881	    *.$objext)
5882	       ;;
5883	    $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
5884	       if test "X$precious_files_regex" != "X"; then
5885		 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
5886		 then
5887		   continue
5888		 fi
5889	       fi
5890	       removelist="$removelist $p"
5891	       ;;
5892	    *) ;;
5893	  esac
5894	done
5895	test -n "$removelist" && \
5896	  func_show_eval "${RM}r \$removelist"
5897      fi
5898
5899      # Now set the variables for building old libraries.
5900      if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
5901	oldlibs="$oldlibs $output_objdir/$libname.$libext"
5902
5903	# Transform .lo files to .o files.
5904	oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
5905      fi
5906
5907      # Eliminate all temporary directories.
5908      #for path in $notinst_path; do
5909      #	lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`
5910      #	deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`
5911      #	dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`
5912      #done
5913
5914      if test -n "$xrpath"; then
5915	# If the user specified any rpath flags, then add them.
5916	temp_xrpath=
5917	for libdir in $xrpath; do
5918	  temp_xrpath="$temp_xrpath -R$libdir"
5919	  case "$finalize_rpath " in
5920	  *" $libdir "*) ;;
5921	  *) finalize_rpath="$finalize_rpath $libdir" ;;
5922	  esac
5923	done
5924	if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
5925	  dependency_libs="$temp_xrpath $dependency_libs"
5926	fi
5927      fi
5928
5929      # Make sure dlfiles contains only unique files that won't be dlpreopened
5930      old_dlfiles="$dlfiles"
5931      dlfiles=
5932      for lib in $old_dlfiles; do
5933	case " $dlprefiles $dlfiles " in
5934	*" $lib "*) ;;
5935	*) dlfiles="$dlfiles $lib" ;;
5936	esac
5937      done
5938
5939      # Make sure dlprefiles contains only unique files
5940      old_dlprefiles="$dlprefiles"
5941      dlprefiles=
5942      for lib in $old_dlprefiles; do
5943	case "$dlprefiles " in
5944	*" $lib "*) ;;
5945	*) dlprefiles="$dlprefiles $lib" ;;
5946	esac
5947      done
5948
5949      if test "$build_libtool_libs" = yes; then
5950	if test -n "$rpath"; then
5951	  case $host in
5952	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
5953	    # these systems don't actually have a c library (as such)!
5954	    ;;
5955	  *-*-rhapsody* | *-*-darwin1.[012])
5956	    # Rhapsody C library is in the System framework
5957	    deplibs="$deplibs System.ltframework"
5958	    ;;
5959	  *-*-netbsd*)
5960	    # Don't link with libc until the a.out ld.so is fixed.
5961	    ;;
5962	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5963	    # Do not include libc due to us having libc/libc_r.
5964	    ;;
5965	  *-*-sco3.2v5* | *-*-sco5v6*)
5966	    # Causes problems with __ctype
5967	    ;;
5968	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
5969	    # Compiler inserts libc in the correct place for threads to work
5970	    ;;
5971	  *)
5972	    # Add libc to deplibs on all other systems if necessary.
5973	    if test "$build_libtool_need_lc" = "yes"; then
5974	      deplibs="$deplibs -lc"
5975	    fi
5976	    ;;
5977	  esac
5978	fi
5979
5980	# Transform deplibs into only deplibs that can be linked in shared.
5981	name_save=$name
5982	libname_save=$libname
5983	release_save=$release
5984	versuffix_save=$versuffix
5985	major_save=$major
5986	# I'm not sure if I'm treating the release correctly.  I think
5987	# release should show up in the -l (ie -lgmp5) so we don't want to
5988	# add it in twice.  Is that correct?
5989	release=""
5990	versuffix=""
5991	major=""
5992	newdeplibs=
5993	droppeddeps=no
5994	case $deplibs_check_method in
5995	pass_all)
5996	  # Don't check for shared/static.  Everything works.
5997	  # This might be a little naive.  We might want to check
5998	  # whether the library exists or not.  But this is on
5999	  # osf3 & osf4 and I'm not really sure... Just
6000	  # implementing what was already the behavior.
6001	  newdeplibs=$deplibs
6002	  ;;
6003	test_compile)
6004	  # This code stresses the "libraries are programs" paradigm to its
6005	  # limits. Maybe even breaks it.  We compile a program, linking it
6006	  # against the deplibs as a proxy for the library.  Then we can check
6007	  # whether they linked in statically or dynamically with ldd.
6008	  $opt_dry_run || $RM conftest.c
6009	  cat > conftest.c <<EOF
6010	  int main() { return 0; }
6011EOF
6012	  $opt_dry_run || $RM conftest
6013	  if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
6014	    ldd_output=`ldd conftest`
6015	    for i in $deplibs; do
6016	      case $i in
6017	      -l*)
6018		func_stripname -l '' "$i"
6019		name=$func_stripname_result
6020		if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6021		  case " $predeps $postdeps " in
6022		  *" $i "*)
6023		    newdeplibs="$newdeplibs $i"
6024		    i=""
6025		    ;;
6026		  esac
6027		fi
6028		if test -n "$i" ; then
6029		  libname=`eval "\\$ECHO \"$libname_spec\""`
6030		  deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
6031		  set dummy $deplib_matches; shift
6032		  deplib_match=$1
6033		  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6034		    newdeplibs="$newdeplibs $i"
6035		  else
6036		    droppeddeps=yes
6037		    $ECHO
6038		    $ECHO "*** Warning: dynamic linker does not accept needed library $i."
6039		    $ECHO "*** I have the capability to make that library automatically link in when"
6040		    $ECHO "*** you link to this library.  But I can only do this if you have a"
6041		    $ECHO "*** shared version of the library, which I believe you do not have"
6042		    $ECHO "*** because a test_compile did reveal that the linker did not use it for"
6043		    $ECHO "*** its dynamic dependency list that programs get resolved with at runtime."
6044		  fi
6045		fi
6046		;;
6047	      *)
6048		newdeplibs="$newdeplibs $i"
6049		;;
6050	      esac
6051	    done
6052	  else
6053	    # Error occurred in the first compile.  Let's try to salvage
6054	    # the situation: Compile a separate program for each library.
6055	    for i in $deplibs; do
6056	      case $i in
6057	      -l*)
6058		func_stripname -l '' "$i"
6059		name=$func_stripname_result
6060		$opt_dry_run || $RM conftest
6061		if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
6062		  ldd_output=`ldd conftest`
6063		  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6064		    case " $predeps $postdeps " in
6065		    *" $i "*)
6066		      newdeplibs="$newdeplibs $i"
6067		      i=""
6068		      ;;
6069		    esac
6070		  fi
6071		  if test -n "$i" ; then
6072		    libname=`eval "\\$ECHO \"$libname_spec\""`
6073		    deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
6074		    set dummy $deplib_matches; shift
6075		    deplib_match=$1
6076		    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6077		      newdeplibs="$newdeplibs $i"
6078		    else
6079		      droppeddeps=yes
6080		      $ECHO
6081		      $ECHO "*** Warning: dynamic linker does not accept needed library $i."
6082		      $ECHO "*** I have the capability to make that library automatically link in when"
6083		      $ECHO "*** you link to this library.  But I can only do this if you have a"
6084		      $ECHO "*** shared version of the library, which you do not appear to have"
6085		      $ECHO "*** because a test_compile did reveal that the linker did not use this one"
6086		      $ECHO "*** as a dynamic dependency that programs can get resolved with at runtime."
6087		    fi
6088		  fi
6089		else
6090		  droppeddeps=yes
6091		  $ECHO
6092		  $ECHO "*** Warning!  Library $i is needed by this library but I was not able to"
6093		  $ECHO "*** make it link in!  You will probably need to install it or some"
6094		  $ECHO "*** library that it depends on before this library will be fully"
6095		  $ECHO "*** functional.  Installing it before continuing would be even better."
6096		fi
6097		;;
6098	      *)
6099		newdeplibs="$newdeplibs $i"
6100		;;
6101	      esac
6102	    done
6103	  fi
6104	  ;;
6105	file_magic*)
6106	  set dummy $deplibs_check_method; shift
6107	  file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6108	  for a_deplib in $deplibs; do
6109	    case $a_deplib in
6110	    -l*)
6111	      func_stripname -l '' "$a_deplib"
6112	      name=$func_stripname_result
6113	      if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6114		case " $predeps $postdeps " in
6115		*" $a_deplib "*)
6116		  newdeplibs="$newdeplibs $a_deplib"
6117		  a_deplib=""
6118		  ;;
6119		esac
6120	      fi
6121	      if test -n "$a_deplib" ; then
6122		libname=`eval "\\$ECHO \"$libname_spec\""`
6123		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
6124		  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
6125		  for potent_lib in $potential_libs; do
6126		      # Follow soft links.
6127		      if ls -lLd "$potent_lib" 2>/dev/null |
6128			 $GREP " -> " >/dev/null; then
6129			continue
6130		      fi
6131		      # The statement above tries to avoid entering an
6132		      # endless loop below, in case of cyclic links.
6133		      # We might still enter an endless loop, since a link
6134		      # loop can be closed while we follow links,
6135		      # but so what?
6136		      potlib="$potent_lib"
6137		      while test -h "$potlib" 2>/dev/null; do
6138			potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
6139			case $potliblink in
6140			[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
6141			*) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
6142			esac
6143		      done
6144		      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
6145			 $SED -e 10q |
6146			 $EGREP "$file_magic_regex" > /dev/null; then
6147			newdeplibs="$newdeplibs $a_deplib"
6148			a_deplib=""
6149			break 2
6150		      fi
6151		  done
6152		done
6153	      fi
6154	      if test -n "$a_deplib" ; then
6155		droppeddeps=yes
6156		$ECHO
6157		$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
6158		$ECHO "*** I have the capability to make that library automatically link in when"
6159		$ECHO "*** you link to this library.  But I can only do this if you have a"
6160		$ECHO "*** shared version of the library, which you do not appear to have"
6161		$ECHO "*** because I did check the linker path looking for a file starting"
6162		if test -z "$potlib" ; then
6163		  $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
6164		else
6165		  $ECHO "*** with $libname and none of the candidates passed a file format test"
6166		  $ECHO "*** using a file magic. Last file checked: $potlib"
6167		fi
6168	      fi
6169	      ;;
6170	    *)
6171	      # Add a -L argument.
6172	      newdeplibs="$newdeplibs $a_deplib"
6173	      ;;
6174	    esac
6175	  done # Gone through all deplibs.
6176	  ;;
6177	match_pattern*)
6178	  set dummy $deplibs_check_method; shift
6179	  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6180	  for a_deplib in $deplibs; do
6181	    case $a_deplib in
6182	    -l*)
6183	      func_stripname -l '' "$a_deplib"
6184	      name=$func_stripname_result
6185	      if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6186		case " $predeps $postdeps " in
6187		*" $a_deplib "*)
6188		  newdeplibs="$newdeplibs $a_deplib"
6189		  a_deplib=""
6190		  ;;
6191		esac
6192	      fi
6193	      if test -n "$a_deplib" ; then
6194		libname=`eval "\\$ECHO \"$libname_spec\""`
6195		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
6196		  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
6197		  for potent_lib in $potential_libs; do
6198		    potlib="$potent_lib" # see symlink-check above in file_magic test
6199		    if eval "\$ECHO \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \
6200		       $EGREP "$match_pattern_regex" > /dev/null; then
6201		      newdeplibs="$newdeplibs $a_deplib"
6202		      a_deplib=""
6203		      break 2
6204		    fi
6205		  done
6206		done
6207	      fi
6208	      if test -n "$a_deplib" ; then
6209		droppeddeps=yes
6210		$ECHO
6211		$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
6212		$ECHO "*** I have the capability to make that library automatically link in when"
6213		$ECHO "*** you link to this library.  But I can only do this if you have a"
6214		$ECHO "*** shared version of the library, which you do not appear to have"
6215		$ECHO "*** because I did check the linker path looking for a file starting"
6216		if test -z "$potlib" ; then
6217		  $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
6218		else
6219		  $ECHO "*** with $libname and none of the candidates passed a file format test"
6220		  $ECHO "*** using a regex pattern. Last file checked: $potlib"
6221		fi
6222	      fi
6223	      ;;
6224	    *)
6225	      # Add a -L argument.
6226	      newdeplibs="$newdeplibs $a_deplib"
6227	      ;;
6228	    esac
6229	  done # Gone through all deplibs.
6230	  ;;
6231	none | unknown | *)
6232	  newdeplibs=""
6233	  tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \
6234	      -e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'`
6235	  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6236	    for i in $predeps $postdeps ; do
6237	      # can't use Xsed below, because $i might contain '/'
6238	      tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`
6239	    done
6240	  fi
6241	  if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[	 ]//g' |
6242	     $GREP . >/dev/null; then
6243	    $ECHO
6244	    if test "X$deplibs_check_method" = "Xnone"; then
6245	      $ECHO "*** Warning: inter-library dependencies are not supported in this platform."
6246	    else
6247	      $ECHO "*** Warning: inter-library dependencies are not known to be supported."
6248	    fi
6249	    $ECHO "*** All declared inter-library dependencies are being dropped."
6250	    droppeddeps=yes
6251	  fi
6252	  ;;
6253	esac
6254	versuffix=$versuffix_save
6255	major=$major_save
6256	release=$release_save
6257	libname=$libname_save
6258	name=$name_save
6259
6260	case $host in
6261	*-*-rhapsody* | *-*-darwin1.[012])
6262	  # On Rhapsody replace the C library with the System framework
6263	  newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
6264	  ;;
6265	esac
6266
6267	if test "$droppeddeps" = yes; then
6268	  if test "$module" = yes; then
6269	    $ECHO
6270	    $ECHO "*** Warning: libtool could not satisfy all declared inter-library"
6271	    $ECHO "*** dependencies of module $libname.  Therefore, libtool will create"
6272	    $ECHO "*** a static module, that should work as long as the dlopening"
6273	    $ECHO "*** application is linked with the -dlopen flag."
6274	    if test -z "$global_symbol_pipe"; then
6275	      $ECHO
6276	      $ECHO "*** However, this would only work if libtool was able to extract symbol"
6277	      $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
6278	      $ECHO "*** not find such a program.  So, this module is probably useless."
6279	      $ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
6280	    fi
6281	    if test "$build_old_libs" = no; then
6282	      oldlibs="$output_objdir/$libname.$libext"
6283	      build_libtool_libs=module
6284	      build_old_libs=yes
6285	    else
6286	      build_libtool_libs=no
6287	    fi
6288	  else
6289	    $ECHO "*** The inter-library dependencies that have been dropped here will be"
6290	    $ECHO "*** automatically added whenever a program is linked with this library"
6291	    $ECHO "*** or is declared to -dlopen it."
6292
6293	    if test "$allow_undefined" = no; then
6294	      $ECHO
6295	      $ECHO "*** Since this library must not contain undefined symbols,"
6296	      $ECHO "*** because either the platform does not support them or"
6297	      $ECHO "*** it was explicitly requested with -no-undefined,"
6298	      $ECHO "*** libtool will only create a static version of it."
6299	      if test "$build_old_libs" = no; then
6300		oldlibs="$output_objdir/$libname.$libext"
6301		build_libtool_libs=module
6302		build_old_libs=yes
6303	      else
6304		build_libtool_libs=no
6305	      fi
6306	    fi
6307	  fi
6308	fi
6309	# Done checking deplibs!
6310	deplibs=$newdeplibs
6311      fi
6312      # Time to change all our "foo.ltframework" stuff back to "-framework foo"
6313      case $host in
6314	*-*-darwin*)
6315	  newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6316	  new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6317	  deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6318	  ;;
6319      esac
6320
6321      # move library search paths that coincide with paths to not yet
6322      # installed libraries to the beginning of the library search list
6323      new_libs=
6324      for path in $notinst_path; do
6325	case " $new_libs " in
6326	*" -L$path/$objdir "*) ;;
6327	*)
6328	  case " $deplibs " in
6329	  *" -L$path/$objdir "*)
6330	    new_libs="$new_libs -L$path/$objdir" ;;
6331	  esac
6332	  ;;
6333	esac
6334      done
6335      for deplib in $deplibs; do
6336	case $deplib in
6337	-L*)
6338	  case " $new_libs " in
6339	  *" $deplib "*) ;;
6340	  *) new_libs="$new_libs $deplib" ;;
6341	  esac
6342	  ;;
6343	*) new_libs="$new_libs $deplib" ;;
6344	esac
6345      done
6346      deplibs="$new_libs"
6347
6348      # All the library-specific variables (install_libdir is set above).
6349      library_names=
6350      old_library=
6351      dlname=
6352
6353      # Test again, we may have decided not to build it any more
6354      if test "$build_libtool_libs" = yes; then
6355	if test "$hardcode_into_libs" = yes; then
6356	  # Hardcode the library paths
6357	  hardcode_libdirs=
6358	  dep_rpath=
6359	  rpath="$finalize_rpath"
6360	  test "$mode" != relink && rpath="$compile_rpath$rpath"
6361	  for libdir in $rpath; do
6362	    if test -n "$hardcode_libdir_flag_spec"; then
6363	      if test -n "$hardcode_libdir_separator"; then
6364		if test -z "$hardcode_libdirs"; then
6365		  hardcode_libdirs="$libdir"
6366		else
6367		  # Just accumulate the unique libdirs.
6368		  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
6369		  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
6370		    ;;
6371		  *)
6372		    hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
6373		    ;;
6374		  esac
6375		fi
6376	      else
6377		eval flag=\"$hardcode_libdir_flag_spec\"
6378		dep_rpath="$dep_rpath $flag"
6379	      fi
6380	    elif test -n "$runpath_var"; then
6381	      case "$perm_rpath " in
6382	      *" $libdir "*) ;;
6383	      *) perm_rpath="$perm_rpath $libdir" ;;
6384	      esac
6385	    fi
6386	  done
6387	  # Substitute the hardcoded libdirs into the rpath.
6388	  if test -n "$hardcode_libdir_separator" &&
6389	     test -n "$hardcode_libdirs"; then
6390	    libdir="$hardcode_libdirs"
6391	    if test -n "$hardcode_libdir_flag_spec_ld"; then
6392	      eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
6393	    else
6394	      eval dep_rpath=\"$hardcode_libdir_flag_spec\"
6395	    fi
6396	  fi
6397	  if test -n "$runpath_var" && test -n "$perm_rpath"; then
6398	    # We should set the runpath_var.
6399	    rpath=
6400	    for dir in $perm_rpath; do
6401	      rpath="$rpath$dir:"
6402	    done
6403	    eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
6404	  fi
6405	  test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
6406	fi
6407
6408	shlibpath="$finalize_shlibpath"
6409	test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
6410	if test -n "$shlibpath"; then
6411	  eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
6412	fi
6413
6414	# Get the real and link names of the library.
6415	eval shared_ext=\"$shrext_cmds\"
6416	eval library_names=\"$library_names_spec\"
6417	set dummy $library_names
6418	shift
6419	realname="$1"
6420	shift
6421
6422	if test -n "$soname_spec"; then
6423	  eval soname=\"$soname_spec\"
6424	else
6425	  soname="$realname"
6426	fi
6427	if test -z "$dlname"; then
6428	  dlname=$soname
6429	fi
6430
6431	lib="$output_objdir/$realname"
6432	linknames=
6433	for link
6434	do
6435	  linknames="$linknames $link"
6436	done
6437
6438	# Use standard objects if they are pic
6439	test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
6440	test "X$libobjs" = "X " && libobjs=
6441
6442	delfiles=
6443	if test -n "$export_symbols" && test -n "$include_expsyms"; then
6444	  $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
6445	  export_symbols="$output_objdir/$libname.uexp"
6446	  delfiles="$delfiles $export_symbols"
6447	fi
6448
6449	orig_export_symbols=
6450	case $host_os in
6451	cygwin* | mingw*)
6452	  if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
6453	    # exporting using user supplied symfile
6454	    if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
6455	      # and it's NOT already a .def file. Must figure out
6456	      # which of the given symbols are data symbols and tag
6457	      # them as such. So, trigger use of export_symbols_cmds.
6458	      # export_symbols gets reassigned inside the "prepare
6459	      # the list of exported symbols" if statement, so the
6460	      # include_expsyms logic still works.
6461	      orig_export_symbols="$export_symbols"
6462	      export_symbols=
6463	      always_export_symbols=yes
6464	    fi
6465	  fi
6466	  ;;
6467	esac
6468
6469	# Prepare the list of exported symbols
6470	if test -z "$export_symbols"; then
6471	  if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
6472	    func_verbose "generating symbol list for \`$libname.la'"
6473	    export_symbols="$output_objdir/$libname.exp"
6474	    $opt_dry_run || $RM $export_symbols
6475	    cmds=$export_symbols_cmds
6476	    save_ifs="$IFS"; IFS='~'
6477	    for cmd in $cmds; do
6478	      IFS="$save_ifs"
6479	      eval cmd=\"$cmd\"
6480	      func_len " $cmd"
6481	      len=$func_len_result
6482	      if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
6483		func_show_eval "$cmd" 'exit $?'
6484		skipped_export=false
6485	      else
6486		# The command line is too long to execute in one step.
6487		func_verbose "using reloadable object file for export list..."
6488		skipped_export=:
6489		# Break out early, otherwise skipped_export may be
6490		# set to false by a later but shorter cmd.
6491		break
6492	      fi
6493	    done
6494	    IFS="$save_ifs"
6495	    if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
6496	      func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
6497	      func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
6498	    fi
6499	  fi
6500	fi
6501
6502	if test -n "$export_symbols" && test -n "$include_expsyms"; then
6503	  tmp_export_symbols="$export_symbols"
6504	  test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
6505	  $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
6506	fi
6507
6508	if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
6509	  # The given exports_symbols file has to be filtered, so filter it.
6510	  func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
6511	  # FIXME: $output_objdir/$libname.filter potentially contains lots of
6512	  # 's' commands which not all seds can handle. GNU sed should be fine
6513	  # though. Also, the filter scales superlinearly with the number of
6514	  # global variables. join(1) would be nice here, but unfortunately
6515	  # isn't a blessed tool.
6516	  $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
6517	  delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
6518	  export_symbols=$output_objdir/$libname.def
6519	  $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
6520	fi
6521
6522	tmp_deplibs=
6523	for test_deplib in $deplibs; do
6524	  case " $convenience " in
6525	  *" $test_deplib "*) ;;
6526	  *)
6527	    tmp_deplibs="$tmp_deplibs $test_deplib"
6528	    ;;
6529	  esac
6530	done
6531	deplibs="$tmp_deplibs"
6532
6533	if test -n "$convenience"; then
6534	  if test -n "$whole_archive_flag_spec" &&
6535	    test "$compiler_needs_object" = yes &&
6536	    test -z "$libobjs"; then
6537	    # extract the archives, so we have objects to list.
6538	    # TODO: could optimize this to just extract one archive.
6539	    whole_archive_flag_spec=
6540	  fi
6541	  if test -n "$whole_archive_flag_spec"; then
6542	    save_libobjs=$libobjs
6543	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
6544	    test "X$libobjs" = "X " && libobjs=
6545	  else
6546	    gentop="$output_objdir/${outputname}x"
6547	    generated="$generated $gentop"
6548
6549	    func_extract_archives $gentop $convenience
6550	    libobjs="$libobjs $func_extract_archives_result"
6551	    test "X$libobjs" = "X " && libobjs=
6552	  fi
6553	fi
6554
6555	if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
6556	  eval flag=\"$thread_safe_flag_spec\"
6557	  linker_flags="$linker_flags $flag"
6558	fi
6559
6560	# Make a backup of the uninstalled library when relinking
6561	if test "$mode" = relink; then
6562	  $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
6563	fi
6564
6565	# Do each of the archive commands.
6566	if test "$module" = yes && test -n "$module_cmds" ; then
6567	  if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
6568	    eval test_cmds=\"$module_expsym_cmds\"
6569	    cmds=$module_expsym_cmds
6570	  else
6571	    eval test_cmds=\"$module_cmds\"
6572	    cmds=$module_cmds
6573	  fi
6574	else
6575	  if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
6576	    eval test_cmds=\"$archive_expsym_cmds\"
6577	    cmds=$archive_expsym_cmds
6578	  else
6579	    eval test_cmds=\"$archive_cmds\"
6580	    cmds=$archive_cmds
6581	  fi
6582	fi
6583
6584	if test "X$skipped_export" != "X:" &&
6585	   func_len " $test_cmds" &&
6586	   len=$func_len_result &&
6587	   test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
6588	  :
6589	else
6590	  # The command line is too long to link in one step, link piecewise
6591	  # or, if using GNU ld and skipped_export is not :, use a linker
6592	  # script.
6593
6594	  # Save the value of $output and $libobjs because we want to
6595	  # use them later.  If we have whole_archive_flag_spec, we
6596	  # want to use save_libobjs as it was before
6597	  # whole_archive_flag_spec was expanded, because we can't
6598	  # assume the linker understands whole_archive_flag_spec.
6599	  # This may have to be revisited, in case too many
6600	  # convenience libraries get linked in and end up exceeding
6601	  # the spec.
6602	  if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
6603	    save_libobjs=$libobjs
6604	  fi
6605	  save_output=$output
6606	  output_la=`$ECHO "X$output" | $Xsed -e "$basename"`
6607
6608	  # Clear the reloadable object creation command queue and
6609	  # initialize k to one.
6610	  test_cmds=
6611	  concat_cmds=
6612	  objlist=
6613	  last_robj=
6614	  k=1
6615
6616	  if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
6617	    output=${output_objdir}/${output_la}.lnkscript
6618	    func_verbose "creating GNU ld script: $output"
6619	    $ECHO 'INPUT (' > $output
6620	    for obj in $save_libobjs
6621	    do
6622	      $ECHO "$obj" >> $output
6623	    done
6624	    $ECHO ')' >> $output
6625	    delfiles="$delfiles $output"
6626	  elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
6627	    output=${output_objdir}/${output_la}.lnk
6628	    func_verbose "creating linker input file list: $output"
6629	    : > $output
6630	    set x $save_libobjs
6631	    shift
6632	    firstobj=
6633	    if test "$compiler_needs_object" = yes; then
6634	      firstobj="$1 "
6635	      shift
6636	    fi
6637	    for obj
6638	    do
6639	      $ECHO "$obj" >> $output
6640	    done
6641	    delfiles="$delfiles $output"
6642	    output=$firstobj\"$file_list_spec$output\"
6643	  else
6644	    if test -n "$save_libobjs"; then
6645	      func_verbose "creating reloadable object files..."
6646	      output=$output_objdir/$output_la-${k}.$objext
6647	      eval test_cmds=\"$reload_cmds\"
6648	      func_len " $test_cmds"
6649	      len0=$func_len_result
6650	      len=$len0
6651
6652	      # Loop over the list of objects to be linked.
6653	      for obj in $save_libobjs
6654	      do
6655		func_len " $obj"
6656		func_arith $len + $func_len_result
6657		len=$func_arith_result
6658		if test "X$objlist" = X ||
6659		   test "$len" -lt "$max_cmd_len"; then
6660		  func_append objlist " $obj"
6661		else
6662		  # The command $test_cmds is almost too long, add a
6663		  # command to the queue.
6664		  if test "$k" -eq 1 ; then
6665		    # The first file doesn't have a previous command to add.
6666		    eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
6667		  else
6668		    # All subsequent reloadable object files will link in