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