Changeset 3118 for trunk/ltmain.sh


Ignore:
Timestamp:
Dec 4, 2013 3:51:50 PM (7 years ago)
Author:
stefan
Message:

merge r2552 and r2554 from autotools-update branch

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk

  • trunk/ltmain.sh

    r2 r3118  
    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
     2# libtool (GNU libtool) 2.4.2
     3# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
     4
     5# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
     6# 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
     7# This is free software; see the source for copying conditions.  There is NO
     8# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
     9
     10# GNU Libtool is free software; you can redistribute it and/or modify
    911# it under the terms of the GNU General Public License as published by
    1012# the Free Software Foundation; either version 2 of the License, or
    1113# (at your option) any later version.
    1214#
    13 # This program is distributed in the hope that it will be useful, but
     15# As a special exception to the GNU General Public License,
     16# if you distribute this file as part of a program or library that
     17# is built using GNU Libtool, you may include this file under the
     18# same distribution terms that you use for the rest of that program.
     19#
     20# GNU Libtool is distributed in the hope that it will be useful, but
    1421# WITHOUT ANY WARRANTY; without even the implied warranty of
    1522# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     
    1724#
    1825# 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.
     26# along with GNU Libtool; see the file COPYING.  If not, a copy
     27# can be downloaded from http://www.gnu.org/licenses/gpl.html,
     28# or obtained by writing to the Free Software Foundation, Inc.,
     29# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
     30
     31# Usage: $progname [OPTION]... [MODE-ARG]...
    2132#
    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"
     33# Provide generalized library-building support services.
     34#
     35#       --config             show all configuration variables
     36#       --debug              enable verbose shell tracing
     37#   -n, --dry-run            display commands without modifying any files
     38#       --features           display basic configuration information and exit
     39#       --mode=MODE          use operation mode MODE
     40#       --preserve-dup-deps  don't remove duplicate dependency libraries
     41#       --quiet, --silent    don't print informational messages
     42#       --no-quiet, --no-silent
     43#                            print informational messages (default)
     44#       --no-warn            don't display warning messages
     45#       --tag=TAG            use configuration variables from tag TAG
     46#   -v, --verbose            print more informational messages than default
     47#       --no-verbose         don't print the extra informational messages
     48#       --version            print version information
     49#   -h, --help, --help-all   print short, long, or detailed help message
     50#
     51# MODE must be one of the following:
     52#
     53#         clean              remove files from the build directory
     54#         compile            compile a source file into a libtool object
     55#         execute            automatically set library path, then run a program
     56#         finish             complete the installation of libtool libraries
     57#         install            install libraries or executables
     58#         link               create a library or an executable
     59#         uninstall          remove libraries from an installed directory
     60#
     61# MODE-ARGS vary depending on the MODE.  When passed as first option,
     62# `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
     63# Try `$progname --help --mode=MODE' for a more detailed description of MODE.
     64#
     65# When reporting a bug, please describe a test case to reproduce it and
     66# include the following information:
     67#
     68#         host-triplet: $host
     69#         shell:                $SHELL
     70#         compiler:             $LTCC
     71#         compiler flags:               $LTCFLAGS
     72#         linker:               $LD (gnu? $with_gnu_ld)
     73#         $progname:    (GNU libtool) 2.4.2
     74#         automake:     $automake_version
     75#         autoconf:     $autoconf_version
     76#
     77# Report bugs to <bug-libtool@gnu.org>.
     78# GNU libtool home page: <http://www.gnu.org/software/libtool/>.
     79# General help using GNU software: <http://www.gnu.org/gethelp/>.
     80
     81PROGRAM=libtool
     82PACKAGE=libtool
     83VERSION=2.4.2
     84TIMESTAMP=""
     85package_revision=1.3337
     86
     87# Be Bourne compatible
     88if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
     89  emulate sh
     90  NULLCMD=:
     91  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
     92  # is contrary to our usage.  Disable this feature.
     93  alias -g '${1+"$@"}'='"$@"'
     94  setopt NO_GLOB_SUBST
     95else
     96  case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
     97fi
     98BIN_SH=xpg4; export BIN_SH # for Tru64
     99DUALCASE=1; export DUALCASE # for MKS sh
     100
     101# A function that is used when there is no print builtin or printf.
     102func_fallback_echo ()
     103{
     104  eval 'cat <<_LTECHO_EOF
     105$1
     106_LTECHO_EOF'
     107}
     108
     109# NLS nuisances: We save the old values to restore during execute mode.
     110lt_user_locale=
     111lt_safe_locale=
     112for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
     113do
     114  eval "if test \"\${$lt_var+set}\" = set; then
     115          save_$lt_var=\$$lt_var
     116          $lt_var=C
     117          export $lt_var
     118          lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
     119          lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
     120        fi"
     121done
     122LC_ALL=C
     123LANGUAGE=C
     124export LANGUAGE LC_ALL
     125
     126$lt_unset CDPATH
     127
    28128
    29129# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
     
    34134progpath="$0"
    35135
    36 # The name of this program:
    37 progname=`echo "$progpath" | $SED $basename`
    38 modename="$progname"
     136
     137
     138: ${CP="cp -f"}
     139test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
     140: ${MAKE="make"}
     141: ${MKDIR="mkdir"}
     142: ${MV="mv -f"}
     143: ${RM="rm -f"}
     144: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
     145: ${Xsed="$SED -e 1s/^X//"}
    39146
    40147# Global variables:
    41148EXIT_SUCCESS=0
    42149EXIT_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
    53 fi
    54 
    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   :
    65 else
    66   # Restart under the correct shell, and then maybe $echo will work.
    67   exec $SHELL "$progpath" --no-reexec ${1+"$@"}
    68 fi
    69 
    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
    77 fi
    78 
    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
    110 fi
    111 if test "${LANG+set}" = set; then
    112   save_LANG="$LANG"; LANG=C; export LANG
    113 fi
     150EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.
     151EXIT_SKIP=77      # $? = 77 is used to indicate a skipped test to automake.
     152
     153exit_status=$EXIT_SUCCESS
    114154
    115155# Make sure IFS has a sensible default
     
    118158IFS="   $lt_nl"
    119159
    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
     160dirname="s,/[^/]*$,,"
     161basename="s,^.*/,,"
     162
     163# func_dirname file append nondir_replacement
     164# Compute the dirname of FILE.  If nonempty, add APPEND to the result,
     165# otherwise set result to NONDIR_REPLACEMENT.
     166func_dirname ()
     167{
     168    func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`
     169    if test "X$func_dirname_result" = "X${1}"; then
     170      func_dirname_result="${3}"
     171    else
     172      func_dirname_result="$func_dirname_result${2}"
     173    fi
     174} # func_dirname may be replaced by extended shell implementation
     175
     176
     177# func_basename file
     178func_basename ()
     179{
     180    func_basename_result=`$ECHO "${1}" | $SED "$basename"`
     181} # func_basename may be replaced by extended shell implementation
     182
     183
     184# func_dirname_and_basename file append nondir_replacement
     185# perform func_basename and func_dirname in a single function
     186# call:
     187#   dirname:  Compute the dirname of FILE.  If nonempty,
     188#             add APPEND to the result, otherwise set result
     189#             to NONDIR_REPLACEMENT.
     190#             value returned in "$func_dirname_result"
     191#   basename: Compute filename of FILE.
     192#             value retuned in "$func_basename_result"
     193# Implementation must be kept synchronized with func_dirname
     194# and func_basename. For efficiency, we do not delegate to
     195# those functions but instead duplicate the functionality here.
     196func_dirname_and_basename ()
     197{
     198    # Extract subdirectory from the argument.
     199    func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
     200    if test "X$func_dirname_result" = "X${1}"; then
     201      func_dirname_result="${3}"
     202    else
     203      func_dirname_result="$func_dirname_result${2}"
     204    fi
     205    func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
     206} # func_dirname_and_basename may be replaced by extended shell implementation
     207
     208
     209# func_stripname prefix suffix name
     210# strip PREFIX and SUFFIX off of NAME.
     211# PREFIX and SUFFIX must not contain globbing or regex special
     212# characters, hashes, percent signs, but SUFFIX may contain a leading
     213# dot (in which case that matches only a dot).
     214# func_strip_suffix prefix name
     215func_stripname ()
     216{
     217    case ${2} in
     218      .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
     219      *)  func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
     220    esac
     221} # func_stripname may be replaced by extended shell implementation
     222
     223
     224# These SED scripts presuppose an absolute path with a trailing slash.
     225pathcar='s,^/\([^/]*\).*$,\1,'
     226pathcdr='s,^/[^/]*,,'
     227removedotparts=':dotsl
     228                s@/\./@/@g
     229                t dotsl
     230                s,/\.$,/,'
     231collapseslashes='s@/\{1,\}@/@g'
     232finalslash='s,/*$,/,'
     233
     234# func_normal_abspath PATH
     235# Remove doubled-up and trailing slashes, "." path components,
     236# and cancel out any ".." path components in PATH after making
     237# it an absolute path.
     238#             value returned in "$func_normal_abspath_result"
     239func_normal_abspath ()
     240{
     241  # Start from root dir and reassemble the path.
     242  func_normal_abspath_result=
     243  func_normal_abspath_tpath=$1
     244  func_normal_abspath_altnamespace=
     245  case $func_normal_abspath_tpath in
     246    "")
     247      # Empty path, that just means $cwd.
     248      func_stripname '' '/' "`pwd`"
     249      func_normal_abspath_result=$func_stripname_result
     250      return
     251    ;;
     252    # The next three entries are used to spot a run of precisely
     253    # two leading slashes without using negated character classes;
     254    # we take advantage of case's first-match behaviour.
     255    ///*)
     256      # Unusual form of absolute path, do nothing.
     257    ;;
     258    //*)
     259      # Not necessarily an ordinary path; POSIX reserves leading '//'
     260      # and for example Cygwin uses it to access remote file shares
     261      # over CIFS/SMB, so we conserve a leading double slash if found.
     262      func_normal_abspath_altnamespace=/
     263    ;;
     264    /*)
     265      # Absolute path, do nothing.
     266    ;;
     267    *)
     268      # Relative path, prepend $cwd.
     269      func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
     270    ;;
     271  esac
     272  # Cancel out all the simple stuff to save iterations.  We also want
     273  # the path to end with a slash for ease of parsing, so make sure
     274  # there is one (and only one) here.
     275  func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
     276        -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
     277  while :; do
     278    # Processed it all yet?
     279    if test "$func_normal_abspath_tpath" = / ; then
     280      # If we ascended to the root using ".." the result may be empty now.
     281      if test -z "$func_normal_abspath_result" ; then
     282        func_normal_abspath_result=/
     283      fi
     284      break
     285    fi
     286    func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
     287        -e "$pathcar"`
     288    func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
     289        -e "$pathcdr"`
     290    # Figure out what to do with it
     291    case $func_normal_abspath_tcomponent in
     292      "")
     293        # Trailing empty path component, ignore it.
     294      ;;
     295      ..)
     296        # Parent dir; strip last assembled component from result.
     297        func_dirname "$func_normal_abspath_result"
     298        func_normal_abspath_result=$func_dirname_result
     299      ;;
     300      *)
     301        # Actual path component, append it.
     302        func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
     303      ;;
     304    esac
     305  done
     306  # Restore leading double-slash if one was found on entry.
     307  func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
     308}
     309
     310# func_relative_path SRCDIR DSTDIR
     311# generates a relative path from SRCDIR to DSTDIR, with a trailing
     312# slash if non-empty, suitable for immediately appending a filename
     313# without needing to append a separator.
     314#             value returned in "$func_relative_path_result"
     315func_relative_path ()
     316{
     317  func_relative_path_result=
     318  func_normal_abspath "$1"
     319  func_relative_path_tlibdir=$func_normal_abspath_result
     320  func_normal_abspath "$2"
     321  func_relative_path_tbindir=$func_normal_abspath_result
     322
     323  # Ascend the tree starting from libdir
     324  while :; do
     325    # check if we have found a prefix of bindir
     326    case $func_relative_path_tbindir in
     327      $func_relative_path_tlibdir)
     328        # found an exact match
     329        func_relative_path_tcancelled=
     330        break
     331        ;;
     332      $func_relative_path_tlibdir*)
     333        # found a matching prefix
     334        func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
     335        func_relative_path_tcancelled=$func_stripname_result
     336        if test -z "$func_relative_path_result"; then
     337          func_relative_path_result=.
     338        fi
     339        break
     340        ;;
     341      *)
     342        func_dirname $func_relative_path_tlibdir
     343        func_relative_path_tlibdir=${func_dirname_result}
     344        if test "x$func_relative_path_tlibdir" = x ; then
     345          # Have to descend all the way to the root!
     346          func_relative_path_result=../$func_relative_path_result
     347          func_relative_path_tcancelled=$func_relative_path_tbindir
     348          break
     349        fi
     350        func_relative_path_result=../$func_relative_path_result
     351        ;;
     352    esac
     353  done
     354
     355  # Now calculate path; take care to avoid doubling-up slashes.
     356  func_stripname '' '/' "$func_relative_path_result"
     357  func_relative_path_result=$func_stripname_result
     358  func_stripname '/' '/' "$func_relative_path_tcancelled"
     359  if test "x$func_stripname_result" != x ; then
     360    func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
     361  fi
     362
     363  # Normalisation. If bindir is libdir, return empty string,
     364  # else relative path ending with a slash; either way, target
     365  # file name can be directly appended.
     366  if test ! -z "$func_relative_path_result"; then
     367    func_stripname './' '' "$func_relative_path_result/"
     368    func_relative_path_result=$func_stripname_result
     369  fi
     370}
     371
     372# The name of this program:
     373func_dirname_and_basename "$progpath"
     374progname=$func_basename_result
     375
     376# Make sure we have an absolute path for reexecution:
     377case $progpath in
     378  [\\/]*|[A-Za-z]:\\*) ;;
     379  *[\\/]*)
     380     progdir=$func_dirname_result
     381     progdir=`cd "$progdir" && pwd`
     382     progpath="$progdir/$progname"
     383     ;;
     384  *)
     385     save_IFS="$IFS"
     386     IFS=${PATH_SEPARATOR-:}
     387     for progdir in $PATH; do
     388       IFS="$save_IFS"
     389       test -x "$progdir/$progname" && break
     390     done
     391     IFS="$save_IFS"
     392     test -n "$progdir" || progdir=`pwd`
     393     progpath="$progdir/$progname"
     394     ;;
     395esac
     396
     397# Sed substitution that helps us do robust quoting.  It backslashifies
     398# metacharacters that are still active within double-quoted strings.
     399Xsed="${SED}"' -e 1s/^X//'
     400sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
     401
     402# Same as above, but do not quote variable references.
     403double_quote_subst='s/\(["`\\]\)/\\\1/g'
     404
     405# Sed substitution that turns a string into a regex matching for the
     406# string literally.
     407sed_make_literal_regex='s,[].[^$\\*\/],\\&,g'
     408
     409# Sed substitution that converts a w32 file name or path
     410# which contains forward slashes, into one that contains
     411# (escaped) backslashes.  A very naive implementation.
     412lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
     413
     414# Re-`\' parameter expansions in output of double_quote_subst that were
     415# `\'-ed in input to the same.  If an odd number of `\' preceded a '$'
     416# in input to double_quote_subst, that '$' was protected from expansion.
     417# Since each input `\' is now two `\'s, look for any number of runs of
     418# four `\'s followed by two `\'s and then a '$'.  `\' that '$'.
     419bs='\\'
     420bs2='\\\\'
     421bs4='\\\\\\\\'
     422dollar='\$'
     423sed_double_backslash="\
     424  s/$bs4/&\\
     425/g
     426  s/^$bs2$dollar/$bs&/
     427  s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
     428  s/\n//g"
     429
     430# Standard options:
     431opt_dry_run=false
     432opt_help=false
     433opt_quiet=false
     434opt_verbose=false
     435opt_warning=:
     436
     437# func_echo arg...
     438# Echo program name prefixed message, along with the current mode
     439# name if it has been set yet.
     440func_echo ()
     441{
     442    $ECHO "$progname: ${opt_mode+$opt_mode: }$*"
     443}
     444
     445# func_verbose arg...
     446# Echo program name prefixed message in verbose mode only.
     447func_verbose ()
     448{
     449    $opt_verbose && func_echo ${1+"$@"}
     450
     451    # A bug in bash halts the script if the last line of a function
     452    # fails when set -e is in force, so we need another command to
     453    # work around that:
     454    :
     455}
     456
     457# func_echo_all arg...
     458# Invoke $ECHO with all args, space-separated.
     459func_echo_all ()
     460{
     461    $ECHO "$*"
     462}
     463
     464# func_error arg...
     465# Echo program name prefixed message to standard error.
     466func_error ()
     467{
     468    $ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
     469}
     470
     471# func_warning arg...
     472# Echo program name prefixed warning message to standard error.
     473func_warning ()
     474{
     475    $opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
     476
     477    # bash bug again:
     478    :
     479}
     480
     481# func_fatal_error arg...
     482# Echo program name prefixed message to standard error, and exit.
     483func_fatal_error ()
     484{
     485    func_error ${1+"$@"}
     486    exit $EXIT_FAILURE
     487}
     488
     489# func_fatal_help arg...
     490# Echo program name prefixed message to standard error, followed by
     491# a help hint, and exit.
     492func_fatal_help ()
     493{
     494    func_error ${1+"$@"}
     495    func_fatal_error "$help"
     496}
     497help="Try \`$progname --help' for more information."  ## default
     498
     499
     500# func_grep expression filename
     501# Check whether EXPRESSION matches any line of FILENAME, without output.
     502func_grep ()
     503{
     504    $GREP "$1" "$2" >/dev/null 2>&1
     505}
     506
     507
     508# func_mkdir_p directory-path
     509# Make sure the entire path to DIRECTORY-PATH is available.
     510func_mkdir_p ()
     511{
     512    my_directory_path="$1"
     513    my_dir_list=
     514
     515    if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
     516
     517      # Protect directory names starting with `-'
     518      case $my_directory_path in
     519        -*) my_directory_path="./$my_directory_path" ;;
     520      esac
     521
     522      # While some portion of DIR does not yet exist...
     523      while test ! -d "$my_directory_path"; do
     524        # ...make a list in topmost first order.  Use a colon delimited
     525        # list incase some portion of path contains whitespace.
     526        my_dir_list="$my_directory_path:$my_dir_list"
     527
     528        # If the last portion added has no slash in it, the list is done
     529        case $my_directory_path in */*) ;; *) break ;; esac
     530
     531        # ...otherwise throw away the child directory and loop
     532        my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
     533      done
     534      my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
     535
     536      save_mkdir_p_IFS="$IFS"; IFS=':'
     537      for my_dir in $my_dir_list; do
     538        IFS="$save_mkdir_p_IFS"
     539        # mkdir can fail with a `File exist' error if two processes
     540        # try to create one of the directories concurrently.  Don't
     541        # stop in that case!
     542        $MKDIR "$my_dir" 2>/dev/null || :
     543      done
     544      IFS="$save_mkdir_p_IFS"
     545
     546      # Bail out if we (or some other process) failed to create a directory.
     547      test -d "$my_directory_path" || \
     548        func_fatal_error "Failed to create \`$1'"
     549    fi
     550}
     551
    143552
    144553# func_mktempdir [string]
     
    150559    my_template="${TMPDIR-/tmp}/${1-$progname}"
    151560
    152     if test "$run" = ":"; then
     561    if test "$opt_dry_run" = ":"; then
    153562      # Return a directory name, but don't create it in dry-run mode
    154563      my_tmpdir="${my_template}-$$"
     
    159568
    160569      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
     570        # Failing that, at least try and use $RANDOM to avoid a race
     571        my_tmpdir="${my_template}-${RANDOM-0}$$"
     572
     573        save_mktempdir_umask=`umask`
     574        umask 0077
     575        $MKDIR "$my_tmpdir"
     576        umask $save_mktempdir_umask
    168577      fi
    169578
    170579      # 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
     580      test -d "$my_tmpdir" || \
     581        func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
     582    fi
     583
     584    $ECHO "$my_tmpdir"
     585}
     586
     587
     588# func_quote_for_eval arg
     589# Aesthetically quote ARG to be evaled later.
     590# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
     591# is double-quoted, suitable for a subsequent eval, whereas
     592# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
     593# which are still active within double quotes backslashified.
     594func_quote_for_eval ()
     595{
     596    case $1 in
     597      *[\\\`\"\$]*)
     598        func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
     599      *)
     600        func_quote_for_eval_unquoted_result="$1" ;;
     601    esac
     602
     603    case $func_quote_for_eval_unquoted_result in
     604      # Double-quote args containing shell metacharacters to delay
     605      # word splitting, command substitution and and variable
     606      # expansion for a subsequent eval.
     607      # Many Bourne shells cannot handle close brackets correctly
     608      # in scan sets, so we specify it separately.
     609      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
     610        func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
     611        ;;
     612      *)
     613        func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
     614    esac
     615}
     616
     617
     618# func_quote_for_expand arg
     619# Aesthetically quote ARG to be evaled later; same as above,
     620# but do not quote variable references.
     621func_quote_for_expand ()
     622{
     623    case $1 in
     624      *[\\\`\"]*)
     625        my_arg=`$ECHO "$1" | $SED \
     626            -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
     627      *)
     628        my_arg="$1" ;;
     629    esac
     630
     631    case $my_arg in
     632      # Double-quote args containing shell metacharacters to delay
     633      # word splitting and command substitution for a subsequent eval.
     634      # Many Bourne shells cannot handle close brackets correctly
     635      # in scan sets, so we specify it separately.
     636      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
     637        my_arg="\"$my_arg\""
     638        ;;
     639    esac
     640
     641    func_quote_for_expand_result="$my_arg"
     642}
     643
     644
     645# func_show_eval cmd [fail_exp]
     646# Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
     647# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
     648# is given, then evaluate it.
     649func_show_eval ()
     650{
     651    my_cmd="$1"
     652    my_fail_exp="${2-:}"
     653
     654    ${opt_silent-false} || {
     655      func_quote_for_expand "$my_cmd"
     656      eval "func_echo $func_quote_for_expand_result"
     657    }
     658
     659    if ${opt_dry_run-false}; then :; else
     660      eval "$my_cmd"
     661      my_status=$?
     662      if test "$my_status" -eq 0; then :; else
     663        eval "(exit $my_status); $my_fail_exp"
     664      fi
     665    fi
     666}
     667
     668
     669# func_show_eval_locale cmd [fail_exp]
     670# Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
     671# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
     672# is given, then evaluate it.  Use the saved locale for evaluation.
     673func_show_eval_locale ()
     674{
     675    my_cmd="$1"
     676    my_fail_exp="${2-:}"
     677
     678    ${opt_silent-false} || {
     679      func_quote_for_expand "$my_cmd"
     680      eval "func_echo $func_quote_for_expand_result"
     681    }
     682
     683    if ${opt_dry_run-false}; then :; else
     684      eval "$lt_user_locale
     685            $my_cmd"
     686      my_status=$?
     687      eval "$lt_safe_locale"
     688      if test "$my_status" -eq 0; then :; else
     689        eval "(exit $my_status); $my_fail_exp"
     690      fi
     691    fi
     692}
     693
     694# func_tr_sh
     695# Turn $1 into a string suitable for a shell variable name.
     696# Result is stored in $func_tr_sh_result.  All characters
     697# not in the set a-zA-Z0-9_ are replaced with '_'. Further,
     698# if $1 begins with a digit, a '_' is prepended as well.
     699func_tr_sh ()
     700{
     701  case $1 in
     702  [0-9]* | *[!a-zA-Z0-9_]*)
     703    func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'`
     704    ;;
     705  * )
     706    func_tr_sh_result=$1
     707    ;;
     708  esac
     709}
     710
     711
     712# func_version
     713# Echo version message to standard output and exit.
     714func_version ()
     715{
     716    $opt_debug
     717
     718    $SED -n '/(C)/!b go
     719        :more
     720        /\./!{
     721          N
     722          s/\n# / /
     723          b more
     724        }
     725        :go
     726        /^# '$PROGRAM' (GNU /,/# warranty; / {
     727        s/^# //
     728        s/^# *$//
     729        s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
     730        p
     731     }' < "$progpath"
     732     exit $?
     733}
     734
     735# func_usage
     736# Echo short help message to standard output and exit.
     737func_usage ()
     738{
     739    $opt_debug
     740
     741    $SED -n '/^# Usage:/,/^#  *.*--help/ {
     742        s/^# //
     743        s/^# *$//
     744        s/\$progname/'$progname'/
     745        p
     746    }' < "$progpath"
     747    echo
     748    $ECHO "run \`$progname --help | more' for full usage"
     749    exit $?
     750}
     751
     752# func_help [NOEXIT]
     753# Echo long help message to standard output and exit,
     754# unless 'noexit' is passed as argument.
     755func_help ()
     756{
     757    $opt_debug
     758
     759    $SED -n '/^# Usage:/,/# Report bugs to/ {
     760        :print
     761        s/^# //
     762        s/^# *$//
     763        s*\$progname*'$progname'*
     764        s*\$host*'"$host"'*
     765        s*\$SHELL*'"$SHELL"'*
     766        s*\$LTCC*'"$LTCC"'*
     767        s*\$LTCFLAGS*'"$LTCFLAGS"'*
     768        s*\$LD*'"$LD"'*
     769        s/\$with_gnu_ld/'"$with_gnu_ld"'/
     770        s/\$automake_version/'"`(${AUTOMAKE-automake} --version) 2>/dev/null |$SED 1q`"'/
     771        s/\$autoconf_version/'"`(${AUTOCONF-autoconf} --version) 2>/dev/null |$SED 1q`"'/
     772        p
     773        d
     774     }
     775     /^# .* home page:/b print
     776     /^# General help using/b print
     777     ' < "$progpath"
     778    ret=$?
     779    if test -z "$1"; then
     780      exit $ret
     781    fi
     782}
     783
     784# func_missing_arg argname
     785# Echo program name prefixed message to standard error and set global
     786# exit_cmd.
     787func_missing_arg ()
     788{
     789    $opt_debug
     790
     791    func_error "missing argument for $1."
     792    exit_cmd=exit
     793}
     794
     795
     796# func_split_short_opt shortopt
     797# Set func_split_short_opt_name and func_split_short_opt_arg shell
     798# variables after splitting SHORTOPT after the 2nd character.
     799func_split_short_opt ()
     800{
     801    my_sed_short_opt='1s/^\(..\).*$/\1/;q'
     802    my_sed_short_rest='1s/^..\(.*\)$/\1/;q'
     803
     804    func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`
     805    func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`
     806} # func_split_short_opt may be replaced by extended shell implementation
     807
     808
     809# func_split_long_opt longopt
     810# Set func_split_long_opt_name and func_split_long_opt_arg shell
     811# variables after splitting LONGOPT at the `=' sign.
     812func_split_long_opt ()
     813{
     814    my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q'
     815    my_sed_long_arg='1s/^--[^=]*=//'
     816
     817    func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`
     818    func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`
     819} # func_split_long_opt may be replaced by extended shell implementation
     820
     821exit_cmd=:
     822
     823
     824
     825
     826
     827magic="%%%MAGIC variable%%%"
     828magic_exe="%%%MAGIC EXE variable%%%"
     829
     830# Global variables.
     831nonopt=
     832preserve_args=
     833lo2o="s/\\.lo\$/.${objext}/"
     834o2lo="s/\\.${objext}\$/.lo/"
     835extracted_archives=
     836extracted_serial=0
     837
     838# If this variable is set in any of the actions, the command in it
     839# will be execed at the end.  This prevents here-documents from being
     840# left over by shells.
     841exec_cmd=
     842
     843# func_append var value
     844# Append VALUE to the end of shell variable VAR.
     845func_append ()
     846{
     847    eval "${1}=\$${1}\${2}"
     848} # func_append may be replaced by extended shell implementation
     849
     850# func_append_quoted var value
     851# Quote VALUE and append to the end of shell variable VAR, separated
     852# by a space.
     853func_append_quoted ()
     854{
     855    func_quote_for_eval "${2}"
     856    eval "${1}=\$${1}\\ \$func_quote_for_eval_result"
     857} # func_append_quoted may be replaced by extended shell implementation
     858
     859
     860# func_arith arithmetic-term...
     861func_arith ()
     862{
     863    func_arith_result=`expr "${@}"`
     864} # func_arith may be replaced by extended shell implementation
     865
     866
     867# func_len string
     868# STRING may not start with a hyphen.
     869func_len ()
     870{
     871    func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len`
     872} # func_len may be replaced by extended shell implementation
     873
     874
     875# func_lo2o object
     876func_lo2o ()
     877{
     878    func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`
     879} # func_lo2o may be replaced by extended shell implementation
     880
     881
     882# func_xform libobj-or-source
     883func_xform ()
     884{
     885    func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`
     886} # func_xform may be replaced by extended shell implementation
     887
     888
     889# func_fatal_configuration arg...
     890# Echo program name prefixed message to standard error, followed by
     891# a configuration failure hint, and exit.
     892func_fatal_configuration ()
     893{
     894    func_error ${1+"$@"}
     895    func_error "See the $PACKAGE documentation for more information."
     896    func_fatal_error "Fatal configuration error."
     897}
     898
     899
     900# func_config
     901# Display the configuration for all the tags in this script.
     902func_config ()
     903{
     904    re_begincf='^# ### BEGIN LIBTOOL'
     905    re_endcf='^# ### END LIBTOOL'
     906
     907    # Default configuration.
     908    $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
     909
     910    # Now print the configurations for the tags.
     911    for tagname in $taglist; do
     912      $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
     913    done
     914
     915    exit $?
     916}
     917
     918# func_features
     919# Display the features supported by this script.
     920func_features ()
     921{
     922    echo "host: $host"
     923    if test "$build_libtool_libs" = yes; then
     924      echo "enable shared libraries"
     925    else
     926      echo "disable shared libraries"
     927    fi
     928    if test "$build_old_libs" = yes; then
     929      echo "enable static libraries"
     930    else
     931      echo "disable static libraries"
     932    fi
     933
     934    exit $?
     935}
     936
     937# func_enable_tag tagname
     938# Verify that TAGNAME is valid, and either flag an error and exit, or
     939# enable the TAGNAME tag.  We also add TAGNAME to the global $taglist
     940# variable here.
     941func_enable_tag ()
     942{
     943  # Global variable:
     944  tagname="$1"
     945
     946  re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
     947  re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
     948  sed_extractcf="/$re_begincf/,/$re_endcf/p"
     949
     950  # Validate tagname.
     951  case $tagname in
     952    *[!-_A-Za-z0-9,/]*)
     953      func_fatal_error "invalid tag name: $tagname"
     954      ;;
     955  esac
     956
     957  # Don't test for the "default" C tag, as we know it's
     958  # there but not specially marked.
     959  case $tagname in
     960    CC) ;;
     961    *)
     962      if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
     963        taglist="$taglist $tagname"
     964
     965        # Evaluate the configuration.  Be careful to quote the path
     966        # and the sed script, to avoid splitting on whitespace, but
     967        # also don't use non-portable quotes within backquotes within
     968        # quotes we have to do it in 2 steps:
     969        extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
     970        eval "$extractedcf"
     971      else
     972        func_error "ignoring unknown tag $tagname"
     973      fi
     974      ;;
     975  esac
     976}
     977
     978# func_check_version_match
     979# Ensure that we are using m4 macros, and libtool script from the same
     980# release of libtool.
     981func_check_version_match ()
     982{
     983  if test "$package_revision" != "$macro_revision"; then
     984    if test "$VERSION" != "$macro_version"; then
     985      if test -z "$macro_version"; then
     986        cat >&2 <<_LT_EOF
     987$progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
     988$progname: definition of this LT_INIT comes from an older release.
     989$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
     990$progname: and run autoconf again.
     991_LT_EOF
     992      else
     993        cat >&2 <<_LT_EOF
     994$progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
     995$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
     996$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
     997$progname: and run autoconf again.
     998_LT_EOF
     999      fi
     1000    else
     1001      cat >&2 <<_LT_EOF
     1002$progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,
     1003$progname: but the definition of this LT_INIT comes from revision $macro_revision.
     1004$progname: You should recreate aclocal.m4 with macros from revision $package_revision
     1005$progname: of $PACKAGE $VERSION and run autoconf again.
     1006_LT_EOF
     1007    fi
     1008
     1009    exit $EXIT_MISMATCH
     1010  fi
     1011}
     1012
     1013
     1014# Shorthand for --mode=foo, only valid as the first argument
     1015case $1 in
     1016clean|clea|cle|cl)
     1017  shift; set dummy --mode clean ${1+"$@"}; shift
     1018  ;;
     1019compile|compil|compi|comp|com|co|c)
     1020  shift; set dummy --mode compile ${1+"$@"}; shift
     1021  ;;
     1022execute|execut|execu|exec|exe|ex|e)
     1023  shift; set dummy --mode execute ${1+"$@"}; shift
     1024  ;;
     1025finish|finis|fini|fin|fi|f)
     1026  shift; set dummy --mode finish ${1+"$@"}; shift
     1027  ;;
     1028install|instal|insta|inst|ins|in|i)
     1029  shift; set dummy --mode install ${1+"$@"}; shift
     1030  ;;
     1031link|lin|li|l)
     1032  shift; set dummy --mode link ${1+"$@"}; shift
     1033  ;;
     1034uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
     1035  shift; set dummy --mode uninstall ${1+"$@"}; shift
     1036  ;;
     1037esac
     1038
     1039
     1040
     1041# Option defaults:
     1042opt_debug=:
     1043opt_dry_run=false
     1044opt_config=false
     1045opt_preserve_dup_deps=false
     1046opt_features=false
     1047opt_finish=false
     1048opt_help=false
     1049opt_help_all=false
     1050opt_silent=:
     1051opt_warning=:
     1052opt_verbose=:
     1053opt_silent=false
     1054opt_verbose=false
     1055
     1056
     1057# Parse options once, thoroughly.  This comes as soon as possible in the
     1058# script to make things like `--version' happen as quickly as we can.
     1059{
     1060  # this just eases exit handling
     1061  while test $# -gt 0; do
     1062    opt="$1"
     1063    shift
     1064    case $opt in
     1065      --debug|-x)       opt_debug='set -x'
     1066                        func_echo "enabling shell trace mode"
     1067                        $opt_debug
     1068                        ;;
     1069      --dry-run|--dryrun|-n)
     1070                        opt_dry_run=:
     1071                        ;;
     1072      --config)
     1073                        opt_config=:
     1074func_config
     1075                        ;;
     1076      --dlopen|-dlopen)
     1077                        optarg="$1"
     1078                        opt_dlopen="${opt_dlopen+$opt_dlopen
     1079}$optarg"
     1080                        shift
     1081                        ;;
     1082      --preserve-dup-deps)
     1083                        opt_preserve_dup_deps=:
     1084                        ;;
     1085      --features)
     1086                        opt_features=:
     1087func_features
     1088                        ;;
     1089      --finish)
     1090                        opt_finish=:
     1091set dummy --mode finish ${1+"$@"}; shift
     1092                        ;;
     1093      --help)
     1094                        opt_help=:
     1095                        ;;
     1096      --help-all)
     1097                        opt_help_all=:
     1098opt_help=': help-all'
     1099                        ;;
     1100      --mode)
     1101                        test $# = 0 && func_missing_arg $opt && break
     1102                        optarg="$1"
     1103                        opt_mode="$optarg"
     1104case $optarg in
     1105  # Valid mode arguments:
     1106  clean|compile|execute|finish|install|link|relink|uninstall) ;;
     1107
     1108  # Catch anything else as an error
     1109  *) func_error "invalid argument for $opt"
     1110     exit_cmd=exit
     1111     break
     1112     ;;
     1113esac
     1114                        shift
     1115                        ;;
     1116      --no-silent|--no-quiet)
     1117                        opt_silent=false
     1118func_append preserve_args " $opt"
     1119                        ;;
     1120      --no-warning|--no-warn)
     1121                        opt_warning=false
     1122func_append preserve_args " $opt"
     1123                        ;;
     1124      --no-verbose)
     1125                        opt_verbose=false
     1126func_append preserve_args " $opt"
     1127                        ;;
     1128      --silent|--quiet)
     1129                        opt_silent=:
     1130func_append preserve_args " $opt"
     1131        opt_verbose=false
     1132                        ;;
     1133      --verbose|-v)
     1134                        opt_verbose=:
     1135func_append preserve_args " $opt"
     1136opt_silent=false
     1137                        ;;
     1138      --tag)
     1139                        test $# = 0 && func_missing_arg $opt && break
     1140                        optarg="$1"
     1141                        opt_tag="$optarg"
     1142func_append preserve_args " $opt $optarg"
     1143func_enable_tag "$optarg"
     1144                        shift
     1145                        ;;
     1146
     1147      -\?|-h)           func_usage                              ;;
     1148      --help)           func_help                               ;;
     1149      --version)        func_version                            ;;
     1150
     1151      # Separate optargs to long options:
     1152      --*=*)
     1153                        func_split_long_opt "$opt"
     1154                        set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}
     1155                        shift
     1156                        ;;
     1157
     1158      # Separate non-argument short options:
     1159      -\?*|-h*|-n*|-v*)
     1160                        func_split_short_opt "$opt"
     1161                        set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}
     1162                        shift
     1163                        ;;
     1164
     1165      --)               break                                   ;;
     1166      -*)               func_fatal_help "unrecognized option \`$opt'" ;;
     1167      *)                set dummy "$opt" ${1+"$@"};     shift; break  ;;
     1168    esac
     1169  done
     1170
     1171  # Validate options:
     1172
     1173  # save first non-option argument
     1174  if test "$#" -gt 0; then
     1175    nonopt="$opt"
     1176    shift
     1177  fi
     1178
     1179  # preserve --debug
     1180  test "$opt_debug" = : || func_append preserve_args " --debug"
     1181
     1182  case $host in
     1183    *cygwin* | *mingw* | *pw32* | *cegcc*)
     1184      # don't eliminate duplications in $postdeps and $predeps
     1185      opt_duplicate_compiler_generated_deps=:
     1186      ;;
     1187    *)
     1188      opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
     1189      ;;
     1190  esac
     1191
     1192  $opt_help || {
     1193    # Sanity checks first:
     1194    func_check_version_match
     1195
     1196    if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
     1197      func_fatal_configuration "not configured to build any kind of library"
     1198    fi
     1199
     1200    # Darwin sucks
     1201    eval std_shrext=\"$shrext_cmds\"
     1202
     1203    # Only execute mode is allowed to have -dlopen flags.
     1204    if test -n "$opt_dlopen" && test "$opt_mode" != execute; then
     1205      func_error "unrecognized option \`-dlopen'"
     1206      $ECHO "$help" 1>&2
     1207      exit $EXIT_FAILURE
     1208    fi
     1209
     1210    # Change the help message to a mode-specific one.
     1211    generic_help="$help"
     1212    help="Try \`$progname --help --mode=$opt_mode' for more information."
     1213  }
     1214
     1215
     1216  # Bail if the options were screwed
     1217  $exit_cmd $EXIT_FAILURE
     1218}
     1219
     1220
     1221
     1222
     1223## ----------- ##
     1224##    Main.    ##
     1225## ----------- ##
     1226
     1227# func_lalib_p file
     1228# True iff FILE is a libtool `.la' library or `.lo' object file.
     1229# This function is only a basic sanity check; it will hardly flush out
     1230# determined imposters.
     1231func_lalib_p ()
     1232{
     1233    test -f "$1" &&
     1234      $SED -e 4q "$1" 2>/dev/null \
     1235        | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
     1236}
     1237
     1238# func_lalib_unsafe_p file
     1239# True iff FILE is a libtool `.la' library or `.lo' object file.
     1240# This function implements the same check as func_lalib_p without
     1241# resorting to external programs.  To this end, it redirects stdin and
     1242# closes it afterwards, without saving the original file descriptor.
     1243# As a safety measure, use it only where a negative result would be
     1244# fatal anyway.  Works if `file' does not exist.
     1245func_lalib_unsafe_p ()
     1246{
     1247    lalib_p=no
     1248    if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
     1249        for lalib_p_l in 1 2 3 4
     1250        do
     1251            read lalib_p_line
     1252            case "$lalib_p_line" in
     1253                \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
     1254            esac
     1255        done
     1256        exec 0<&5 5<&-
     1257    fi
     1258    test "$lalib_p" = yes
     1259}
     1260
     1261# func_ltwrapper_script_p file
     1262# True iff FILE is a libtool wrapper script
     1263# This function is only a basic sanity check; it will hardly flush out
     1264# determined imposters.
     1265func_ltwrapper_script_p ()
     1266{
     1267    func_lalib_p "$1"
     1268}
     1269
     1270# func_ltwrapper_executable_p file
     1271# True iff FILE is a libtool wrapper executable
     1272# This function is only a basic sanity check; it will hardly flush out
     1273# determined imposters.
     1274func_ltwrapper_executable_p ()
     1275{
     1276    func_ltwrapper_exec_suffix=
     1277    case $1 in
     1278    *.exe) ;;
     1279    *) func_ltwrapper_exec_suffix=.exe ;;
     1280    esac
     1281    $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
     1282}
     1283
     1284# func_ltwrapper_scriptname file
     1285# Assumes file is an ltwrapper_executable
     1286# uses $file to determine the appropriate filename for a
     1287# temporary ltwrapper_script.
     1288func_ltwrapper_scriptname ()
     1289{
     1290    func_dirname_and_basename "$1" "" "."
     1291    func_stripname '' '.exe' "$func_basename_result"
     1292    func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
     1293}
     1294
     1295# func_ltwrapper_p file
     1296# True iff FILE is a libtool wrapper script or wrapper executable
     1297# This function is only a basic sanity check; it will hardly flush out
     1298# determined imposters.
     1299func_ltwrapper_p ()
     1300{
     1301    func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
     1302}
     1303
     1304
     1305# func_execute_cmds commands fail_cmd
     1306# Execute tilde-delimited COMMANDS.
     1307# If FAIL_CMD is given, eval that upon failure.
     1308# FAIL_CMD may read-access the current command in variable CMD!
     1309func_execute_cmds ()
     1310{
     1311    $opt_debug
     1312    save_ifs=$IFS; IFS='~'
     1313    for cmd in $1; do
     1314      IFS=$save_ifs
     1315      eval cmd=\"$cmd\"
     1316      func_show_eval "$cmd" "${2-:}"
     1317    done
     1318    IFS=$save_ifs
     1319}
     1320
     1321
     1322# func_source file
     1323# Source FILE, adding directory component if necessary.
     1324# Note that it is not necessary on cygwin/mingw to append a dot to
     1325# FILE even if both FILE and FILE.exe exist: automatic-append-.exe
     1326# behavior happens only for exec(3), not for open(2)!  Also, sourcing
     1327# `FILE.' does not work on cygwin managed mounts.
     1328func_source ()
     1329{
     1330    $opt_debug
     1331    case $1 in
     1332    */* | *\\*) . "$1" ;;
     1333    *)          . "./$1" ;;
     1334    esac
     1335}
     1336
     1337
     1338# func_resolve_sysroot PATH
     1339# Replace a leading = in PATH with a sysroot.  Store the result into
     1340# func_resolve_sysroot_result
     1341func_resolve_sysroot ()
     1342{
     1343  func_resolve_sysroot_result=$1
     1344  case $func_resolve_sysroot_result in
     1345  =*)
     1346    func_stripname '=' '' "$func_resolve_sysroot_result"
     1347    func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
     1348    ;;
     1349  esac
     1350}
     1351
     1352# func_replace_sysroot PATH
     1353# If PATH begins with the sysroot, replace it with = and
     1354# store the result into func_replace_sysroot_result.
     1355func_replace_sysroot ()
     1356{
     1357  case "$lt_sysroot:$1" in
     1358  ?*:"$lt_sysroot"*)
     1359    func_stripname "$lt_sysroot" '' "$1"
     1360    func_replace_sysroot_result="=$func_stripname_result"
     1361    ;;
     1362  *)
     1363    # Including no sysroot.
     1364    func_replace_sysroot_result=$1
     1365    ;;
     1366  esac
     1367}
     1368
     1369# func_infer_tag arg
     1370# Infer tagged configuration to use if any are available and
     1371# if one wasn't chosen via the "--tag" command line option.
     1372# Only attempt this if the compiler in the base compile
     1373# command doesn't match the default compiler.
     1374# arg is usually of the form 'gcc ...'
     1375func_infer_tag ()
     1376{
     1377    $opt_debug
     1378    if test -n "$available_tags" && test -z "$tagname"; then
     1379      CC_quoted=
     1380      for arg in $CC; do
     1381        func_append_quoted CC_quoted "$arg"
     1382      done
     1383      CC_expanded=`func_echo_all $CC`
     1384      CC_quoted_expanded=`func_echo_all $CC_quoted`
     1385      case $@ in
     1386      # Blanks in the command may have been stripped by the calling shell,
     1387      # but not from the CC environment variable when configure was run.
     1388      " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
     1389      " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
     1390      # Blanks at the start of $base_compile will cause this to fail
     1391      # if we don't check for them as well.
     1392      *)
     1393        for z in $available_tags; do
     1394          if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
     1395            # Evaluate the configuration.
     1396            eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
     1397            CC_quoted=
     1398            for arg in $CC; do
     1399              # Double-quote args containing other shell metacharacters.
     1400              func_append_quoted CC_quoted "$arg"
     1401            done
     1402            CC_expanded=`func_echo_all $CC`
     1403            CC_quoted_expanded=`func_echo_all $CC_quoted`
     1404            case "$@ " in
     1405            " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
     1406            " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
     1407              # The compiler in the base compile command matches
     1408              # the one in the tagged configuration.
     1409              # Assume this is the tagged configuration we want.
     1410              tagname=$z
     1411              break
     1412              ;;
     1413            esac
     1414          fi
     1415        done
     1416        # If $tagname still isn't set, then no tagged configuration
     1417        # was found and let the user know that the "--tag" command
     1418        # line option must be used.
     1419        if test -z "$tagname"; then
     1420          func_echo "unable to infer tagged configuration"
     1421          func_fatal_error "specify a tag with \`--tag'"
     1422#       else
     1423#         func_verbose "using $tagname tagged configuration"
     1424        fi
     1425        ;;
     1426      esac
     1427    fi
     1428}
     1429
     1430
     1431
     1432# func_write_libtool_object output_name pic_name nonpic_name
     1433# Create a libtool object file (analogous to a ".la" file),
     1434# but don't create it if we're doing a dry run.
     1435func_write_libtool_object ()
     1436{
     1437    write_libobj=${1}
     1438    if test "$build_libtool_libs" = yes; then
     1439      write_lobj=\'${2}\'
     1440    else
     1441      write_lobj=none
     1442    fi
     1443
     1444    if test "$build_old_libs" = yes; then
     1445      write_oldobj=\'${3}\'
     1446    else
     1447      write_oldobj=none
     1448    fi
     1449
     1450    $opt_dry_run || {
     1451      cat >${write_libobj}T <<EOF
     1452# $write_libobj - a libtool object file
     1453# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
     1454#
     1455# Please DO NOT delete this file!
     1456# It is necessary for linking the library.
     1457
     1458# Name of the PIC object.
     1459pic_object=$write_lobj
     1460
     1461# Name of the non-PIC object
     1462non_pic_object=$write_oldobj
     1463
     1464EOF
     1465      $MV "${write_libobj}T" "${write_libobj}"
     1466    }
     1467}
     1468
     1469
     1470##################################################
     1471# FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
     1472##################################################
     1473
     1474# func_convert_core_file_wine_to_w32 ARG
     1475# Helper function used by file name conversion functions when $build is *nix,
     1476# and $host is mingw, cygwin, or some other w32 environment. Relies on a
     1477# correctly configured wine environment available, with the winepath program
     1478# in $build's $PATH.
     1479#
     1480# ARG is the $build file name to be converted to w32 format.
     1481# Result is available in $func_convert_core_file_wine_to_w32_result, and will
     1482# be empty on error (or when ARG is empty)
     1483func_convert_core_file_wine_to_w32 ()
     1484{
     1485  $opt_debug
     1486  func_convert_core_file_wine_to_w32_result="$1"
     1487  if test -n "$1"; then
     1488    # Unfortunately, winepath does not exit with a non-zero error code, so we
     1489    # are forced to check the contents of stdout. On the other hand, if the
     1490    # command is not found, the shell will set an exit code of 127 and print
     1491    # *an error message* to stdout. So we must check for both error code of
     1492    # zero AND non-empty stdout, which explains the odd construction:
     1493    func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
     1494    if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then
     1495      func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
     1496        $SED -e "$lt_sed_naive_backslashify"`
     1497    else
     1498      func_convert_core_file_wine_to_w32_result=
     1499    fi
     1500  fi
     1501}
     1502# end: func_convert_core_file_wine_to_w32
     1503
     1504
     1505# func_convert_core_path_wine_to_w32 ARG
     1506# Helper function used by path conversion functions when $build is *nix, and
     1507# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
     1508# configured wine environment available, with the winepath program in $build's
     1509# $PATH. Assumes ARG has no leading or trailing path separator characters.
     1510#
     1511# ARG is path to be converted from $build format to win32.
     1512# Result is available in $func_convert_core_path_wine_to_w32_result.
     1513# Unconvertible file (directory) names in ARG are skipped; if no directory names
     1514# are convertible, then the result may be empty.
     1515func_convert_core_path_wine_to_w32 ()
     1516{
     1517  $opt_debug
     1518  # unfortunately, winepath doesn't convert paths, only file names
     1519  func_convert_core_path_wine_to_w32_result=""
     1520  if test -n "$1"; then
     1521    oldIFS=$IFS
     1522    IFS=:
     1523    for func_convert_core_path_wine_to_w32_f in $1; do
     1524      IFS=$oldIFS
     1525      func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
     1526      if test -n "$func_convert_core_file_wine_to_w32_result" ; then
     1527        if test -z "$func_convert_core_path_wine_to_w32_result"; then
     1528          func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"
     1529        else
     1530          func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
     1531        fi
     1532      fi
     1533    done
     1534    IFS=$oldIFS
     1535  fi
     1536}
     1537# end: func_convert_core_path_wine_to_w32
     1538
     1539
     1540# func_cygpath ARGS...
     1541# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
     1542# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
     1543# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
     1544# (2), returns the Cygwin file name or path in func_cygpath_result (input
     1545# file name or path is assumed to be in w32 format, as previously converted
     1546# from $build's *nix or MSYS format). In case (3), returns the w32 file name
     1547# or path in func_cygpath_result (input file name or path is assumed to be in
     1548# Cygwin format). Returns an empty string on error.
     1549#
     1550# ARGS are passed to cygpath, with the last one being the file name or path to
     1551# be converted.
     1552#
     1553# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
     1554# environment variable; do not put it in $PATH.
     1555func_cygpath ()
     1556{
     1557  $opt_debug
     1558  if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
     1559    func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
     1560    if test "$?" -ne 0; then
     1561      # on failure, ensure result is empty
     1562      func_cygpath_result=
     1563    fi
     1564  else
     1565    func_cygpath_result=
     1566    func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"
     1567  fi
     1568}
     1569#end: func_cygpath
     1570
     1571
     1572# func_convert_core_msys_to_w32 ARG
     1573# Convert file name or path ARG from MSYS format to w32 format.  Return
     1574# result in func_convert_core_msys_to_w32_result.
     1575func_convert_core_msys_to_w32 ()
     1576{
     1577  $opt_debug
     1578  # awkward: cmd appends spaces to result
     1579  func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
     1580    $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
     1581}
     1582#end: func_convert_core_msys_to_w32
     1583
     1584
     1585# func_convert_file_check ARG1 ARG2
     1586# Verify that ARG1 (a file name in $build format) was converted to $host
     1587# format in ARG2. Otherwise, emit an error message, but continue (resetting
     1588# func_to_host_file_result to ARG1).
     1589func_convert_file_check ()
     1590{
     1591  $opt_debug
     1592  if test -z "$2" && test -n "$1" ; then
     1593    func_error "Could not determine host file name corresponding to"
     1594    func_error "  \`$1'"
     1595    func_error "Continuing, but uninstalled executables may not work."
     1596    # Fallback:
     1597    func_to_host_file_result="$1"
     1598  fi
     1599}
     1600# end func_convert_file_check
     1601
     1602
     1603# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
     1604# Verify that FROM_PATH (a path in $build format) was converted to $host
     1605# format in TO_PATH. Otherwise, emit an error message, but continue, resetting
     1606# func_to_host_file_result to a simplistic fallback value (see below).
     1607func_convert_path_check ()
     1608{
     1609  $opt_debug
     1610  if test -z "$4" && test -n "$3"; then
     1611    func_error "Could not determine the host path corresponding to"
     1612    func_error "  \`$3'"
     1613    func_error "Continuing, but uninstalled executables may not work."
     1614    # Fallback.  This is a deliberately simplistic "conversion" and
     1615    # should not be "improved".  See libtool.info.
     1616    if test "x$1" != "x$2"; then
     1617      lt_replace_pathsep_chars="s|$1|$2|g"
     1618      func_to_host_path_result=`echo "$3" |
     1619        $SED -e "$lt_replace_pathsep_chars"`
     1620    else
     1621      func_to_host_path_result="$3"
     1622    fi
     1623  fi
     1624}
     1625# end func_convert_path_check
     1626
     1627
     1628# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
     1629# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
     1630# and appending REPL if ORIG matches BACKPAT.
     1631func_convert_path_front_back_pathsep ()
     1632{
     1633  $opt_debug
     1634  case $4 in
     1635  $1 ) func_to_host_path_result="$3$func_to_host_path_result"
     1636    ;;
     1637  esac
     1638  case $4 in
     1639  $2 ) func_append func_to_host_path_result "$3"
     1640    ;;
     1641  esac
     1642}
     1643# end func_convert_path_front_back_pathsep
     1644
     1645
     1646##################################################
     1647# $build to $host FILE NAME CONVERSION FUNCTIONS #
     1648##################################################
     1649# invoked via `$to_host_file_cmd ARG'
     1650#
     1651# In each case, ARG is the path to be converted from $build to $host format.
     1652# Result will be available in $func_to_host_file_result.
     1653
     1654
     1655# func_to_host_file ARG
     1656# Converts the file name ARG from $build format to $host format. Return result
     1657# in func_to_host_file_result.
     1658func_to_host_file ()
     1659{
     1660  $opt_debug
     1661  $to_host_file_cmd "$1"
     1662}
     1663# end func_to_host_file
     1664
     1665
     1666# func_to_tool_file ARG LAZY
     1667# converts the file name ARG from $build format to toolchain format. Return
     1668# result in func_to_tool_file_result.  If the conversion in use is listed
     1669# in (the comma separated) LAZY, no conversion takes place.
     1670func_to_tool_file ()
     1671{
     1672  $opt_debug
     1673  case ,$2, in
     1674    *,"$to_tool_file_cmd",*)
     1675      func_to_tool_file_result=$1
     1676      ;;
     1677    *)
     1678      $to_tool_file_cmd "$1"
     1679      func_to_tool_file_result=$func_to_host_file_result
     1680      ;;
     1681  esac
     1682}
     1683# end func_to_tool_file
     1684
     1685
     1686# func_convert_file_noop ARG
     1687# Copy ARG to func_to_host_file_result.
     1688func_convert_file_noop ()
     1689{
     1690  func_to_host_file_result="$1"
     1691}
     1692# end func_convert_file_noop
     1693
     1694
     1695# func_convert_file_msys_to_w32 ARG
     1696# Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
     1697# conversion to w32 is not available inside the cwrapper.  Returns result in
     1698# func_to_host_file_result.
     1699func_convert_file_msys_to_w32 ()
     1700{
     1701  $opt_debug
     1702  func_to_host_file_result="$1"
     1703  if test -n "$1"; then
     1704    func_convert_core_msys_to_w32 "$1"
     1705    func_to_host_file_result="$func_convert_core_msys_to_w32_result"
     1706  fi
     1707  func_convert_file_check "$1" "$func_to_host_file_result"
     1708}
     1709# end func_convert_file_msys_to_w32
     1710
     1711
     1712# func_convert_file_cygwin_to_w32 ARG
     1713# Convert file name ARG from Cygwin to w32 format.  Returns result in
     1714# func_to_host_file_result.
     1715func_convert_file_cygwin_to_w32 ()
     1716{
     1717  $opt_debug
     1718  func_to_host_file_result="$1"
     1719  if test -n "$1"; then
     1720    # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
     1721    # LT_CYGPATH in this case.
     1722    func_to_host_file_result=`cygpath -m "$1"`
     1723  fi
     1724  func_convert_file_check "$1" "$func_to_host_file_result"
     1725}
     1726# end func_convert_file_cygwin_to_w32
     1727
     1728
     1729# func_convert_file_nix_to_w32 ARG
     1730# Convert file name ARG from *nix to w32 format.  Requires a wine environment
     1731# and a working winepath. Returns result in func_to_host_file_result.
     1732func_convert_file_nix_to_w32 ()
     1733{
     1734  $opt_debug
     1735  func_to_host_file_result="$1"
     1736  if test -n "$1"; then
     1737    func_convert_core_file_wine_to_w32 "$1"
     1738    func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"
     1739  fi
     1740  func_convert_file_check "$1" "$func_to_host_file_result"
     1741}
     1742# end func_convert_file_nix_to_w32
     1743
     1744
     1745# func_convert_file_msys_to_cygwin ARG
     1746# Convert file name ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
     1747# Returns result in func_to_host_file_result.
     1748func_convert_file_msys_to_cygwin ()
     1749{
     1750  $opt_debug
     1751  func_to_host_file_result="$1"
     1752  if test -n "$1"; then
     1753    func_convert_core_msys_to_w32 "$1"
     1754    func_cygpath -u "$func_convert_core_msys_to_w32_result"
     1755    func_to_host_file_result="$func_cygpath_result"
     1756  fi
     1757  func_convert_file_check "$1" "$func_to_host_file_result"
     1758}
     1759# end func_convert_file_msys_to_cygwin
     1760
     1761
     1762# func_convert_file_nix_to_cygwin ARG
     1763# Convert file name ARG from *nix to Cygwin format.  Requires Cygwin installed
     1764# in a wine environment, working winepath, and LT_CYGPATH set.  Returns result
     1765# in func_to_host_file_result.
     1766func_convert_file_nix_to_cygwin ()
     1767{
     1768  $opt_debug
     1769  func_to_host_file_result="$1"
     1770  if test -n "$1"; then
     1771    # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
     1772    func_convert_core_file_wine_to_w32 "$1"
     1773    func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
     1774    func_to_host_file_result="$func_cygpath_result"
     1775  fi
     1776  func_convert_file_check "$1" "$func_to_host_file_result"
     1777}
     1778# end func_convert_file_nix_to_cygwin
     1779
     1780
     1781#############################################
     1782# $build to $host PATH CONVERSION FUNCTIONS #
     1783#############################################
     1784# invoked via `$to_host_path_cmd ARG'
     1785#
     1786# In each case, ARG is the path to be converted from $build to $host format.
     1787# The result will be available in $func_to_host_path_result.
     1788#
     1789# Path separators are also converted from $build format to $host format.  If
     1790# ARG begins or ends with a path separator character, it is preserved (but
     1791# converted to $host format) on output.
     1792#
     1793# All path conversion functions are named using the following convention:
     1794#   file name conversion function    : func_convert_file_X_to_Y ()
     1795#   path conversion function         : func_convert_path_X_to_Y ()
     1796# where, for any given $build/$host combination the 'X_to_Y' value is the
     1797# same.  If conversion functions are added for new $build/$host combinations,
     1798# the two new functions must follow this pattern, or func_init_to_host_path_cmd
     1799# will break.
     1800
     1801
     1802# func_init_to_host_path_cmd
     1803# Ensures that function "pointer" variable $to_host_path_cmd is set to the
     1804# appropriate value, based on the value of $to_host_file_cmd.
     1805to_host_path_cmd=
     1806func_init_to_host_path_cmd ()
     1807{
     1808  $opt_debug
     1809  if test -z "$to_host_path_cmd"; then
     1810    func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
     1811    to_host_path_cmd="func_convert_path_${func_stripname_result}"
     1812  fi
     1813}
     1814
     1815
     1816# func_to_host_path ARG
     1817# Converts the path ARG from $build format to $host format. Return result
     1818# in func_to_host_path_result.
     1819func_to_host_path ()
     1820{
     1821  $opt_debug
     1822  func_init_to_host_path_cmd
     1823  $to_host_path_cmd "$1"
     1824}
     1825# end func_to_host_path
     1826
     1827
     1828# func_convert_path_noop ARG
     1829# Copy ARG to func_to_host_path_result.
     1830func_convert_path_noop ()
     1831{
     1832  func_to_host_path_result="$1"
     1833}
     1834# end func_convert_path_noop
     1835
     1836
     1837# func_convert_path_msys_to_w32 ARG
     1838# Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
     1839# conversion to w32 is not available inside the cwrapper.  Returns result in
     1840# func_to_host_path_result.
     1841func_convert_path_msys_to_w32 ()
     1842{
     1843  $opt_debug
     1844  func_to_host_path_result="$1"
     1845  if test -n "$1"; then
     1846    # Remove leading and trailing path separator characters from ARG.  MSYS
     1847    # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
     1848    # and winepath ignores them completely.
     1849    func_stripname : : "$1"
     1850    func_to_host_path_tmp1=$func_stripname_result
     1851    func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
     1852    func_to_host_path_result="$func_convert_core_msys_to_w32_result"
     1853    func_convert_path_check : ";" \
     1854      "$func_to_host_path_tmp1" "$func_to_host_path_result"
     1855    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
     1856  fi
     1857}
     1858# end func_convert_path_msys_to_w32
     1859
     1860
     1861# func_convert_path_cygwin_to_w32 ARG
     1862# Convert path ARG from Cygwin to w32 format.  Returns result in
     1863# func_to_host_file_result.
     1864func_convert_path_cygwin_to_w32 ()
     1865{
     1866  $opt_debug
     1867  func_to_host_path_result="$1"
     1868  if test -n "$1"; then
     1869    # See func_convert_path_msys_to_w32:
     1870    func_stripname : : "$1"
     1871    func_to_host_path_tmp1=$func_stripname_result
     1872    func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
     1873    func_convert_path_check : ";" \
     1874      "$func_to_host_path_tmp1" "$func_to_host_path_result"
     1875    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
     1876  fi
     1877}
     1878# end func_convert_path_cygwin_to_w32
     1879
     1880
     1881# func_convert_path_nix_to_w32 ARG
     1882# Convert path ARG from *nix to w32 format.  Requires a wine environment and
     1883# a working winepath.  Returns result in func_to_host_file_result.
     1884func_convert_path_nix_to_w32 ()
     1885{
     1886  $opt_debug
     1887  func_to_host_path_result="$1"
     1888  if test -n "$1"; then
     1889    # See func_convert_path_msys_to_w32:
     1890    func_stripname : : "$1"
     1891    func_to_host_path_tmp1=$func_stripname_result
     1892    func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
     1893    func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"
     1894    func_convert_path_check : ";" \
     1895      "$func_to_host_path_tmp1" "$func_to_host_path_result"
     1896    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
     1897  fi
     1898}
     1899# end func_convert_path_nix_to_w32
     1900
     1901
     1902# func_convert_path_msys_to_cygwin ARG
     1903# Convert path ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
     1904# Returns result in func_to_host_file_result.
     1905func_convert_path_msys_to_cygwin ()
     1906{
     1907  $opt_debug
     1908  func_to_host_path_result="$1"
     1909  if test -n "$1"; then
     1910    # See func_convert_path_msys_to_w32:
     1911    func_stripname : : "$1"
     1912    func_to_host_path_tmp1=$func_stripname_result
     1913    func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
     1914    func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
     1915    func_to_host_path_result="$func_cygpath_result"
     1916    func_convert_path_check : : \
     1917      "$func_to_host_path_tmp1" "$func_to_host_path_result"
     1918    func_convert_path_front_back_pathsep ":*" "*:" : "$1"
     1919  fi
     1920}
     1921# end func_convert_path_msys_to_cygwin
     1922
     1923
     1924# func_convert_path_nix_to_cygwin ARG
     1925# Convert path ARG from *nix to Cygwin format.  Requires Cygwin installed in a
     1926# a wine environment, working winepath, and LT_CYGPATH set.  Returns result in
     1927# func_to_host_file_result.
     1928func_convert_path_nix_to_cygwin ()
     1929{
     1930  $opt_debug
     1931  func_to_host_path_result="$1"
     1932  if test -n "$1"; then
     1933    # Remove leading and trailing path separator characters from
     1934    # ARG. msys behavior is inconsistent here, cygpath turns them
     1935    # into '.;' and ';.', and winepath ignores them completely.
     1936    func_stripname : : "$1"
     1937    func_to_host_path_tmp1=$func_stripname_result
     1938    func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
     1939    func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
     1940    func_to_host_path_result="$func_cygpath_result"
     1941    func_convert_path_check : : \
     1942      "$func_to_host_path_tmp1" "$func_to_host_path_result"
     1943    func_convert_path_front_back_pathsep ":*" "*:" : "$1"
     1944  fi
     1945}
     1946# end func_convert_path_nix_to_cygwin
     1947
     1948
     1949# func_mode_compile arg...
     1950func_mode_compile ()
     1951{
     1952    $opt_debug
     1953    # Get the compilation command and the source file.
     1954    base_compile=
     1955    srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
     1956    suppress_opt=yes
     1957    suppress_output=
     1958    arg_mode=normal
     1959    libobj=
     1960    later=
     1961    pie_flag=
     1962
     1963    for arg
     1964    do
     1965      case $arg_mode in
     1966      arg  )
     1967        # do not "continue".  Instead, add this to base_compile
     1968        lastarg="$arg"
     1969        arg_mode=normal
     1970        ;;
     1971
     1972      target )
     1973        libobj="$arg"
     1974        arg_mode=normal
     1975        continue
     1976        ;;
     1977
     1978      normal )
     1979        # Accept any command-line options.
     1980        case $arg in
     1981        -o)
     1982          test -n "$libobj" && \
     1983            func_fatal_error "you cannot specify \`-o' more than once"
     1984          arg_mode=target
     1985          continue
     1986          ;;
     1987
     1988        -pie | -fpie | -fPIE)
     1989          func_append pie_flag " $arg"
     1990          continue
     1991          ;;
     1992
     1993        -shared | -static | -prefer-pic | -prefer-non-pic)
     1994          func_append later " $arg"
     1995          continue
     1996          ;;
     1997
     1998        -no-suppress)
     1999          suppress_opt=no
     2000          continue
     2001          ;;
     2002
     2003        -Xcompiler)
     2004          arg_mode=arg  #  the next one goes into the "base_compile" arg list
     2005          continue      #  The current "srcfile" will either be retained or
     2006          ;;            #  replaced later.  I would guess that would be a bug.
     2007
     2008        -Wc,*)
     2009          func_stripname '-Wc,' '' "$arg"
     2010          args=$func_stripname_result
     2011          lastarg=
     2012          save_ifs="$IFS"; IFS=','
     2013          for arg in $args; do
     2014            IFS="$save_ifs"
     2015            func_append_quoted lastarg "$arg"
     2016          done
     2017          IFS="$save_ifs"
     2018          func_stripname ' ' '' "$lastarg"
     2019          lastarg=$func_stripname_result
     2020
     2021          # Add the arguments to base_compile.
     2022          func_append base_compile " $lastarg"
     2023          continue
     2024          ;;
     2025
     2026        *)
     2027          # Accept the current argument as the source file.
     2028          # The previous "srcfile" becomes the current argument.
     2029          #
     2030          lastarg="$srcfile"
     2031          srcfile="$arg"
     2032          ;;
     2033        esac  #  case $arg
     2034        ;;
     2035      esac    #  case $arg_mode
     2036
     2037      # Aesthetically quote the previous argument.
     2038      func_append_quoted base_compile "$lastarg"
     2039    done # for arg
     2040
     2041    case $arg_mode in
     2042    arg)
     2043      func_fatal_error "you must specify an argument for -Xcompile"
     2044      ;;
     2045    target)
     2046      func_fatal_error "you must specify a target with \`-o'"
     2047      ;;
     2048    *)
     2049      # Get the name of the library object.
     2050      test -z "$libobj" && {
     2051        func_basename "$srcfile"
     2052        libobj="$func_basename_result"
     2053      }
     2054      ;;
     2055    esac
     2056
     2057    # Recognize several different file suffixes.
     2058    # If the user specifies -o file.o, it is replaced with file.lo
     2059    case $libobj in
     2060    *.[cCFSifmso] | \
     2061    *.ada | *.adb | *.ads | *.asm | \
     2062    *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
     2063    *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup)
     2064      func_xform "$libobj"
     2065      libobj=$func_xform_result
     2066      ;;
     2067    esac
     2068
     2069    case $libobj in
     2070    *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
     2071    *)
     2072      func_fatal_error "cannot determine name of library object from \`$libobj'"
     2073      ;;
     2074    esac
     2075
     2076    func_infer_tag $base_compile
     2077
     2078    for arg in $later; do
     2079      case $arg in
     2080      -shared)
     2081        test "$build_libtool_libs" != yes && \
     2082          func_fatal_configuration "can not build a shared library"
     2083        build_old_libs=no
     2084        continue
     2085        ;;
     2086
     2087      -static)
     2088        build_libtool_libs=no
     2089        build_old_libs=yes
     2090        continue
     2091        ;;
     2092
     2093      -prefer-pic)
     2094        pic_mode=yes
     2095        continue
     2096        ;;
     2097
     2098      -prefer-non-pic)
     2099        pic_mode=no
     2100        continue
     2101        ;;
     2102      esac
     2103    done
     2104
     2105    func_quote_for_eval "$libobj"
     2106    test "X$libobj" != "X$func_quote_for_eval_result" \
     2107      && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'    &()|`$[]' \
     2108      && func_warning "libobj name \`$libobj' may not contain shell special characters."
     2109    func_dirname_and_basename "$obj" "/" ""
     2110    objname="$func_basename_result"
     2111    xdir="$func_dirname_result"
     2112    lobj=${xdir}$objdir/$objname
     2113
     2114    test -z "$base_compile" && \
     2115      func_fatal_help "you must specify a compilation command"
     2116
     2117    # Delete any leftover library objects.
     2118    if test "$build_old_libs" = yes; then
     2119      removelist="$obj $lobj $libobj ${libobj}T"
     2120    else
     2121      removelist="$lobj $libobj ${libobj}T"
     2122    fi
     2123
     2124    # On Cygwin there's no "real" PIC flag so we must build both object types
     2125    case $host_os in
     2126    cygwin* | mingw* | pw32* | os2* | cegcc*)
     2127      pic_mode=default
     2128      ;;
     2129    esac
     2130    if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
     2131      # non-PIC code in shared libraries is not supported
     2132      pic_mode=default
     2133    fi
     2134
     2135    # Calculate the filename of the output object if compiler does
     2136    # not support -o with -c
     2137    if test "$compiler_c_o" = no; then
     2138      output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
     2139      lockfile="$output_obj.lock"
     2140    else
     2141      output_obj=
     2142      need_locks=no
     2143      lockfile=
     2144    fi
     2145
     2146    # Lock this critical section if it is needed
     2147    # We use this script file to make the link, it avoids creating a new file
     2148    if test "$need_locks" = yes; then
     2149      until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
     2150        func_echo "Waiting for $lockfile to be removed"
     2151        sleep 2
     2152      done
     2153    elif test "$need_locks" = warn; then
     2154      if test -f "$lockfile"; then
     2155        $ECHO "\
     2156*** ERROR, $lockfile exists and contains:
     2157`cat $lockfile 2>/dev/null`
     2158
     2159This indicates that another process is trying to use the same
     2160temporary object file, and libtool could not work around it because
     2161your compiler does not support \`-c' and \`-o' together.  If you
     2162repeat this compilation, it may succeed, by chance, but you had better
     2163avoid parallel builds (make -j) in this platform, or get a better
     2164compiler."
     2165
     2166        $opt_dry_run || $RM $removelist
    1732167        exit $EXIT_FAILURE
     2168      fi
     2169      func_append removelist " $output_obj"
     2170      $ECHO "$srcfile" > "$lockfile"
     2171    fi
     2172
     2173    $opt_dry_run || $RM $removelist
     2174    func_append removelist " $lockfile"
     2175    trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
     2176
     2177    func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
     2178    srcfile=$func_to_tool_file_result
     2179    func_quote_for_eval "$srcfile"
     2180    qsrcfile=$func_quote_for_eval_result
     2181
     2182    # Only build a PIC object if we are building libtool libraries.
     2183    if test "$build_libtool_libs" = yes; then
     2184      # Without this assignment, base_compile gets emptied.
     2185      fbsd_hideous_sh_bug=$base_compile
     2186
     2187      if test "$pic_mode" != no; then
     2188        command="$base_compile $qsrcfile $pic_flag"
     2189      else
     2190        # Don't build PIC code
     2191        command="$base_compile $qsrcfile"
     2192      fi
     2193
     2194      func_mkdir_p "$xdir$objdir"
     2195
     2196      if test -z "$output_obj"; then
     2197        # Place PIC objects in $objdir
     2198        func_append command " -o $lobj"
     2199      fi
     2200
     2201      func_show_eval_locale "$command"  \
     2202          'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
     2203
     2204      if test "$need_locks" = warn &&
     2205         test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
     2206        $ECHO "\
     2207*** ERROR, $lockfile contains:
     2208`cat $lockfile 2>/dev/null`
     2209
     2210but it should contain:
     2211$srcfile
     2212
     2213This indicates that another process is trying to use the same
     2214temporary object file, and libtool could not work around it because
     2215your compiler does not support \`-c' and \`-o' together.  If you
     2216repeat this compilation, it may succeed, by chance, but you had better
     2217avoid parallel builds (make -j) in this platform, or get a better
     2218compiler."
     2219
     2220        $opt_dry_run || $RM $removelist
     2221        exit $EXIT_FAILURE
     2222      fi
     2223
     2224      # Just move the object if needed, then go on to compile the next one
     2225      if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
     2226        func_show_eval '$MV "$output_obj" "$lobj"' \
     2227          'error=$?; $opt_dry_run || $RM $removelist; exit $error'
     2228      fi
     2229
     2230      # Allow error messages only from the first compilation.
     2231      if test "$suppress_opt" = yes; then
     2232        suppress_output=' >/dev/null 2>&1'
     2233      fi
     2234    fi
     2235
     2236    # Only build a position-dependent object if we build old libraries.
     2237    if test "$build_old_libs" = yes; then
     2238      if test "$pic_mode" != yes; then
     2239        # Don't build PIC code
     2240        command="$base_compile $qsrcfile$pie_flag"
     2241      else
     2242        command="$base_compile $qsrcfile $pic_flag"
     2243      fi
     2244      if test "$compiler_c_o" = yes; then
     2245        func_append command " -o $obj"
     2246      fi
     2247
     2248      # Suppress compiler output if we already did a PIC compilation.
     2249      func_append command "$suppress_output"
     2250      func_show_eval_locale "$command" \
     2251        '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
     2252
     2253      if test "$need_locks" = warn &&
     2254         test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
     2255        $ECHO "\
     2256*** ERROR, $lockfile contains:
     2257`cat $lockfile 2>/dev/null`
     2258
     2259but it should contain:
     2260$srcfile
     2261
     2262This indicates that another process is trying to use the same
     2263temporary object file, and libtool could not work around it because
     2264your compiler does not support \`-c' and \`-o' together.  If you
     2265repeat this compilation, it may succeed, by chance, but you had better
     2266avoid parallel builds (make -j) in this platform, or get a better
     2267compiler."
     2268
     2269        $opt_dry_run || $RM $removelist
     2270        exit $EXIT_FAILURE
     2271      fi
     2272
     2273      # Just move the object if needed
     2274      if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
     2275        func_show_eval '$MV "$output_obj" "$obj"' \
     2276          'error=$?; $opt_dry_run || $RM $removelist; exit $error'
     2277      fi
     2278    fi
     2279
     2280    $opt_dry_run || {
     2281      func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
     2282
     2283      # Unlock the critical section if it was locked
     2284      if test "$need_locks" != no; then
     2285        removelist=$lockfile
     2286        $RM "$lockfile"
     2287      fi
     2288    }
     2289
     2290    exit $EXIT_SUCCESS
     2291}
     2292
     2293$opt_help || {
     2294  test "$opt_mode" = compile && func_mode_compile ${1+"$@"}
     2295}
     2296
     2297func_mode_help ()
     2298{
     2299    # We need to display help for each of the modes.
     2300    case $opt_mode in
     2301      "")
     2302        # Generic help is extracted from the usage comments
     2303        # at the start of this file.
     2304        func_help
     2305        ;;
     2306
     2307      clean)
     2308        $ECHO \
     2309"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
     2310
     2311Remove files from the build directory.
     2312
     2313RM is the name of the program to use to delete files associated with each FILE
     2314(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
     2315to RM.
     2316
     2317If FILE is a libtool library, object or program, all the files associated
     2318with it are deleted. Otherwise, only FILE itself is deleted using RM."
     2319        ;;
     2320
     2321      compile)
     2322      $ECHO \
     2323"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
     2324
     2325Compile a source file into a libtool library object.
     2326
     2327This mode accepts the following additional options:
     2328
     2329  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
     2330  -no-suppress      do not suppress compiler output for multiple passes
     2331  -prefer-pic       try to build PIC objects only
     2332  -prefer-non-pic   try to build non-PIC objects only
     2333  -shared           do not build a \`.o' file suitable for static linking
     2334  -static           only build a \`.o' file suitable for static linking
     2335  -Wc,FLAG          pass FLAG directly to the compiler
     2336
     2337COMPILE-COMMAND is a command to be used in creating a \`standard' object file
     2338from the given SOURCEFILE.
     2339
     2340The output file name is determined by removing the directory component from
     2341SOURCEFILE, then substituting the C source code suffix \`.c' with the
     2342library object suffix, \`.lo'."
     2343        ;;
     2344
     2345      execute)
     2346        $ECHO \
     2347"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
     2348
     2349Automatically set library path, then run a program.
     2350
     2351This mode accepts the following additional options:
     2352
     2353  -dlopen FILE      add the directory containing FILE to the library path
     2354
     2355This mode sets the library path environment variable according to \`-dlopen'
     2356flags.
     2357
     2358If any of the ARGS are libtool executable wrappers, then they are translated
     2359into their corresponding uninstalled binary, and any of their required library
     2360directories are added to the library path.
     2361
     2362Then, COMMAND is executed, with ARGS as arguments."
     2363        ;;
     2364
     2365      finish)
     2366        $ECHO \
     2367"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
     2368
     2369Complete the installation of libtool libraries.
     2370
     2371Each LIBDIR is a directory that contains libtool libraries.
     2372
     2373The commands that this mode executes may require superuser privileges.  Use
     2374the \`--dry-run' option if you just want to see what would be executed."
     2375        ;;
     2376
     2377      install)
     2378        $ECHO \
     2379"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
     2380
     2381Install executables or libraries.
     2382
     2383INSTALL-COMMAND is the installation command.  The first component should be
     2384either the \`install' or \`cp' program.
     2385
     2386The following components of INSTALL-COMMAND are treated specially:
     2387
     2388  -inst-prefix-dir PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
     2389
     2390The rest of the components are interpreted as arguments to that command (only
     2391BSD-compatible install options are recognized)."
     2392        ;;
     2393
     2394      link)
     2395        $ECHO \
     2396"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
     2397
     2398Link object files or libraries together to form another library, or to
     2399create an executable program.
     2400
     2401LINK-COMMAND is a command using the C compiler that you would use to create
     2402a program from several object files.
     2403
     2404The following components of LINK-COMMAND are treated specially:
     2405
     2406  -all-static       do not do any dynamic linking at all
     2407  -avoid-version    do not add a version suffix if possible
     2408  -bindir BINDIR    specify path to binaries directory (for systems where
     2409                    libraries must be found in the PATH setting at runtime)
     2410  -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
     2411  -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
     2412  -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
     2413  -export-symbols SYMFILE
     2414                    try to export only the symbols listed in SYMFILE
     2415  -export-symbols-regex REGEX
     2416                    try to export only the symbols matching REGEX
     2417  -LLIBDIR          search LIBDIR for required installed libraries
     2418  -lNAME            OUTPUT-FILE requires the installed library libNAME
     2419  -module           build a library that can dlopened
     2420  -no-fast-install  disable the fast-install mode
     2421  -no-install       link a not-installable executable
     2422  -no-undefined     declare that a library does not refer to external symbols
     2423  -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
     2424  -objectlist FILE  Use a list of object files found in FILE to specify objects
     2425  -precious-files-regex REGEX
     2426                    don't remove output files matching REGEX
     2427  -release RELEASE  specify package release information
     2428  -rpath LIBDIR     the created library will eventually be installed in LIBDIR
     2429  -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
     2430  -shared           only do dynamic linking of libtool libraries
     2431  -shrext SUFFIX    override the standard shared library file extension
     2432  -static           do not do any dynamic linking of uninstalled libtool libraries
     2433  -static-libtool-libs
     2434                    do not do any dynamic linking of libtool libraries
     2435  -version-info CURRENT[:REVISION[:AGE]]
     2436                    specify library version info [each variable defaults to 0]
     2437  -weak LIBNAME     declare that the target provides the LIBNAME interface
     2438  -Wc,FLAG
     2439  -Xcompiler FLAG   pass linker-specific FLAG directly to the compiler
     2440  -Wl,FLAG
     2441  -Xlinker FLAG     pass linker-specific FLAG directly to the linker
     2442  -XCClinker FLAG   pass link-specific FLAG to the compiler driver (CC)
     2443
     2444All other options (arguments beginning with \`-') are ignored.
     2445
     2446Every other argument is treated as a filename.  Files ending in \`.la' are
     2447treated as uninstalled libtool libraries, other files are standard or library
     2448object files.
     2449
     2450If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
     2451only library objects (\`.lo' files) may be specified, and \`-rpath' is
     2452required, except when creating a convenience library.
     2453
     2454If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
     2455using \`ar' and \`ranlib', or on Windows using \`lib'.
     2456
     2457If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
     2458is created, otherwise an executable program is created."
     2459        ;;
     2460
     2461      uninstall)
     2462        $ECHO \
     2463"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
     2464
     2465Remove libraries from an installation directory.
     2466
     2467RM is the name of the program to use to delete files associated with each FILE
     2468(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
     2469to RM.
     2470
     2471If FILE is a libtool library, all the files associated with it are deleted.
     2472Otherwise, only FILE itself is deleted using RM."
     2473        ;;
     2474
     2475      *)
     2476        func_fatal_help "invalid operation mode \`$opt_mode'"
     2477        ;;
     2478    esac
     2479
     2480    echo
     2481    $ECHO "Try \`$progname --help' for more information about other modes."
     2482}
     2483
     2484# Now that we've collected a possible --mode arg, show help if necessary
     2485if $opt_help; then
     2486  if test "$opt_help" = :; then
     2487    func_mode_help
     2488  else
     2489    {
     2490      func_help noexit
     2491      for opt_mode in compile link execute install finish uninstall clean; do
     2492        func_mode_help
     2493      done
     2494    } | sed -n '1p; 2,$s/^Usage:/  or: /p'
     2495    {
     2496      func_help noexit
     2497      for opt_mode in compile link execute install finish uninstall clean; do
     2498        echo
     2499        func_mode_help
     2500      done
     2501    } |
     2502    sed '1d
     2503      /^When reporting/,/^Report/{
     2504        H
     2505        d
    1742506      }
     2507      $x
     2508      /information about other modes/d
     2509      /more detailed .*MODE/d
     2510      s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
     2511  fi
     2512  exit $?
     2513fi
     2514
     2515
     2516# func_mode_execute arg...
     2517func_mode_execute ()
     2518{
     2519    $opt_debug
     2520    # The first argument is the command name.
     2521    cmd="$nonopt"
     2522    test -z "$cmd" && \
     2523      func_fatal_help "you must specify a COMMAND"
     2524
     2525    # Handle -dlopen flags immediately.
     2526    for file in $opt_dlopen; do
     2527      test -f "$file" \
     2528        || func_fatal_help "\`$file' is not a file"
     2529
     2530      dir=
     2531      case $file in
     2532      *.la)
     2533        func_resolve_sysroot "$file"
     2534        file=$func_resolve_sysroot_result
     2535
     2536        # Check to see that this really is a libtool archive.
     2537        func_lalib_unsafe_p "$file" \
     2538          || func_fatal_help "\`$lib' is not a valid libtool archive"
     2539
     2540        # Read the libtool library.
     2541        dlname=
     2542        library_names=
     2543        func_source "$file"
     2544
     2545        # Skip this library if it cannot be dlopened.
     2546        if test -z "$dlname"; then
     2547          # Warn if it was a shared library.
     2548          test -n "$library_names" && \
     2549            func_warning "\`$file' was not linked with \`-export-dynamic'"
     2550          continue
     2551        fi
     2552
     2553        func_dirname "$file" "" "."
     2554        dir="$func_dirname_result"
     2555
     2556        if test -f "$dir/$objdir/$dlname"; then
     2557          func_append dir "/$objdir"
     2558        else
     2559          if test ! -f "$dir/$dlname"; then
     2560            func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
     2561          fi
     2562        fi
     2563        ;;
     2564
     2565      *.lo)
     2566        # Just add the directory containing the .lo file.
     2567        func_dirname "$file" "" "."
     2568        dir="$func_dirname_result"
     2569        ;;
     2570
     2571      *)
     2572        func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
     2573        continue
     2574        ;;
     2575      esac
     2576
     2577      # Get the absolute pathname.
     2578      absdir=`cd "$dir" && pwd`
     2579      test -n "$absdir" && dir="$absdir"
     2580
     2581      # Now add the directory to shlibpath_var.
     2582      if eval "test -z \"\$$shlibpath_var\""; then
     2583        eval "$shlibpath_var=\"\$dir\""
     2584      else
     2585        eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
     2586      fi
     2587    done
     2588
     2589    # This variable tells wrapper scripts just to set shlibpath_var
     2590    # rather than running their programs.
     2591    libtool_execute_magic="$magic"
     2592
     2593    # Check if any of the arguments is a wrapper script.
     2594    args=
     2595    for file
     2596    do
     2597      case $file in
     2598      -* | *.la | *.lo ) ;;
     2599      *)
     2600        # Do a test to see if this is really a libtool program.
     2601        if func_ltwrapper_script_p "$file"; then
     2602          func_source "$file"
     2603          # Transform arg to wrapped name.
     2604          file="$progdir/$program"
     2605        elif func_ltwrapper_executable_p "$file"; then
     2606          func_ltwrapper_scriptname "$file"
     2607          func_source "$func_ltwrapper_scriptname_result"
     2608          # Transform arg to wrapped name.
     2609          file="$progdir/$program"
     2610        fi
     2611        ;;
     2612      esac
     2613      # Quote arguments (to preserve shell metacharacters).
     2614      func_append_quoted args "$file"
     2615    done
     2616
     2617    if test "X$opt_dry_run" = Xfalse; then
     2618      if test -n "$shlibpath_var"; then
     2619        # Export the shlibpath_var.
     2620        eval "export $shlibpath_var"
     2621      fi
     2622
     2623      # Restore saved environment variables
     2624      for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
     2625      do
     2626        eval "if test \"\${save_$lt_var+set}\" = set; then
     2627                $lt_var=\$save_$lt_var; export $lt_var
     2628              else
     2629                $lt_unset $lt_var
     2630              fi"
     2631      done
     2632
     2633      # Now prepare to actually exec the command.
     2634      exec_cmd="\$cmd$args"
     2635    else
     2636      # Display what would be done.
     2637      if test -n "$shlibpath_var"; then
     2638        eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
     2639        echo "export $shlibpath_var"
     2640      fi
     2641      $ECHO "$cmd$args"
     2642      exit $EXIT_SUCCESS
    1752643    fi
    176 
    177     $echo "X$my_tmpdir" | $Xsed
    178 }
    179 
     2644}
     2645
     2646test "$opt_mode" = execute && func_mode_execute ${1+"$@"}
     2647
     2648
     2649# func_mode_finish arg...
     2650func_mode_finish ()
     2651{
     2652    $opt_debug
     2653    libs=
     2654    libdirs=
     2655    admincmds=
     2656
     2657    for opt in "$nonopt" ${1+"$@"}
     2658    do
     2659      if test -d "$opt"; then
     2660        func_append libdirs " $opt"
     2661
     2662      elif test -f "$opt"; then
     2663        if func_lalib_unsafe_p "$opt"; then
     2664          func_append libs " $opt"
     2665        else
     2666          func_warning "\`$opt' is not a valid libtool archive"
     2667        fi
     2668
     2669      else
     2670        func_fatal_error "invalid argument \`$opt'"
     2671      fi
     2672    done
     2673
     2674    if test -n "$libs"; then
     2675      if test -n "$lt_sysroot"; then
     2676        sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
     2677        sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
     2678      else
     2679        sysroot_cmd=
     2680      fi
     2681
     2682      # Remove sysroot references
     2683      if $opt_dry_run; then
     2684        for lib in $libs; do
     2685          echo "removing references to $lt_sysroot and \`=' prefixes from $lib"
     2686        done
     2687      else
     2688        tmpdir=`func_mktempdir`
     2689        for lib in $libs; do
     2690          sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
     2691            > $tmpdir/tmp-la
     2692          mv -f $tmpdir/tmp-la $lib
     2693        done
     2694        ${RM}r "$tmpdir"
     2695      fi
     2696    fi
     2697
     2698    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
     2699      for libdir in $libdirs; do
     2700        if test -n "$finish_cmds"; then
     2701          # Do each command in the finish commands.
     2702          func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
     2703'"$cmd"'"'
     2704        fi
     2705        if test -n "$finish_eval"; then
     2706          # Do the single finish_eval.
     2707          eval cmds=\"$finish_eval\"
     2708          $opt_dry_run || eval "$cmds" || func_append admincmds "
     2709       $cmds"
     2710        fi
     2711      done
     2712    fi
     2713
     2714    # Exit here if they wanted silent mode.
     2715    $opt_silent && exit $EXIT_SUCCESS
     2716
     2717    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
     2718      echo "----------------------------------------------------------------------"
     2719      echo "Libraries have been installed in:"
     2720      for libdir in $libdirs; do
     2721        $ECHO "   $libdir"
     2722      done
     2723      echo
     2724      echo "If you ever happen to want to link against installed libraries"
     2725      echo "in a given directory, LIBDIR, you must either use libtool, and"
     2726      echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
     2727      echo "flag during linking and do at least one of the following:"
     2728      if test -n "$shlibpath_var"; then
     2729        echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
     2730        echo "     during execution"
     2731      fi
     2732      if test -n "$runpath_var"; then
     2733        echo "   - add LIBDIR to the \`$runpath_var' environment variable"
     2734        echo "     during linking"
     2735      fi
     2736      if test -n "$hardcode_libdir_flag_spec"; then
     2737        libdir=LIBDIR
     2738        eval flag=\"$hardcode_libdir_flag_spec\"
     2739
     2740        $ECHO "   - use the \`$flag' linker flag"
     2741      fi
     2742      if test -n "$admincmds"; then
     2743        $ECHO "   - have your system administrator run these commands:$admincmds"
     2744      fi
     2745      if test -f /etc/ld.so.conf; then
     2746        echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
     2747      fi
     2748      echo
     2749
     2750      echo "See any operating system documentation about shared libraries for"
     2751      case $host in
     2752        solaris2.[6789]|solaris2.1[0-9])
     2753          echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
     2754          echo "pages."
     2755          ;;
     2756        *)
     2757          echo "more information, such as the ld(1) and ld.so(8) manual pages."
     2758          ;;
     2759      esac
     2760      echo "----------------------------------------------------------------------"
     2761    fi
     2762    exit $EXIT_SUCCESS
     2763}
     2764
     2765test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
     2766
     2767
     2768# func_mode_install arg...
     2769func_mode_install ()
     2770{
     2771    $opt_debug
     2772    # There may be an optional sh(1) argument at the beginning of
     2773    # install_prog (especially on Windows NT).
     2774    if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
     2775       # Allow the use of GNU shtool's install command.
     2776       case $nonopt in *shtool*) :;; *) false;; esac; then
     2777      # Aesthetically quote it.
     2778      func_quote_for_eval "$nonopt"
     2779      install_prog="$func_quote_for_eval_result "
     2780      arg=$1
     2781      shift
     2782    else
     2783      install_prog=
     2784      arg=$nonopt
     2785    fi
     2786
     2787    # The real first argument should be the name of the installation program.
     2788    # Aesthetically quote it.
     2789    func_quote_for_eval "$arg"
     2790    func_append install_prog "$func_quote_for_eval_result"
     2791    install_shared_prog=$install_prog
     2792    case " $install_prog " in
     2793      *[\\\ /]cp\ *) install_cp=: ;;
     2794      *) install_cp=false ;;
     2795    esac
     2796
     2797    # We need to accept at least all the BSD install flags.
     2798    dest=
     2799    files=
     2800    opts=
     2801    prev=
     2802    install_type=
     2803    isdir=no
     2804    stripme=
     2805    no_mode=:
     2806    for arg
     2807    do
     2808      arg2=
     2809      if test -n "$dest"; then
     2810        func_append files " $dest"
     2811        dest=$arg
     2812        continue
     2813      fi
     2814
     2815      case $arg in
     2816      -d) isdir=yes ;;
     2817      -f)
     2818        if $install_cp; then :; else
     2819          prev=$arg
     2820        fi
     2821        ;;
     2822      -g | -m | -o)
     2823        prev=$arg
     2824        ;;
     2825      -s)
     2826        stripme=" -s"
     2827        continue
     2828        ;;
     2829      -*)
     2830        ;;
     2831      *)
     2832        # If the previous option needed an argument, then skip it.
     2833        if test -n "$prev"; then
     2834          if test "x$prev" = x-m && test -n "$install_override_mode"; then
     2835            arg2=$install_override_mode
     2836            no_mode=false
     2837          fi
     2838          prev=
     2839        else
     2840          dest=$arg
     2841          continue
     2842        fi
     2843        ;;
     2844      esac
     2845
     2846      # Aesthetically quote the argument.
     2847      func_quote_for_eval "$arg"
     2848      func_append install_prog " $func_quote_for_eval_result"
     2849      if test -n "$arg2"; then
     2850        func_quote_for_eval "$arg2"
     2851      fi
     2852      func_append install_shared_prog " $func_quote_for_eval_result"
     2853    done
     2854
     2855    test -z "$install_prog" && \
     2856      func_fatal_help "you must specify an install program"
     2857
     2858    test -n "$prev" && \
     2859      func_fatal_help "the \`$prev' option requires an argument"
     2860
     2861    if test -n "$install_override_mode" && $no_mode; then
     2862      if $install_cp; then :; else
     2863        func_quote_for_eval "$install_override_mode"
     2864        func_append install_shared_prog " -m $func_quote_for_eval_result"
     2865      fi
     2866    fi
     2867
     2868    if test -z "$files"; then
     2869      if test -z "$dest"; then
     2870        func_fatal_help "no file or destination specified"
     2871      else
     2872        func_fatal_help "you must specify a destination"
     2873      fi
     2874    fi
     2875
     2876    # Strip any trailing slash from the destination.
     2877    func_stripname '' '/' "$dest"
     2878    dest=$func_stripname_result
     2879
     2880    # Check to see that the destination is a directory.
     2881    test -d "$dest" && isdir=yes
     2882    if test "$isdir" = yes; then
     2883      destdir="$dest"
     2884      destname=
     2885    else
     2886      func_dirname_and_basename "$dest" "" "."
     2887      destdir="$func_dirname_result"
     2888      destname="$func_basename_result"
     2889
     2890      # Not a directory, so check to see that there is only one file specified.
     2891      set dummy $files; shift
     2892      test "$#" -gt 1 && \
     2893        func_fatal_help "\`$dest' is not a directory"
     2894    fi
     2895    case $destdir in
     2896    [\\/]* | [A-Za-z]:[\\/]*) ;;
     2897    *)
     2898      for file in $files; do
     2899        case $file in
     2900        *.lo) ;;
     2901        *)
     2902          func_fatal_help "\`$destdir' must be an absolute directory name"
     2903          ;;
     2904        esac
     2905      done
     2906      ;;
     2907    esac
     2908
     2909    # This variable tells wrapper scripts just to set variables rather
     2910    # than running their programs.
     2911    libtool_install_magic="$magic"
     2912
     2913    staticlibs=
     2914    future_libdirs=
     2915    current_libdirs=
     2916    for file in $files; do
     2917
     2918      # Do each installation.
     2919      case $file in
     2920      *.$libext)
     2921        # Do the static libraries later.
     2922        func_append staticlibs " $file"
     2923        ;;
     2924
     2925      *.la)
     2926        func_resolve_sysroot "$file"
     2927        file=$func_resolve_sysroot_result
     2928
     2929        # Check to see that this really is a libtool archive.
     2930        func_lalib_unsafe_p "$file" \
     2931          || func_fatal_help "\`$file' is not a valid libtool archive"
     2932
     2933        library_names=
     2934        old_library=
     2935        relink_command=
     2936        func_source "$file"
     2937
     2938        # Add the libdir to current_libdirs if it is the destination.
     2939        if test "X$destdir" = "X$libdir"; then
     2940          case "$current_libdirs " in
     2941          *" $libdir "*) ;;
     2942          *) func_append current_libdirs " $libdir" ;;
     2943          esac
     2944        else
     2945          # Note the libdir as a future libdir.
     2946          case "$future_libdirs " in
     2947          *" $libdir "*) ;;
     2948          *) func_append future_libdirs " $libdir" ;;
     2949          esac
     2950        fi
     2951
     2952        func_dirname "$file" "/" ""
     2953        dir="$func_dirname_result"
     2954        func_append dir "$objdir"
     2955
     2956        if test -n "$relink_command"; then
     2957          # Determine the prefix the user has applied to our future dir.
     2958          inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
     2959
     2960          # Don't allow the user to place us outside of our expected
     2961          # location b/c this prevents finding dependent libraries that
     2962          # are installed to the same prefix.
     2963          # At present, this check doesn't affect windows .dll's that
     2964          # are installed into $libdir/../bin (currently, that works fine)
     2965          # but it's something to keep an eye on.
     2966          test "$inst_prefix_dir" = "$destdir" && \
     2967            func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
     2968
     2969          if test -n "$inst_prefix_dir"; then
     2970            # Stick the inst_prefix_dir data into the link command.
     2971            relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
     2972          else
     2973            relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
     2974          fi
     2975
     2976          func_warning "relinking \`$file'"
     2977          func_show_eval "$relink_command" \
     2978            'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
     2979        fi
     2980
     2981        # See the names of the shared library.
     2982        set dummy $library_names; shift
     2983        if test -n "$1"; then
     2984          realname="$1"
     2985          shift
     2986
     2987          srcname="$realname"
     2988          test -n "$relink_command" && srcname="$realname"T
     2989
     2990          # Install the shared library and build the symlinks.
     2991          func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
     2992              'exit $?'
     2993          tstripme="$stripme"
     2994          case $host_os in
     2995          cygwin* | mingw* | pw32* | cegcc*)
     2996            case $realname in
     2997            *.dll.a)
     2998              tstripme=""
     2999              ;;
     3000            esac
     3001            ;;
     3002          esac
     3003          if test -n "$tstripme" && test -n "$striplib"; then
     3004            func_show_eval "$striplib $destdir/$realname" 'exit $?'
     3005          fi
     3006
     3007          if test "$#" -gt 0; then
     3008            # Delete the old symlinks, and create new ones.
     3009            # Try `ln -sf' first, because the `ln' binary might depend on
     3010            # the symlink we replace!  Solaris /bin/ln does not understand -f,
     3011            # so we also need to try rm && ln -s.
     3012            for linkname
     3013            do
     3014              test "$linkname" != "$realname" \
     3015                && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
     3016            done
     3017          fi
     3018
     3019          # Do each command in the postinstall commands.
     3020          lib="$destdir/$realname"
     3021          func_execute_cmds "$postinstall_cmds" 'exit $?'
     3022        fi
     3023
     3024        # Install the pseudo-library for information purposes.
     3025        func_basename "$file"
     3026        name="$func_basename_result"
     3027        instname="$dir/$name"i
     3028        func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
     3029
     3030        # Maybe install the static library, too.
     3031        test -n "$old_library" && func_append staticlibs " $dir/$old_library"
     3032        ;;
     3033
     3034      *.lo)
     3035        # Install (i.e. copy) a libtool object.
     3036
     3037        # Figure out destination file name, if it wasn't already specified.
     3038        if test -n "$destname"; then
     3039          destfile="$destdir/$destname"
     3040        else
     3041          func_basename "$file"
     3042          destfile="$func_basename_result"
     3043          destfile="$destdir/$destfile"
     3044        fi
     3045
     3046        # Deduce the name of the destination old-style object file.
     3047        case $destfile in
     3048        *.lo)
     3049          func_lo2o "$destfile"
     3050          staticdest=$func_lo2o_result
     3051          ;;
     3052        *.$objext)
     3053          staticdest="$destfile"
     3054          destfile=
     3055          ;;
     3056        *)
     3057          func_fatal_help "cannot copy a libtool object to \`$destfile'"
     3058          ;;
     3059        esac
     3060
     3061        # Install the libtool object if requested.
     3062        test -n "$destfile" && \
     3063          func_show_eval "$install_prog $file $destfile" 'exit $?'
     3064
     3065        # Install the old object if enabled.
     3066        if test "$build_old_libs" = yes; then
     3067          # Deduce the name of the old-style object file.
     3068          func_lo2o "$file"
     3069          staticobj=$func_lo2o_result
     3070          func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
     3071        fi
     3072        exit $EXIT_SUCCESS
     3073        ;;
     3074
     3075      *)
     3076        # Figure out destination file name, if it wasn't already specified.
     3077        if test -n "$destname"; then
     3078          destfile="$destdir/$destname"
     3079        else
     3080          func_basename "$file"
     3081          destfile="$func_basename_result"
     3082          destfile="$destdir/$destfile"
     3083        fi
     3084
     3085        # If the file is missing, and there is a .exe on the end, strip it
     3086        # because it is most likely a libtool script we actually want to
     3087        # install
     3088        stripped_ext=""
     3089        case $file in
     3090          *.exe)
     3091            if test ! -f "$file"; then
     3092              func_stripname '' '.exe' "$file"
     3093              file=$func_stripname_result
     3094              stripped_ext=".exe"
     3095            fi
     3096            ;;
     3097        esac
     3098
     3099        # Do a test to see if this is really a libtool program.
     3100        case $host in
     3101        *cygwin* | *mingw*)
     3102            if func_ltwrapper_executable_p "$file"; then
     3103              func_ltwrapper_scriptname "$file"
     3104              wrapper=$func_ltwrapper_scriptname_result
     3105            else
     3106              func_stripname '' '.exe' "$file"
     3107              wrapper=$func_stripname_result
     3108            fi
     3109            ;;
     3110        *)
     3111            wrapper=$file
     3112            ;;
     3113        esac
     3114        if func_ltwrapper_script_p "$wrapper"; then
     3115          notinst_deplibs=
     3116          relink_command=
     3117
     3118          func_source "$wrapper"
     3119
     3120          # Check the variables that should have been set.
     3121          test -z "$generated_by_libtool_version" && \
     3122            func_fatal_error "invalid libtool wrapper script \`$wrapper'"
     3123
     3124          finalize=yes
     3125          for lib in $notinst_deplibs; do
     3126            # Check to see that each library is installed.
     3127            libdir=
     3128            if test -f "$lib"; then
     3129              func_source "$lib"
     3130            fi
     3131            libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
     3132            if test -n "$libdir" && test ! -f "$libfile"; then
     3133              func_warning "\`$lib' has not been installed in \`$libdir'"
     3134              finalize=no
     3135            fi
     3136          done
     3137
     3138          relink_command=
     3139          func_source "$wrapper"
     3140
     3141          outputname=
     3142          if test "$fast_install" = no && test -n "$relink_command"; then
     3143            $opt_dry_run || {
     3144              if test "$finalize" = yes; then
     3145                tmpdir=`func_mktempdir`
     3146                func_basename "$file$stripped_ext"
     3147                file="$func_basename_result"
     3148                outputname="$tmpdir/$file"
     3149                # Replace the output file specification.
     3150                relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
     3151
     3152                $opt_silent || {
     3153                  func_quote_for_expand "$relink_command"
     3154                  eval "func_echo $func_quote_for_expand_result"
     3155                }
     3156                if eval "$relink_command"; then :
     3157                  else
     3158                  func_error "error: relink \`$file' with the above command before installing it"
     3159                  $opt_dry_run || ${RM}r "$tmpdir"
     3160                  continue
     3161                fi
     3162                file="$outputname"
     3163              else
     3164                func_warning "cannot relink \`$file'"
     3165              fi
     3166            }
     3167          else
     3168            # Install the binary that we compiled earlier.
     3169            file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
     3170          fi
     3171        fi
     3172
     3173        # remove .exe since cygwin /usr/bin/install will append another
     3174        # one anyway
     3175        case $install_prog,$host in
     3176        */usr/bin/install*,*cygwin*)
     3177          case $file:$destfile in
     3178          *.exe:*.exe)
     3179            # this is ok
     3180            ;;
     3181          *.exe:*)
     3182            destfile=$destfile.exe
     3183            ;;
     3184          *:*.exe)
     3185            func_stripname '' '.exe' "$destfile"
     3186            destfile=$func_stripname_result
     3187            ;;
     3188          esac
     3189          ;;
     3190        esac
     3191        func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
     3192        $opt_dry_run || if test -n "$outputname"; then
     3193          ${RM}r "$tmpdir"
     3194        fi
     3195        ;;
     3196      esac
     3197    done
     3198
     3199    for file in $staticlibs; do
     3200      func_basename "$file"
     3201      name="$func_basename_result"
     3202
     3203      # Set up the ranlib parameters.
     3204      oldlib="$destdir/$name"
     3205      func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
     3206      tool_oldlib=$func_to_tool_file_result
     3207
     3208      func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
     3209
     3210      if test -n "$stripme" && test -n "$old_striplib"; then
     3211        func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
     3212      fi
     3213
     3214      # Do each command in the postinstall commands.
     3215      func_execute_cmds "$old_postinstall_cmds" 'exit $?'
     3216    done
     3217
     3218    test -n "$future_libdirs" && \
     3219      func_warning "remember to run \`$progname --finish$future_libdirs'"
     3220
     3221    if test -n "$current_libdirs"; then
     3222      # Maybe just do a dry run.
     3223      $opt_dry_run && current_libdirs=" -n$current_libdirs"
     3224      exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
     3225    else
     3226      exit $EXIT_SUCCESS
     3227    fi
     3228}
     3229
     3230test "$opt_mode" = install && func_mode_install ${1+"$@"}
     3231
     3232
     3233# func_generate_dlsyms outputname originator pic_p
     3234# Extract symbols from dlprefiles and create ${outputname}S.o with
     3235# a dlpreopen symbol table.
     3236func_generate_dlsyms ()
     3237{
     3238    $opt_debug
     3239    my_outputname="$1"
     3240    my_originator="$2"
     3241    my_pic_p="${3-no}"
     3242    my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
     3243    my_dlsyms=
     3244
     3245    if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
     3246      if test -n "$NM" && test -n "$global_symbol_pipe"; then
     3247        my_dlsyms="${my_outputname}S.c"
     3248      else
     3249        func_error "not configured to extract global symbols from dlpreopened files"
     3250      fi
     3251    fi
     3252
     3253    if test -n "$my_dlsyms"; then
     3254      case $my_dlsyms in
     3255      "") ;;
     3256      *.c)
     3257        # Discover the nlist of each of the dlfiles.
     3258        nlist="$output_objdir/${my_outputname}.nm"
     3259
     3260        func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
     3261
     3262        # Parse the name list into a source file.
     3263        func_verbose "creating $output_objdir/$my_dlsyms"
     3264
     3265        $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
     3266/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
     3267/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
     3268
     3269#ifdef __cplusplus
     3270extern \"C\" {
     3271#endif
     3272
     3273#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
     3274#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
     3275#endif
     3276
     3277/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
     3278#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
     3279/* DATA imports from DLLs on WIN32 con't be const, because runtime
     3280   relocations are performed -- see ld's documentation on pseudo-relocs.  */
     3281# define LT_DLSYM_CONST
     3282#elif defined(__osf__)
     3283/* This system does not cope well with relocations in const data.  */
     3284# define LT_DLSYM_CONST
     3285#else
     3286# define LT_DLSYM_CONST const
     3287#endif
     3288
     3289/* External symbol declarations for the compiler. */\
     3290"
     3291
     3292        if test "$dlself" = yes; then
     3293          func_verbose "generating symbol list for \`$output'"
     3294
     3295          $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
     3296
     3297          # Add our own program objects to the symbol list.
     3298          progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
     3299          for progfile in $progfiles; do
     3300            func_to_tool_file "$progfile" func_convert_file_msys_to_w32
     3301            func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"
     3302            $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
     3303          done
     3304
     3305          if test -n "$exclude_expsyms"; then
     3306            $opt_dry_run || {
     3307              eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
     3308              eval '$MV "$nlist"T "$nlist"'
     3309            }
     3310          fi
     3311
     3312          if test -n "$export_symbols_regex"; then
     3313            $opt_dry_run || {
     3314              eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
     3315              eval '$MV "$nlist"T "$nlist"'
     3316            }
     3317          fi
     3318
     3319          # Prepare the list of exported symbols
     3320          if test -z "$export_symbols"; then
     3321            export_symbols="$output_objdir/$outputname.exp"
     3322            $opt_dry_run || {
     3323              $RM $export_symbols
     3324              eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
     3325              case $host in
     3326              *cygwin* | *mingw* | *cegcc* )
     3327                eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
     3328                eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
     3329                ;;
     3330              esac
     3331            }
     3332          else
     3333            $opt_dry_run || {
     3334              eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
     3335              eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
     3336              eval '$MV "$nlist"T "$nlist"'
     3337              case $host in
     3338                *cygwin* | *mingw* | *cegcc* )
     3339                  eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
     3340                  eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
     3341                  ;;
     3342              esac
     3343            }
     3344          fi
     3345        fi
     3346
     3347        for dlprefile in $dlprefiles; do
     3348          func_verbose "extracting global C symbols from \`$dlprefile'"
     3349          func_basename "$dlprefile"
     3350          name="$func_basename_result"
     3351          case $host in
     3352            *cygwin* | *mingw* | *cegcc* )
     3353              # if an import library, we need to obtain dlname
     3354              if func_win32_import_lib_p "$dlprefile"; then
     3355                func_tr_sh "$dlprefile"
     3356                eval "curr_lafile=\$libfile_$func_tr_sh_result"
     3357                dlprefile_dlbasename=""
     3358                if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
     3359                  # Use subshell, to avoid clobbering current variable values
     3360                  dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
     3361                  if test -n "$dlprefile_dlname" ; then
     3362                    func_basename "$dlprefile_dlname"
     3363                    dlprefile_dlbasename="$func_basename_result"
     3364                  else
     3365                    # no lafile. user explicitly requested -dlpreopen <import library>.
     3366                    $sharedlib_from_linklib_cmd "$dlprefile"
     3367                    dlprefile_dlbasename=$sharedlib_from_linklib_result
     3368                  fi
     3369                fi
     3370                $opt_dry_run || {
     3371                  if test -n "$dlprefile_dlbasename" ; then
     3372                    eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
     3373                  else
     3374                    func_warning "Could not compute DLL name from $name"
     3375                    eval '$ECHO ": $name " >> "$nlist"'
     3376                  fi
     3377                  func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
     3378                  eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
     3379                    $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
     3380                }
     3381              else # not an import lib
     3382                $opt_dry_run || {
     3383                  eval '$ECHO ": $name " >> "$nlist"'
     3384                  func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
     3385                  eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
     3386                }
     3387              fi
     3388            ;;
     3389            *)
     3390              $opt_dry_run || {
     3391                eval '$ECHO ": $name " >> "$nlist"'
     3392                func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
     3393                eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
     3394              }
     3395            ;;
     3396          esac
     3397        done
     3398
     3399        $opt_dry_run || {
     3400          # Make sure we have at least an empty file.
     3401          test -f "$nlist" || : > "$nlist"
     3402
     3403          if test -n "$exclude_expsyms"; then
     3404            $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
     3405            $MV "$nlist"T "$nlist"
     3406          fi
     3407
     3408          # Try sorting and uniquifying the output.
     3409          if $GREP -v "^: " < "$nlist" |
     3410              if sort -k 3 </dev/null >/dev/null 2>&1; then
     3411                sort -k 3
     3412              else
     3413                sort +2
     3414              fi |
     3415              uniq > "$nlist"S; then
     3416            :
     3417          else
     3418            $GREP -v "^: " < "$nlist" > "$nlist"S
     3419          fi
     3420
     3421          if test -f "$nlist"S; then
     3422            eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
     3423          else
     3424            echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
     3425          fi
     3426
     3427          echo >> "$output_objdir/$my_dlsyms" "\
     3428
     3429/* The mapping between symbol names and symbols.  */
     3430typedef struct {
     3431  const char *name;
     3432  void *address;
     3433} lt_dlsymlist;
     3434extern LT_DLSYM_CONST lt_dlsymlist
     3435lt_${my_prefix}_LTX_preloaded_symbols[];
     3436LT_DLSYM_CONST lt_dlsymlist
     3437lt_${my_prefix}_LTX_preloaded_symbols[] =
     3438{\
     3439  { \"$my_originator\", (void *) 0 },"
     3440
     3441          case $need_lib_prefix in
     3442          no)
     3443            eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
     3444            ;;
     3445          *)
     3446            eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
     3447            ;;
     3448          esac
     3449          echo >> "$output_objdir/$my_dlsyms" "\
     3450  {0, (void *) 0}
     3451};
     3452
     3453/* This works around a problem in FreeBSD linker */
     3454#ifdef FREEBSD_WORKAROUND
     3455static const void *lt_preloaded_setup() {
     3456  return lt_${my_prefix}_LTX_preloaded_symbols;
     3457}
     3458#endif
     3459
     3460#ifdef __cplusplus
     3461}
     3462#endif\
     3463"
     3464        } # !$opt_dry_run
     3465
     3466        pic_flag_for_symtable=
     3467        case "$compile_command " in
     3468        *" -static "*) ;;
     3469        *)
     3470          case $host in
     3471          # compiling the symbol table file with pic_flag works around
     3472          # a FreeBSD bug that causes programs to crash when -lm is
     3473          # linked before any other PIC object.  But we must not use
     3474          # pic_flag when linking with -static.  The problem exists in
     3475          # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
     3476          *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
     3477            pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
     3478          *-*-hpux*)
     3479            pic_flag_for_symtable=" $pic_flag"  ;;
     3480          *)
     3481            if test "X$my_pic_p" != Xno; then
     3482              pic_flag_for_symtable=" $pic_flag"
     3483            fi
     3484            ;;
     3485          esac
     3486          ;;
     3487        esac
     3488        symtab_cflags=
     3489        for arg in $LTCFLAGS; do
     3490          case $arg in
     3491          -pie | -fpie | -fPIE) ;;
     3492          *) func_append symtab_cflags " $arg" ;;
     3493          esac
     3494        done
     3495
     3496        # Now compile the dynamic symbol file.
     3497        func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
     3498
     3499        # Clean up the generated files.
     3500        func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
     3501
     3502        # Transform the symbol file into the correct name.
     3503        symfileobj="$output_objdir/${my_outputname}S.$objext"
     3504        case $host in
     3505        *cygwin* | *mingw* | *cegcc* )
     3506          if test -f "$output_objdir/$my_outputname.def"; then
     3507            compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
     3508            finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
     3509          else
     3510            compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
     3511            finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
     3512          fi
     3513          ;;
     3514        *)
     3515          compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
     3516          finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
     3517          ;;
     3518        esac
     3519        ;;
     3520      *)
     3521        func_fatal_error "unknown suffix for \`$my_dlsyms'"
     3522        ;;
     3523      esac
     3524    else
     3525      # We keep going just in case the user didn't refer to
     3526      # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
     3527      # really was required.
     3528
     3529      # Nullify the symbol file.
     3530      compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
     3531      finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
     3532    fi
     3533}
    1803534
    1813535# func_win32_libid arg
     
    1853539# Has to be a shell function in order to 'eat' the argument
    1863540# that is supplied when $file_magic_command is called.
     3541# Despite the name, also deal with 64 bit binaries.
    1873542func_win32_libid ()
    1883543{
     3544  $opt_debug
    1893545  win32_libid_type="unknown"
    1903546  win32_fileres=`file -L $1 2>/dev/null`
     
    1943550    ;;
    1953551  *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;};}'`
     3552    # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
     3553    if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
     3554       $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
     3555      func_to_tool_file "$1" func_convert_file_msys_to_w32
     3556      win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
     3557        $SED -n -e '
     3558            1,100{
     3559                / I /{
     3560                    s,.*,import,
     3561                    p
     3562                    q
     3563                }
     3564            }'`
    2003565      case $win32_nmres in
    2013566      import*)  win32_libid_type="x86 archive import";;
     
    2153580    ;;
    2163581  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
     3582  $ECHO "$win32_libid_type"
     3583}
     3584
     3585# func_cygming_dll_for_implib ARG
     3586#
     3587# Platform-specific function to extract the
     3588# name of the DLL associated with the specified
     3589# import library ARG.
     3590# Invoked by eval'ing the libtool variable
     3591#    $sharedlib_from_linklib_cmd
     3592# Result is available in the variable
     3593#    $sharedlib_from_linklib_result
     3594func_cygming_dll_for_implib ()
     3595{
     3596  $opt_debug
     3597  sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
     3598}
     3599
     3600# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
     3601#
     3602# The is the core of a fallback implementation of a
     3603# platform-specific function to extract the name of the
     3604# DLL associated with the specified import library LIBNAME.
     3605#
     3606# SECTION_NAME is either .idata$6 or .idata$7, depending
     3607# on the platform and compiler that created the implib.
     3608#
     3609# Echos the name of the DLL associated with the
     3610# specified import library.
     3611func_cygming_dll_for_implib_fallback_core ()
     3612{
     3613  $opt_debug
     3614  match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
     3615  $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
     3616    $SED '/^Contents of section '"$match_literal"':/{
     3617      # Place marker at beginning of archive member dllname section
     3618      s/.*/====MARK====/
     3619      p
     3620      d
     3621    }
     3622    # These lines can sometimes be longer than 43 characters, but
     3623    # are always uninteresting
     3624    /:[  ]*file format pe[i]\{,1\}-/d
     3625    /^In archive [^:]*:/d
     3626    # Ensure marker is printed
     3627    /^====MARK====/p
     3628    # Remove all lines with less than 43 characters
     3629    /^.\{43\}/!d
     3630    # From remaining lines, remove first 43 characters
     3631    s/^.\{43\}//' |
     3632    $SED -n '
     3633      # Join marker and all lines until next marker into a single line
     3634      /^====MARK====/ b para
     3635      H
     3636      $ b para
     3637      b
     3638      :para
     3639      x
     3640      s/\n//g
     3641      # Remove the marker
     3642      s/^====MARK====//
     3643      # Remove trailing dots and whitespace
     3644      s/[\. \t]*$//
     3645      # Print
     3646      /./p' |
     3647    # we now have a list, one entry per line, of the stringified
     3648    # contents of the appropriate section of all members of the
     3649    # archive which possess that section. Heuristic: eliminate
     3650    # all those which have a first or second character that is
     3651    # a '.' (that is, objdump's representation of an unprintable
     3652    # character.) This should work for all archives with less than
     3653    # 0x302f exports -- but will fail for DLLs whose name actually
     3654    # begins with a literal '.' or a single character followed by
     3655    # a '.'.
     3656    #
     3657    # Of those that remain, print the first one.
     3658    $SED -e '/^\./d;/^.\./d;q'
     3659}
     3660
     3661# func_cygming_gnu_implib_p ARG
     3662# This predicate returns with zero status (TRUE) if
     3663# ARG is a GNU/binutils-style import library. Returns
     3664# with nonzero status (FALSE) otherwise.
     3665func_cygming_gnu_implib_p ()
     3666{
     3667  $opt_debug
     3668  func_to_tool_file "$1" func_convert_file_msys_to_w32
     3669  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)$'`
     3670  test -n "$func_cygming_gnu_implib_tmp"
     3671}
     3672
     3673# func_cygming_ms_implib_p ARG
     3674# This predicate returns with zero status (TRUE) if
     3675# ARG is an MS-style import library. Returns
     3676# with nonzero status (FALSE) otherwise.
     3677func_cygming_ms_implib_p ()
     3678{
     3679  $opt_debug
     3680  func_to_tool_file "$1" func_convert_file_msys_to_w32
     3681  func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
     3682  test -n "$func_cygming_ms_implib_tmp"
     3683}
     3684
     3685# func_cygming_dll_for_implib_fallback ARG
     3686# Platform-specific function to extract the
     3687# name of the DLL associated with the specified
     3688# import library ARG.
     3689#
     3690# This fallback implementation is for use when $DLLTOOL
     3691# does not support the --identify-strict option.
     3692# Invoked by eval'ing the libtool variable
     3693#    $sharedlib_from_linklib_cmd
     3694# Result is available in the variable
     3695#    $sharedlib_from_linklib_result
     3696func_cygming_dll_for_implib_fallback ()
     3697{
     3698  $opt_debug
     3699  if func_cygming_gnu_implib_p "$1" ; then
     3700    # binutils import library
     3701    sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
     3702  elif func_cygming_ms_implib_p "$1" ; then
     3703    # ms-generated import library
     3704    sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
     3705  else
     3706    # unknown
     3707    sharedlib_from_linklib_result=""
     3708  fi
    2843709}
    2853710
     
    2883713func_extract_an_archive ()
    2893714{
     3715    $opt_debug
    2903716    f_ex_an_ar_dir="$1"; shift
    2913717    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 $?
     3718    if test "$lock_old_archive_extraction" = yes; then
     3719      lockfile=$f_ex_an_ar_oldlib.lock
     3720      until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
     3721        func_echo "Waiting for $lockfile to be removed"
     3722        sleep 2
     3723      done
     3724    fi
     3725    func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
     3726                   'stat=$?; rm -f "$lockfile"; exit $stat'
     3727    if test "$lock_old_archive_extraction" = yes; then
     3728      $opt_dry_run || rm -f "$lockfile"
     3729    fi
    2953730    if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
    2963731     :
    2973732    else
    298       $echo "$modename: ERROR: object name conflicts: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" 1>&2
    299       exit $EXIT_FAILURE
     3733      func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
    3003734    fi
    3013735}
     3736
    3023737
    3033738# func_extract_archives gentop oldlib ...
    3043739func_extract_archives ()
    3053740{
     3741    $opt_debug
    3063742    my_gentop="$1"; shift
    3073743    my_oldlibs=${1+"$@"}
     
    3103746    my_xabs=""
    3113747    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
    3223748
    3233749    for my_xlib in $my_oldlibs; do
     
    3273753        *) my_xabs=`pwd`"/$my_xlib" ;;
    3283754      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
     3755      func_basename "$my_xlib"
     3756      my_xlib="$func_basename_result"
     3757      my_xlib_u=$my_xlib
     3758      while :; do
     3759        case " $extracted_archives " in
     3760        *" $my_xlib_u "*)
     3761          func_arith $extracted_serial + 1
     3762          extracted_serial=$func_arith_result
     3763          my_xlib_u=lt$extracted_serial-$my_xlib ;;
     3764        *) break ;;
     3765        esac
     3766      done
     3767      extracted_archives="$extracted_archives $my_xlib_u"
     3768      my_xdir="$my_gentop/$my_xlib_u"
     3769
     3770      func_mkdir_p "$my_xdir"
     3771
    3403772      case $host in
    3413773      *-darwin*)
    342         $show "Extracting $my_xabs"
     3774        func_verbose "Extracting $my_xabs"
    3433775        # Do not bother doing anything if just a dry run
    344         if test -z "$run"; then
     3776        $opt_dry_run || {
    3453777          darwin_orig_dir=`pwd`
    3463778          cd $my_xdir || exit $?
    3473779          darwin_archive=$my_xabs
    3483780          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://'`
     3781          darwin_base_archive=`basename "$darwin_archive"`
     3782          darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
     3783          if test -n "$darwin_arches"; then
     3784            darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
    3533785            darwin_arch=
    354             $show "$darwin_base_archive has multiple architectures $darwin_arches"
     3786            func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
    3553787            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}"
     3788              func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
     3789              $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
    3583790              cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
    3593791              func_extract_an_archive "`pwd`" "${darwin_base_archive}"
    3603792              cd "$darwin_curdir"
    361               $rm "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
     3793              $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
    3623794            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`
     3795            ## Okay now we've a bunch of thin objects, gotta fatten them up :)
     3796            darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
    3653797            darwin_file=
    3663798            darwin_files=
    3673799            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
     3800              darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
     3801              $LIPO -create -output "$darwin_file" $darwin_files
    3703802            done # $darwin_filelist
    371             ${rm}r unfat-$$
     3803            $RM -rf unfat-$$
    3723804            cd "$darwin_orig_dir"
    3733805          else
    374             cd "$darwin_orig_dir"
    375             func_extract_an_archive "$my_xdir" "$my_xabs"
     3806            cd $darwin_orig_dir
     3807            func_extract_an_archive "$my_xdir" "$my_xabs"
    3763808          fi # $darwin_arches
    377         fi # $run
     3809        } # !$opt_dry_run
    3783810        ;;
    3793811      *)
    3803812        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
    4213813        ;;
    4223814      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`"
    434         else
    435           $echo "$progname: ignoring unknown tag $tagname" 1>&2
    436         fi
    437         ;;
    438       esac
     3815      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
     3816    done
     3817
     3818    func_extract_archives_result="$my_oldobjs"
     3819}
     3820
     3821
     3822# func_emit_wrapper [arg=no]
     3823#
     3824# Emit a libtool wrapper script on stdout.
     3825# Don't directly open a file because we may want to
     3826# incorporate the script contents within a cygwin/mingw
     3827# wrapper executable.  Must ONLY be called from within
     3828# func_mode_link because it depends on a number of variables
     3829# set therein.
     3830#
     3831# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
     3832# variable will take.  If 'yes', then the emitted script
     3833# will assume that the directory in which it is stored is
     3834# the $objdir directory.  This is a cygwin/mingw-specific
     3835# behavior.
     3836func_emit_wrapper ()
     3837{
     3838        func_emit_wrapper_arg1=${1-no}
     3839
     3840        $ECHO "\
     3841#! $SHELL
     3842
     3843# $output - temporary wrapper script for $objdir/$outputname
     3844# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
     3845#
     3846# The $output program cannot be directly executed until all the libtool
     3847# libraries that it depends on are installed.
     3848#
     3849# This wrapper script should never be moved out of the build directory.
     3850# If it is, it will not operate correctly.
     3851
     3852# Sed substitution that helps us do robust quoting.  It backslashifies
     3853# metacharacters that are still active within double-quoted strings.
     3854sed_quote_subst='$sed_quote_subst'
     3855
     3856# Be Bourne compatible
     3857if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
     3858  emulate sh
     3859  NULLCMD=:
     3860  # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
     3861  # is contrary to our usage.  Disable this feature.
     3862  alias -g '\${1+\"\$@\"}'='\"\$@\"'
     3863  setopt NO_GLOB_SUBST
     3864else
     3865  case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
     3866fi
     3867BIN_SH=xpg4; export BIN_SH # for Tru64
     3868DUALCASE=1; export DUALCASE # for MKS sh
     3869
     3870# The HP-UX ksh and POSIX shell print the target directory to stdout
     3871# if CDPATH is set.
     3872(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
     3873
     3874relink_command=\"$relink_command\"
     3875
     3876# This environment variable determines our operation mode.
     3877if test \"\$libtool_install_magic\" = \"$magic\"; then
     3878  # install mode needs the following variables:
     3879  generated_by_libtool_version='$macro_version'
     3880  notinst_deplibs='$notinst_deplibs'
     3881else
     3882  # When we are sourced in execute mode, \$file and \$ECHO are already set.
     3883  if test \"\$libtool_execute_magic\" != \"$magic\"; then
     3884    file=\"\$0\""
     3885
     3886    qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
     3887    $ECHO "\
     3888
     3889# A function that is used when there is no print builtin or printf.
     3890func_fallback_echo ()
     3891{
     3892  eval 'cat <<_LTECHO_EOF
     3893\$1
     3894_LTECHO_EOF'
     3895}
     3896    ECHO=\"$qECHO\"
     3897  fi
     3898
     3899# Very basic option parsing. These options are (a) specific to
     3900# the libtool wrapper, (b) are identical between the wrapper
     3901# /script/ and the wrapper /executable/ which is used only on
     3902# windows platforms, and (c) all begin with the string "--lt-"
     3903# (application programs are unlikely to have options which match
     3904# this pattern).
     3905#
     3906# There are only two supported options: --lt-debug and
     3907# --lt-dump-script. There is, deliberately, no --lt-help.
     3908#
     3909# The first argument to this parsing function should be the
     3910# script's $0 value, followed by "$@".
     3911lt_option_debug=
     3912func_parse_lt_options ()
     3913{
     3914  lt_script_arg0=\$0
     3915  shift
     3916  for lt_opt
     3917  do
     3918    case \"\$lt_opt\" in
     3919    --lt-debug) lt_option_debug=1 ;;
     3920    --lt-dump-script)
     3921        lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
     3922        test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
     3923        lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
     3924        cat \"\$lt_dump_D/\$lt_dump_F\"
     3925        exit 0
    4393926      ;;
    440     *)
    441       eval "$prev=\$arg"
     3927    --lt-*)
     3928        \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
     3929        exit 1
    4423930      ;;
    4433931    esac
    444 
    445     prev=
    446     prevopt=
    447     continue
     3932  done
     3933
     3934  # Print the debug banner immediately:
     3935  if test -n \"\$lt_option_debug\"; then
     3936    echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
    4483937  fi
    449 
    450   # Have we seen a non-optional argument yet?
    451   case $arg in
    452   --help)
    453     show_help=yes
     3938}
     3939
     3940# Used when --lt-debug. Prints its arguments to stdout
     3941# (redirection is the responsibility of the caller)
     3942func_lt_dump_args ()
     3943{
     3944  lt_dump_args_N=1;
     3945  for lt_arg
     3946  do
     3947    \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
     3948    lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
     3949  done
     3950}
     3951
     3952# Core function for launching the target application
     3953func_exec_program_core ()
     3954{
     3955"
     3956  case $host in
     3957  # Backslashes separate directories on plain windows
     3958  *-*-mingw | *-*-os2* | *-cegcc*)
     3959    $ECHO "\
     3960      if test -n \"\$lt_option_debug\"; then
     3961        \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
     3962        func_lt_dump_args \${1+\"\$@\"} 1>&2
     3963      fi
     3964      exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
     3965"
    4543966    ;;
    4553967
    456   --version)
    457     $echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
    458     $echo
    459     $echo "Copyright (C) 2005  Free Software Foundation, Inc."
    460     $echo "This is free software; see the source for copying conditions.  There is NO"
    461     $echo "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
    462     exit $?
    463     ;;
    464 
    465   --config)
    466     ${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $progpath
    467     # Now print the configurations for the tags.
    468     for tagname in $taglist; do
    469       ${SED} -n -e "/^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^# ### END LIBTOOL TAG CONFIG: $tagname$/p" < "$progpath"
    470     done
    471     exit $?
    472     ;;
    473 
    474   --debug)
    475     $echo "$progname: enabling shell trace mode"
    476     set -x
    477     preserve_args="$preserve_args $arg"
    478     ;;
    479 
    480   --dry-run | -n)
    481     run=:
    482     ;;
    483 
    484   --features)
    485     $echo "host: $host"
    486     if test "$build_libtool_libs" = yes; then
    487       $echo "enable shared libraries"
    488     else
    489       $echo "disable shared libraries"
    490     fi
    491     if test "$build_old_libs" = yes; then
    492       $echo "enable static libraries"
    493     else
    494       $echo "disable static libraries"
    495     fi
    496     exit $?
    497     ;;
    498 
    499   --finish) mode="finish" ;;
    500 
    501   --mode) prevopt="--mode" prev=mode ;;
    502   --mode=*) mode="$optarg" ;;
    503 
    504   --preserve-dup-deps) duplicate_deps="yes" ;;
    505 
    506   --quiet | --silent)
    507     show=:
    508     preserve_args="$preserve_args $arg"
    509     ;;
    510 
    511   --tag)
    512     prevopt="--tag"
    513     prev=tag
    514     preserve_args="$preserve_args --tag"
    515     ;;
    516   --tag=*)
    517     set tag "$optarg" ${1+"$@"}
    518     shift
    519     prev=tag
    520     preserve_args="$preserve_args --tag"
    521     ;;
    522 
    523   -dlopen)
    524     prevopt="-dlopen"
    525     prev=execute_dlfiles
    526     ;;
    527 
    528   -*)
    529     $echo "$modename: unrecognized option \`$arg'" 1>&2
    530     $echo "$help" 1>&2
    531     exit $EXIT_FAILURE
    532     ;;
    533 
    5343968  *)
    535     nonopt="$arg"
    536     break
     3969    $ECHO "\
     3970      if test -n \"\$lt_option_debug\"; then
     3971        \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
     3972        func_lt_dump_args \${1+\"\$@\"} 1>&2
     3973      fi
     3974      exec \"\$progdir/\$program\" \${1+\"\$@\"}
     3975"
    5373976    ;;
    5383977  esac
    539 done
    540 
    541 if test -n "$prevopt"; then
    542   $echo "$modename: option \`$prevopt' requires an argument" 1>&2
    543   $echo "$help" 1>&2
    544   exit $EXIT_FAILURE
    545 fi
    546 
    547 case $disable_libs in
    548 no)
    549   ;;
    550 shared)
    551   build_libtool_libs=no
    552   build_old_libs=yes
    553   ;;
    554 static)
    555   build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
    556   ;;
    557 esac
    558 
    559 # If this variable is set in any of the actions, the command in it
    560 # will be execed at the end.  This prevents here-documents from being
    561 # left over by shells.
    562 exec_cmd=
    563 
    564 if test -z "$show_help"; then
    565 
    566   # Infer the operation mode.
    567   if test -z "$mode"; then
    568     $echo "*** Warning: inferring the mode of operation is deprecated." 1>&2
    569     $echo "*** Future versions of Libtool will require --mode=MODE be specified." 1>&2
    570     case $nonopt in
    571     *cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*)
    572       mode=link
    573       for arg
    574       do
    575         case $arg in
    576         -c)
    577            mode=compile
    578            break
    579            ;;
    580         esac
    581       done
    582       ;;
    583     *db | *dbx | *strace | *truss)
    584       mode=execute
    585       ;;
    586     *install*|cp|mv)
    587       mode=install
    588       ;;
    589     *rm)
    590       mode=uninstall
    591       ;;
    592     *)
    593       # If we have no mode, but dlfiles were specified, then do execute mode.
    594       test -n "$execute_dlfiles" && mode=execute
    595 
    596       # Just use the default operation mode.
    597       if test -z "$mode"; then
    598         if test -n "$nonopt"; then
    599           $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
    600         else
    601           $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
    602         fi
    603       fi
    604       ;;
     3978  $ECHO "\
     3979      \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
     3980      exit 1
     3981}
     3982
     3983# A function to encapsulate launching the target application
     3984# Strips options in the --lt-* namespace from \$@ and
     3985# launches target application with the remaining arguments.
     3986func_exec_program ()
     3987{
     3988  case \" \$* \" in
     3989  *\\ --lt-*)
     3990    for lt_wr_arg
     3991    do
     3992      case \$lt_wr_arg in
     3993      --lt-*) ;;
     3994      *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
     3995      esac
     3996      shift
     3997    done ;;
     3998  esac
     3999  func_exec_program_core \${1+\"\$@\"}
     4000}
     4001
     4002  # Parse options
     4003  func_parse_lt_options \"\$0\" \${1+\"\$@\"}
     4004
     4005  # Find the directory that this script lives in.
     4006  thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
     4007  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
     4008
     4009  # Follow symbolic links until we get to the real thisdir.
     4010  file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
     4011  while test -n \"\$file\"; do
     4012    destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
     4013
     4014    # If there was a directory component, then change thisdir.
     4015    if test \"x\$destdir\" != \"x\$file\"; then
     4016      case \"\$destdir\" in
     4017      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
     4018      *) thisdir=\"\$thisdir/\$destdir\" ;;
     4019      esac
     4020    fi
     4021
     4022    file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
     4023    file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
     4024  done
     4025
     4026  # Usually 'no', except on cygwin/mingw when embedded into
     4027  # the cwrapper.
     4028  WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
     4029  if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
     4030    # special case for '.'
     4031    if test \"\$thisdir\" = \".\"; then
     4032      thisdir=\`pwd\`
     4033    fi
     4034    # remove .libs from thisdir
     4035    case \"\$thisdir\" in
     4036    *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
     4037    $objdir )   thisdir=. ;;
    6054038    esac
    6064039  fi
    6074040
    608   # Only execute mode is allowed to have -dlopen flags.
    609   if test -n "$execute_dlfiles" && test "$mode" != execute; then
    610     $echo "$modename: unrecognized option \`-dlopen'" 1>&2
    611     $echo "$help" 1>&2
    612     exit $EXIT_FAILURE
     4041  # Try to get the absolute directory name.
     4042  absdir=\`cd \"\$thisdir\" && pwd\`
     4043  test -n \"\$absdir\" && thisdir=\"\$absdir\"
     4044"
     4045
     4046        if test "$fast_install" = yes; then
     4047          $ECHO "\
     4048  program=lt-'$outputname'$exeext
     4049  progdir=\"\$thisdir/$objdir\"
     4050
     4051  if test ! -f \"\$progdir/\$program\" ||
     4052     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
     4053       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
     4054
     4055    file=\"\$\$-\$program\"
     4056
     4057    if test ! -d \"\$progdir\"; then
     4058      $MKDIR \"\$progdir\"
     4059    else
     4060      $RM \"\$progdir/\$file\"
     4061    fi"
     4062
     4063          $ECHO "\
     4064
     4065    # relink executable if necessary
     4066    if test -n \"\$relink_command\"; then
     4067      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
     4068      else
     4069        $ECHO \"\$relink_command_output\" >&2
     4070        $RM \"\$progdir/\$file\"
     4071        exit 1
     4072      fi
     4073    fi
     4074
     4075    $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
     4076    { $RM \"\$progdir/\$program\";
     4077      $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
     4078    $RM \"\$progdir/\$file\"
     4079  fi"
     4080        else
     4081          $ECHO "\
     4082  program='$outputname'
     4083  progdir=\"\$thisdir/$objdir\"
     4084"
     4085        fi
     4086
     4087        $ECHO "\
     4088
     4089  if test -f \"\$progdir/\$program\"; then"
     4090
     4091        # fixup the dll searchpath if we need to.
     4092        #
     4093        # Fix the DLL searchpath if we need to.  Do this before prepending
     4094        # to shlibpath, because on Windows, both are PATH and uninstalled
     4095        # libraries must come first.
     4096        if test -n "$dllsearchpath"; then
     4097          $ECHO "\
     4098    # Add the dll search path components to the executable PATH
     4099    PATH=$dllsearchpath:\$PATH
     4100"
     4101        fi
     4102
     4103        # Export our shlibpath_var if we have one.
     4104        if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
     4105          $ECHO "\
     4106    # Add our own library path to $shlibpath_var
     4107    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
     4108
     4109    # Some systems cannot cope with colon-terminated $shlibpath_var
     4110    # The second colon is a workaround for a bug in BeOS R4 sed
     4111    $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
     4112
     4113    export $shlibpath_var
     4114"
     4115        fi
     4116
     4117        $ECHO "\
     4118    if test \"\$libtool_execute_magic\" != \"$magic\"; then
     4119      # Run the actual program with our arguments.
     4120      func_exec_program \${1+\"\$@\"}
     4121    fi
     4122  else
     4123    # The program doesn't exist.
     4124    \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
     4125    \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
     4126    \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
     4127    exit 1
    6134128  fi
    614 
    615   # Change the help message to a mode-specific one.
    616   generic_help="$help"
    617   help="Try \`$modename --help --mode=$mode' for more information."
    618 
    619   # These modes are in order of execution frequency so that they run quickly.
    620   case $mode in
    621   # libtool compile mode
    622   compile)
    623     modename="$modename: compile"
    624     # Get the compilation command and the source file.
    625     base_compile=
    626     srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
    627     suppress_opt=yes
    628     suppress_output=
    629     arg_mode=normal
    630     libobj=
    631     later=
    632 
    633     for arg
    634     do
    635       case $arg_mode in
    636       arg  )
    637         # do not "continue".  Instead, add this to base_compile
    638         lastarg="$arg"
    639         arg_mode=normal
    640         ;;
    641 
    642       target )
    643         libobj="$arg"
    644         arg_mode=normal
    645         continue
    646         ;;
    647 
    648       normal )
    649         # Accept any command-line options.
    650         case $arg in
    651         -o)
    652           if test -n "$libobj" ; then
    653             $echo "$modename: you cannot specify \`-o' more than once" 1>&2
    654             exit $EXIT_FAILURE
    655           fi
    656           arg_mode=target
    657           continue
    658           ;;
    659 
    660         -static | -prefer-pic | -prefer-non-pic)
    661           later="$later $arg"
    662           continue
    663           ;;
    664 
    665         -no-suppress)
    666           suppress_opt=no
    667           continue
    668           ;;
    669 
    670         -Xcompiler)
    671           arg_mode=arg  #  the next one goes into the "base_compile" arg list
    672           continue      #  The current "srcfile" will either be retained or
    673           ;;            #  replaced later.  I would guess that would be a bug.
    674 
    675         -Wc,*)
    676           args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
    677           lastarg=
    678           save_ifs="$IFS"; IFS=','
    679           for arg in $args; do
    680             IFS="$save_ifs"
    681 
    682             # Double-quote args containing other shell metacharacters.
    683             # Many Bourne shells cannot handle close brackets correctly
    684             # in scan sets, so we specify it separately.
    685             case $arg in
    686               *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
    687               arg="\"$arg\""
    688               ;;
     4129fi\
     4130"
     4131}
     4132
     4133
     4134# func_emit_cwrapperexe_src
     4135# emit the source code for a wrapper executable on stdout
     4136# Must ONLY be called from within func_mode_link because
     4137# it depends on a number of variable set therein.
     4138func_emit_cwrapperexe_src ()
     4139{
     4140        cat <<EOF
     4141
     4142/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
     4143   Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
     4144
     4145   The $output program cannot be directly executed until all the libtool
     4146   libraries that it depends on are installed.
     4147
     4148   This wrapper executable should never be moved out of the build directory.
     4149   If it is, it will not operate correctly.
     4150*/
     4151EOF
     4152            cat <<"EOF"
     4153#ifdef _MSC_VER
     4154# define _CRT_SECURE_NO_DEPRECATE 1
     4155#endif
     4156#include <stdio.h>
     4157#include <stdlib.h>
     4158#ifdef _MSC_VER
     4159# include <direct.h>
     4160# include <process.h>
     4161# include <io.h>
     4162#else
     4163# include <unistd.h>
     4164# include <stdint.h>
     4165# ifdef __CYGWIN__
     4166#  include <io.h>
     4167# endif
     4168#endif
     4169#include <malloc.h>
     4170#include <stdarg.h>
     4171#include <assert.h>
     4172#include <string.h>
     4173#include <ctype.h>
     4174#include <errno.h>
     4175#include <fcntl.h>
     4176#include <sys/stat.h>
     4177
     4178/* declarations of non-ANSI functions */
     4179#if defined(__MINGW32__)
     4180# ifdef __STRICT_ANSI__
     4181int _putenv (const char *);
     4182# endif
     4183#elif defined(__CYGWIN__)
     4184# ifdef __STRICT_ANSI__
     4185char *realpath (const char *, char *);
     4186int putenv (char *);
     4187int setenv (const char *, const char *, int);
     4188# endif
     4189/* #elif defined (other platforms) ... */
     4190#endif
     4191
     4192/* portability defines, excluding path handling macros */
     4193#if defined(_MSC_VER)
     4194# define setmode _setmode
     4195# define stat    _stat
     4196# define chmod   _chmod
     4197# define getcwd  _getcwd
     4198# define putenv  _putenv
     4199# define S_IXUSR _S_IEXEC
     4200# ifndef _INTPTR_T_DEFINED
     4201#  define _INTPTR_T_DEFINED
     4202#  define intptr_t int
     4203# endif
     4204#elif defined(__MINGW32__)
     4205# define setmode _setmode
     4206# define stat    _stat
     4207# define chmod   _chmod
     4208# define getcwd  _getcwd
     4209# define putenv  _putenv
     4210#elif defined(__CYGWIN__)
     4211# define HAVE_SETENV
     4212# define FOPEN_WB "wb"
     4213/* #elif defined (other platforms) ... */
     4214#endif
     4215
     4216#if defined(PATH_MAX)
     4217# define LT_PATHMAX PATH_MAX
     4218#elif defined(MAXPATHLEN)
     4219# define LT_PATHMAX MAXPATHLEN
     4220#else
     4221# define LT_PATHMAX 1024
     4222#endif
     4223
     4224#ifndef S_IXOTH
     4225# define S_IXOTH 0
     4226#endif
     4227#ifndef S_IXGRP
     4228# define S_IXGRP 0
     4229#endif
     4230
     4231/* path handling portability macros */
     4232#ifndef DIR_SEPARATOR
     4233# define DIR_SEPARATOR '/'
     4234# define PATH_SEPARATOR ':'
     4235#endif
     4236
     4237#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
     4238  defined (__OS2__)
     4239# define HAVE_DOS_BASED_FILE_SYSTEM
     4240# define FOPEN_WB "wb"
     4241# ifndef DIR_SEPARATOR_2
     4242#  define DIR_SEPARATOR_2 '\\'
     4243# endif
     4244# ifndef PATH_SEPARATOR_2
     4245#  define PATH_SEPARATOR_2 ';'
     4246# endif
     4247#endif
     4248
     4249#ifndef DIR_SEPARATOR_2
     4250# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
     4251#else /* DIR_SEPARATOR_2 */
     4252# define IS_DIR_SEPARATOR(ch) \
     4253        (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
     4254#endif /* DIR_SEPARATOR_2 */
     4255
     4256#ifndef PATH_SEPARATOR_2
     4257# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
     4258#else /* PATH_SEPARATOR_2 */
     4259# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
     4260#endif /* PATH_SEPARATOR_2 */
     4261
     4262#ifndef FOPEN_WB
     4263# define FOPEN_WB "w"
     4264#endif
     4265#ifndef _O_BINARY
     4266# define _O_BINARY 0
     4267#endif
     4268
     4269#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
     4270#define XFREE(stale) do { \
     4271  if (stale) { free ((void *) stale); stale = 0; } \
     4272} while (0)
     4273
     4274#if defined(LT_DEBUGWRAPPER)
     4275static int lt_debug = 1;
     4276#else
     4277static int lt_debug = 0;
     4278#endif
     4279
     4280const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
     4281
     4282void *xmalloc (size_t num);
     4283char *xstrdup (const char *string);
     4284const char *base_name (const char *name);
     4285char *find_executable (const char *wrapper);
     4286char *chase_symlinks (const char *pathspec);
     4287int make_executable (const char *path);
     4288int check_executable (const char *path);
     4289char *strendzap (char *str, const char *pat);
     4290void lt_debugprintf (const char *file, int line, const char *fmt, ...);
     4291void lt_fatal (const char *file, int line, const char *message, ...);
     4292static const char *nonnull (const char *s);
     4293static const char *nonempty (const char *s);
     4294void lt_setenv (const char *name, const char *value);
     4295char *lt_extend_str (const char *orig_value, const char *add, int to_end);
     4296void lt_update_exe_path (const char *name, const char *value);
     4297void lt_update_lib_path (const char *name, const char *value);
     4298char **prepare_spawn (char **argv);
     4299void lt_dump_script (FILE *f);
     4300EOF
     4301
     4302            cat <<EOF
     4303volatile const char * MAGIC_EXE = "$magic_exe";
     4304const char * LIB_PATH_VARNAME = "$shlibpath_var";
     4305EOF
     4306
     4307            if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
     4308              func_to_host_path "$temp_rpath"
     4309              cat <<EOF
     4310const char * LIB_PATH_VALUE   = "$func_to_host_path_result";
     4311EOF
     4312            else
     4313              cat <<"EOF"
     4314const char * LIB_PATH_VALUE   = "";
     4315EOF
     4316            fi
     4317
     4318            if test -n "$dllsearchpath"; then
     4319              func_to_host_path "$dllsearchpath:"
     4320              cat <<EOF
     4321const char * EXE_PATH_VARNAME = "PATH";
     4322const char * EXE_PATH_VALUE   = "$func_to_host_path_result";
     4323EOF
     4324            else
     4325              cat <<"EOF"
     4326const char * EXE_PATH_VARNAME = "";
     4327const char * EXE_PATH_VALUE   = "";
     4328EOF
     4329            fi
     4330
     4331            if test "$fast_install" = yes; then
     4332              cat <<EOF
     4333const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
     4334EOF
     4335            else
     4336              cat <<EOF
     4337const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
     4338EOF
     4339            fi
     4340
     4341
     4342            cat <<"EOF"
     4343
     4344#define LTWRAPPER_OPTION_PREFIX         "--lt-"
     4345
     4346static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
     4347static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
     4348static const char *debug_opt            = LTWRAPPER_OPTION_PREFIX "debug";
     4349
     4350int
     4351main (int argc, char *argv[])
     4352{
     4353  char **newargz;
     4354  int  newargc;
     4355  char *tmp_pathspec;
     4356  char *actual_cwrapper_path;
     4357  char *actual_cwrapper_name;
     4358  char *target_name;
     4359  char *lt_argv_zero;
     4360  intptr_t rval = 127;
     4361
     4362  int i;
     4363
     4364  program_name = (char *) xstrdup (base_name (argv[0]));
     4365  newargz = XMALLOC (char *, argc + 1);
     4366
     4367  /* very simple arg parsing; don't want to rely on getopt
     4368   * also, copy all non cwrapper options to newargz, except
     4369   * argz[0], which is handled differently
     4370   */
     4371  newargc=0;
     4372  for (i = 1; i < argc; i++)
     4373    {
     4374      if (strcmp (argv[i], dumpscript_opt) == 0)
     4375        {
     4376EOF
     4377            case "$host" in
     4378              *mingw* | *cygwin* )
     4379                # make stdout use "unix" line endings
     4380                echo "          setmode(1,_O_BINARY);"
     4381                ;;
     4382              esac
     4383
     4384            cat <<"EOF"
     4385          lt_dump_script (stdout);
     4386          return 0;
     4387        }
     4388      if (strcmp (argv[i], debug_opt) == 0)
     4389        {
     4390          lt_debug = 1;
     4391          continue;
     4392        }
     4393      if (strcmp (argv[i], ltwrapper_option_prefix) == 0)
     4394        {
     4395          /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
     4396             namespace, but it is not one of the ones we know about and
     4397             have already dealt with, above (inluding dump-script), then
     4398             report an error. Otherwise, targets might begin to believe
     4399             they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
     4400             namespace. The first time any user complains about this, we'll
     4401             need to make LTWRAPPER_OPTION_PREFIX a configure-time option
     4402             or a configure.ac-settable value.
     4403           */
     4404          lt_fatal (__FILE__, __LINE__,
     4405                    "unrecognized %s option: '%s'",
     4406                    ltwrapper_option_prefix, argv[i]);
     4407        }
     4408      /* otherwise ... */
     4409      newargz[++newargc] = xstrdup (argv[i]);
     4410    }
     4411  newargz[++newargc] = NULL;
     4412
     4413EOF
     4414            cat <<EOF
     4415  /* The GNU banner must be the first non-error debug message */
     4416  lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");
     4417EOF
     4418            cat <<"EOF"
     4419  lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
     4420  lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
     4421
     4422  tmp_pathspec = find_executable (argv[0]);
     4423  if (tmp_pathspec == NULL)
     4424    lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
     4425  lt_debugprintf (__FILE__, __LINE__,
     4426                  "(main) found exe (before symlink chase) at: %s\n",
     4427                  tmp_pathspec);
     4428
     4429  actual_cwrapper_path = chase_symlinks (tmp_pathspec);
     4430  lt_debugprintf (__FILE__, __LINE__,
     4431                  "(main) found exe (after symlink chase) at: %s\n",
     4432                  actual_cwrapper_path);
     4433  XFREE (tmp_pathspec);
     4434
     4435  actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
     4436  strendzap (actual_cwrapper_path, actual_cwrapper_name);
     4437
     4438  /* wrapper name transforms */
     4439  strendzap (actual_cwrapper_name, ".exe");
     4440  tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
     4441  XFREE (actual_cwrapper_name);
     4442  actual_cwrapper_name = tmp_pathspec;
     4443  tmp_pathspec = 0;
     4444
     4445  /* target_name transforms -- use actual target program name; might have lt- prefix */
     4446  target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
     4447  strendzap (target_name, ".exe");
     4448  tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
     4449  XFREE (target_name);
     4450  target_name = tmp_pathspec;
     4451  tmp_pathspec = 0;
     4452
     4453  lt_debugprintf (__FILE__, __LINE__,
     4454                  "(main) libtool target name: %s\n",
     4455                  target_name);
     4456EOF
     4457
     4458            cat <<EOF
     4459  newargz[0] =
     4460    XMALLOC (char, (strlen (actual_cwrapper_path) +
     4461                    strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
     4462  strcpy (newargz[0], actual_cwrapper_path);
     4463  strcat (newargz[0], "$objdir");
     4464  strcat (newargz[0], "/");
     4465EOF
     4466
     4467            cat <<"EOF"
     4468  /* stop here, and copy so we don't have to do this twice */
     4469  tmp_pathspec = xstrdup (newargz[0]);
     4470
     4471  /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
     4472  strcat (newargz[0], actual_cwrapper_name);
     4473
     4474  /* DO want the lt- prefix here if it exists, so use target_name */
     4475  lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
     4476  XFREE (tmp_pathspec);
     4477  tmp_pathspec = NULL;
     4478EOF
     4479
     4480            case $host_os in
     4481              mingw*)
     4482            cat <<"EOF"
     4483  {
     4484    char* p;
     4485    while ((p = strchr (newargz[0], '\\')) != NULL)
     4486      {
     4487        *p = '/';
     4488      }
     4489    while ((p = strchr (lt_argv_zero, '\\')) != NULL)
     4490      {
     4491        *p = '/';
     4492      }
     4493  }
     4494EOF
     4495            ;;
    6894496            esac
    690             lastarg="$lastarg $arg"
    691           done
    692           IFS="$save_ifs"
    693           lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
    694 
    695           # Add the arguments to base_compile.
    696           base_compile="$base_compile $lastarg"
    697           continue
    698           ;;
    699 
    700         * )
    701           # Accept the current argument as the source file.
    702           # The previous "srcfile" becomes the current argument.
    703           #
    704           lastarg="$srcfile"
    705           srcfile="$arg"
    706           ;;
    707         esac  #  case $arg
    708         ;;
    709       esac    #  case $arg_mode
    710 
    711       # Aesthetically quote the previous argument.
    712       lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
    713 
    714       case $lastarg in
    715       # Double-quote args containing other shell metacharacters.
    716       # Many Bourne shells cannot handle close brackets correctly
    717       # in scan sets, and some SunOS ksh mistreat backslash-escaping
    718       # in scan sets (worked around with variable expansion),
    719       # and furthermore cannot handle '|' '&' '(' ')' in scan sets
    720       # at all, so we specify them separately.
    721       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
    722         lastarg="\"$lastarg\""
    723         ;;
    724       esac
    725 
    726       base_compile="$base_compile $lastarg"
    727     done # for arg
    728 
    729     case $arg_mode in
    730     arg)
    731       $echo "$modename: you must specify an argument for -Xcompile"
    732       exit $EXIT_FAILURE
    733       ;;
    734     target)
    735       $echo "$modename: you must specify a target with \`-o'" 1>&2
    736       exit $EXIT_FAILURE
    737       ;;
    738     *)
    739       # Get the name of the library object.
    740       [ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
    741       ;;
     4497
     4498            cat <<"EOF"
     4499  XFREE (target_name);
     4500  XFREE (actual_cwrapper_path);
     4501  XFREE (actual_cwrapper_name);
     4502
     4503  lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
     4504  lt_setenv ("DUALCASE", "1");  /* for MSK sh */
     4505  /* Update the DLL searchpath.  EXE_PATH_VALUE ($dllsearchpath) must
     4506     be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
     4507     because on Windows, both *_VARNAMEs are PATH but uninstalled
     4508     libraries must come first. */
     4509  lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
     4510  lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
     4511
     4512  lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
     4513                  nonnull (lt_argv_zero));
     4514  for (i = 0; i < newargc; i++)
     4515    {
     4516      lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
     4517                      i, nonnull (newargz[i]));
     4518    }
     4519
     4520EOF
     4521
     4522            case $host_os in
     4523              mingw*)
     4524                cat <<"EOF"
     4525  /* execv doesn't actually work on mingw as expected on unix */
     4526  newargz = prepare_spawn (newargz);
     4527  rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
     4528  if (rval == -1)
     4529    {
     4530      /* failed to start process */
     4531      lt_debugprintf (__FILE__, __LINE__,
     4532                      "(main) failed to launch target \"%s\": %s\n",
     4533                      lt_argv_zero, nonnull (strerror (errno)));
     4534      return 127;
     4535    }
     4536  return rval;
     4537EOF
     4538                ;;
     4539              *)
     4540                cat <<"EOF"
     4541  execv (lt_argv_zero, newargz);
     4542  return rval; /* =127, but avoids unused variable warning */
     4543EOF
     4544                ;;
     4545            esac
     4546
     4547            cat <<"EOF"
     4548}
     4549
     4550void *
     4551xmalloc (size_t num)
     4552{
     4553  void *p = (void *) malloc (num);
     4554  if (!p)
     4555    lt_fatal (__FILE__, __LINE__, "memory exhausted");
     4556
     4557  return p;
     4558}
     4559
     4560char *
     4561xstrdup (const char *string)
     4562{
     4563  return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
     4564                          string) : NULL;
     4565}
     4566
     4567const char *
     4568base_name (const char *name)
     4569{
     4570  const char *base;
     4571
     4572#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
     4573  /* Skip over the disk name in MSDOS pathnames. */
     4574  if (isalpha ((unsigned char) name[0]) && name[1] == ':')
     4575    name += 2;
     4576#endif
     4577
     4578  for (base = name; *name; name++)
     4579    if (IS_DIR_SEPARATOR (*name))
     4580      base = name + 1;
     4581  return base;
     4582}
     4583
     4584int
     4585check_executable (const char *path)
     4586{
     4587  struct stat st;
     4588
     4589  lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
     4590                  nonempty (path));
     4591  if ((!path) || (!*path))
     4592    return 0;
     4593
     4594  if ((stat (path, &st) >= 0)
     4595      && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
     4596    return 1;
     4597  else
     4598    return 0;
     4599}
     4600
     4601int
     4602make_executable (const char *path)
     4603{
     4604  int rval = 0;
     4605  struct stat st;
     4606
     4607  lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
     4608                  nonempty (path));
     4609  if ((!path) || (!*path))
     4610    return 0;
     4611
     4612  if (stat (path, &st) >= 0)
     4613    {
     4614      rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
     4615    }
     4616  return rval;
     4617}
     4618
     4619/* Searches for the full path of the wrapper.  Returns
     4620   newly allocated full path name if found, NULL otherwise
     4621   Does not chase symlinks, even on platforms that support them.
     4622*/
     4623char *
     4624find_executable (const char *wrapper)
     4625{
     4626  int has_slash = 0;
     4627  const char *p;
     4628  const char *p_next;
     4629  /* static buffer for getcwd */
     4630  char tmp[LT_PATHMAX + 1];
     4631  int tmp_len;
     4632  char *concat_name;
     4633
     4634  lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
     4635                  nonempty (wrapper));
     4636
     4637  if ((wrapper == NULL) || (*wrapper == '\0'))
     4638    return NULL;
     4639
     4640  /* Absolute path? */
     4641#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
     4642  if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
     4643    {
     4644      concat_name = xstrdup (wrapper);
     4645      if (check_executable (concat_name))
     4646        return concat_name;
     4647      XFREE (concat_name);
     4648    }
     4649  else
     4650    {
     4651#endif
     4652      if (IS_DIR_SEPARATOR (wrapper[0]))
     4653        {
     4654          concat_name = xstrdup (wrapper);
     4655          if (check_executable (concat_name))
     4656            return concat_name;
     4657          XFREE (concat_name);
     4658        }
     4659#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
     4660    }
     4661#endif
     4662
     4663  for (p = wrapper; *p; p++)
     4664    if (*p == '/')
     4665      {
     4666        has_slash = 1;
     4667        break;
     4668      }
     4669  if (!has_slash)
     4670    {
     4671      /* no slashes; search PATH */
     4672      const char *path = getenv ("PATH");
     4673      if (path != NULL)
     4674        {
     4675          for (p = path; *p; p = p_next)
     4676            {
     4677              const char *q;
     4678              size_t p_len;
     4679              for (q = p; *q; q++)
     4680                if (IS_PATH_SEPARATOR (*q))
     4681                  break;
     4682              p_len = q - p;
     4683              p_next = (*q == '\0' ? q : q + 1);
     4684              if (p_len == 0)
     4685                {
     4686                  /* empty path: current directory */
     4687                  if (getcwd (tmp, LT_PATHMAX) == NULL)
     4688                    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
     4689                              nonnull (strerror (errno)));
     4690                  tmp_len = strlen (tmp);
     4691                  concat_name =
     4692                    XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
     4693                  memcpy (concat_name, tmp, tmp_len);
     4694                  concat_name[tmp_len] = '/';
     4695                  strcpy (concat_name + tmp_len + 1, wrapper);
     4696                }
     4697              else
     4698                {
     4699                  concat_name =
     4700                    XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
     4701                  memcpy (concat_name, p, p_len);
     4702                  concat_name[p_len] = '/';
     4703                  strcpy (concat_name + p_len + 1, wrapper);
     4704                }
     4705              if (check_executable (concat_name))
     4706                return concat_name;
     4707              XFREE (concat_name);
     4708            }
     4709        }
     4710      /* not found in PATH; assume curdir */
     4711    }
     4712  /* Relative path | not found in path: prepend cwd */
     4713  if (getcwd (tmp, LT_PATHMAX) == NULL)
     4714    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
     4715              nonnull (strerror (errno)));
     4716  tmp_len = strlen (tmp);
     4717  concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
     4718  memcpy (concat_name, tmp, tmp_len);
     4719  concat_name[tmp_len] = '/';
     4720  strcpy (concat_name + tmp_len + 1, wrapper);
     4721
     4722  if (check_executable (concat_name))
     4723    return concat_name;
     4724  XFREE (concat_name);
     4725  return NULL;
     4726}
     4727
     4728char *
     4729chase_symlinks (const char *pathspec)
     4730{
     4731#ifndef S_ISLNK
     4732  return xstrdup (pathspec);
     4733#else
     4734  char buf[LT_PATHMAX];
     4735  struct stat s;
     4736  char *tmp_pathspec = xstrdup (pathspec);
     4737  char *p;
     4738  int has_symlinks = 0;
     4739  while (strlen (tmp_pathspec) && !has_symlinks)
     4740    {
     4741      lt_debugprintf (__FILE__, __LINE__,
     4742                      "checking path component for symlinks: %s\n",
     4743                      tmp_pathspec);
     4744      if (lstat (tmp_pathspec, &s) == 0)
     4745        {
     4746          if (S_ISLNK (s.st_mode) != 0)
     4747            {
     4748              has_symlinks = 1;
     4749              break;
     4750            }
     4751
     4752          /* search backwards for last DIR_SEPARATOR */
     4753          p = tmp_pathspec + strlen (tmp_pathspec) - 1;
     4754          while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
     4755            p--;
     4756          if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
     4757            {
     4758              /* no more DIR_SEPARATORS left */
     4759              break;
     4760            }
     4761          *p = '\0';
     4762        }
     4763      else
     4764        {
     4765          lt_fatal (__FILE__, __LINE__,
     4766                    "error accessing file \"%s\": %s",
     4767                    tmp_pathspec, nonnull (strerror (errno)));
     4768        }
     4769    }
     4770  XFREE (tmp_pathspec);
     4771
     4772  if (!has_symlinks)
     4773    {
     4774      return xstrdup (pathspec);
     4775    }
     4776
     4777  tmp_pathspec = realpath (pathspec, buf);
     4778  if (tmp_pathspec == 0)
     4779    {
     4780      lt_fatal (__FILE__, __LINE__,
     4781                "could not follow symlinks for %s", pathspec);
     4782    }
     4783  return xstrdup (tmp_pathspec);
     4784#endif
     4785}
     4786
     4787char *
     4788strendzap (char *str, const char *pat)
     4789{
     4790  size_t len, patlen;
     4791
     4792  assert (str != NULL);
     4793  assert (pat != NULL);
     4794
     4795  len = strlen (str);
     4796  patlen = strlen (pat);
     4797
     4798  if (patlen <= len)
     4799    {
     4800      str += len - patlen;
     4801      if (strcmp (str, pat) == 0)
     4802        *str = '\0';
     4803    }
     4804  return str;
     4805}
     4806
     4807void
     4808lt_debugprintf (const char *file, int line, const char *fmt, ...)
     4809{
     4810  va_list args;
     4811  if (lt_debug)
     4812    {
     4813      (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
     4814      va_start (args, fmt);
     4815      (void) vfprintf (stderr, fmt, args);
     4816      va_end (args);
     4817    }
     4818}
     4819
     4820static void
     4821lt_error_core (int exit_status, const char *file,
     4822               int line, const char *mode,
     4823               const char *message, va_list ap)
     4824{
     4825  fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
     4826  vfprintf (stderr, message, ap);
     4827  fprintf (stderr, ".\n");
     4828
     4829  if (exit_status >= 0)
     4830    exit (exit_status);
     4831}
     4832
     4833void
     4834lt_fatal (const char *file, int line, const char *message, ...)
     4835{
     4836  va_list ap;
     4837  va_start (ap, message);
     4838  lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
     4839  va_end (ap);
     4840}
     4841
     4842static const char *
     4843nonnull (const char *s)
     4844{
     4845  return s ? s : "(null)";
     4846}
     4847
     4848static const char *
     4849nonempty (const char *s)
     4850{
     4851  return (s && !*s) ? "(empty)" : nonnull (s);
     4852}
     4853
     4854void
     4855lt_setenv (const char *name, const char *value)
     4856{
     4857  lt_debugprintf (__FILE__, __LINE__,
     4858                  "(lt_setenv) setting '%s' to '%s'\n",
     4859                  nonnull (name), nonnull (value));
     4860  {
     4861#ifdef HAVE_SETENV
     4862    /* always make a copy, for consistency with !HAVE_SETENV */
     4863    char *str = xstrdup (value);
     4864    setenv (name, str, 1);
     4865#else
     4866    int len = strlen (name) + 1 + strlen (value) + 1;
     4867    char *str = XMALLOC (char, len);
     4868    sprintf (str, "%s=%s", name, value);
     4869    if (putenv (str) != EXIT_SUCCESS)
     4870      {
     4871        XFREE (str);
     4872      }
     4873#endif
     4874  }
     4875}
     4876
     4877char *
     4878lt_extend_str (const char *orig_value, const char *add, int to_end)
     4879{
     4880  char *new_value;
     4881  if (orig_value && *orig_value)
     4882    {
     4883      int orig_value_len = strlen (orig_value);
     4884      int add_len = strlen (add);
     4885      new_value = XMALLOC (char, add_len + orig_value_len + 1);
     4886      if (to_end)
     4887        {
     4888          strcpy (new_value, orig_value);
     4889          strcpy (new_value + orig_value_len, add);
     4890        }
     4891      else
     4892        {
     4893          strcpy (new_value, add);
     4894          strcpy (new_value + add_len, orig_value);
     4895        }
     4896    }
     4897  else
     4898    {
     4899      new_value = xstrdup (add);
     4900    }
     4901  return new_value;
     4902}
     4903
     4904void
     4905lt_update_exe_path (const char *name, const char *value)
     4906{
     4907  lt_debugprintf (__FILE__, __LINE__,
     4908                  "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
     4909                  nonnull (name), nonnull (value));
     4910
     4911  if (name && *name && value && *value)
     4912    {
     4913      char *new_value = lt_extend_str (getenv (name), value, 0);
     4914      /* some systems can't cope with a ':'-terminated path #' */
     4915      int len = strlen (new_value);
     4916      while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
     4917        {
     4918          new_value[len-1] = '\0';
     4919        }
     4920      lt_setenv (name, new_value);
     4921      XFREE (new_value);
     4922    }
     4923}
     4924
     4925void
     4926lt_update_lib_path (const char *name, const char *value)
     4927{
     4928  lt_debugprintf (__FILE__, __LINE__,
     4929                  "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
     4930                  nonnull (name), nonnull (value));
     4931
     4932  if (name && *name && value && *value)
     4933    {
     4934      char *new_value = lt_extend_str (getenv (name), value, 0);
     4935      lt_setenv (name, new_value);
     4936      XFREE (new_value);
     4937    }
     4938}
     4939
     4940EOF
     4941            case $host_os in
     4942              mingw*)
     4943                cat <<"EOF"
     4944
     4945/* Prepares an argument vector before calling spawn().
     4946   Note that spawn() does not by itself call the command interpreter
     4947     (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
     4948      ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
     4949         GetVersionEx(&v);
     4950         v.dwPlatformId == VER_PLATFORM_WIN32_NT;
     4951      }) ? "cmd.exe" : "command.com").
     4952   Instead it simply concatenates the arguments, separated by ' ', and calls
     4953   CreateProcess().  We must quote the arguments since Win32 CreateProcess()
     4954   interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
     4955   special way:
     4956   - Space and tab are interpreted as delimiters. They are not treated as
     4957     delimiters if they are surrounded by double quotes: "...".
     4958   - Unescaped double quotes are removed from the input. Their only effect is
     4959     that within double quotes, space and tab are treated like normal
     4960     characters.
     4961   - Backslashes not followed by double quotes are not special.
     4962   - But 2*n+1 backslashes followed by a double quote become
     4963     n backslashes followed by a double quote (n >= 0):
     4964       \" -> "
     4965       \\\" -> \"
     4966       \\\\\" -> \\"
     4967 */
     4968#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"
     4969#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"
     4970char **
     4971prepare_spawn (char **argv)
     4972{
     4973  size_t argc;
     4974  char **new_argv;
     4975  size_t i;
     4976
     4977  /* Count number of arguments.  */
     4978  for (argc = 0; argv[argc] != NULL; argc++)
     4979    ;
     4980
     4981  /* Allocate new argument vector.  */
     4982  new_argv = XMALLOC (char *, argc + 1);
     4983
     4984  /* Put quoted arguments into the new argument vector.  */
     4985  for (i = 0; i < argc; i++)
     4986    {
     4987      const char *string = argv[i];
     4988
     4989      if (string[0] == '\0')
     4990        new_argv[i] = xstrdup ("\"\"");
     4991      else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
     4992        {
     4993          int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
     4994          size_t length;
     4995          unsigned int backslashes;
     4996          const char *s;
     4997          char *quoted_string;
     4998          char *p;
     4999
     5000          length = 0;
     5001          backslashes = 0;
     5002          if (quote_around)
     5003            length++;
     5004          for (s = string; *s != '\0'; s++)
     5005            {
     5006              char c = *s;
     5007              if (c == '"')
     5008                length += backslashes + 1;
     5009              length++;
     5010              if (c == '\\')
     5011                backslashes++;
     5012              else
     5013                backslashes = 0;
     5014            }
     5015          if (quote_around)
     5016            length += backslashes + 1;
     5017
     5018          quoted_string = XMALLOC (char, length + 1);
     5019
     5020          p = quoted_string;
     5021          backslashes = 0;
     5022          if (quote_around)
     5023            *p++ = '"';
     5024          for (s = string; *s != '\0'; s++)
     5025            {
     5026              char c = *s;
     5027              if (c == '"')
     5028                {
     5029                  unsigned int j;
     5030                  for (j = backslashes + 1; j > 0; j--)
     5031                    *p++ = '\\';
     5032                }
     5033              *p++ = c;
     5034              if (c == '\\')
     5035                backslashes++;
     5036              else
     5037                backslashes = 0;
     5038            }
     5039          if (quote_around)
     5040            {
     5041              unsigned int j;
     5042              for (j = backslashes; j > 0; j--)
     5043                *p++ = '\\';
     5044              *p++ = '"';
     5045            }
     5046          *p = '\0';
     5047
     5048          new_argv[i] = quoted_string;
     5049        }
     5050      else
     5051        new_argv[i] = (char *) string;
     5052    }
     5053  new_argv[argc] = NULL;
     5054
     5055  return new_argv;
     5056}
     5057EOF
     5058                ;;
     5059            esac
     5060
     5061            cat <<"EOF"
     5062void lt_dump_script (FILE* f)
     5063{
     5064EOF
     5065            func_emit_wrapper yes |
     5066              $SED -n -e '
     5067s/^\(.\{79\}\)\(..*\)/\1\
     5068\2/
     5069h
     5070s/\([\\"]\)/\\\1/g
     5071s/$/\\n/
     5072s/\([^\n]*\).*/  fputs ("\1", f);/p
     5073g
     5074D'
     5075            cat <<"EOF"
     5076}
     5077EOF
     5078}
     5079# end: func_emit_cwrapperexe_src
     5080
     5081# func_win32_import_lib_p ARG
     5082# True if ARG is an import lib, as indicated by $file_magic_cmd
     5083func_win32_import_lib_p ()
     5084{
     5085    $opt_debug
     5086    case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
     5087    *import*) : ;;
     5088    *) false ;;
    7425089    esac
    743 
    744     # Recognize several different file suffixes.
    745     # If the user specifies -o file.o, it is replaced with file.lo
    746     xform='[cCFSifmso]'
    747     case $libobj in
    748     *.ada) xform=ada ;;
    749     *.adb) xform=adb ;;
    750     *.ads) xform=ads ;;
    751     *.asm) xform=asm ;;
    752     *.c++) xform=c++ ;;
    753     *.cc) xform=cc ;;
    754     *.ii) xform=ii ;;
    755     *.class) xform=class ;;
    756     *.cpp) xform=cpp ;;
    757     *.cxx) xform=cxx ;;
    758     *.f90) xform=f90 ;;
    759     *.for) xform=for ;;
    760     *.java) xform=java ;;
    761     esac
    762 
    763     libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
    764 
    765     case $libobj in
    766     *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
    767     *)
    768       $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
    769       exit $EXIT_FAILURE
    770       ;;
    771     esac
    772 
    773     func_infer_tag $base_compile
    774 
    775     for arg in $later; do
    776       case $arg in
    777       -static)
    778         build_old_libs=yes
    779         continue
    780         ;;
    781 
    782       -prefer-pic)
    783         pic_mode=yes
    784         continue
    785         ;;
    786 
    787       -prefer-non-pic)
    788         pic_mode=no
    789         continue
    790         ;;
    791       esac
    792     done
    793 
    794     qlibobj=`$echo "X$libobj" | $Xsed -e "$sed_quote_subst"`
    795     case $qlibobj in
    796       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
    797         qlibobj="\"$qlibobj\"" ;;
    798     esac
    799     test "X$libobj" != "X$qlibobj" \
    800         && $echo "X$libobj" | grep '[]~#^*{};<>?"'"'"'  &()|`$[]' \
    801         && $echo "$modename: libobj name \`$libobj' may not contain shell special characters."
    802     objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
    803     xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
    804     if test "X$xdir" = "X$obj"; then
    805       xdir=
    806     else
    807       xdir=$xdir/
    808     fi
    809     lobj=${xdir}$objdir/$objname
    810 
    811     if test -z "$base_compile"; then
    812       $echo "$modename: you must specify a compilation command" 1>&2
    813       $echo "$help" 1>&2
    814       exit $EXIT_FAILURE
    815     fi
    816 
    817     # Delete any leftover library objects.
    818     if test "$build_old_libs" = yes; then
    819       removelist="$obj $lobj $libobj ${libobj}T"
    820     else
    821       removelist="$lobj $libobj ${libobj}T"
    822     fi
    823 
    824     $run $rm $removelist
    825     trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
    826 
    827     # On Cygwin there's no "real" PIC flag so we must build both object types
    828     case $host_os in
    829     cygwin* | mingw* | pw32* | os2*)
    830       pic_mode=default
    831       ;;
    832     esac
    833     if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
    834       # non-PIC code in shared libraries is not supported
    835       pic_mode=default
    836     fi
    837 
    838     # Calculate the filename of the output object if compiler does
    839     # not support -o with -c
    840     if test "$compiler_c_o" = no; then
    841       output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
    842       lockfile="$output_obj.lock"
    843       removelist="$removelist $output_obj $lockfile"
    844       trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
    845     else
    846       output_obj=
    847       need_locks=no
    848       lockfile=
    849     fi
    850 
    851     # Lock this critical section if it is needed
    852     # We use this script file to make the link, it avoids creating a new file
    853     if test "$need_locks" = yes; then
    854       until $run ln "$progpath" "$lockfile" 2>/dev/null; do
    855         $show "Waiting for $lockfile to be removed"
    856         sleep 2
    857       done
    858     elif test "$need_locks" = warn; then
    859       if test -f "$lockfile"; then
    860         $echo "\
    861 *** ERROR, $lockfile exists and contains:
    862 `cat $lockfile 2>/dev/null`
    863 
    864 This indicates that another process is trying to use the same
    865 temporary object file, and libtool could not work around it because
    866 your compiler does not support \`-c' and \`-o' together.  If you
    867 repeat this compilation, it may succeed, by chance, but you had better
    868 avoid parallel builds (make -j) in this platform, or get a better
    869 compiler."
    870 
    871         $run $rm $removelist
    872         exit $EXIT_FAILURE
    873       fi
    874       $echo "$srcfile" > "$lockfile"
    875     fi
    876 
    877     if test -n "$fix_srcfile_path"; then
    878       eval srcfile=\"$fix_srcfile_path\"
    879     fi
    880     qsrcfile=`$echo "X$srcfile" | $Xsed -e "$sed_quote_subst"`
    881     case $qsrcfile in
    882       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
    883       qsrcfile="\"$qsrcfile\"" ;;
    884     esac
    885 
    886     $run $rm "$libobj" "${libobj}T"
    887 
    888     # Create a libtool object file (analogous to a ".la" file),
    889     # but don't create it if we're doing a dry run.
    890     test -z "$run" && cat > ${libobj}T <<EOF
    891 # $libobj - a libtool object file
    892 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
    893 #
    894 # Please DO NOT delete this file!
    895 # It is necessary for linking the library.
    896 
    897 # Name of the PIC object.
    898 EOF
    899 
    900     # Only build a PIC object if we are building libtool libraries.
    901     if test "$build_libtool_libs" = yes; then
    902       # Without this assignment, base_compile gets emptied.
    903       fbsd_hideous_sh_bug=$base_compile
    904 
    905       if test "$pic_mode" != no; then
    906         command="$base_compile $qsrcfile $pic_flag"
    907       else
    908         # Don't build PIC code
    909         command="$base_compile $qsrcfile"
    910       fi
    911 
    912       if test ! -d "${xdir}$objdir"; then
    913         $show "$mkdir ${xdir}$objdir"
    914         $run $mkdir ${xdir}$objdir
    915         exit_status=$?
    916         if test "$exit_status" -ne 0 && test ! -d "${xdir}$objdir"; then
    917           exit $exit_status
    918         fi
    919       fi
    920 
    921       if test -z "$output_obj"; then
    922         # Place PIC objects in $objdir
    923         command="$command -o $lobj"
    924       fi
    925 
    926       $run $rm "$lobj" "$output_obj"
    927 
    928       $show "$command"
    929       if $run eval "$command"; then :
    930       else
    931         test -n "$output_obj" && $run $rm $removelist
    932         exit $EXIT_FAILURE
    933       fi
    934 
    935       if test "$need_locks" = warn &&
    936          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
    937         $echo "\
    938 *** ERROR, $lockfile contains:
    939 `cat $lockfile 2>/dev/null`
    940 
    941 but it should contain:
    942 $srcfile
    943 
    944 This indicates that another process is trying to use the same
    945 temporary object file, and libtool could not work around it because
    946 your compiler does not support \`-c' and \`-o' together.  If you
    947 repeat this compilation, it may succeed, by chance, but you had better
    948 avoid parallel builds (make -j) in this platform, or get a better
    949 compiler."
    950 
    951         $run $rm $removelist
    952         exit $EXIT_FAILURE
    953       fi
    954 
    955       # Just move the object if needed, then go on to compile the next one
    956       if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
    957         $show "$mv $output_obj $lobj"
    958         if $run $mv $output_obj $lobj; then :
    959         else
    960           error=$?
    961           $run $rm $removelist
    962           exit $error
    963         fi
    964       fi
    965 
    966       # Append the name of the PIC object to the libtool object file.
    967       test -z "$run" && cat >> ${libobj}T <<EOF
    968 pic_object='$objdir/$objname'
    969 
    970 EOF
    971 
    972       # Allow error messages only from the first compilation.
    973       if test "$suppress_opt" = yes; then
    974         suppress_output=' >/dev/null 2>&1'
    975       fi
    976     else
    977       # No PIC object so indicate it doesn't exist in the libtool
    978       # object file.
    979       test -z "$run" && cat >> ${libobj}T <<EOF
    980 pic_object=none
    981 
    982 EOF
    983     fi
    984 
    985     # Only build a position-dependent object if we build old libraries.
    986     if test "$build_old_libs" = yes; then
    987       if test "$pic_mode" != yes; then
    988         # Don't build PIC code
    989         command="$base_compile $qsrcfile"
    990       else
    991         command="$base_compile $qsrcfile $pic_flag"
    992       fi
    993       if test "$compiler_c_o" = yes; then
    994         command="$command -o $obj"
    995       fi
    996 
    997       # Suppress compiler output if we already did a PIC compilation.
    998       command="$command$suppress_output"
    999       $run $rm "$obj" "$output_obj"
    1000       $show "$command"
    1001       if $run eval "$command"; then :
    1002       else
    1003         $run $rm $removelist
    1004         exit $EXIT_FAILURE
    1005       fi
    1006 
    1007       if test "$need_locks" = warn &&
    1008          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
    1009         $echo "\
    1010 *** ERROR, $lockfile contains:
    1011 `cat $lockfile 2>/dev/null`
    1012 
    1013 but it should contain:
    1014 $srcfile
    1015 
    1016 This indicates that another process is trying to use the same
    1017 temporary object file, and libtool could not work around it because
    1018 your compiler does not support \`-c' and \`-o' together.  If you
    1019 repeat this compilation, it may succeed, by chance, but you had better
    1020 avoid parallel builds (make -j) in this platform, or get a better
    1021 compiler."
    1022 
    1023         $run $rm $removelist
    1024         exit $EXIT_FAILURE
    1025       fi
    1026 
    1027       # Just move the object if needed
    1028       if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
    1029         $show "$mv $output_obj $obj"
    1030         if $run $mv $output_obj $obj; then :
    1031         else
    1032           error=$?
    1033           $run $rm $removelist
    1034           exit $error
    1035         fi
    1036       fi
    1037 
    1038       # Append the name of the non-PIC object the libtool object file.
    1039       # Only append if the libtool object file exists.
    1040       test -z "$run" && cat >> ${libobj}T <<EOF
    1041 # Name of the non-PIC object.
    1042 non_pic_object='$objname'
    1043 
    1044 EOF
    1045     else
    1046       # Append the name of the non-PIC object the libtool object file.
    1047       # Only append if the libtool object file exists.
    1048       test -z "$run" && cat >> ${libobj}T <<EOF
    1049 # Name of the non-PIC object.
    1050 non_pic_object=none
    1051 
    1052 EOF
    1053     fi
    1054 
    1055     $run $mv "${libobj}T" "${libobj}"
    1056 
    1057     # Unlock the critical section if it was locked
    1058     if test "$need_locks" != no; then
    1059       $run $rm "$lockfile"
    1060     fi
    1061 
    1062     exit $EXIT_SUCCESS
    1063     ;;
    1064 
    1065   # libtool link mode
    1066   link | relink)
    1067     modename="$modename: link"
     5090}
     5091
     5092# func_mode_link arg...
     5093func_mode_link ()
     5094{
     5095    $opt_debug
    10685096    case $host in
    1069     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
     5097    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
    10705098      # It is impossible to link a dll without this setting, and
    10715099      # we shouldn't force the makefile maintainer to figure out
     
    10855113      ;;
    10865114    esac
    1087     libtool_args="$nonopt"
     5115    libtool_args=$nonopt
    10885116    base_compile="$nonopt $@"
    1089     compile_command="$nonopt"
    1090     finalize_command="$nonopt"
     5117    compile_command=$nonopt
     5118    finalize_command=$nonopt
    10915119
    10925120    compile_rpath=
     
    11035131    lib_search_path=`pwd`
    11045132    inst_prefix_dir=
     5133    new_inherited_linker_flags=
    11055134
    11065135    avoid_version=no
     5136    bindir=
    11075137    dlfiles=
    11085138    dlprefiles=
     
    11185148    objs=
    11195149    non_pic_objects=
    1120     notinst_path= # paths that contain not-installed libtool libraries
    11215150    precious_files_regex=
    11225151    prefer_static_libs=no
     
    11325161    vinfo=
    11335162    vinfo_number=no
    1134 
     5163    weak_libs=
     5164    single_module="${wl}-single_module"
    11355165    func_infer_tag $base_compile
    11365166
     
    11395169    do
    11405170      case $arg in
    1141       -all-static | -static)
    1142         if test "X$arg" = "X-all-static"; then
     5171      -shared)
     5172        test "$build_libtool_libs" != yes && \
     5173          func_fatal_configuration "can not build a shared library"
     5174        build_old_libs=no
     5175        break
     5176        ;;
     5177      -all-static | -static | -static-libtool-libs)
     5178        case $arg in
     5179        -all-static)
    11435180          if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
    1144             $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
     5181            func_warning "complete static linking is impossible in this configuration"
    11455182          fi
    11465183          if test -n "$link_static_flag"; then
     
    11485185          fi
    11495186          prefer_static_libs=yes
    1150         else
     5187          ;;
     5188        -static)
    11515189          if test -z "$pic_flag" && test -n "$link_static_flag"; then
    11525190            dlopen_self=$dlopen_self_static
    11535191          fi
    11545192          prefer_static_libs=built
    1155         fi
     5193          ;;
     5194        -static-libtool-libs)
     5195          if test -z "$pic_flag" && test -n "$link_static_flag"; then
     5196            dlopen_self=$dlopen_self_static
     5197          fi
     5198          prefer_static_libs=yes
     5199          ;;
     5200        esac
    11565201        build_libtool_libs=no
    11575202        build_old_libs=yes
     
    11685213      arg="$1"
    11695214      shift
    1170       case $arg in
    1171       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
    1172         qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
    1173         ;;
    1174       *) qarg=$arg ;;
    1175       esac
    1176       libtool_args="$libtool_args $qarg"
     5215      func_quote_for_eval "$arg"
     5216      qarg=$func_quote_for_eval_unquoted_result
     5217      func_append libtool_args " $func_quote_for_eval_result"
    11775218
    11785219      # If the previous option needs an argument, assign it.
     
    11805221        case $prev in
    11815222        output)
    1182           compile_command="$compile_command @OUTPUT@"
    1183           finalize_command="$finalize_command @OUTPUT@"
     5223          func_append compile_command " @OUTPUT@"
     5224          func_append finalize_command " @OUTPUT@"
    11845225          ;;
    11855226        esac
    11865227
    11875228        case $prev in
     5229        bindir)
     5230          bindir="$arg"
     5231          prev=
     5232          continue
     5233          ;;
    11885234        dlfiles|dlprefiles)
    11895235          if test "$preload" = no; then
    11905236            # Add the symbol object into the linking commands.
    1191             compile_command="$compile_command @SYMFILE@"
    1192             finalize_command="$finalize_command @SYMFILE@"
     5237            func_append compile_command " @SYMFILE@"
     5238            func_append finalize_command " @SYMFILE@"
    11935239            preload=yes
    11945240          fi
     
    12175263          *)
    12185264            if test "$prev" = dlfiles; then
    1219               dlfiles="$dlfiles $arg"
     5265              func_append dlfiles " $arg"
    12205266            else
    1221               dlprefiles="$dlprefiles $arg"
     5267              func_append dlprefiles " $arg"
    12225268            fi
    12235269            prev=
     
    12285274        expsyms)
    12295275          export_symbols="$arg"
    1230           if test ! -f "$arg"; then
    1231             $echo "$modename: symbol file \`$arg' does not exist"
    1232             exit $EXIT_FAILURE
    1233           fi
     5276          test -f "$arg" \
     5277            || func_fatal_error "symbol file \`$arg' does not exist"
    12345278          prev=
    12355279          continue
     
    12405284          continue
    12415285          ;;
     5286        framework)
     5287          case $host in
     5288            *-*-darwin*)
     5289              case "$deplibs " in
     5290                *" $qarg.ltframework "*) ;;
     5291                *) func_append deplibs " $qarg.ltframework" # this is fixed later
     5292                   ;;
     5293              esac
     5294              ;;
     5295          esac
     5296          prev=
     5297          continue
     5298          ;;
    12425299        inst_prefix)
    12435300          inst_prefix_dir="$arg"
     5301          prev=
     5302          continue
     5303          ;;
     5304        objectlist)
     5305          if test -f "$arg"; then
     5306            save_arg=$arg
     5307            moreargs=
     5308            for fil in `cat "$save_arg"`
     5309            do
     5310#             func_append moreargs " $fil"
     5311              arg=$fil
     5312              # A libtool-controlled object.
     5313
     5314              # Check to see that this really is a libtool object.
     5315              if func_lalib_unsafe_p "$arg"; then
     5316                pic_object=
     5317                non_pic_object=
     5318
     5319                # Read the .lo file
     5320                func_source "$arg"
     5321
     5322                if test -z "$pic_object" ||
     5323                   test -z "$non_pic_object" ||
     5324                   test "$pic_object" = none &&
     5325                   test "$non_pic_object" = none; then
     5326                  func_fatal_error "cannot find name of object for \`$arg'"
     5327                fi
     5328
     5329                # Extract subdirectory from the argument.
     5330                func_dirname "$arg" "/" ""
     5331                xdir="$func_dirname_result"
     5332
     5333                if test "$pic_object" != none; then
     5334                  # Prepend the subdirectory the object is found in.
     5335                  pic_object="$xdir$pic_object"
     5336
     5337                  if test "$prev" = dlfiles; then
     5338                    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
     5339                      func_append dlfiles " $pic_object"
     5340                      prev=
     5341                      continue
     5342                    else
     5343                      # If libtool objects are unsupported, then we need to preload.
     5344                      prev=dlprefiles
     5345                    fi
     5346                  fi
     5347
     5348                  # CHECK ME:  I think I busted this.  -Ossama
     5349                  if test "$prev" = dlprefiles; then
     5350                    # Preload the old-style object.
     5351                    func_append dlprefiles " $pic_object"
     5352                    prev=
     5353                  fi
     5354
     5355                  # A PIC object.
     5356                  func_append libobjs " $pic_object"
     5357                  arg="$pic_object"
     5358                fi
     5359
     5360                # Non-PIC object.
     5361                if test "$non_pic_object" != none; then
     5362                  # Prepend the subdirectory the object is found in.
     5363                  non_pic_object="$xdir$non_pic_object"
     5364
     5365                  # A standard non-PIC object
     5366                  func_append non_pic_objects " $non_pic_object"
     5367                  if test -z "$pic_object" || test "$pic_object" = none ; then
     5368                    arg="$non_pic_object"
     5369                  fi
     5370                else
     5371                  # If the PIC object exists, use it instead.
     5372                  # $xdir was prepended to $pic_object above.
     5373                  non_pic_object="$pic_object"
     5374                  func_append non_pic_objects " $non_pic_object"
     5375                fi
     5376              else
     5377                # Only an error if not doing a dry-run.
     5378                if $opt_dry_run; then
     5379                  # Extract subdirectory from the argument.
     5380                  func_dirname "$arg" "/" ""
     5381                  xdir="$func_dirname_result"
     5382
     5383                  func_lo2o "$arg"
     5384                  pic_object=$xdir$objdir/$func_lo2o_result
     5385                  non_pic_object=$xdir$func_lo2o_result
     5386                  func_append libobjs " $pic_object"
     5387                  func_append non_pic_objects " $non_pic_object"
     5388                else
     5389                  func_fatal_error "\`$arg' is not a valid libtool object"
     5390                fi
     5391              fi
     5392            done
     5393          else
     5394            func_fatal_error "link input file \`$arg' does not exist"
     5395          fi
     5396          arg=$save_arg
    12445397          prev=
    12455398          continue
     
    12555408          continue
    12565409          ;;
    1257         objectlist)
    1258           if test -f "$arg"; then
    1259             save_arg=$arg
    1260             moreargs=
    1261             for fil in `cat $save_arg`
    1262             do
    1263 #             moreargs="$moreargs $fil"
    1264               arg=$fil
    1265               # A libtool-controlled object.
    1266 
    1267               # Check to see that this really is a libtool object.
    1268               if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
    1269                 pic_object=
    1270                 non_pic_object=
    1271 
    1272                 # Read the .lo file
    1273                 # If there is no directory component, then add one.
    1274                 case $arg in
    1275                 */* | *\\*) . $arg ;;
    1276                 *) . ./$arg ;;
    1277                 esac
    1278 
    1279                 if test -z "$pic_object" || \
    1280                    test -z "$non_pic_object" ||
    1281                    test "$pic_object" = none && \
    1282                    test "$non_pic_object" = none; then
    1283                   $echo "$modename: cannot find name of object for \`$arg'" 1>&2
    1284                   exit $EXIT_FAILURE
    1285                 fi
    1286 
    1287                 # Extract subdirectory from the argument.
    1288                 xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
    1289                 if test "X$xdir" = "X$arg"; then
    1290                   xdir=
    1291                 else
    1292                   xdir="$xdir/"
    1293                 fi
    1294 
    1295                 if test "$pic_object" != none; then
    1296                   # Prepend the subdirectory the object is found in.
    1297                   pic_object="$xdir$pic_object"
    1298 
    1299                   if test "$prev" = dlfiles; then
    1300                     if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
    1301                       dlfiles="$dlfiles $pic_object"
    1302                       prev=
    1303                       continue
    1304                     else
    1305                       # If libtool objects are unsupported, then we need to preload.
    1306                       prev=dlprefiles
    1307                     fi
    1308                   fi
    1309 
    1310                   # CHECK ME:  I think I busted this.  -Ossama
    1311                   if test "$prev" = dlprefiles; then
    1312                     # Preload the old-style object.
    1313                     dlprefiles="$dlprefiles $pic_object"
    1314                     prev=
    1315                   fi
    1316 
    1317                   # A PIC object.
    1318                   libobjs="$libobjs $pic_object"
    1319                   arg="$pic_object"
    1320                 fi
    1321 
    1322                 # Non-PIC object.
    1323                 if test "$non_pic_object" != none; then
    1324                   # Prepend the subdirectory the object is found in.
    1325                   non_pic_object="$xdir$non_pic_object"
    1326 
    1327                   # A standard non-PIC object
    1328                   non_pic_objects="$non_pic_objects $non_pic_object"
    1329                   if test -z "$pic_object" || test "$pic_object" = none ; then
    1330                     arg="$non_pic_object"
    1331                   fi
    1332                 else
    1333                   # If the PIC object exists, use it instead.
    1334                   # $xdir was prepended to $pic_object above.
    1335                   non_pic_object="$pic_object"
    1336                   non_pic_objects="$non_pic_objects $non_pic_object"
    1337                 fi
    1338               else
    1339                 # Only an error if not doing a dry-run.
    1340                 if test -z "$run"; then
    1341                   $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
    1342                   exit $EXIT_FAILURE
    1343                 else
    1344                   # Dry-run case.
    1345 
    1346                   # Extract subdirectory from the argument.
    1347                   xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
    1348                   if test "X$xdir" = "X$arg"; then
    1349                     xdir=
    1350                   else
    1351                     xdir="$xdir/"
    1352                   fi
    1353 
    1354                   pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
    1355                   non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
    1356                   libobjs="$libobjs $pic_object"
    1357                   non_pic_objects="$non_pic_objects $non_pic_object"
    1358                 fi
    1359               fi
    1360             done
    1361           else
    1362             $echo "$modename: link input file \`$save_arg' does not exist"
    1363             exit $EXIT_FAILURE
    1364           fi
    1365           arg=$save_arg
    1366           prev=
    1367           continue
    1368           ;;
    13695410        rpath | xrpath)
    13705411          # We need an absolute path.
     
    13725413          [\\/]* | [A-Za-z]:[\\/]*) ;;
    13735414          *)
    1374             $echo "$modename: only absolute run-paths are allowed" 1>&2
    1375             exit $EXIT_FAILURE
     5415            func_fatal_error "only absolute run-paths are allowed"
    13765416            ;;
    13775417          esac
     
    13795419            case "$rpath " in
    13805420            *" $arg "*) ;;
    1381             *) rpath="$rpath $arg" ;;
     5421            *) func_append rpath " $arg" ;;
    13825422            esac
    13835423          else
    13845424            case "$xrpath " in
    13855425            *" $arg "*) ;;
    1386             *) xrpath="$xrpath $arg" ;;
     5426            *) func_append xrpath " $arg" ;;
    13875427            esac
    13885428          fi
     
    13905430          continue
    13915431          ;;
     5432        shrext)
     5433          shrext_cmds="$arg"
     5434          prev=
     5435          continue
     5436          ;;
     5437        weak)
     5438          func_append weak_libs " $arg"
     5439          prev=
     5440          continue
     5441          ;;
     5442        xcclinker)
     5443          func_append linker_flags " $qarg"
     5444          func_append compiler_flags " $qarg"
     5445          prev=
     5446          func_append compile_command " $qarg"
     5447          func_append finalize_command " $qarg"
     5448          continue
     5449          ;;
    13925450        xcompiler)
    1393           compiler_flags="$compiler_flags $qarg"
     5451          func_append compiler_flags " $qarg"
    13945452          prev=
    1395           compile_command="$compile_command $qarg"
    1396           finalize_command="$finalize_command $qarg"
     5453          func_append compile_command " $qarg"
     5454          func_append finalize_command " $qarg"
    13975455          continue
    13985456          ;;
    13995457        xlinker)
    1400           linker_flags="$linker_flags $qarg"
    1401           compiler_flags="$compiler_flags $wl$qarg"
     5458          func_append linker_flags " $qarg"
     5459          func_append compiler_flags " $wl$qarg"
    14025460          prev=
    1403           compile_command="$compile_command $wl$qarg"
    1404           finalize_command="$finalize_command $wl$qarg"
    1405           continue
    1406           ;;
    1407         xcclinker)
    1408           linker_flags="$linker_flags $qarg"
    1409           compiler_flags="$compiler_flags $qarg"
    1410           prev=
    1411           compile_command="$compile_command $qarg"
    1412           finalize_command="$finalize_command $qarg"
    1413           continue
    1414           ;;
    1415         shrext)
    1416           shrext_cmds="$arg"
    1417           prev=
    1418           continue
    1419           ;;
    1420         darwin_framework|darwin_framework_skip)
    1421           test "$prev" = "darwin_framework" && compiler_flags="$compiler_flags $arg"
    1422           compile_command="$compile_command $arg"
    1423           finalize_command="$finalize_command $arg"
    1424           prev=
     5461          func_append compile_command " $wl$qarg"
     5462          func_append finalize_command " $wl$qarg"
    14255463          continue
    14265464          ;;
     
    14385476      -all-static)
    14395477        if test -n "$link_static_flag"; then
    1440           compile_command="$compile_command $link_static_flag"
    1441           finalize_command="$finalize_command $link_static_flag"
     5478          # See comment for -static flag below, for more details.
     5479          func_append compile_command " $link_static_flag"
     5480          func_append finalize_command " $link_static_flag"
    14425481        fi
    14435482        continue
     
    14465485      -allow-undefined)
    14475486        # FIXME: remove this flag sometime in the future.
    1448         $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
    1449         continue
     5487        func_fatal_error "\`-allow-undefined' must not be used because it is the default"
    14505488        ;;
    14515489
     
    14555493        ;;
    14565494
     5495      -bindir)
     5496        prev=bindir
     5497        continue
     5498        ;;
     5499
    14575500      -dlopen)
    14585501        prev=dlfiles
     
    14725515      -export-symbols | -export-symbols-regex)
    14735516        if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
    1474           $echo "$modename: more than one -exported-symbols argument is not allowed"
    1475           exit $EXIT_FAILURE
     5517          func_fatal_error "more than one -exported-symbols argument is not allowed"
    14765518        fi
    14775519        if test "X$arg" = "X-export-symbols"; then
     
    14835525        ;;
    14845526
    1485       -framework|-arch|-isysroot)
    1486         case " $CC " in
    1487           *" ${arg} ${1} "* | *" ${arg} ${1} "*)
    1488                 prev=darwin_framework_skip ;;
    1489           *) compiler_flags="$compiler_flags $arg"
    1490              prev=darwin_framework ;;
    1491         esac
    1492         compile_command="$compile_command $arg"
    1493         finalize_command="$finalize_command $arg"
     5527      -framework)
     5528        prev=framework
    14945529        continue
    14955530        ;;
     
    15055540        case $with_gcc/$host in
    15065541        no/*-*-irix* | /*-*-irix*)
    1507           compile_command="$compile_command $arg"
    1508           finalize_command="$finalize_command $arg"
     5542          func_append compile_command " $arg"
     5543          func_append finalize_command " $arg"
    15095544          ;;
    15105545        esac
     
    15135548
    15145549      -L*)
    1515         dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
     5550        func_stripname "-L" '' "$arg"
     5551        if test -z "$func_stripname_result"; then
     5552          if test "$#" -gt 0; then
     5553            func_fatal_error "require no space between \`-L' and \`$1'"
     5554          else
     5555            func_fatal_error "need path for \`-L' option"
     5556          fi
     5557        fi
     5558        func_resolve_sysroot "$func_stripname_result"
     5559        dir=$func_resolve_sysroot_result
    15165560        # We need an absolute path.
    15175561        case $dir in
     
    15195563        *)
    15205564          absdir=`cd "$dir" && pwd`
    1521           if test -z "$absdir"; then
    1522             $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
    1523             absdir="$dir"
    1524             notinst_path="$notinst_path $dir"
    1525           fi
     5565          test -z "$absdir" && \
     5566            func_fatal_error "cannot determine absolute directory name of \`$dir'"
    15265567          dir="$absdir"
    15275568          ;;
    15285569        esac
    15295570        case "$deplibs " in
    1530         *" -L$dir "*) ;;
     5571        *" -L$dir "* | *" $arg "*)
     5572          # Will only happen for absolute or sysroot arguments
     5573          ;;
    15315574        *)
    1532           deplibs="$deplibs -L$dir"
    1533           lib_search_path="$lib_search_path $dir"
     5575</