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