Ignore:
Timestamp:
Jan 30, 2018 8:45:30 PM (2 years ago)
Author:
lou
Message:

Bring clp into the autotools-update world. Very rough. Builds and passes
unit test but non-doxygen documentation and examples are untested.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/autotools-update/Clp/ltmain.sh

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