Changeset 289 for trunk/autoconf


Ignore:
Timestamp:
Jan 12, 2012 5:48:13 AM (9 years ago)
Author:
kulshres
Message:

regenerate files

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/autoconf/ltmain.sh

    r209 r289  
    1 # Generated from ltmain.m4sh.
    2 
    3 # ltmain.sh (GNU libtool) 2.2.6b
     1
     2# libtool (GNU libtool) 2.4
    43# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
    54
    6 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007 2008 Free Software Foundation, Inc.
     5# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
     6# 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
    77# This is free software; see the source for copying conditions.  There is NO
    88# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
     
    3333# Provide generalized library-building support services.
    3434#
    35 #     --config             show all configuration variables
    36 #     --debug              enable verbose shell tracing
    37 # -n, --dry-run            display commands without modifying any files
    38 #     --features           display basic configuration information and exit
    39 #     --mode=MODE          use operation mode MODE
    40 #     --preserve-dup-deps  don't remove duplicate dependency libraries
    41 #     --quiet, --silent    don't print informational messages
    42 #     --tag=TAG            use configuration variables from tag TAG
    43 # -v, --verbose            print informational messages (default)
    44 #     --version            print version information
    45 # -h, --help               print short or long help message
     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#       --tag=TAG            use configuration variables from tag TAG
     45#   -v, --verbose            print more informational messages than default
     46#       --no-verbose         don't print the extra informational messages
     47#       --version            print version information
     48#   -h, --help, --help-all   print short, long, or detailed help message
    4649#
    4750# MODE must be one of the following:
    4851#
    49 #       clean              remove files from the build directory
    50 #       compile            compile a source file into a libtool object
    51 #       execute            automatically set library path, then run a program
    52 #       finish             complete the installation of libtool libraries
    53 #       install            install libraries or executables
    54 #       link               create a library or an executable
    55 #       uninstall          remove libraries from an installed directory
     52#         clean              remove files from the build directory
     53#         compile            compile a source file into a libtool object
     54#         execute            automatically set library path, then run a program
     55#         finish             complete the installation of libtool libraries
     56#         install            install libraries or executables
     57#         link               create a library or an executable
     58#         uninstall          remove libraries from an installed directory
    5659#
    57 # MODE-ARGS vary depending on the MODE.
     60# MODE-ARGS vary depending on the MODE.  When passed as first option,
     61# `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
    5862# Try `$progname --help --mode=MODE' for a more detailed description of MODE.
    5963#
     
    6165# include the following information:
    6266#
    63 #       host-triplet:   $host
    64 #       shell:          $SHELL
    65 #       compiler:               $LTCC
    66 #       compiler flags:         $LTCFLAGS
    67 #       linker:         $LD (gnu? $with_gnu_ld)
    68 #       $progname:              (GNU libtool) 2.2.6b
    69 #       automake:               $automake_version
    70 #       autoconf:               $autoconf_version
     67#         host-triplet: $host
     68#         shell:                $SHELL
     69#         compiler:             $LTCC
     70#         compiler flags:               $LTCFLAGS
     71#         linker:               $LD (gnu? $with_gnu_ld)
     72#         $progname:    (GNU libtool) 2.4
     73#         automake:     $automake_version
     74#         autoconf:     $autoconf_version
    7175#
    7276# Report bugs to <bug-libtool@gnu.org>.
    73 
    74 PROGRAM=ltmain.sh
     77# GNU libtool home page: <http://www.gnu.org/software/libtool/>.
     78# General help using GNU software: <http://www.gnu.org/gethelp/>.
     79
     80PROGRAM=libtool
    7581PACKAGE=libtool
    76 VERSION=2.2.6b
     82VERSION=2.4
    7783TIMESTAMP=""
    78 package_revision=1.3018
     84package_revision=1.3293
    7985
    8086# Be Bourne compatible
     
    9298DUALCASE=1; export DUALCASE # for MKS sh
    9399
     100# A function that is used when there is no print builtin or printf.
     101func_fallback_echo ()
     102{
     103  eval 'cat <<_LTECHO_EOF
     104$1
     105_LTECHO_EOF'
     106}
     107
    94108# NLS nuisances: We save the old values to restore during execute mode.
    95 # Only set LANG and LC_ALL to C if already set.
    96 # These must not be set unconditionally because not all systems understand
    97 # e.g. LANG=C (notably SCO).
    98109lt_user_locale=
    99110lt_safe_locale=
     
    108119        fi"
    109120done
     121LC_ALL=C
     122LANGUAGE=C
     123export LANGUAGE LC_ALL
    110124
    111125$lt_unset CDPATH
    112126
    113127
     128# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
     129# is ksh but when the shell is invoked as "sh" and the current value of
     130# the _XPG environment variable is not equal to 1 (one), the special
     131# positional parameter $0, within a function call, is the name of the
     132# function.
     133progpath="$0"
    114134
    115135
    116136
    117137: ${CP="cp -f"}
    118 : ${ECHO="echo"}
    119 : ${EGREP="/usr/bin/grep -E"}
    120 : ${FGREP="/usr/bin/grep -F"}
    121 : ${GREP="/usr/bin/grep"}
     138test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
     139: ${EGREP="grep -E"}
     140: ${FGREP="grep -F"}
     141: ${GREP="grep"}
    122142: ${LN_S="ln -s"}
    123143: ${MAKE="make"}
     
    125145: ${MV="mv -f"}
    126146: ${RM="rm -f"}
    127 : ${SED="/usr/bin/sed"}
     147: ${SED="sed"}
    128148: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
    129149: ${Xsed="$SED -e 1s/^X//"}
     
    144164dirname="s,/[^/]*$,,"
    145165basename="s,^.*/,,"
     166
     167# func_dirname file append nondir_replacement
     168# Compute the dirname of FILE.  If nonempty, add APPEND to the result,
     169# otherwise set result to NONDIR_REPLACEMENT.
     170func_dirname ()
     171{
     172    func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`
     173    if test "X$func_dirname_result" = "X${1}"; then
     174      func_dirname_result="${3}"
     175    else
     176      func_dirname_result="$func_dirname_result${2}"
     177    fi
     178} # func_dirname may be replaced by extended shell implementation
     179
     180
     181# func_basename file
     182func_basename ()
     183{
     184    func_basename_result=`$ECHO "${1}" | $SED "$basename"`
     185} # func_basename may be replaced by extended shell implementation
     186
    146187
    147188# func_dirname_and_basename file append nondir_replacement
     
    159200func_dirname_and_basename ()
    160201{
    161   # Extract subdirectory from the argument.
    162   func_dirname_result=`$ECHO "X${1}" | $Xsed -e "$dirname"`
    163   if test "X$func_dirname_result" = "X${1}"; then
    164     func_dirname_result="${3}"
    165   else
    166     func_dirname_result="$func_dirname_result${2}"
     202    # Extract subdirectory from the argument.
     203    func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
     204    if test "X$func_dirname_result" = "X${1}"; then
     205      func_dirname_result="${3}"
     206    else
     207      func_dirname_result="$func_dirname_result${2}"
     208    fi
     209    func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
     210} # func_dirname_and_basename may be replaced by extended shell implementation
     211
     212
     213# func_stripname prefix suffix name
     214# strip PREFIX and SUFFIX off of NAME.
     215# PREFIX and SUFFIX must not contain globbing or regex special
     216# characters, hashes, percent signs, but SUFFIX may contain a leading
     217# dot (in which case that matches only a dot).
     218# func_strip_suffix prefix name
     219func_stripname ()
     220{
     221    case ${2} in
     222      .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
     223      *)  func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
     224    esac
     225} # func_stripname may be replaced by extended shell implementation
     226
     227
     228# These SED scripts presuppose an absolute path with a trailing slash.
     229pathcar='s,^/\([^/]*\).*$,\1,'
     230pathcdr='s,^/[^/]*,,'
     231removedotparts=':dotsl
     232                s@/\./@/@g
     233                t dotsl
     234                s,/\.$,/,'
     235collapseslashes='s@/\{1,\}@/@g'
     236finalslash='s,/*$,/,'
     237
     238# func_normal_abspath PATH
     239# Remove doubled-up and trailing slashes, "." path components,
     240# and cancel out any ".." path components in PATH after making
     241# it an absolute path.
     242#             value returned in "$func_normal_abspath_result"
     243func_normal_abspath ()
     244{
     245  # Start from root dir and reassemble the path.
     246  func_normal_abspath_result=
     247  func_normal_abspath_tpath=$1
     248  func_normal_abspath_altnamespace=
     249  case $func_normal_abspath_tpath in
     250    "")
     251      # Empty path, that just means $cwd.
     252      func_stripname '' '/' "`pwd`"
     253      func_normal_abspath_result=$func_stripname_result
     254      return
     255    ;;
     256    # The next three entries are used to spot a run of precisely
     257    # two leading slashes without using negated character classes;
     258    # we take advantage of case's first-match behaviour.
     259    ///*)
     260      # Unusual form of absolute path, do nothing.
     261    ;;
     262    //*)
     263      # Not necessarily an ordinary path; POSIX reserves leading '//'
     264      # and for example Cygwin uses it to access remote file shares
     265      # over CIFS/SMB, so we conserve a leading double slash if found.
     266      func_normal_abspath_altnamespace=/
     267    ;;
     268    /*)
     269      # Absolute path, do nothing.
     270    ;;
     271    *)
     272      # Relative path, prepend $cwd.
     273      func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
     274    ;;
     275  esac
     276  # Cancel out all the simple stuff to save iterations.  We also want
     277  # the path to end with a slash for ease of parsing, so make sure
     278  # there is one (and only one) here.
     279  func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
     280        -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
     281  while :; do
     282    # Processed it all yet?
     283    if test "$func_normal_abspath_tpath" = / ; then
     284      # If we ascended to the root using ".." the result may be empty now.
     285      if test -z "$func_normal_abspath_result" ; then
     286        func_normal_abspath_result=/
     287      fi
     288      break
     289    fi
     290    func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
     291        -e "$pathcar"`
     292    func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
     293        -e "$pathcdr"`
     294    # Figure out what to do with it
     295    case $func_normal_abspath_tcomponent in
     296      "")
     297        # Trailing empty path component, ignore it.
     298      ;;
     299      ..)
     300        # Parent dir; strip last assembled component from result.
     301        func_dirname "$func_normal_abspath_result"
     302        func_normal_abspath_result=$func_dirname_result
     303      ;;
     304      *)
     305        # Actual path component, append it.
     306        func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
     307      ;;
     308    esac
     309  done
     310  # Restore leading double-slash if one was found on entry.
     311  func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
     312}
     313
     314# func_relative_path SRCDIR DSTDIR
     315# generates a relative path from SRCDIR to DSTDIR, with a trailing
     316# slash if non-empty, suitable for immediately appending a filename
     317# without needing to append a separator.
     318#             value returned in "$func_relative_path_result"
     319func_relative_path ()
     320{
     321  func_relative_path_result=
     322  func_normal_abspath "$1"
     323  func_relative_path_tlibdir=$func_normal_abspath_result
     324  func_normal_abspath "$2"
     325  func_relative_path_tbindir=$func_normal_abspath_result
     326
     327  # Ascend the tree starting from libdir
     328  while :; do
     329    # check if we have found a prefix of bindir
     330    case $func_relative_path_tbindir in
     331      $func_relative_path_tlibdir)
     332        # found an exact match
     333        func_relative_path_tcancelled=
     334        break
     335        ;;
     336      $func_relative_path_tlibdir*)
     337        # found a matching prefix
     338        func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
     339        func_relative_path_tcancelled=$func_stripname_result
     340        if test -z "$func_relative_path_result"; then
     341          func_relative_path_result=.
     342        fi
     343        break
     344        ;;
     345      *)
     346        func_dirname $func_relative_path_tlibdir
     347        func_relative_path_tlibdir=${func_dirname_result}
     348        if test "x$func_relative_path_tlibdir" = x ; then
     349          # Have to descend all the way to the root!
     350          func_relative_path_result=../$func_relative_path_result
     351          func_relative_path_tcancelled=$func_relative_path_tbindir
     352          break
     353        fi
     354        func_relative_path_result=../$func_relative_path_result
     355        ;;
     356    esac
     357  done
     358
     359  # Now calculate path; take care to avoid doubling-up slashes.
     360  func_stripname '' '/' "$func_relative_path_result"
     361  func_relative_path_result=$func_stripname_result
     362  func_stripname '/' '/' "$func_relative_path_tcancelled"
     363  if test "x$func_stripname_result" != x ; then
     364    func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
    167365  fi
    168   func_basename_result=`$ECHO "X${1}" | $Xsed -e "$basename"`
    169 }
    170 
    171 # Generated shell functions inserted here.
    172 
    173 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
    174 # is ksh but when the shell is invoked as "sh" and the current value of
    175 # the _XPG environment variable is not equal to 1 (one), the special
    176 # positional parameter $0, within a function call, is the name of the
    177 # function.
    178 progpath="$0"
     366
     367  # Normalisation. If bindir is libdir, return empty string,
     368  # else relative path ending with a slash; either way, target
     369  # file name can be directly appended.
     370  if test ! -z "$func_relative_path_result"; then
     371    func_stripname './' '' "$func_relative_path_result/"
     372    func_relative_path_result=$func_stripname_result
     373  fi
     374}
    179375
    180376# The name of this program:
    181 # In the unlikely event $progname began with a '-', it would play havoc with
    182 # func_echo (imagine progname=-n), so we prepend ./ in that case:
    183377func_dirname_and_basename "$progpath"
    184378progname=$func_basename_result
    185 case $progname in
    186   -*) progname=./$progname ;;
    187 esac
    188379
    189380# Make sure we have an absolute path for reexecution:
     
    216407double_quote_subst='s/\(["`\\]\)/\\\1/g'
    217408
     409# Sed substitution that turns a string into a regex matching for the
     410# string literally.
     411sed_make_literal_regex='s,[].[^$\\*\/],\\&,g'
     412
     413# Sed substitution that converts a w32 file name or path
     414# which contains forward slashes, into one that contains
     415# (escaped) backslashes.  A very naive implementation.
     416lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
     417
    218418# Re-`\' parameter expansions in output of double_quote_subst that were
    219419# `\'-ed in input to the same.  If an odd number of `\' preceded a '$'
     
    244444func_echo ()
    245445{
    246     $ECHO "$progname${mode+: }$mode: $*"
     446    $ECHO "$progname: ${opt_mode+$opt_mode: }$*"
    247447}
    248448
     
    259459}
    260460
     461# func_echo_all arg...
     462# Invoke $ECHO with all args, space-separated.
     463func_echo_all ()
     464{
     465    $ECHO "$*"
     466}
     467
    261468# func_error arg...
    262469# Echo program name prefixed message to standard error.
    263470func_error ()
    264471{
    265     $ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
     472    $ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
    266473}
    267474
     
    270477func_warning ()
    271478{
    272     $opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
     479    $opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
    273480
    274481    # bash bug again:
     
    327534
    328535        # ...otherwise throw away the child directory and loop
    329         my_directory_path=`$ECHO "X$my_directory_path" | $Xsed -e "$dirname"`
     536        my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
    330537      done
    331       my_dir_list=`$ECHO "X$my_dir_list" | $Xsed -e 's,:*$,,'`
     538      my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
    332539
    333540      save_mkdir_p_IFS="$IFS"; IFS=':'
     
    379586    fi
    380587
    381     $ECHO "X$my_tmpdir" | $Xsed
     588    $ECHO "$my_tmpdir"
    382589}
    383590
     
    393600    case $1 in
    394601      *[\\\`\"\$]*)
    395         func_quote_for_eval_unquoted_result=`$ECHO "X$1" | $Xsed -e "$sed_quote_subst"` ;;
     602        func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
    396603      *)
    397604        func_quote_for_eval_unquoted_result="$1" ;;
     
    420627    case $1 in
    421628      *[\\\`\"]*)
    422         my_arg=`$ECHO "X$1" | $Xsed \
     629        my_arg=`$ECHO "$1" | $SED \
    423630            -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
    424631      *)
     
    489696}
    490697
    491 
    492 
     698# func_tr_sh
     699# Turn $1 into a string suitable for a shell variable name.
     700# Result is stored in $func_tr_sh_result.  All characters
     701# not in the set a-zA-Z0-9_ are replaced with '_'. Further,
     702# if $1 begins with a digit, a '_' is prepended as well.
     703func_tr_sh ()
     704{
     705  case $1 in
     706  [0-9]* | *[!a-zA-Z0-9_]*)
     707    func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'`
     708    ;;
     709  * )
     710    func_tr_sh_result=$1
     711    ;;
     712  esac
     713}
    493714
    494715
     
    497718func_version ()
    498719{
    499     $SED -n '/^# '$PROGRAM' (GNU /,/# warranty; / {
     720    $opt_debug
     721
     722    $SED -n '/(C)/!b go
     723        :more
     724        /\./!{
     725          N
     726          s/\n# / /
     727          b more
     728        }
     729        :go
     730        /^# '$PROGRAM' (GNU /,/# warranty; / {
    500731        s/^# //
    501732        s/^# *$//
     
    510741func_usage ()
    511742{
    512     $SED -n '/^# Usage:/,/# -h/ {
     743    $opt_debug
     744
     745    $SED -n '/^# Usage:/,/^#  *.*--help/ {
    513746        s/^# //
    514747        s/^# *$//
     
    516749        p
    517750    }' < "$progpath"
    518     $ECHO
     751    echo
    519752    $ECHO "run \`$progname --help | more' for full usage"
    520753    exit $?
    521754}
    522755
    523 # func_help
    524 # Echo long help message to standard output and exit.
     756# func_help [NOEXIT]
     757# Echo long help message to standard output and exit,
     758# unless 'noexit' is passed as argument.
    525759func_help ()
    526760{
     761    $opt_debug
     762
    527763    $SED -n '/^# Usage:/,/# Report bugs to/ {
     764        :print
    528765        s/^# //
    529766        s/^# *$//
     
    538775        s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
    539776        p
    540      }' < "$progpath"
    541     exit $?
     777        d
     778     }
     779     /^# .* home page:/b print
     780     /^# General help using/b print
     781     ' < "$progpath"
     782    ret=$?
     783    if test -z "$1"; then
     784      exit $ret
     785    fi
    542786}
    543787
     
    547791func_missing_arg ()
    548792{
    549     func_error "missing argument for $1"
     793    $opt_debug
     794
     795    func_error "missing argument for $1."
    550796    exit_cmd=exit
    551797}
    552798
     799
     800# func_split_short_opt shortopt
     801# Set func_split_short_opt_name and func_split_short_opt_arg shell
     802# variables after splitting SHORTOPT after the 2nd character.
     803func_split_short_opt ()
     804{
     805    my_sed_short_opt='1s/^\(..\).*$/\1/;q'
     806    my_sed_short_rest='1s/^..\(.*\)$/\1/;q'
     807
     808    func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`
     809    func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`
     810} # func_split_short_opt may be replaced by extended shell implementation
     811
     812
     813# func_split_long_opt longopt
     814# Set func_split_long_opt_name and func_split_long_opt_arg shell
     815# variables after splitting LONGOPT at the `=' sign.
     816func_split_long_opt ()
     817{
     818    my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q'
     819    my_sed_long_arg='1s/^--[^=]*=//'
     820
     821    func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`
     822    func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`
     823} # func_split_long_opt may be replaced by extended shell implementation
     824
    553825exit_cmd=:
    554826
     
    556828
    557829
    558 
    559 # Check that we have a working $ECHO.
    560 if test "X$1" = X--no-reexec; then
    561   # Discard the --no-reexec flag, and continue.
    562   shift
    563 elif test "X$1" = X--fallback-echo; then
    564   # Avoid inline document here, it may be left over
    565   :
    566 elif test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t'; then
    567   # Yippee, $ECHO works!
    568   :
    569 else
    570   # Restart under the correct shell, and then maybe $ECHO will work.
    571   exec $SHELL "$progpath" --no-reexec ${1+"$@"}
    572 fi
    573 
    574 if test "X$1" = X--fallback-echo; then
    575   # used as fallback echo
    576   shift
    577   cat <<EOF
    578 $*
    579 EOF
    580   exit $EXIT_SUCCESS
    581 fi
    582830
    583831magic="%%%MAGIC variable%%%"
     
    585833
    586834# Global variables.
    587 # $mode is unset
    588835nonopt=
    589 execute_dlfiles=
    590836preserve_args=
    591837lo2o="s/\\.lo\$/.${objext}/"
     
    594840extracted_serial=0
    595841
    596 opt_dry_run=false
    597 opt_duplicate_deps=false
    598 opt_silent=false
    599 opt_debug=:
    600 
    601842# If this variable is set in any of the actions, the command in it
    602843# will be execed at the end.  This prevents here-documents from being
     
    604845exec_cmd=
    605846
     847# func_append var value
     848# Append VALUE to the end of shell variable VAR.
     849func_append ()
     850{
     851    eval "${1}=\$${1}\${2}"
     852} # func_append may be replaced by extended shell implementation
     853
     854# func_append_quoted var value
     855# Quote VALUE and append to the end of shell variable VAR, separated
     856# by a space.
     857func_append_quoted ()
     858{
     859    func_quote_for_eval "${2}"
     860    eval "${1}=\$${1}\\ \$func_quote_for_eval_result"
     861} # func_append_quoted may be replaced by extended shell implementation
     862
     863
     864# func_arith arithmetic-term...
     865func_arith ()
     866{
     867    func_arith_result=`expr "${@}"`
     868} # func_arith may be replaced by extended shell implementation
     869
     870
     871# func_len string
     872# STRING may not start with a hyphen.
     873func_len ()
     874{
     875    func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len`
     876} # func_len may be replaced by extended shell implementation
     877
     878
     879# func_lo2o object
     880func_lo2o ()
     881{
     882    func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`
     883} # func_lo2o may be replaced by extended shell implementation
     884
     885
     886# func_xform libobj-or-source
     887func_xform ()
     888{
     889    func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`
     890} # func_xform may be replaced by extended shell implementation
     891
     892
    606893# func_fatal_configuration arg...
    607894# Echo program name prefixed message to standard error, followed by
     
    637924func_features ()
    638925{
    639     $ECHO "host: $host"
     926    echo "host: $host"
    640927    if test "$build_libtool_libs" = yes; then
    641       $ECHO "enable shared libraries"
     928      echo "enable shared libraries"
    642929    else
    643       $ECHO "disable shared libraries"
     930      echo "disable shared libraries"
    644931    fi
    645932    if test "$build_old_libs" = yes; then
    646       $ECHO "enable static libraries"
     933      echo "enable static libraries"
    647934    else
    648       $ECHO "disable static libraries"
     935      echo "disable static libraries"
    649936    fi
    650937
     
    691978      ;;
    692979  esac
    693 }
    694 
    695 # Parse options once, thoroughly.  This comes as soon as possible in
    696 # the script to make things like `libtool --version' happen quickly.
    697 {
    698 
    699   # Shorthand for --mode=foo, only valid as the first argument
    700   case $1 in
    701   clean|clea|cle|cl)
    702     shift; set dummy --mode clean ${1+"$@"}; shift
    703     ;;
    704   compile|compil|compi|comp|com|co|c)
    705     shift; set dummy --mode compile ${1+"$@"}; shift
    706     ;;
    707   execute|execut|execu|exec|exe|ex|e)
    708     shift; set dummy --mode execute ${1+"$@"}; shift
    709     ;;
    710   finish|finis|fini|fin|fi|f)
    711     shift; set dummy --mode finish ${1+"$@"}; shift
    712     ;;
    713   install|instal|insta|inst|ins|in|i)
    714     shift; set dummy --mode install ${1+"$@"}; shift
    715     ;;
    716   link|lin|li|l)
    717     shift; set dummy --mode link ${1+"$@"}; shift
    718     ;;
    719   uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
    720     shift; set dummy --mode uninstall ${1+"$@"}; shift
    721     ;;
    722   esac
    723 
    724   # Parse non-mode specific arguments:
    725   while test "$#" -gt 0; do
    726     opt="$1"
    727     shift
    728 
    729     case $opt in
    730       --config)         func_config                                     ;;
    731 
    732       --debug)          preserve_args="$preserve_args $opt"
    733                         func_echo "enabling shell trace mode"
    734                         opt_debug='set -x'
    735                         $opt_debug
    736                         ;;
    737 
    738       -dlopen)          test "$#" -eq 0 && func_missing_arg "$opt" && break
    739                         execute_dlfiles="$execute_dlfiles $1"
    740                         shift
    741                         ;;
    742 
    743       --dry-run | -n)   opt_dry_run=:                                   ;;
    744       --features)       func_features                                   ;;
    745       --finish)         mode="finish"                                   ;;
    746 
    747       --mode)           test "$#" -eq 0 && func_missing_arg "$opt" && break
    748                         case $1 in
    749                           # Valid mode arguments:
    750                           clean)        ;;
    751                           compile)      ;;
    752                           execute)      ;;
    753                           finish)       ;;
    754                           install)      ;;
    755                           link)         ;;
    756                           relink)       ;;
    757                           uninstall)    ;;
    758 
    759                           # Catch anything else as an error
    760                           *) func_error "invalid argument for $opt"
    761                              exit_cmd=exit
    762                              break
    763                              ;;
    764                         esac
    765 
    766                         mode="$1"
    767                         shift
    768                         ;;
    769 
    770       --preserve-dup-deps)
    771                         opt_duplicate_deps=:                            ;;
    772 
    773       --quiet|--silent) preserve_args="$preserve_args $opt"
    774                         opt_silent=:
    775                         ;;
    776 
    777       --verbose| -v)    preserve_args="$preserve_args $opt"
    778                         opt_silent=false
    779                         ;;
    780 
    781       --tag)            test "$#" -eq 0 && func_missing_arg "$opt" && break
    782                         preserve_args="$preserve_args $opt $1"
    783                         func_enable_tag "$1"    # tagname is set here
    784                         shift
    785                         ;;
    786 
    787       # Separate optargs to long options:
    788       -dlopen=*|--mode=*|--tag=*)
    789                         func_opt_split "$opt"
    790                         set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}
    791                         shift
    792                         ;;
    793 
    794       -\?|-h)           func_usage                                      ;;
    795       --help)           opt_help=:                                      ;;
    796       --version)        func_version                                    ;;
    797 
    798       -*)               func_fatal_help "unrecognized option \`$opt'"   ;;
    799 
    800       *)                nonopt="$opt"
    801                         break
    802                         ;;
    803     esac
    804   done
    805 
    806 
    807   case $host in
    808     *cygwin* | *mingw* | *pw32* | *cegcc*)
    809       # don't eliminate duplications in $postdeps and $predeps
    810       opt_duplicate_compiler_generated_deps=:
    811       ;;
    812     *)
    813       opt_duplicate_compiler_generated_deps=$opt_duplicate_deps
    814       ;;
    815   esac
    816 
    817   # Having warned about all mis-specified options, bail out if
    818   # anything was wrong.
    819   $exit_cmd $EXIT_FAILURE
    820980}
    821981
     
    8561016
    8571017
     1018# Shorthand for --mode=foo, only valid as the first argument
     1019case $1 in
     1020clean|clea|cle|cl)
     1021  shift; set dummy --mode clean ${1+"$@"}; shift
     1022  ;;
     1023compile|compil|compi|comp|com|co|c)
     1024  shift; set dummy --mode compile ${1+"$@"}; shift
     1025  ;;
     1026execute|execut|execu|exec|exe|ex|e)
     1027  shift; set dummy --mode execute ${1+"$@"}; shift
     1028  ;;
     1029finish|finis|fini|fin|fi|f)
     1030  shift; set dummy --mode finish ${1+"$@"}; shift
     1031  ;;
     1032install|instal|insta|inst|ins|in|i)
     1033  shift; set dummy --mode install ${1+"$@"}; shift
     1034  ;;
     1035link|lin|li|l)
     1036  shift; set dummy --mode link ${1+"$@"}; shift
     1037  ;;
     1038uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
     1039  shift; set dummy --mode uninstall ${1+"$@"}; shift
     1040  ;;
     1041esac
     1042
     1043
     1044
     1045# Option defaults:
     1046opt_debug=:
     1047opt_dry_run=false
     1048opt_config=false
     1049opt_preserve_dup_deps=false
     1050opt_features=false
     1051opt_finish=false
     1052opt_help=false
     1053opt_help_all=false
     1054opt_silent=:
     1055opt_verbose=:
     1056opt_silent=false
     1057opt_verbose=false
     1058
     1059
     1060# Parse options once, thoroughly.  This comes as soon as possible in the
     1061# script to make things like `--version' happen as quickly as we can.
     1062{
     1063  # this just eases exit handling
     1064  while test $# -gt 0; do
     1065    opt="$1"
     1066    shift
     1067    case $opt in
     1068      --debug|-x)       opt_debug='set -x'
     1069                        func_echo "enabling shell trace mode"
     1070                        $opt_debug
     1071                        ;;
     1072      --dry-run|--dryrun|-n)
     1073                        opt_dry_run=:
     1074                        ;;
     1075      --config)
     1076                        opt_config=:
     1077func_config
     1078                        ;;
     1079      --dlopen|-dlopen)
     1080                        optarg="$1"
     1081                        opt_dlopen="${opt_dlopen+$opt_dlopen
     1082}$optarg"
     1083                        shift
     1084                        ;;
     1085      --preserve-dup-deps)
     1086                        opt_preserve_dup_deps=:
     1087                        ;;
     1088      --features)
     1089                        opt_features=:
     1090func_features
     1091                        ;;
     1092      --finish)
     1093                        opt_finish=:
     1094set dummy --mode finish ${1+"$@"}; shift
     1095                        ;;
     1096      --help)
     1097                        opt_help=:
     1098                        ;;
     1099      --help-all)
     1100                        opt_help_all=:
     1101opt_help=': help-all'
     1102                        ;;
     1103      --mode)
     1104                        test $# = 0 && func_missing_arg $opt && break
     1105                        optarg="$1"
     1106                        opt_mode="$optarg"
     1107case $optarg in
     1108  # Valid mode arguments:
     1109  clean|compile|execute|finish|install|link|relink|uninstall) ;;
     1110
     1111  # Catch anything else as an error
     1112  *) func_error "invalid argument for $opt"
     1113     exit_cmd=exit
     1114     break
     1115     ;;
     1116esac
     1117                        shift
     1118                        ;;
     1119      --no-silent|--no-quiet)
     1120                        opt_silent=false
     1121func_append preserve_args " $opt"
     1122                        ;;
     1123      --no-verbose)
     1124                        opt_verbose=false
     1125func_append preserve_args " $opt"
     1126                        ;;
     1127      --silent|--quiet)
     1128                        opt_silent=:
     1129func_append preserve_args " $opt"
     1130        opt_verbose=false
     1131                        ;;
     1132      --verbose|-v)
     1133                        opt_verbose=:
     1134func_append preserve_args " $opt"
     1135opt_silent=false
     1136                        ;;
     1137      --tag)
     1138                        test $# = 0 && func_missing_arg $opt && break
     1139                        optarg="$1"
     1140                        opt_tag="$optarg"
     1141func_append preserve_args " $opt $optarg"
     1142func_enable_tag "$optarg"
     1143                        shift
     1144                        ;;
     1145
     1146      -\?|-h)           func_usage                              ;;
     1147      --help)           func_help                               ;;
     1148      --version)        func_version                            ;;
     1149
     1150      # Separate optargs to long options:
     1151      --*=*)
     1152                        func_split_long_opt "$opt"
     1153                        set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}
     1154                        shift
     1155                        ;;
     1156
     1157      # Separate non-argument short options:
     1158      -\?*|-h*|-n*|-v*)
     1159                        func_split_short_opt "$opt"
     1160                        set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}
     1161                        shift
     1162                        ;;
     1163
     1164      --)               break                                   ;;
     1165      -*)               func_fatal_help "unrecognized option \`$opt'" ;;
     1166      *)                set dummy "$opt" ${1+"$@"};     shift; break  ;;
     1167    esac
     1168  done
     1169
     1170  # Validate options:
     1171
     1172  # save first non-option argument
     1173  if test "$#" -gt 0; then
     1174    nonopt="$opt"
     1175    shift
     1176  fi
     1177
     1178  # preserve --debug
     1179  test "$opt_debug" = : || func_append preserve_args " --debug"
     1180
     1181  case $host in
     1182    *cygwin* | *mingw* | *pw32* | *cegcc*)
     1183      # don't eliminate duplications in $postdeps and $predeps
     1184      opt_duplicate_compiler_generated_deps=:
     1185      ;;
     1186    *)
     1187      opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
     1188      ;;
     1189  esac
     1190
     1191  $opt_help || {
     1192    # Sanity checks first:
     1193    func_check_version_match
     1194
     1195    if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
     1196      func_fatal_configuration "not configured to build any kind of library"
     1197    fi
     1198
     1199    # Darwin sucks
     1200    eval std_shrext=\"$shrext_cmds\"
     1201
     1202    # Only execute mode is allowed to have -dlopen flags.
     1203    if test -n "$opt_dlopen" && test "$opt_mode" != execute; then
     1204      func_error "unrecognized option \`-dlopen'"
     1205      $ECHO "$help" 1>&2
     1206      exit $EXIT_FAILURE
     1207    fi
     1208
     1209    # Change the help message to a mode-specific one.
     1210    generic_help="$help"
     1211    help="Try \`$progname --help --mode=$opt_mode' for more information."
     1212  }
     1213
     1214
     1215  # Bail if the options were screwed
     1216  $exit_cmd $EXIT_FAILURE
     1217}
     1218
     1219
     1220
     1221
    8581222## ----------- ##
    8591223##    Main.    ##
    8601224## ----------- ##
    861 
    862 $opt_help || {
    863   # Sanity checks first:
    864   func_check_version_match
    865 
    866   if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
    867     func_fatal_configuration "not configured to build any kind of library"
    868   fi
    869 
    870   test -z "$mode" && func_fatal_error "error: you must specify a MODE."
    871 
    872 
    873   # Darwin sucks
    874   eval std_shrext=\"$shrext_cmds\"
    875 
    876 
    877   # Only execute mode is allowed to have -dlopen flags.
    878   if test -n "$execute_dlfiles" && test "$mode" != execute; then
    879     func_error "unrecognized option \`-dlopen'"
    880     $ECHO "$help" 1>&2
    881     exit $EXIT_FAILURE
    882   fi
    883 
    884   # Change the help message to a mode-specific one.
    885   generic_help="$help"
    886   help="Try \`$progname --help --mode=$mode' for more information."
    887 }
    888 
    8891225
    8901226# func_lalib_p file
     
    9511287func_ltwrapper_scriptname ()
    9521288{
    953     func_ltwrapper_scriptname_result=""
    954     if func_ltwrapper_executable_p "$1"; then
    955         func_dirname_and_basename "$1" "" "."
    956         func_stripname '' '.exe' "$func_basename_result"
    957         func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
    958     fi
     1289    func_dirname_and_basename "$1" "" "."
     1290    func_stripname '' '.exe' "$func_basename_result"
     1291    func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
    9591292}
    9601293
     
    10021335
    10031336
     1337# func_resolve_sysroot PATH
     1338# Replace a leading = in PATH with a sysroot.  Store the result into
     1339# func_resolve_sysroot_result
     1340func_resolve_sysroot ()
     1341{
     1342  func_resolve_sysroot_result=$1
     1343  case $func_resolve_sysroot_result in
     1344  =*)
     1345    func_stripname '=' '' "$func_resolve_sysroot_result"
     1346    func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
     1347    ;;
     1348  esac
     1349}
     1350
     1351# func_replace_sysroot PATH
     1352# If PATH begins with the sysroot, replace it with = and
     1353# store the result into func_replace_sysroot_result.
     1354func_replace_sysroot ()
     1355{
     1356  case "$lt_sysroot:$1" in
     1357  ?*:"$lt_sysroot"*)
     1358    func_stripname "$lt_sysroot" '' "$1"
     1359    func_replace_sysroot_result="=$func_stripname_result"
     1360    ;;
     1361  *)
     1362    # Including no sysroot.
     1363    func_replace_sysroot_result=$1
     1364    ;;
     1365  esac
     1366}
     1367
    10041368# func_infer_tag arg
    10051369# Infer tagged configuration to use if any are available and
     
    10141378      CC_quoted=
    10151379      for arg in $CC; do
    1016         func_quote_for_eval "$arg"
    1017         CC_quoted="$CC_quoted $func_quote_for_eval_result"
     1380        func_append_quoted CC_quoted "$arg"
    10181381      done
     1382      CC_expanded=`func_echo_all $CC`
     1383      CC_quoted_expanded=`func_echo_all $CC_quoted`
    10191384      case $@ in
    10201385      # Blanks in the command may have been stripped by the calling shell,
    10211386      # but not from the CC environment variable when configure was run.
    1022       " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*) ;;
     1387      " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
     1388      " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
    10231389      # Blanks at the start of $base_compile will cause this to fail
    10241390      # if we don't check for them as well.
     
    10311397            for arg in $CC; do
    10321398              # Double-quote args containing other shell metacharacters.
    1033               func_quote_for_eval "$arg"
    1034               CC_quoted="$CC_quoted $func_quote_for_eval_result"
     1399              func_append_quoted CC_quoted "$arg"
    10351400            done
     1401            CC_expanded=`func_echo_all $CC`
     1402            CC_quoted_expanded=`func_echo_all $CC_quoted`
    10361403            case "$@ " in
    1037               " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*)
     1404            " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
     1405            " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
    10381406              # The compiler in the base compile command matches
    10391407              # the one in the tagged configuration.
     
    10981466}
    10991467
     1468
     1469##################################################
     1470# FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
     1471##################################################
     1472
     1473# func_convert_core_file_wine_to_w32 ARG
     1474# Helper function used by file name conversion functions when $build is *nix,
     1475# and $host is mingw, cygwin, or some other w32 environment. Relies on a
     1476# correctly configured wine environment available, with the winepath program
     1477# in $build's $PATH.
     1478#
     1479# ARG is the $build file name to be converted to w32 format.
     1480# Result is available in $func_convert_core_file_wine_to_w32_result, and will
     1481# be empty on error (or when ARG is empty)
     1482func_convert_core_file_wine_to_w32 ()
     1483{
     1484  $opt_debug
     1485  func_convert_core_file_wine_to_w32_result="$1"
     1486  if test -n "$1"; then
     1487    # Unfortunately, winepath does not exit with a non-zero error code, so we
     1488    # are forced to check the contents of stdout. On the other hand, if the
     1489    # command is not found, the shell will set an exit code of 127 and print
     1490    # *an error message* to stdout. So we must check for both error code of
     1491    # zero AND non-empty stdout, which explains the odd construction:
     1492    func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
     1493    if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then
     1494      func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
     1495        $SED -e "$lt_sed_naive_backslashify"`
     1496    else
     1497      func_convert_core_file_wine_to_w32_result=
     1498    fi
     1499  fi
     1500}
     1501# end: func_convert_core_file_wine_to_w32
     1502
     1503
     1504# func_convert_core_path_wine_to_w32 ARG
     1505# Helper function used by path conversion functions when $build is *nix, and
     1506# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
     1507# configured wine environment available, with the winepath program in $build's
     1508# $PATH. Assumes ARG has no leading or trailing path separator characters.
     1509#
     1510# ARG is path to be converted from $build format to win32.
     1511# Result is available in $func_convert_core_path_wine_to_w32_result.
     1512# Unconvertible file (directory) names in ARG are skipped; if no directory names
     1513# are convertible, then the result may be empty.
     1514func_convert_core_path_wine_to_w32 ()
     1515{
     1516  $opt_debug
     1517  # unfortunately, winepath doesn't convert paths, only file names
     1518  func_convert_core_path_wine_to_w32_result=""
     1519  if test -n "$1"; then
     1520    oldIFS=$IFS
     1521    IFS=:
     1522    for func_convert_core_path_wine_to_w32_f in $1; do
     1523      IFS=$oldIFS
     1524      func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
     1525      if test -n "$func_convert_core_file_wine_to_w32_result" ; then
     1526        if test -z "$func_convert_core_path_wine_to_w32_result"; then
     1527          func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"
     1528        else
     1529          func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
     1530        fi
     1531      fi
     1532    done
     1533    IFS=$oldIFS
     1534  fi
     1535}
     1536# end: func_convert_core_path_wine_to_w32
     1537
     1538
     1539# func_cygpath ARGS...
     1540# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
     1541# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
     1542# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
     1543# (2), returns the Cygwin file name or path in func_cygpath_result (input
     1544# file name or path is assumed to be in w32 format, as previously converted
     1545# from $build's *nix or MSYS format). In case (3), returns the w32 file name
     1546# or path in func_cygpath_result (input file name or path is assumed to be in
     1547# Cygwin format). Returns an empty string on error.
     1548#
     1549# ARGS are passed to cygpath, with the last one being the file name or path to
     1550# be converted.
     1551#
     1552# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
     1553# environment variable; do not put it in $PATH.
     1554func_cygpath ()
     1555{
     1556  $opt_debug
     1557  if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
     1558    func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
     1559    if test "$?" -ne 0; then
     1560      # on failure, ensure result is empty
     1561      func_cygpath_result=
     1562    fi
     1563  else
     1564    func_cygpath_result=
     1565    func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"
     1566  fi
     1567}
     1568#end: func_cygpath
     1569
     1570
     1571# func_convert_core_msys_to_w32 ARG
     1572# Convert file name or path ARG from MSYS format to w32 format.  Return
     1573# result in func_convert_core_msys_to_w32_result.
     1574func_convert_core_msys_to_w32 ()
     1575{
     1576  $opt_debug
     1577  # awkward: cmd appends spaces to result
     1578  func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
     1579    $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
     1580}
     1581#end: func_convert_core_msys_to_w32
     1582
     1583
     1584# func_convert_file_check ARG1 ARG2
     1585# Verify that ARG1 (a file name in $build format) was converted to $host
     1586# format in ARG2. Otherwise, emit an error message, but continue (resetting
     1587# func_to_host_file_result to ARG1).
     1588func_convert_file_check ()
     1589{
     1590  $opt_debug
     1591  if test -z "$2" && test -n "$1" ; then
     1592    func_error "Could not determine host file name corresponding to"
     1593    func_error "  \`$1'"
     1594    func_error "Continuing, but uninstalled executables may not work."
     1595    # Fallback:
     1596    func_to_host_file_result="$1"
     1597  fi
     1598}
     1599# end func_convert_file_check
     1600
     1601
     1602# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
     1603# Verify that FROM_PATH (a path in $build format) was converted to $host
     1604# format in TO_PATH. Otherwise, emit an error message, but continue, resetting
     1605# func_to_host_file_result to a simplistic fallback value (see below).
     1606func_convert_path_check ()
     1607{
     1608  $opt_debug
     1609  if test -z "$4" && test -n "$3"; then
     1610    func_error "Could not determine the host path corresponding to"
     1611    func_error "  \`$3'"
     1612    func_error "Continuing, but uninstalled executables may not work."
     1613    # Fallback.  This is a deliberately simplistic "conversion" and
     1614    # should not be "improved".  See libtool.info.
     1615    if test "x$1" != "x$2"; then
     1616      lt_replace_pathsep_chars="s|$1|$2|g"
     1617      func_to_host_path_result=`echo "$3" |
     1618        $SED -e "$lt_replace_pathsep_chars"`
     1619    else
     1620      func_to_host_path_result="$3"
     1621    fi
     1622  fi
     1623}
     1624# end func_convert_path_check
     1625
     1626
     1627# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
     1628# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
     1629# and appending REPL if ORIG matches BACKPAT.
     1630func_convert_path_front_back_pathsep ()
     1631{
     1632  $opt_debug
     1633  case $4 in
     1634  $1 ) func_to_host_path_result="$3$func_to_host_path_result"
     1635    ;;
     1636  esac
     1637  case $4 in
     1638  $2 ) func_append func_to_host_path_result "$3"
     1639    ;;
     1640  esac
     1641}
     1642# end func_convert_path_front_back_pathsep
     1643
     1644
     1645##################################################
     1646# $build to $host FILE NAME CONVERSION FUNCTIONS #
     1647##################################################
     1648# invoked via `$to_host_file_cmd ARG'
     1649#
     1650# In each case, ARG is the path to be converted from $build to $host format.
     1651# Result will be available in $func_to_host_file_result.
     1652
     1653
     1654# func_to_host_file ARG
     1655# Converts the file name ARG from $build format to $host format. Return result
     1656# in func_to_host_file_result.
     1657func_to_host_file ()
     1658{
     1659  $opt_debug
     1660  $to_host_file_cmd "$1"
     1661}
     1662# end func_to_host_file
     1663
     1664
     1665# func_to_tool_file ARG LAZY
     1666# converts the file name ARG from $build format to toolchain format. Return
     1667# result in func_to_tool_file_result.  If the conversion in use is listed
     1668# in (the comma separated) LAZY, no conversion takes place.
     1669func_to_tool_file ()
     1670{
     1671  $opt_debug
     1672  case ,$2, in
     1673    *,"$to_tool_file_cmd",*)
     1674      func_to_tool_file_result=$1
     1675      ;;
     1676    *)
     1677      $to_tool_file_cmd "$1"
     1678      func_to_tool_file_result=$func_to_host_file_result
     1679      ;;
     1680  esac
     1681}
     1682# end func_to_tool_file
     1683
     1684
     1685# func_convert_file_noop ARG
     1686# Copy ARG to func_to_host_file_result.
     1687func_convert_file_noop ()
     1688{
     1689  func_to_host_file_result="$1"
     1690}
     1691# end func_convert_file_noop
     1692
     1693
     1694# func_convert_file_msys_to_w32 ARG
     1695# Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
     1696# conversion to w32 is not available inside the cwrapper.  Returns result in
     1697# func_to_host_file_result.
     1698func_convert_file_msys_to_w32 ()
     1699{
     1700  $opt_debug
     1701  func_to_host_file_result="$1"
     1702  if test -n "$1"; then
     1703    func_convert_core_msys_to_w32 "$1"
     1704    func_to_host_file_result="$func_convert_core_msys_to_w32_result"
     1705  fi
     1706  func_convert_file_check "$1" "$func_to_host_file_result"
     1707}
     1708# end func_convert_file_msys_to_w32
     1709
     1710
     1711# func_convert_file_cygwin_to_w32 ARG
     1712# Convert file name ARG from Cygwin to w32 format.  Returns result in
     1713# func_to_host_file_result.
     1714func_convert_file_cygwin_to_w32 ()
     1715{
     1716  $opt_debug
     1717  func_to_host_file_result="$1"
     1718  if test -n "$1"; then
     1719    # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
     1720    # LT_CYGPATH in this case.
     1721    func_to_host_file_result=`cygpath -m "$1"`
     1722  fi
     1723  func_convert_file_check "$1" "$func_to_host_file_result"
     1724}
     1725# end func_convert_file_cygwin_to_w32
     1726
     1727
     1728# func_convert_file_nix_to_w32 ARG
     1729# Convert file name ARG from *nix to w32 format.  Requires a wine environment
     1730# and a working winepath. Returns result in func_to_host_file_result.
     1731func_convert_file_nix_to_w32 ()
     1732{
     1733  $opt_debug
     1734  func_to_host_file_result="$1"
     1735  if test -n "$1"; then
     1736    func_convert_core_file_wine_to_w32 "$1"
     1737    func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"
     1738  fi
     1739  func_convert_file_check "$1" "$func_to_host_file_result"
     1740}
     1741# end func_convert_file_nix_to_w32
     1742
     1743
     1744# func_convert_file_msys_to_cygwin ARG
     1745# Convert file name ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
     1746# Returns result in func_to_host_file_result.
     1747func_convert_file_msys_to_cygwin ()
     1748{
     1749  $opt_debug
     1750  func_to_host_file_result="$1"
     1751  if test -n "$1"; then
     1752    func_convert_core_msys_to_w32 "$1"
     1753    func_cygpath -u "$func_convert_core_msys_to_w32_result"
     1754    func_to_host_file_result="$func_cygpath_result"
     1755  fi
     1756  func_convert_file_check "$1" "$func_to_host_file_result"
     1757}
     1758# end func_convert_file_msys_to_cygwin
     1759
     1760
     1761# func_convert_file_nix_to_cygwin ARG
     1762# Convert file name ARG from *nix to Cygwin format.  Requires Cygwin installed
     1763# in a wine environment, working winepath, and LT_CYGPATH set.  Returns result
     1764# in func_to_host_file_result.
     1765func_convert_file_nix_to_cygwin ()
     1766{
     1767  $opt_debug
     1768  func_to_host_file_result="$1"
     1769  if test -n "$1"; then
     1770    # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
     1771    func_convert_core_file_wine_to_w32 "$1"
     1772    func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
     1773    func_to_host_file_result="$func_cygpath_result"
     1774  fi
     1775  func_convert_file_check "$1" "$func_to_host_file_result"
     1776}
     1777# end func_convert_file_nix_to_cygwin
     1778
     1779
     1780#############################################
     1781# $build to $host PATH CONVERSION FUNCTIONS #
     1782#############################################
     1783# invoked via `$to_host_path_cmd ARG'
     1784#
     1785# In each case, ARG is the path to be converted from $build to $host format.
     1786# The result will be available in $func_to_host_path_result.
     1787#
     1788# Path separators are also converted from $build format to $host format.  If
     1789# ARG begins or ends with a path separator character, it is preserved (but
     1790# converted to $host format) on output.
     1791#
     1792# All path conversion functions are named using the following convention:
     1793#   file name conversion function    : func_convert_file_X_to_Y ()
     1794#   path conversion function         : func_convert_path_X_to_Y ()
     1795# where, for any given $build/$host combination the 'X_to_Y' value is the
     1796# same.  If conversion functions are added for new $build/$host combinations,
     1797# the two new functions must follow this pattern, or func_init_to_host_path_cmd
     1798# will break.
     1799
     1800
     1801# func_init_to_host_path_cmd
     1802# Ensures that function "pointer" variable $to_host_path_cmd is set to the
     1803# appropriate value, based on the value of $to_host_file_cmd.
     1804to_host_path_cmd=
     1805func_init_to_host_path_cmd ()
     1806{
     1807  $opt_debug
     1808  if test -z "$to_host_path_cmd"; then
     1809    func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
     1810    to_host_path_cmd="func_convert_path_${func_stripname_result}"
     1811  fi
     1812}
     1813
     1814
     1815# func_to_host_path ARG
     1816# Converts the path ARG from $build format to $host format. Return result
     1817# in func_to_host_path_result.
     1818func_to_host_path ()
     1819{
     1820  $opt_debug
     1821  func_init_to_host_path_cmd
     1822  $to_host_path_cmd "$1"
     1823}
     1824# end func_to_host_path
     1825
     1826
     1827# func_convert_path_noop ARG
     1828# Copy ARG to func_to_host_path_result.
     1829func_convert_path_noop ()
     1830{
     1831  func_to_host_path_result="$1"
     1832}
     1833# end func_convert_path_noop
     1834
     1835
     1836# func_convert_path_msys_to_w32 ARG
     1837# Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
     1838# conversion to w32 is not available inside the cwrapper.  Returns result in
     1839# func_to_host_path_result.
     1840func_convert_path_msys_to_w32 ()
     1841{
     1842  $opt_debug
     1843  func_to_host_path_result="$1"
     1844  if test -n "$1"; then
     1845    # Remove leading and trailing path separator characters from ARG.  MSYS
     1846    # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
     1847    # and winepath ignores them completely.
     1848    func_stripname : : "$1"
     1849    func_to_host_path_tmp1=$func_stripname_result
     1850    func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
     1851    func_to_host_path_result="$func_convert_core_msys_to_w32_result"
     1852    func_convert_path_check : ";" \
     1853      "$func_to_host_path_tmp1" "$func_to_host_path_result"
     1854    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
     1855  fi
     1856}
     1857# end func_convert_path_msys_to_w32
     1858
     1859
     1860# func_convert_path_cygwin_to_w32 ARG
     1861# Convert path ARG from Cygwin to w32 format.  Returns result in
     1862# func_to_host_file_result.
     1863func_convert_path_cygwin_to_w32 ()
     1864{
     1865  $opt_debug
     1866  func_to_host_path_result="$1"
     1867  if test -n "$1"; then
     1868    # See func_convert_path_msys_to_w32:
     1869    func_stripname : : "$1"
     1870    func_to_host_path_tmp1=$func_stripname_result
     1871    func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
     1872    func_convert_path_check : ";" \
     1873      "$func_to_host_path_tmp1" "$func_to_host_path_result"
     1874    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
     1875  fi
     1876}
     1877# end func_convert_path_cygwin_to_w32
     1878
     1879
     1880# func_convert_path_nix_to_w32 ARG
     1881# Convert path ARG from *nix to w32 format.  Requires a wine environment and
     1882# a working winepath.  Returns result in func_to_host_file_result.
     1883func_convert_path_nix_to_w32 ()
     1884{
     1885  $opt_debug
     1886  func_to_host_path_result="$1"
     1887  if test -n "$1"; then
     1888    # See func_convert_path_msys_to_w32:
     1889    func_stripname : : "$1"
     1890    func_to_host_path_tmp1=$func_stripname_result
     1891    func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
     1892    func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"
     1893    func_convert_path_check : ";" \
     1894      "$func_to_host_path_tmp1" "$func_to_host_path_result"
     1895    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
     1896  fi
     1897}
     1898# end func_convert_path_nix_to_w32
     1899
     1900
     1901# func_convert_path_msys_to_cygwin ARG
     1902# Convert path ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
     1903# Returns result in func_to_host_file_result.
     1904func_convert_path_msys_to_cygwin ()
     1905{
     1906  $opt_debug
     1907  func_to_host_path_result="$1"
     1908  if test -n "$1"; then
     1909    # See func_convert_path_msys_to_w32:
     1910    func_stripname : : "$1"
     1911    func_to_host_path_tmp1=$func_stripname_result
     1912    func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
     1913    func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
     1914    func_to_host_path_result="$func_cygpath_result"
     1915    func_convert_path_check : : \
     1916      "$func_to_host_path_tmp1" "$func_to_host_path_result"
     1917    func_convert_path_front_back_pathsep ":*" "*:" : "$1"
     1918  fi
     1919}
     1920# end func_convert_path_msys_to_cygwin
     1921
     1922
     1923# func_convert_path_nix_to_cygwin ARG
     1924# Convert path ARG from *nix to Cygwin format.  Requires Cygwin installed in a
     1925# a wine environment, working winepath, and LT_CYGPATH set.  Returns result in
     1926# func_to_host_file_result.
     1927func_convert_path_nix_to_cygwin ()
     1928{
     1929  $opt_debug
     1930  func_to_host_path_result="$1"
     1931  if test -n "$1"; then
     1932    # Remove leading and trailing path separator characters from
     1933    # ARG. msys behavior is inconsistent here, cygpath turns them
     1934    # into '.;' and ';.', and winepath ignores them completely.
     1935    func_stripname : : "$1"
     1936    func_to_host_path_tmp1=$func_stripname_result
     1937    func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
     1938    func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
     1939    func_to_host_path_result="$func_cygpath_result"
     1940    func_convert_path_check : : \
     1941      "$func_to_host_path_tmp1" "$func_to_host_path_result"
     1942    func_convert_path_front_back_pathsep ":*" "*:" : "$1"
     1943  fi
     1944}
     1945# end func_convert_path_nix_to_cygwin
     1946
     1947
    11001948# func_mode_compile arg...
    11011949func_mode_compile ()
     
    11381986
    11391987        -pie | -fpie | -fPIE)
    1140           pie_flag="$pie_flag $arg"
     1988          func_append pie_flag " $arg"
    11411989          continue
    11421990          ;;
    11431991
    11441992        -shared | -static | -prefer-pic | -prefer-non-pic)
    1145           later="$later $arg"
     1993          func_append later " $arg"
    11461994          continue
    11471995          ;;
     
    11642012          for arg in $args; do
    11652013            IFS="$save_ifs"
    1166             func_quote_for_eval "$arg"
    1167             lastarg="$lastarg $func_quote_for_eval_result"
     2014            func_append_quoted lastarg "$arg"
    11682015          done
    11692016          IFS="$save_ifs"
     
    11722019
    11732020          # Add the arguments to base_compile.
    1174           base_compile="$base_compile $lastarg"
     2021          func_append base_compile " $lastarg"
    11752022          continue
    11762023          ;;
     
    11882035
    11892036      # Aesthetically quote the previous argument.
    1190       func_quote_for_eval "$lastarg"
    1191       base_compile="$base_compile $func_quote_for_eval_result"
     2037      func_append_quoted base_compile "$lastarg"
    11922038    done # for arg
    11932039
     
    12142060    *.ada | *.adb | *.ads | *.asm | \
    12152061    *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
    1216     *.[fF][09]? | *.for | *.java | *.obj | *.sx)
     2062    *.[fF][09]? | *.for | *.java | *.obj | *.sx | *.cu | *.cup)
    12172063      func_xform "$libobj"
    12182064      libobj=$func_xform_result
     
    12892135    # not support -o with -c
    12902136    if test "$compiler_c_o" = no; then
    1291       output_obj=`$ECHO "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
     2137      output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
    12922138      lockfile="$output_obj.lock"
    12932139    else
     
    13202166        exit $EXIT_FAILURE
    13212167      fi
    1322       removelist="$removelist $output_obj"
     2168      func_append removelist " $output_obj"
    13232169      $ECHO "$srcfile" > "$lockfile"
    13242170    fi
    13252171
    13262172    $opt_dry_run || $RM $removelist
    1327     removelist="$removelist $lockfile"
     2173    func_append removelist " $lockfile"
    13282174    trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
    13292175
    1330     if test -n "$fix_srcfile_path"; then
    1331       eval srcfile=\"$fix_srcfile_path\"
    1332     fi
     2176    func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
     2177    srcfile=$func_to_tool_file_result
    13332178    func_quote_for_eval "$srcfile"
    13342179    qsrcfile=$func_quote_for_eval_result
     
    13502195      if test -z "$output_obj"; then
    13512196        # Place PIC objects in $objdir
    1352         command="$command -o $lobj"
     2197        func_append command " -o $lobj"
    13532198      fi
    13542199
     
    13972242      fi
    13982243      if test "$compiler_c_o" = yes; then
    1399         command="$command -o $obj"
     2244        func_append command " -o $obj"
    14002245      fi
    14012246
    14022247      # Suppress compiler output if we already did a PIC compilation.
    1403       command="$command$suppress_output"
     2248      func_append command "$suppress_output"
    14042249      func_show_eval_locale "$command" \
    14052250        '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
     
    14462291
    14472292$opt_help || {
    1448 test "$mode" = compile && func_mode_compile ${1+"$@"}
     2293  test "$opt_mode" = compile && func_mode_compile ${1+"$@"}
    14492294}
    14502295
     
    14522297{
    14532298    # We need to display help for each of the modes.
    1454     case $mode in
     2299    case $opt_mode in
    14552300      "")
    14562301        # Generic help is extracted from the usage comments
     
    14832328  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
    14842329  -no-suppress      do not suppress compiler output for multiple passes
    1485   -prefer-pic       try to building PIC objects only
    1486   -prefer-non-pic   try to building non-PIC objects only
     2330  -prefer-pic       try to build PIC objects only
     2331  -prefer-non-pic   try to build non-PIC objects only
    14872332  -shared           do not build a \`.o' file suitable for static linking
    14882333  -static           only build a \`.o' file suitable for static linking
     2334  -Wc,FLAG          pass FLAG directly to the compiler
    14892335
    14902336COMPILE-COMMAND is a command to be used in creating a \`standard' object file
     
    15392385The following components of INSTALL-COMMAND are treated specially:
    15402386
    1541   -inst-prefix PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
     2387  -inst-prefix-dir PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
    15422388
    15432389The rest of the components are interpreted as arguments to that command (only
     
    15592405  -all-static       do not do any dynamic linking at all
    15602406  -avoid-version    do not add a version suffix if possible
     2407  -bindir BINDIR    specify path to binaries directory (for systems where
     2408                    libraries must be found in the PATH setting at runtime)
    15612409  -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
    15622410  -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
     
    15872435                    specify library version info [each variable defaults to 0]
    15882436  -weak LIBNAME     declare that the target provides the LIBNAME interface
     2437  -Wc,FLAG
     2438  -Xcompiler FLAG   pass linker-specific FLAG directly to the compiler
     2439  -Wl,FLAG
     2440  -Xlinker FLAG     pass linker-specific FLAG directly to the linker
     2441  -XCClinker FLAG   pass link-specific FLAG to the compiler driver (CC)
    15892442
    15902443All other options (arguments beginning with \`-') are ignored.
     
    16202473
    16212474      *)
    1622         func_fatal_help "invalid operation mode \`$mode'"
     2475        func_fatal_help "invalid operation mode \`$opt_mode'"
    16232476        ;;
    16242477    esac
    16252478
    1626     $ECHO
     2479    echo
    16272480    $ECHO "Try \`$progname --help' for more information about other modes."
    1628 
    1629     exit $?
    1630 }
    1631 
    1632   # Now that we've collected a possible --mode arg, show help if necessary
    1633   $opt_help && func_mode_help
     2481}
     2482
     2483# Now that we've collected a possible --mode arg, show help if necessary
     2484if $opt_help; then
     2485  if test "$opt_help" = :; then
     2486    func_mode_help
     2487  else
     2488    {
     2489      func_help noexit
     2490      for opt_mode in compile link execute install finish uninstall clean; do
     2491        func_mode_help
     2492      done
     2493    } | sed -n '1p; 2,$s/^Usage:/  or: /p'
     2494    {
     2495      func_help noexit
     2496      for opt_mode in compile link execute install finish uninstall clean; do
     2497        echo
     2498        func_mode_help
     2499      done
     2500    } |
     2501    sed '1d
     2502      /^When reporting/,/^Report/{
     2503        H
     2504        d
     2505      }
     2506      $x
     2507      /information about other modes/d
     2508      /more detailed .*MODE/d
     2509      s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
     2510  fi
     2511  exit $?
     2512fi
    16342513
    16352514
     
    16442523
    16452524    # Handle -dlopen flags immediately.
    1646     for file in $execute_dlfiles; do
     2525    for file in $opt_dlopen; do
    16472526      test -f "$file" \
    16482527        || func_fatal_help "\`$file' is not a file"
     
    16512530      case $file in
    16522531      *.la)
     2532        func_resolve_sysroot "$file"
     2533        file=$func_resolve_sysroot_result
     2534
    16532535        # Check to see that this really is a libtool archive.
    16542536        func_lalib_unsafe_p "$file" \
     
    16722554
    16732555        if test -f "$dir/$objdir/$dlname"; then
    1674           dir="$dir/$objdir"
     2556          func_append dir "/$objdir"
    16752557        else
    16762558          if test ! -f "$dir/$dlname"; then
     
    17132595    do
    17142596      case $file in
    1715       -*) ;;
     2597      -* | *.la | *.lo ) ;;
    17162598      *)
    17172599        # Do a test to see if this is really a libtool program.
     
    17292611      esac
    17302612      # Quote arguments (to preserve shell metacharacters).
    1731       func_quote_for_eval "$file"
    1732       args="$args $func_quote_for_eval_result"
     2613      func_append_quoted args "$file"
    17332614    done
    17342615
     
    17552636      if test -n "$shlibpath_var"; then
    17562637        eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
    1757         $ECHO "export $shlibpath_var"
     2638        echo "export $shlibpath_var"
    17582639      fi
    17592640      $ECHO "$cmd$args"
     
    17622643}
    17632644
    1764 test "$mode" = execute && func_mode_execute ${1+"$@"}
     2645test "$opt_mode" = execute && func_mode_execute ${1+"$@"}
    17652646
    17662647
     
    17692650{
    17702651    $opt_debug
    1771     libdirs="$nonopt"
     2652    libs=
     2653    libdirs=
    17722654    admincmds=
    17732655
     2656    for opt in "$nonopt" ${1+"$@"}
     2657    do
     2658      if test -d "$opt"; then
     2659        func_append libdirs " $opt"
     2660
     2661      elif test -f "$opt"; then
     2662        if func_lalib_unsafe_p "$opt"; then
     2663          func_append libs " $opt"
     2664        else
     2665          func_warning "\`$opt' is not a valid libtool archive"
     2666        fi
     2667
     2668      else
     2669        func_fatal_error "invalid argument \`$opt'"
     2670      fi
     2671    done
     2672
     2673    if test -n "$libs"; then
     2674      if test -n "$lt_sysroot"; then
     2675        sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
     2676        sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
     2677      else
     2678        sysroot_cmd=
     2679      fi
     2680
     2681      # Remove sysroot references
     2682      if $opt_dry_run; then
     2683        for lib in $libs; do
     2684          echo "removing references to $lt_sysroot and \`=' prefixes from $lib"
     2685        done
     2686      else
     2687        tmpdir=`func_mktempdir`
     2688        for lib in $libs; do
     2689          sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
     2690            > $tmpdir/tmp-la
     2691          mv -f $tmpdir/tmp-la $lib
     2692        done
     2693        ${RM}r "$tmpdir"
     2694      fi
     2695    fi
     2696
    17742697    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
    1775       for dir
    1776       do
    1777         libdirs="$libdirs $dir"
    1778       done
    1779 
    17802698      for libdir in $libdirs; do
    17812699        if test -n "$finish_cmds"; then
     
    17872705          # Do the single finish_eval.
    17882706          eval cmds=\"$finish_eval\"
    1789           $opt_dry_run || eval "$cmds" || admincmds="$admincmds
     2707          $opt_dry_run || eval "$cmds" || func_append admincmds "
    17902708       $cmds"
    17912709        fi
     
    17962714    $opt_silent && exit $EXIT_SUCCESS
    17972715
    1798     $ECHO "X----------------------------------------------------------------------" | $Xsed
    1799     $ECHO "Libraries have been installed in:"
    1800     for libdir in $libdirs; do
    1801       $ECHO "   $libdir"
    1802     done
    1803     $ECHO
    1804     $ECHO "If you ever happen to want to link against installed libraries"
    1805     $ECHO "in a given directory, LIBDIR, you must either use libtool, and"
    1806     $ECHO "specify the full pathname of the library, or use the \`-LLIBDIR'"
    1807     $ECHO "flag during linking and do at least one of the following:"
    1808     if test -n "$shlibpath_var"; then
    1809       $ECHO "   - add LIBDIR to the \`$shlibpath_var' environment variable"
    1810       $ECHO "     during execution"
     2716    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
     2717      echo "----------------------------------------------------------------------"
     2718      echo "Libraries have been installed in:"
     2719      for libdir in $libdirs; do
     2720        $ECHO "   $libdir"
     2721      done
     2722      echo
     2723      echo "If you ever happen to want to link against installed libraries"
     2724      echo "in a given directory, LIBDIR, you must either use libtool, and"
     2725      echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
     2726      echo "flag during linking and do at least one of the following:"
     2727      if test -n "$shlibpath_var"; then
     2728        echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
     2729        echo "     during execution"
     2730      fi
     2731      if test -n "$runpath_var"; then
     2732        echo "   - add LIBDIR to the \`$runpath_var' environment variable"
     2733        echo "     during linking"
     2734      fi
     2735      if test -n "$hardcode_libdir_flag_spec"; then
     2736        libdir=LIBDIR
     2737        eval flag=\"$hardcode_libdir_flag_spec\"
     2738
     2739        $ECHO "   - use the \`$flag' linker flag"
     2740      fi
     2741      if test -n "$admincmds"; then
     2742        $ECHO "   - have your system administrator run these commands:$admincmds"
     2743      fi
     2744      if test -f /etc/ld.so.conf; then
     2745        echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
     2746      fi
     2747      echo
     2748
     2749      echo "See any operating system documentation about shared libraries for"
     2750      case $host in
     2751        solaris2.[6789]|solaris2.1[0-9])
     2752          echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
     2753          echo "pages."
     2754          ;;
     2755        *)
     2756          echo "more information, such as the ld(1) and ld.so(8) manual pages."
     2757          ;;
     2758      esac
     2759      echo "----------------------------------------------------------------------"
    18112760    fi
    1812     if test -n "$runpath_var"; then
    1813       $ECHO "   - add LIBDIR to the \`$runpath_var' environment variable"
    1814       $ECHO "     during linking"
    1815     fi
    1816     if test -n "$hardcode_libdir_flag_spec"; then
    1817       libdir=LIBDIR
    1818       eval flag=\"$hardcode_libdir_flag_spec\"
    1819 
    1820       $ECHO "   - use the \`$flag' linker flag"
    1821     fi
    1822     if test -n "$admincmds"; then
    1823       $ECHO "   - have your system administrator run these commands:$admincmds"
    1824     fi
    1825     if test -f /etc/ld.so.conf; then
    1826       $ECHO "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
    1827     fi
    1828     $ECHO
    1829 
    1830     $ECHO "See any operating system documentation about shared libraries for"
    1831     case $host in
    1832       solaris2.[6789]|solaris2.1[0-9])
    1833         $ECHO "more information, such as the ld(1), crle(1) and ld.so(8) manual"
    1834         $ECHO "pages."
    1835         ;;
    1836       *)
    1837         $ECHO "more information, such as the ld(1) and ld.so(8) manual pages."
    1838         ;;
    1839     esac
    1840     $ECHO "X----------------------------------------------------------------------" | $Xsed
    18412761    exit $EXIT_SUCCESS
    18422762}
    18432763
    1844 test "$mode" = finish && func_mode_finish ${1+"$@"}
     2764test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
    18452765
    18462766
     
    18532773    if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
    18542774       # Allow the use of GNU shtool's install command.
    1855        $ECHO "X$nonopt" | $GREP shtool >/dev/null; then
     2775       case $nonopt in *shtool*) :;; *) false;; esac; then
    18562776      # Aesthetically quote it.
    18572777      func_quote_for_eval "$nonopt"
     
    18672787    # Aesthetically quote it.
    18682788    func_quote_for_eval "$arg"
    1869     install_prog="$install_prog$func_quote_for_eval_result"
     2789    func_append install_prog "$func_quote_for_eval_result"
     2790    install_shared_prog=$install_prog
     2791    case " $install_prog " in
     2792      *[\\\ /]cp\ *) install_cp=: ;;
     2793      *) install_cp=false ;;
     2794    esac
    18702795
    18712796    # We need to accept at least all the BSD install flags.
     
    18772802    isdir=no
    18782803    stripme=
     2804    no_mode=:
    18792805    for arg
    18802806    do
     2807      arg2=
    18812808      if test -n "$dest"; then
    1882         files="$files $dest"
     2809        func_append files " $dest"
    18832810        dest=$arg
    18842811        continue
     
    18882815      -d) isdir=yes ;;
    18892816      -f)
    1890         case " $install_prog " in
    1891         *[\\\ /]cp\ *) ;;
    1892         *) prev=$arg ;;
    1893         esac
     2817        if $install_cp; then :; else
     2818          prev=$arg
     2819        fi
    18942820        ;;
    18952821      -g | -m | -o)
     
    19052831        # If the previous option needed an argument, then skip it.
    19062832        if test -n "$prev"; then
     2833          if test "x$prev" = x-m && test -n "$install_override_mode"; then
     2834            arg2=$install_override_mode
     2835            no_mode=false
     2836          fi
    19072837          prev=
    19082838        else
     
    19152845      # Aesthetically quote the argument.
    19162846      func_quote_for_eval "$arg"
    1917       install_prog="$install_prog $func_quote_for_eval_result"
     2847      func_append install_prog " $func_quote_for_eval_result"
     2848      if test -n "$arg2"; then
     2849        func_quote_for_eval "$arg2"
     2850      fi
     2851      func_append install_shared_prog " $func_quote_for_eval_result"
    19182852    done
    19192853
     
    19232857    test -n "$prev" && \
    19242858      func_fatal_help "the \`$prev' option requires an argument"
     2859
     2860    if test -n "$install_override_mode" && $no_mode; then
     2861      if $install_cp; then :; else
     2862        func_quote_for_eval "$install_override_mode"
     2863        func_append install_shared_prog " -m $func_quote_for_eval_result"
     2864      fi
     2865    fi
    19252866
    19262867    if test -z "$files"; then
     
    19782919      *.$libext)
    19792920        # Do the static libraries later.
    1980         staticlibs="$staticlibs $file"
     2921        func_append staticlibs " $file"
    19812922        ;;
    19822923
    19832924      *.la)
     2925        func_resolve_sysroot "$file"
     2926        file=$func_resolve_sysroot_result
     2927
    19842928        # Check to see that this really is a libtool archive.
    19852929        func_lalib_unsafe_p "$file" \
     
    19952939          case "$current_libdirs " in
    19962940          *" $libdir "*) ;;
    1997           *) current_libdirs="$current_libdirs $libdir" ;;
     2941          *) func_append current_libdirs " $libdir" ;;
    19982942          esac
    19992943        else
     
    20012945          case "$future_libdirs " in
    20022946          *" $libdir "*) ;;
    2003           *) future_libdirs="$future_libdirs $libdir" ;;
     2947          *) func_append future_libdirs " $libdir" ;;
    20042948          esac
    20052949        fi
     
    20072951        func_dirname "$file" "/" ""
    20082952        dir="$func_dirname_result"
    2009         dir="$dir$objdir"
     2953        func_append dir "$objdir"
    20102954
    20112955        if test -n "$relink_command"; then
    20122956          # Determine the prefix the user has applied to our future dir.
    2013           inst_prefix_dir=`$ECHO "X$destdir" | $Xsed -e "s%$libdir\$%%"`
     2957          inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
    20142958
    20152959          # Don't allow the user to place us outside of our expected
     
    20242968          if test -n "$inst_prefix_dir"; then
    20252969            # Stick the inst_prefix_dir data into the link command.
    2026             relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
     2970            relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
    20272971          else
    2028             relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%%"`
     2972            relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
    20292973          fi
    20302974
     
    20442988
    20452989          # Install the shared library and build the symlinks.
    2046           func_show_eval "$install_prog $dir/$srcname $destdir/$realname" \
     2990          func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
    20472991              'exit $?'
    20482992          tstripme="$stripme"
     
    20843028
    20853029        # Maybe install the static library, too.
    2086         test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
     3030        test -n "$old_library" && func_append staticlibs " $dir/$old_library"
    20873031        ;;
    20883032
     
    21843128              func_source "$lib"
    21853129            fi
    2186             libfile="$libdir/"`$ECHO "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
     3130            libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
    21873131            if test -n "$libdir" && test ! -f "$libfile"; then
    21883132              func_warning "\`$lib' has not been installed in \`$libdir'"
     
    22033147                outputname="$tmpdir/$file"
    22043148                # Replace the output file specification.
    2205                 relink_command=`$ECHO "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
     3149                relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
    22063150
    22073151                $opt_silent || {
     
    22223166          else
    22233167            # Install the binary that we compiled earlier.
    2224             file=`$ECHO "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
     3168            file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
    22253169          fi
    22263170        fi
     
    22813225}
    22823226
    2283 test "$mode" = install && func_mode_install ${1+"$@"}
     3227test "$opt_mode" = install && func_mode_install ${1+"$@"}
    22843228
    22853229
     
    23243268#endif
    23253269
     3270#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
     3271#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
     3272#endif
     3273
     3274/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
     3275#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
     3276/* DATA imports from DLLs on WIN32 con't be const, because runtime
     3277   relocations are performed -- see ld's documentation on pseudo-relocs.  */
     3278# define LT_DLSYM_CONST
     3279#elif defined(__osf__)
     3280/* This system does not cope well with relocations in const data.  */
     3281# define LT_DLSYM_CONST
     3282#else
     3283# define LT_DLSYM_CONST const
     3284#endif
     3285
    23263286/* External symbol declarations for the compiler. */\
    23273287"
     
    23333293
    23343294          # Add our own program objects to the symbol list.
    2335           progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
     3295          progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
    23363296          for progfile in $progfiles; do
    2337             func_verbose "extracting global C symbols from \`$progfile'"
    2338             $opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
     3297            func_to_tool_file "$progfile" func_convert_file_msys_to_w32
     3298            func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"
     3299            $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
    23393300          done
    23403301
     
    23723333              eval '$MV "$nlist"T "$nlist"'
    23733334              case $host in
    2374                 *cygwin | *mingw* | *cegcc* )
     3335                *cygwin* | *mingw* | *cegcc* )
    23753336                  eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
    23763337                  eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
     
    23853346          func_basename "$dlprefile"
    23863347          name="$func_basename_result"
    2387           $opt_dry_run || {
    2388             eval '$ECHO ": $name " >> "$nlist"'
    2389             eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
    2390           }
     3348          case $host in
     3349            *cygwin* | *mingw* | *cegcc* )
     3350              # if an import library, we need to obtain dlname
     3351              if func_win32_import_lib_p "$dlprefile"; then
     3352                func_tr_sh "$dlprefile"
     3353                eval "curr_lafile=\$libfile_$func_tr_sh_result"
     3354                dlprefile_dlbasename=""
     3355                if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
     3356                  # Use subshell, to avoid clobbering current variable values
     3357                  dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
     3358                  if test -n "$dlprefile_dlname" ; then
     3359                    func_basename "$dlprefile_dlname"
     3360                    dlprefile_dlbasename="$func_basename_result"
     3361                  else
     3362                    # no lafile. user explicitly requested -dlpreopen <import library>.
     3363                    $sharedlib_from_linklib_cmd "$dlprefile"
     3364                    dlprefile_dlbasename=$sharedlib_from_linklib_result
     3365                  fi
     3366                fi
     3367                $opt_dry_run || {
     3368                  if test -n "$dlprefile_dlbasename" ; then
     3369                    eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
     3370                  else
     3371                    func_warning "Could not compute DLL name from $name"
     3372                    eval '$ECHO ": $name " >> "$nlist"'
     3373                  fi
     3374                  func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
     3375                  eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
     3376                    $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
     3377                }
     3378              else # not an import lib
     3379                $opt_dry_run || {
     3380                  eval '$ECHO ": $name " >> "$nlist"'
     3381                  func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
     3382                  eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
     3383                }
     3384              fi
     3385            ;;
     3386            *)
     3387              $opt_dry_run || {
     3388                eval '$ECHO ": $name " >> "$nlist"'
     3389                func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
     3390                eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
     3391              }
     3392            ;;
     3393          esac
    23913394        done
    23923395
     
    24163419            eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
    24173420          else
    2418             $ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms"
     3421            echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
    24193422          fi
    24203423
    2421           $ECHO >> "$output_objdir/$my_dlsyms" "\
     3424          echo >> "$output_objdir/$my_dlsyms" "\
    24223425
    24233426/* The mapping between symbol names and symbols.  */
     
    24263429  void *address;
    24273430} lt_dlsymlist;
    2428 "
    2429           case $host in
    2430           *cygwin* | *mingw* | *cegcc* )
    2431             $ECHO >> "$output_objdir/$my_dlsyms" "\
    2432 /* DATA imports from DLLs on WIN32 con't be const, because
    2433    runtime relocations are performed -- see ld's documentation
    2434    on pseudo-relocs.  */"
    2435             lt_dlsym_const= ;;
    2436           *osf5*)
    2437             echo >> "$output_objdir/$my_dlsyms" "\
    2438 /* This system does not cope well with relocations in const data */"
    2439             lt_dlsym_const= ;;
    2440           *)
    2441             lt_dlsym_const=const ;;
    2442           esac
    2443 
    2444           $ECHO >> "$output_objdir/$my_dlsyms" "\
    2445 extern $lt_dlsym_const lt_dlsymlist
     3431extern LT_DLSYM_CONST lt_dlsymlist
    24463432lt_${my_prefix}_LTX_preloaded_symbols[];
    2447 $lt_dlsym_const lt_dlsymlist
     3433LT_DLSYM_CONST lt_dlsymlist
    24483434lt_${my_prefix}_LTX_preloaded_symbols[] =
    24493435{\
     
    24583444            ;;
    24593445          esac
    2460           $ECHO >> "$output_objdir/$my_dlsyms" "\
     3446          echo >> "$output_objdir/$my_dlsyms" "\
    24613447  {0, (void *) 0}
    24623448};
     
    25013487          case $arg in
    25023488          -pie | -fpie | -fPIE) ;;
    2503           *) symtab_cflags="$symtab_cflags $arg" ;;
     3489          *) func_append symtab_cflags " $arg" ;;
    25043490          esac
    25053491        done
     
    25163502        *cygwin* | *mingw* | *cegcc* )
    25173503          if test -f "$output_objdir/$my_outputname.def"; then
    2518             compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
    2519             finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
     3504            compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
     3505            finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
    25203506          else
    2521             compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
    2522             finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
     3507            compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
     3508            finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
    25233509          fi
    25243510          ;;
    25253511        *)
    2526           compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
    2527           finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
     3512          compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
     3513          finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
    25283514          ;;
    25293515        esac
     
    25393525
    25403526      # Nullify the symbol file.
    2541       compile_command=`$ECHO "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
    2542       finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
     3527      compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
     3528      finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
    25433529    fi
    25443530}
     
    25503536# Has to be a shell function in order to 'eat' the argument
    25513537# that is supplied when $file_magic_command is called.
     3538# Despite the name, also deal with 64 bit binaries.
    25523539func_win32_libid ()
    25533540{
     
    25603547    ;;
    25613548  *ar\ archive*) # could be an import, or static
     3549    # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
    25623550    if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
    2563        $EGREP 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
    2564       win32_nmres=`eval $NM -f posix -A $1 |
     3551       $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
     3552      func_to_tool_file "$1" func_convert_file_msys_to_w32
     3553      win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
    25653554        $SED -n -e '
    25663555            1,100{
     
    25913580}
    25923581
     3582# func_cygming_dll_for_implib ARG
     3583#
     3584# Platform-specific function to extract the
     3585# name of the DLL associated with the specified
     3586# import library ARG.
     3587# Invoked by eval'ing the libtool variable
     3588#    $sharedlib_from_linklib_cmd
     3589# Result is available in the variable
     3590#    $sharedlib_from_linklib_result
     3591func_cygming_dll_for_implib ()
     3592{
     3593  $opt_debug
     3594  sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
     3595}
     3596
     3597# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
     3598#
     3599# The is the core of a fallback implementation of a
     3600# platform-specific function to extract the name of the
     3601# DLL associated with the specified import library LIBNAME.
     3602#
     3603# SECTION_NAME is either .idata$6 or .idata$7, depending
     3604# on the platform and compiler that created the implib.
     3605#
     3606# Echos the name of the DLL associated with the
     3607# specified import library.
     3608func_cygming_dll_for_implib_fallback_core ()
     3609{
     3610  $opt_debug
     3611  match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
     3612  $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
     3613    $SED '/^Contents of section '"$match_literal"':/{
     3614      # Place marker at beginning of archive member dllname section
     3615      s/.*/====MARK====/
     3616      p
     3617      d
     3618    }
     3619    # These lines can sometimes be longer than 43 characters, but
     3620    # are always uninteresting
     3621    /:[  ]*file format pe[i]\{,1\}-/d
     3622    /^In archive [^:]*:/d
     3623    # Ensure marker is printed
     3624    /^====MARK====/p
     3625    # Remove all lines with less than 43 characters
     3626    /^.\{43\}/!d
     3627    # From remaining lines, remove first 43 characters
     3628    s/^.\{43\}//' |
     3629    $SED -n '
     3630      # Join marker and all lines until next marker into a single line
     3631      /^====MARK====/ b para
     3632      H
     3633      $ b para
     3634      b
     3635      :para
     3636      x
     3637      s/\n//g
     3638      # Remove the marker
     3639      s/^====MARK====//
     3640      # Remove trailing dots and whitespace
     3641      s/[\. \t]*$//
     3642      # Print
     3643      /./p' |
     3644    # we now have a list, one entry per line, of the stringified
     3645    # contents of the appropriate section of all members of the
     3646    # archive which possess that section. Heuristic: eliminate
     3647    # all those which have a first or second character that is
     3648    # a '.' (that is, objdump's representation of an unprintable
     3649    # character.) This should work for all archives with less than
     3650    # 0x302f exports -- but will fail for DLLs whose name actually
     3651    # begins with a literal '.' or a single character followed by
     3652    # a '.'.
     3653    #
     3654    # Of those that remain, print the first one.
     3655    $SED -e '/^\./d;/^.\./d;q'
     3656}
     3657
     3658# func_cygming_gnu_implib_p ARG
     3659# This predicate returns with zero status (TRUE) if
     3660# ARG is a GNU/binutils-style import library. Returns
     3661# with nonzero status (FALSE) otherwise.
     3662func_cygming_gnu_implib_p ()
     3663{
     3664  $opt_debug
     3665  func_to_tool_file "$1" func_convert_file_msys_to_w32
     3666  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)$'`
     3667  test -n "$func_cygming_gnu_implib_tmp"
     3668}
     3669
     3670# func_cygming_ms_implib_p ARG
     3671# This predicate returns with zero status (TRUE) if
     3672# ARG is an MS-style import library. Returns
     3673# with nonzero status (FALSE) otherwise.
     3674func_cygming_ms_implib_p ()
     3675{
     3676  $opt_debug
     3677  func_to_tool_file "$1" func_convert_file_msys_to_w32
     3678  func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
     3679  test -n "$func_cygming_ms_implib_tmp"
     3680}
     3681
     3682# func_cygming_dll_for_implib_fallback ARG
     3683# Platform-specific function to extract the
     3684# name of the DLL associated with the specified
     3685# import library ARG.
     3686#
     3687# This fallback implementation is for use when $DLLTOOL
     3688# does not support the --identify-strict option.
     3689# Invoked by eval'ing the libtool variable
     3690#    $sharedlib_from_linklib_cmd
     3691# Result is available in the variable
     3692#    $sharedlib_from_linklib_result
     3693func_cygming_dll_for_implib_fallback ()
     3694{
     3695  $opt_debug
     3696  if func_cygming_gnu_implib_p "$1" ; then
     3697    # binutils import library
     3698    sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
     3699  elif func_cygming_ms_implib_p "$1" ; then
     3700    # ms-generated import library
     3701    sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
     3702  else
     3703    # unknown
     3704    sharedlib_from_linklib_result=""
     3705  fi
     3706}
    25933707
    25943708
     
    25993713    f_ex_an_ar_dir="$1"; shift
    26003714    f_ex_an_ar_oldlib="$1"
    2601     func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" 'exit $?'
     3715    if test "$lock_old_archive_extraction" = yes; then
     3716      lockfile=$f_ex_an_ar_oldlib.lock
     3717      until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
     3718        func_echo "Waiting for $lockfile to be removed"
     3719        sleep 2
     3720      done
     3721    fi
     3722    func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
     3723                   'stat=$?; rm -f "$lockfile"; exit $stat'
     3724    if test "$lock_old_archive_extraction" = yes; then
     3725      $opt_dry_run || rm -f "$lockfile"
     3726    fi
    26023727    if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
    26033728     :
     
    26703795            darwin_files=
    26713796            for darwin_file in $darwin_filelist; do
    2672               darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
     3797              darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
    26733798              $LIPO -create -output "$darwin_file" $darwin_files
    26743799            done # $darwin_filelist
     
    26853810        ;;
    26863811      esac
    2687       my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
     3812      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
    26883813    done
    26893814
    26903815    func_extract_archives_result="$my_oldobjs"
    26913816}
    2692 
    2693 
    2694 
    2695 # func_emit_wrapper_part1 [arg=no]
    2696 #
    2697 # Emit the first part of a libtool wrapper script on stdout.
    2698 # For more information, see the description associated with
    2699 # func_emit_wrapper(), below.
    2700 func_emit_wrapper_part1 ()
    2701 {
    2702         func_emit_wrapper_part1_arg1=no
    2703         if test -n "$1" ; then
    2704           func_emit_wrapper_part1_arg1=$1
    2705         fi
    2706 
    2707         $ECHO "\
    2708 #! $SHELL
    2709 
    2710 # $output - temporary wrapper script for $objdir/$outputname
    2711 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
    2712 #
    2713 # The $output program cannot be directly executed until all the libtool
    2714 # libraries that it depends on are installed.
    2715 #
    2716 # This wrapper script should never be moved out of the build directory.
    2717 # If it is, it will not operate correctly.
    2718 
    2719 # Sed substitution that helps us do robust quoting.  It backslashifies
    2720 # metacharacters that are still active within double-quoted strings.
    2721 Xsed='${SED} -e 1s/^X//'
    2722 sed_quote_subst='$sed_quote_subst'
    2723 
    2724 # Be Bourne compatible
    2725 if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
    2726   emulate sh
    2727   NULLCMD=:
    2728   # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
    2729   # is contrary to our usage.  Disable this feature.
    2730   alias -g '\${1+\"\$@\"}'='\"\$@\"'
    2731   setopt NO_GLOB_SUBST
    2732 else
    2733   case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
    2734 fi
    2735 BIN_SH=xpg4; export BIN_SH # for Tru64
    2736 DUALCASE=1; export DUALCASE # for MKS sh
    2737 
    2738 # The HP-UX ksh and POSIX shell print the target directory to stdout
    2739 # if CDPATH is set.
    2740 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
    2741 
    2742 relink_command=\"$relink_command\"
    2743 
    2744 # This environment variable determines our operation mode.
    2745 if test \"\$libtool_install_magic\" = \"$magic\"; then
    2746   # install mode needs the following variables:
    2747   generated_by_libtool_version='$macro_version'
    2748   notinst_deplibs='$notinst_deplibs'
    2749 else
    2750   # When we are sourced in execute mode, \$file and \$ECHO are already set.
    2751   if test \"\$libtool_execute_magic\" != \"$magic\"; then
    2752     ECHO=\"$qecho\"
    2753     file=\"\$0\"
    2754     # Make sure echo works.
    2755     if test \"X\$1\" = X--no-reexec; then
    2756       # Discard the --no-reexec flag, and continue.
    2757       shift
    2758     elif test \"X\`{ \$ECHO '\t'; } 2>/dev/null\`\" = 'X\t'; then
    2759       # Yippee, \$ECHO works!
    2760       :
    2761     else
    2762       # Restart under the correct shell, and then maybe \$ECHO will work.
    2763       exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
    2764     fi
    2765   fi\
    2766 "
    2767         $ECHO "\
    2768 
    2769   # Find the directory that this script lives in.
    2770   thisdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
    2771   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
    2772 
    2773   # Follow symbolic links until we get to the real thisdir.
    2774   file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
    2775   while test -n \"\$file\"; do
    2776     destdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
    2777 
    2778     # If there was a directory component, then change thisdir.
    2779     if test \"x\$destdir\" != \"x\$file\"; then
    2780       case \"\$destdir\" in
    2781       [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
    2782       *) thisdir=\"\$thisdir/\$destdir\" ;;
    2783       esac
    2784     fi
    2785 
    2786     file=\`\$ECHO \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
    2787     file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
    2788   done
    2789 "
    2790 }
    2791 # end: func_emit_wrapper_part1
    2792 
    2793 # func_emit_wrapper_part2 [arg=no]
    2794 #
    2795 # Emit the second part of a libtool wrapper script on stdout.
    2796 # For more information, see the description associated with
    2797 # func_emit_wrapper(), below.
    2798 func_emit_wrapper_part2 ()
    2799 {
    2800         func_emit_wrapper_part2_arg1=no
    2801         if test -n "$1" ; then
    2802           func_emit_wrapper_part2_arg1=$1
    2803         fi
    2804 
    2805         $ECHO "\
    2806 
    2807   # Usually 'no', except on cygwin/mingw when embedded into
    2808   # the cwrapper.
    2809   WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_part2_arg1
    2810   if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
    2811     # special case for '.'
    2812     if test \"\$thisdir\" = \".\"; then
    2813       thisdir=\`pwd\`
    2814     fi
    2815     # remove .libs from thisdir
    2816     case \"\$thisdir\" in
    2817     *[\\\\/]$objdir ) thisdir=\`\$ECHO \"X\$thisdir\" | \$Xsed -e 's%[\\\\/][^\\\\/]*$%%'\` ;;
    2818     $objdir )   thisdir=. ;;
    2819     esac
    2820   fi
    2821 
    2822   # Try to get the absolute directory name.
    2823   absdir=\`cd \"\$thisdir\" && pwd\`
    2824   test -n \"\$absdir\" && thisdir=\"\$absdir\"
    2825 "
    2826 
    2827         if test "$fast_install" = yes; then
    2828           $ECHO "\
    2829   program=lt-'$outputname'$exeext
    2830   progdir=\"\$thisdir/$objdir\"
    2831 
    2832   if test ! -f \"\$progdir/\$program\" ||
    2833      { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
    2834        test \"X\$file\" != \"X\$progdir/\$program\"; }; then
    2835 
    2836     file=\"\$\$-\$program\"
    2837 
    2838     if test ! -d \"\$progdir\"; then
    2839       $MKDIR \"\$progdir\"
    2840     else
    2841       $RM \"\$progdir/\$file\"
    2842     fi"
    2843 
    2844           $ECHO "\
    2845 
    2846     # relink executable if necessary
    2847     if test -n \"\$relink_command\"; then
    2848       if relink_command_output=\`eval \$relink_command 2>&1\`; then :
    2849       else
    2850         $ECHO \"\$relink_command_output\" >&2
    2851         $RM \"\$progdir/\$file\"
    2852         exit 1
    2853       fi
    2854     fi
    2855 
    2856     $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
    2857     { $RM \"\$progdir/\$program\";
    2858       $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
    2859     $RM \"\$progdir/\$file\"
    2860   fi"
    2861         else
    2862           $ECHO "\
    2863   program='$outputname'
    2864   progdir=\"\$thisdir/$objdir\"
    2865 "
    2866         fi
    2867 
    2868         $ECHO "\
    2869 
    2870   if test -f \"\$progdir/\$program\"; then"
    2871 
    2872         # Export our shlibpath_var if we have one.
    2873         if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
    2874           $ECHO "\
    2875     # Add our own library path to $shlibpath_var
    2876     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
    2877 
    2878     # Some systems cannot cope with colon-terminated $shlibpath_var
    2879     # The second colon is a workaround for a bug in BeOS R4 sed
    2880     $shlibpath_var=\`\$ECHO \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
    2881 
    2882     export $shlibpath_var
    2883 "
    2884         fi
    2885 
    2886         # fixup the dll searchpath if we need to.
    2887         if test -n "$dllsearchpath"; then
    2888           $ECHO "\
    2889     # Add the dll search path components to the executable PATH
    2890     PATH=$dllsearchpath:\$PATH
    2891 "
    2892         fi
    2893 
    2894         $ECHO "\
    2895     if test \"\$libtool_execute_magic\" != \"$magic\"; then
    2896       # Run the actual program with our arguments.
    2897 "
    2898         case $host in
    2899         # Backslashes separate directories on plain windows
    2900         *-*-mingw | *-*-os2* | *-cegcc*)
    2901           $ECHO "\
    2902       exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
    2903 "
    2904           ;;
    2905 
    2906         *)
    2907           $ECHO "\
    2908       exec \"\$progdir/\$program\" \${1+\"\$@\"}
    2909 "
    2910           ;;
    2911         esac
    2912         $ECHO "\
    2913       \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
    2914       exit 1
    2915     fi
    2916   else
    2917     # The program doesn't exist.
    2918     \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
    2919     \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
    2920     $ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
    2921     exit 1
    2922   fi
    2923 fi\
    2924 "
    2925 }
    2926 # end: func_emit_wrapper_part2
    29273817
    29283818
     
    29433833func_emit_wrapper ()
    29443834{
    2945         func_emit_wrapper_arg1=no
    2946         if test -n "$1" ; then
    2947           func_emit_wrapper_arg1=$1
    2948         fi
    2949 
    2950         # split this up so that func_emit_cwrapperexe_src
    2951         # can call each part independently.
    2952         func_emit_wrapper_part1 "${func_emit_wrapper_arg1}"
    2953         func_emit_wrapper_part2 "${func_emit_wrapper_arg1}"
    2954 }
    2955 
    2956 
    2957 # func_to_host_path arg
     3835        func_emit_wrapper_arg1=${1-no}
     3836
     3837        $ECHO "\
     3838#! $SHELL
     3839
     3840# $output - temporary wrapper script for $objdir/$outputname
     3841# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
    29583842#
    2959 # Convert paths to host format when used with build tools.
    2960 # Intended for use with "native" mingw (where libtool itself
    2961 # is running under the msys shell), or in the following cross-
    2962 # build environments:
    2963 #    $build          $host
    2964 #    mingw (msys)    mingw  [e.g. native]
    2965 #    cygwin          mingw
    2966 #    *nix + wine     mingw
    2967 # where wine is equipped with the `winepath' executable.
    2968 # In the native mingw case, the (msys) shell automatically
    2969 # converts paths for any non-msys applications it launches,
    2970 # but that facility isn't available from inside the cwrapper.
    2971 # Similar accommodations are necessary for $host mingw and
    2972 # $build cygwin.  Calling this function does no harm for other
    2973 # $host/$build combinations not listed above.
     3843# The $output program cannot be directly executed until all the libtool
     3844# libraries that it depends on are installed.
    29743845#
    2975 # ARG is the path (on $build) that should be converted to
    2976 # the proper representation for $host. The result is stored
    2977 # in $func_to_host_path_result.
    2978 func_to_host_path ()
    2979 {
    2980   func_to_host_path_result="$1"
    2981   if test -n "$1" ; then
    2982     case $host in
    2983       *mingw* )
    2984         lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
    2985         case $build in
    2986           *mingw* ) # actually, msys
    2987             # awkward: cmd appends spaces to result
    2988             lt_sed_strip_trailing_spaces="s/[ ]*\$//"
    2989             func_to_host_path_tmp1=`( cmd //c echo "$1" |\
    2990               $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
    2991             func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
    2992               $SED -e "$lt_sed_naive_backslashify"`
    2993             ;;
    2994           *cygwin* )
    2995             func_to_host_path_tmp1=`cygpath -w "$1"`
    2996             func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
    2997               $SED -e "$lt_sed_naive_backslashify"`
    2998             ;;
    2999           * )
    3000             # Unfortunately, winepath does not exit with a non-zero
    3001             # error code, so we are forced to check the contents of
    3002             # stdout. On the other hand, if the command is not
    3003             # found, the shell will set an exit code of 127 and print
    3004             # *an error message* to stdout. So we must check for both
    3005             # error code of zero AND non-empty stdout, which explains
    3006             # the odd construction:
    3007             func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null`
    3008             if test "$?" -eq 0 && test -n "${func_to_host_path_tmp1}"; then
    3009               func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
    3010                 $SED -e "$lt_sed_naive_backslashify"`
    3011             else
    3012               # Allow warning below.
    3013               func_to_host_path_result=""
    3014             fi
    3015             ;;
    3016         esac
    3017         if test -z "$func_to_host_path_result" ; then
    3018           func_error "Could not determine host path corresponding to"
    3019           func_error "  '$1'"
    3020           func_error "Continuing, but uninstalled executables may not work."
    3021           # Fallback:
    3022           func_to_host_path_result="$1"
    3023         fi
    3024         ;;
     3846# This wrapper script should never be moved out of the build directory.
     3847# If it is, it will not operate correctly.
     3848
     3849# Sed substitution that helps us do robust quoting.  It backslashifies
     3850# metacharacters that are still active within double-quoted strings.
     3851sed_quote_subst='$sed_quote_subst'
     3852
     3853# Be Bourne compatible
     3854if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
     3855  emulate sh
     3856  NULLCMD=:
     3857  # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
     3858  # is contrary to our usage.  Disable this feature.
     3859  alias -g '\${1+\"\$@\"}'='\"\$@\"'
     3860  setopt NO_GLOB_SUBST
     3861else
     3862  case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
     3863fi
     3864BIN_SH=xpg4; export BIN_SH # for Tru64
     3865DUALCASE=1; export DUALCASE # for MKS sh
     3866
     3867# The HP-UX ksh and POSIX shell print the target directory to stdout
     3868# if CDPATH is set.
     3869(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
     3870
     3871relink_command=\"$relink_command\"
     3872
     3873# This environment variable determines our operation mode.
     3874if test \"\$libtool_install_magic\" = \"$magic\"; then
     3875  # install mode needs the following variables:
     3876  generated_by_libtool_version='$macro_version'
     3877  notinst_deplibs='$notinst_deplibs'
     3878else
     3879  # When we are sourced in execute mode, \$file and \$ECHO are already set.
     3880  if test \"\$libtool_execute_magic\" != \"$magic\"; then
     3881    file=\"\$0\""
     3882
     3883    qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
     3884    $ECHO "\
     3885
     3886# A function that is used when there is no print builtin or printf.
     3887func_fallback_echo ()
     3888{
     3889  eval 'cat <<_LTECHO_EOF
     3890\$1
     3891_LTECHO_EOF'
     3892}
     3893    ECHO=\"$qECHO\"
     3894  fi
     3895
     3896# Very basic option parsing. These options are (a) specific to
     3897# the libtool wrapper, (b) are identical between the wrapper
     3898# /script/ and the wrapper /executable/ which is used only on
     3899# windows platforms, and (c) all begin with the string "--lt-"
     3900# (application programs are unlikely to have options which match
     3901# this pattern).
     3902#
     3903# There are only two supported options: --lt-debug and
     3904# --lt-dump-script. There is, deliberately, no --lt-help.
     3905#
     3906# The first argument to this parsing function should be the
     3907# script's $0 value, followed by "$@".
     3908lt_option_debug=
     3909func_parse_lt_options ()
     3910{
     3911  lt_script_arg0=\$0
     3912  shift
     3913  for lt_opt
     3914  do
     3915    case \"\$lt_opt\" in
     3916    --lt-debug) lt_option_debug=1 ;;
     3917    --lt-dump-script)
     3918        lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
     3919        test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
     3920        lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
     3921        cat \"\$lt_dump_D/\$lt_dump_F\"
     3922        exit 0
     3923      ;;
     3924    --lt-*)
     3925        \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
     3926        exit 1
     3927      ;;
     3928    esac
     3929  done
     3930
     3931  # Print the debug banner immediately:
     3932  if test -n \"\$lt_option_debug\"; then
     3933    echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
     3934  fi
     3935}
     3936
     3937# Used when --lt-debug. Prints its arguments to stdout
     3938# (redirection is the responsibility of the caller)
     3939func_lt_dump_args ()
     3940{
     3941  lt_dump_args_N=1;
     3942  for lt_arg
     3943  do
     3944    \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
     3945    lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
     3946  done
     3947}
     3948
     3949# Core function for launching the target application
     3950func_exec_program_core ()
     3951{
     3952"
     3953  case $host in
     3954  # Backslashes separate directories on plain windows
     3955  *-*-mingw | *-*-os2* | *-cegcc*)
     3956    $ECHO "\
     3957      if test -n \"\$lt_option_debug\"; then
     3958        \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
     3959        func_lt_dump_args \${1+\"\$@\"} 1>&2
     3960      fi
     3961      exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
     3962"
     3963    ;;
     3964
     3965  *)
     3966    $ECHO "\
     3967      if test -n \"\$lt_option_debug\"; then
     3968        \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
     3969        func_lt_dump_args \${1+\"\$@\"} 1>&2
     3970      fi
     3971      exec \"\$progdir/\$program\" \${1+\"\$@\"}
     3972"
     3973    ;;
     3974  esac
     3975  $ECHO "\
     3976      \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
     3977      exit 1
     3978}
     3979
     3980# A function to encapsulate launching the target application
     3981# Strips options in the --lt-* namespace from \$@ and
     3982# launches target application with the remaining arguments.
     3983func_exec_program ()
     3984{
     3985  for lt_wr_arg
     3986  do
     3987    case \$lt_wr_arg in
     3988    --lt-*) ;;
     3989    *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
     3990    esac
     3991    shift
     3992  done
     3993  func_exec_program_core \${1+\"\$@\"}
     3994}
     3995
     3996  # Parse options
     3997  func_parse_lt_options \"\$0\" \${1+\"\$@\"}
     3998
     3999  # Find the directory that this script lives in.
     4000  thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
     4001  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
     4002
     4003  # Follow symbolic links until we get to the real thisdir.
     4004  file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
     4005  while test -n \"\$file\"; do
     4006    destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
     4007
     4008    # If there was a directory component, then change thisdir.
     4009    if test \"x\$destdir\" != \"x\$file\"; then
     4010      case \"\$destdir\" in
     4011      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
     4012      *) thisdir=\"\$thisdir/\$destdir\" ;;
     4013      esac
     4014    fi
     4015
     4016    file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
     4017    file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
     4018  done
     4019
     4020  # Usually 'no', except on cygwin/mingw when embedded into
     4021  # the cwrapper.
     4022  WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
     4023  if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
     4024    # special case for '.'
     4025    if test \"\$thisdir\" = \".\"; then
     4026      thisdir=\`pwd\`
     4027    fi
     4028    # remove .libs from thisdir
     4029    case \"\$thisdir\" in
     4030    *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
     4031    $objdir )   thisdir=. ;;
    30254032    esac
    30264033  fi
    3027 }
    3028 # end: func_to_host_path
    3029 
    3030 # func_to_host_pathlist arg
    3031 #
    3032 # Convert pathlists to host format when used with build tools.
    3033 # See func_to_host_path(), above. This function supports the
    3034 # following $build/$host combinations (but does no harm for
    3035 # combinations not listed here):
    3036 #    $build          $host
    3037 #    mingw (msys)    mingw  [e.g. native]
    3038 #    cygwin          mingw
    3039 #    *nix + wine     mingw
    3040 #
    3041 # Path separators are also converted from $build format to
    3042 # $host format. If ARG begins or ends with a path separator
    3043 # character, it is preserved (but converted to $host format)
    3044 # on output.
    3045 #
    3046 # ARG is a pathlist (on $build) that should be converted to
    3047 # the proper representation on $host. The result is stored
    3048 # in $func_to_host_pathlist_result.
    3049 func_to_host_pathlist ()
    3050 {
    3051   func_to_host_pathlist_result="$1"
    3052   if test -n "$1" ; then
    3053     case $host in
    3054       *mingw* )
    3055         lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
    3056         # Remove leading and trailing path separator characters from
    3057         # ARG. msys behavior is inconsistent here, cygpath turns them
    3058         # into '.;' and ';.', and winepath ignores them completely.
    3059         func_to_host_pathlist_tmp2="$1"
    3060         # Once set for this call, this variable should not be
    3061         # reassigned. It is used in tha fallback case.
    3062         func_to_host_pathlist_tmp1=`echo "$func_to_host_pathlist_tmp2" |\
    3063           $SED -e 's|^:*||' -e 's|:*$||'`
    3064         case $build in
    3065           *mingw* ) # Actually, msys.
    3066             # Awkward: cmd appends spaces to result.
    3067             lt_sed_strip_trailing_spaces="s/[ ]*\$//"
    3068             func_to_host_pathlist_tmp2=`( cmd //c echo "$func_to_host_pathlist_tmp1" |\
    3069               $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
    3070             func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
    3071               $SED -e "$lt_sed_naive_backslashify"`
    3072             ;;
    3073           *cygwin* )
    3074             func_to_host_pathlist_tmp2=`cygpath -w -p "$func_to_host_pathlist_tmp1"`
    3075             func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
    3076               $SED -e "$lt_sed_naive_backslashify"`
    3077             ;;
    3078           * )
    3079             # unfortunately, winepath doesn't convert pathlists
    3080             func_to_host_pathlist_result=""
    3081             func_to_host_pathlist_oldIFS=$IFS
    3082             IFS=:
    3083             for func_to_host_pathlist_f in $func_to_host_pathlist_tmp1 ; do
    3084               IFS=$func_to_host_pathlist_oldIFS
    3085               if test -n "$func_to_host_pathlist_f" ; then
    3086                 func_to_host_path "$func_to_host_pathlist_f"
    3087                 if test -n "$func_to_host_path_result" ; then
    3088                   if test -z "$func_to_host_pathlist_result" ; then
    3089                     func_to_host_pathlist_result="$func_to_host_path_result"
    3090                   else
    3091                     func_to_host_pathlist_result="$func_to_host_pathlist_result;$func_to_host_path_result"
    3092                   fi
    3093                 fi
    3094               fi
    3095               IFS=:
    3096             done
    3097             IFS=$func_to_host_pathlist_oldIFS
    3098             ;;
    3099         esac
    3100         if test -z "$func_to_host_pathlist_result" ; then
    3101           func_error "Could not determine the host path(s) corresponding to"
    3102           func_error "  '$1'"
    3103           func_error "Continuing, but uninstalled executables may not work."
    3104           # Fallback. This may break if $1 contains DOS-style drive
    3105           # specifications. The fix is not to complicate the expression
    3106           # below, but for the user to provide a working wine installation
    3107           # with winepath so that path translation in the cross-to-mingw
    3108           # case works properly.
    3109           lt_replace_pathsep_nix_to_dos="s|:|;|g"
    3110           func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp1" |\
    3111             $SED -e "$lt_replace_pathsep_nix_to_dos"`
    3112         fi
    3113         # Now, add the leading and trailing path separators back
    3114         case "$1" in
    3115           :* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result"
    3116             ;;
    3117         esac
    3118         case "$1" in
    3119           *: ) func_to_host_pathlist_result="$func_to_host_pathlist_result;"
    3120             ;;
    3121         esac
    3122         ;;
    3123     esac
     4034
     4035  # Try to get the absolute directory name.
     4036  absdir=\`cd \"\$thisdir\" && pwd\`
     4037  test -n \"\$absdir\" && thisdir=\"\$absdir\"
     4038"
     4039
     4040        if test "$fast_install" = yes; then
     4041          $ECHO "\
     4042  program=lt-'$outputname'$exeext
     4043  progdir=\"\$thisdir/$objdir\"
     4044
     4045  if test ! -f \"\$progdir/\$program\" ||
     4046     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
     4047       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
     4048
     4049    file=\"\$\$-\$program\"
     4050
     4051    if test ! -d \"\$progdir\"; then
     4052      $MKDIR \"\$progdir\"
     4053    else
     4054      $RM \"\$progdir/\$file\"
     4055    fi"
     4056
     4057          $ECHO "\
     4058
     4059    # relink executable if necessary
     4060    if test -n \"\$relink_command\"; then
     4061      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
     4062      else
     4063        $ECHO \"\$relink_command_output\" >&2
     4064        $RM \"\$progdir/\$file\"
     4065        exit 1
     4066      fi
     4067    fi
     4068
     4069    $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
     4070    { $RM \"\$progdir/\$program\";
     4071      $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
     4072    $RM \"\$progdir/\$file\"
     4073  fi"
     4074        else
     4075          $ECHO "\
     4076  program='$outputname'
     4077  progdir=\"\$thisdir/$objdir\"
     4078"
     4079        fi
     4080
     4081        $ECHO "\
     4082
     4083  if test -f \"\$progdir/\$program\"; then"
     4084
     4085        # fixup the dll searchpath if we need to.
     4086        #
     4087        # Fix the DLL searchpath if we need to.  Do this before prepending
     4088        # to shlibpath, because on Windows, both are PATH and uninstalled
     4089        # libraries must come first.
     4090        if test -n "$dllsearchpath"; then
     4091          $ECHO "\
     4092    # Add the dll search path components to the executable PATH
     4093    PATH=$dllsearchpath:\$PATH
     4094"
     4095        fi
     4096
     4097        # Export our shlibpath_var if we have one.
     4098        if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
     4099          $ECHO "\
     4100    # Add our own library path to $shlibpath_var
     4101    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
     4102
     4103    # Some systems cannot cope with colon-terminated $shlibpath_var
     4104    # The second colon is a workaround for a bug in BeOS R4 sed
     4105    $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
     4106
     4107    export $shlibpath_var
     4108"
     4109        fi
     4110
     4111        $ECHO "\
     4112    if test \"\$libtool_execute_magic\" != \"$magic\"; then
     4113      # Run the actual program with our arguments.
     4114      func_exec_program \${1+\"\$@\"}
     4115    fi
     4116  else
     4117    # The program doesn't exist.
     4118    \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
     4119    \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
     4120    \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
     4121    exit 1
    31244122  fi
    3125 }
    3126 # end: func_to_host_pathlist
     4123fi\
     4124"
     4125}
     4126
    31274127
    31284128# func_emit_cwrapperexe_src
     
    31424142   This wrapper executable should never be moved out of the build directory.
    31434143   If it is, it will not operate correctly.
    3144 
    3145    Currently, it simply execs the wrapper *script* "$SHELL $output",
    3146    but could eventually absorb all of the scripts functionality and
    3147    exec $objdir/$outputname directly.
    31484144*/
    31494145EOF
    31504146            cat <<"EOF"
     4147#ifdef _MSC_VER
     4148# define _CRT_SECURE_NO_DEPRECATE 1
     4149#endif
    31514150#include <stdio.h>
    31524151#include <stdlib.h>
     
    31554154# include <process.h>
    31564155# include <io.h>
    3157 # define setmode _setmode
    31584156#else
    31594157# include <unistd.h>
     
    31614159# ifdef __CYGWIN__
    31624160#  include <io.h>
    3163 #  define HAVE_SETENV
    3164 #  ifdef __STRICT_ANSI__
    3165 char *realpath (const char *, char *);
    3166 int putenv (char *);
    3167 int setenv (const char *, const char *, int);
    3168 #  endif
    31694161# endif
    31704162#endif
     
    31784170#include <sys/stat.h>
    31794171
     4172/* declarations of non-ANSI functions */
     4173#if defined(__MINGW32__)
     4174# ifdef __STRICT_ANSI__
     4175int _putenv (const char *);
     4176# endif
     4177#elif defined(__CYGWIN__)
     4178# ifdef __STRICT_ANSI__
     4179char *realpath (const char *, char *);
     4180int putenv (char *);
     4181int setenv (const char *, const char *, int);
     4182# endif
     4183/* #elif defined (other platforms) ... */
     4184#endif
     4185
     4186/* portability defines, excluding path handling macros */
     4187#if defined(_MSC_VER)
     4188# define setmode _setmode
     4189# define stat    _stat
     4190# define chmod   _chmod
     4191# define getcwd  _getcwd
     4192# define putenv  _putenv
     4193# define S_IXUSR _S_IEXEC
     4194# ifndef _INTPTR_T_DEFINED
     4195#  define _INTPTR_T_DEFINED
     4196#  define intptr_t int
     4197# endif
     4198#elif defined(__MINGW32__)
     4199# define setmode _setmode
     4200# define stat    _stat
     4201# define chmod   _chmod
     4202# define getcwd  _getcwd
     4203# define putenv  _putenv
     4204#elif defined(__CYGWIN__)
     4205# define HAVE_SETENV
     4206# define FOPEN_WB "wb"
     4207/* #elif defined (other platforms) ... */
     4208#endif
     4209
    31804210#if defined(PATH_MAX)
    31814211# define LT_PATHMAX PATH_MAX
     
    31934223#endif
    31944224
    3195 #ifdef _MSC_VER
    3196 # define S_IXUSR _S_IEXEC
    3197 # define stat _stat
    3198 # ifndef _INTPTR_T_DEFINED
    3199 #  define intptr_t int
    3200 # endif
    3201 #endif
    3202 
     4225/* path handling portability macros */
    32034226#ifndef DIR_SEPARATOR
    32044227# define DIR_SEPARATOR '/'
     
    32314254#endif /* PATH_SEPARATOR_2 */
    32324255
    3233 #ifdef __CYGWIN__
    3234 # define FOPEN_WB "wb"
    3235 #endif
    3236 
    32374256#ifndef FOPEN_WB
    32384257# define FOPEN_WB "w"
     
    32474266} while (0)
    32484267
    3249 #undef LTWRAPPER_DEBUGPRINTF
    3250 #if defined DEBUGWRAPPER
    3251 # define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args
    3252 static void
    3253 ltwrapper_debugprintf (const char *fmt, ...)
    3254 {
    3255     va_list args;
    3256     va_start (args, fmt);
    3257     (void) vfprintf (stderr, fmt, args);
    3258     va_end (args);
    3259 }
     4268#if defined(LT_DEBUGWRAPPER)
     4269static int lt_debug = 1;
    32604270#else
    3261 # define LTWRAPPER_DEBUGPRINTF(args)
     4271static int lt_debug = 0;
    32624272#endif
    32634273
    3264 const char *program_name = NULL;
     4274const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
    32654275
    32664276void *xmalloc (size_t num);
     
    32724282int check_executable (const char *path);
    32734283char *strendzap (char *str, const char *pat);
    3274 void lt_fatal (const char *message, ...);
     4284void lt_debugprintf (const char *file, int line, const char *fmt, ...);
     4285void lt_fatal (const char *file, int line, const char *message, ...);
     4286static const char *nonnull (const char *s);
     4287static const char *nonempty (const char *s);
    32754288void lt_setenv (const char *name, const char *value);
    32764289char *lt_extend_str (const char *orig_value, const char *add, int to_end);
    3277 void lt_opt_process_env_set (const char *arg);
    3278 void lt_opt_process_env_prepend (const char *arg);
    3279 void lt_opt_process_env_append (const char *arg);
    3280 int lt_split_name_value (const char *arg, char** name, char** value);
    32814290void lt_update_exe_path (const char *name, const char *value);
    32824291void lt_update_lib_path (const char *name, const char *value);
    3283 
    3284 static const char *script_text_part1 =
     4292char **prepare_spawn (char **argv);
     4293void lt_dump_script (FILE *f);
    32854294EOF
    32864295
    3287             func_emit_wrapper_part1 yes |
    3288                 $SED -e 's/\([\\"]\)/\\\1/g' \
    3289                      -e 's/^/  "/' -e 's/$/\\n"/'
    3290             echo ";"
    32914296            cat <<EOF
    3292 
    3293 static const char *script_text_part2 =
    3294 EOF
    3295             func_emit_wrapper_part2 yes |
    3296                 $SED -e 's/\([\\"]\)/\\\1/g' \
    3297                      -e 's/^/  "/' -e 's/$/\\n"/'
    3298             echo ";"
    3299 
    3300             cat <<EOF
    3301 const char * MAGIC_EXE = "$magic_exe";
     4297volatile const char * MAGIC_EXE = "$magic_exe";
    33024298const char * LIB_PATH_VARNAME = "$shlibpath_var";
    33034299EOF
    33044300
    33054301            if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
    3306               func_to_host_pathlist "$temp_rpath"
     4302              func_to_host_path "$temp_rpath"
    33074303              cat <<EOF
    3308 const char * LIB_PATH_VALUE   = "$func_to_host_pathlist_result";
     4304const char * LIB_PATH_VALUE   = "$func_to_host_path_result";
    33094305EOF
    33104306            else
     
    33154311
    33164312            if test -n "$dllsearchpath"; then
    3317               func_to_host_pathlist "$dllsearchpath:"
     4313              func_to_host_path "$dllsearchpath:"
    33184314              cat <<EOF
    33194315const char * EXE_PATH_VARNAME = "PATH";
    3320 const char * EXE_PATH_VALUE   = "$func_to_host_pathlist_result";
     4316const char * EXE_PATH_VALUE   = "$func_to_host_path_result";
    33214317EOF
    33224318            else
     
    33414337
    33424338#define LTWRAPPER_OPTION_PREFIX         "--lt-"
    3343 #define LTWRAPPER_OPTION_PREFIX_LENGTH  5
    3344 
    3345 static const size_t opt_prefix_len         = LTWRAPPER_OPTION_PREFIX_LENGTH;
     4339
    33464340static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
    3347 
    33484341static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
    3349 
    3350 static const size_t env_set_opt_len     = LTWRAPPER_OPTION_PREFIX_LENGTH + 7;
    3351 static const char *env_set_opt          = LTWRAPPER_OPTION_PREFIX "env-set";
    3352   /* argument is putenv-style "foo=bar", value of foo is set to bar */
    3353 
    3354 static const size_t env_prepend_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 11;
    3355 static const char *env_prepend_opt      = LTWRAPPER_OPTION_PREFIX "env-prepend";
    3356   /* argument is putenv-style "foo=bar", new value of foo is bar${foo} */
    3357 
    3358 static const size_t env_append_opt_len  = LTWRAPPER_OPTION_PREFIX_LENGTH + 10;
    3359 static const char *env_append_opt       = LTWRAPPER_OPTION_PREFIX "env-append";
    3360   /* argument is putenv-style "foo=bar", new value of foo is ${foo}bar */
     4342static const char *debug_opt            = LTWRAPPER_OPTION_PREFIX "debug";
    33614343
    33624344int
     
    33754357
    33764358  program_name = (char *) xstrdup (base_name (argv[0]));
    3377   LTWRAPPER_DEBUGPRINTF (("(main) argv[0]      : %s\n", argv[0]));
    3378   LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name));
    3379 
    3380   /* very simple arg parsing; don't want to rely on getopt */
     4359  newargz = XMALLOC (char *, argc + 1);
     4360
     4361  /* very simple arg parsing; don't want to rely on getopt
     4362   * also, copy all non cwrapper options to newargz, except
     4363   * argz[0], which is handled differently
     4364   */
     4365  newargc=0;
    33814366  for (i = 1; i < argc; i++)
    33824367    {
     
    33924377
    33934378            cat <<"EOF"
    3394           printf ("%s", script_text_part1);
    3395           printf ("%s", script_text_part2);
     4379          lt_dump_script (stdout);
    33964380          return 0;
    33974381        }
     4382      if (strcmp (argv[i], debug_opt) == 0)
     4383        {
     4384          lt_debug = 1;
     4385          continue;
     4386        }
     4387      if (strcmp (argv[i], ltwrapper_option_prefix) == 0)
     4388        {
     4389          /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
     4390             namespace, but it is not one of the ones we know about and
     4391             have already dealt with, above (inluding dump-script), then
     4392             report an error. Otherwise, targets might begin to believe
     4393             they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
     4394             namespace. The first time any user complains about this, we'll
     4395             need to make LTWRAPPER_OPTION_PREFIX a configure-time option
     4396             or a configure.ac-settable value.
     4397           */
     4398          lt_fatal (__FILE__, __LINE__,
     4399                    "unrecognized %s option: '%s'",
     4400                    ltwrapper_option_prefix, argv[i]);
     4401        }
     4402      /* otherwise ... */
     4403      newargz[++newargc] = xstrdup (argv[i]);
    33984404    }
    3399 
    3400   newargz = XMALLOC (char *, argc + 1);
     4405  newargz[++newargc] = NULL;
     4406
     4407EOF
     4408            cat <<EOF
     4409  /* The GNU banner must be the first non-error debug message */
     4410  lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");
     4411EOF
     4412            cat <<"EOF"
     4413  lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
     4414  lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
     4415
    34014416  tmp_pathspec = find_executable (argv[0]);
    34024417  if (tmp_pathspec == NULL)
    3403     lt_fatal ("Couldn't find %s", argv[0]);
    3404   LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n",
    3405                           tmp_pathspec));
     4418    lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
     4419  lt_debugprintf (__FILE__, __LINE__,
     4420                  "(main) found exe (before symlink chase) at: %s\n",
     4421                  tmp_pathspec);
    34064422
    34074423  actual_cwrapper_path = chase_symlinks (tmp_pathspec);
    3408   LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",
    3409                           actual_cwrapper_path));
     4424  lt_debugprintf (__FILE__, __LINE__,
     4425                  "(main) found exe (after symlink chase) at: %s\n",
     4426                  actual_cwrapper_path);
    34104427  XFREE (tmp_pathspec);
    34114428
    3412   actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));
     4429  actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
    34134430  strendzap (actual_cwrapper_path, actual_cwrapper_name);
    34144431
     
    34284445  tmp_pathspec = 0;
    34294446
    3430   LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n",
    3431                           target_name));
     4447  lt_debugprintf (__FILE__, __LINE__,
     4448                  "(main) libtool target name: %s\n",
     4449                  target_name);
    34324450EOF
    34334451
     
    34794497  lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
    34804498  lt_setenv ("DUALCASE", "1");  /* for MSK sh */
     4499  /* Update the DLL searchpath.  EXE_PATH_VALUE ($dllsearchpath) must
     4500     be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
     4501     because on Windows, both *_VARNAMEs are PATH but uninstalled
     4502     libraries must come first. */
     4503  lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
    34814504  lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
    3482   lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
    3483 
    3484   newargc=0;
    3485   for (i = 1; i < argc; i++)
    3486     {
    3487       if (strncmp (argv[i], env_set_opt, env_set_opt_len) == 0)
    3488         {
    3489           if (argv[i][env_set_opt_len] == '=')
    3490             {
    3491               const char *p = argv[i] + env_set_opt_len + 1;
    3492               lt_opt_process_env_set (p);
    3493             }
    3494           else if (argv[i][env_set_opt_len] == '\0' && i + 1 < argc)
    3495             {
    3496               lt_opt_process_env_set (argv[++i]); /* don't copy */
    3497             }
    3498           else
    3499             lt_fatal ("%s missing required argument", env_set_opt);
    3500           continue;
    3501         }
    3502       if (strncmp (argv[i], env_prepend_opt, env_prepend_opt_len) == 0)
    3503         {
    3504           if (argv[i][env_prepend_opt_len] == '=')
    3505             {
    3506               const char *p = argv[i] + env_prepend_opt_len + 1;
    3507               lt_opt_process_env_prepend (p);
    3508             }
    3509           else if (argv[i][env_prepend_opt_len] == '\0' && i + 1 < argc)
    3510             {
    3511               lt_opt_process_env_prepend (argv[++i]); /* don't copy */
    3512             }
    3513           else
    3514             lt_fatal ("%s missing required argument", env_prepend_opt);
    3515           continue;
    3516         }
    3517       if (strncmp (argv[i], env_append_opt, env_append_opt_len) == 0)
    3518         {
    3519           if (argv[i][env_append_opt_len] == '=')
    3520             {
    3521               const char *p = argv[i] + env_append_opt_len + 1;
    3522               lt_opt_process_env_append (p);
    3523             }
    3524           else if (argv[i][env_append_opt_len] == '\0' && i + 1 < argc)
    3525             {
    3526               lt_opt_process_env_append (argv[++i]); /* don't copy */
    3527             }
    3528           else
    3529             lt_fatal ("%s missing required argument", env_append_opt);
    3530           continue;
    3531         }
    3532       if (strncmp (argv[i], ltwrapper_option_prefix, opt_prefix_len) == 0)
    3533         {
    3534           /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
    3535              namespace, but it is not one of the ones we know about and
    3536              have already dealt with, above (inluding dump-script), then
    3537              report an error. Otherwise, targets might begin to believe
    3538              they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
    3539              namespace. The first time any user complains about this, we'll
    3540              need to make LTWRAPPER_OPTION_PREFIX a configure-time option
    3541              or a configure.ac-settable value.
    3542            */
    3543           lt_fatal ("Unrecognized option in %s namespace: '%s'",
    3544                     ltwrapper_option_prefix, argv[i]);
    3545         }
    3546       /* otherwise ... */
    3547       newargz[++newargc] = xstrdup (argv[i]);
    3548     }
    3549   newargz[++newargc] = NULL;
    3550 
    3551   LTWRAPPER_DEBUGPRINTF     (("(main) lt_argv_zero : %s\n", (lt_argv_zero ? lt_argv_zero : "<NULL>")));
     4505
     4506  lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
     4507                  nonnull (lt_argv_zero));
    35524508  for (i = 0; i < newargc; i++)
    35534509    {
    3554       LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d]   : %s\n", i, (newargz[i] ? newargz[i] : "<NULL>")));
     4510      lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
     4511                      i, nonnull (newargz[i]));
    35554512    }
    35564513
     
    35614518                cat <<"EOF"
    35624519  /* execv doesn't actually work on mingw as expected on unix */
     4520  newargz = prepare_spawn (newargz);
    35634521  rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
    35644522  if (rval == -1)
    35654523    {
    35664524      /* failed to start process */
    3567       LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno));
     4525      lt_debugprintf (__FILE__, __LINE__,
     4526                      "(main) failed to launch target \"%s\": %s\n",
     4527                      lt_argv_zero, nonnull (strerror (errno)));
    35684528      return 127;
    35694529    }
     
    35874547  void *p = (void *) malloc (num);
    35884548  if (!p)
    3589     lt_fatal ("Memory exhausted");
     4549    lt_fatal (__FILE__, __LINE__, "memory exhausted");
    35904550
    35914551  return p;
     
    36214581  struct stat st;
    36224582
    3623   LTWRAPPER_DEBUGPRINTF (("(check_executable)  : %s\n",
    3624                           path ? (*path ? path : "EMPTY!") : "NULL!"));
     4583  lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
     4584                  nonempty (path));
    36254585  if ((!path) || (!*path))
    36264586    return 0;
     
    36394599  struct stat st;
    36404600
    3641   LTWRAPPER_DEBUGPRINTF (("(make_executable)   : %s\n",
    3642                           path ? (*path ? path : "EMPTY!") : "NULL!"));
     4601  lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
     4602                  nonempty (path));
    36434603  if ((!path) || (!*path))
    36444604    return 0;
     
    36664626  char *concat_name;
    36674627
    3668   LTWRAPPER_DEBUGPRINTF (("(find_executable)   : %s\n",
    3669                           wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));
     4628  lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
     4629                  nonempty (wrapper));
    36704630
    36714631  if ((wrapper == NULL) || (*wrapper == '\0'))
     
    37204680                  /* empty path: current directory */
    37214681                  if (getcwd (tmp, LT_PATHMAX) == NULL)
    3722                     lt_fatal ("getcwd failed");
     4682                    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
     4683                              nonnull (strerror (errno)));
    37234684                  tmp_len = strlen (tmp);
    37244685                  concat_name =
     
    37454706  /* Relative path | not found in path: prepend cwd */
    37464707  if (getcwd (tmp, LT_PATHMAX) == NULL)
    3747     lt_fatal ("getcwd failed");
     4708    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
     4709              nonnull (strerror (errno)));
    37484710  tmp_len = strlen (tmp);
    37494711  concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
     
    37714733  while (strlen (tmp_pathspec) && !has_symlinks)
    37724734    {
    3773       LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",
    3774                               tmp_pathspec));
     4735      lt_debugprintf (__FILE__, __LINE__,
     4736                      "checking path component for symlinks: %s\n",
     4737                      tmp_pathspec);
    37754738      if (lstat (tmp_pathspec, &s) == 0)
    37764739        {
     
    37944757      else
    37954758        {
    3796           char *errstr = strerror (errno);
    3797           lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);
     4759          lt_fatal (__FILE__, __LINE__,
     4760                    "error accessing file \"%s\": %s",
     4761                    tmp_pathspec, nonnull (strerror (errno)));
    37984762        }
    37994763    }
     
    38084772  if (tmp_pathspec == 0)
    38094773    {
    3810       lt_fatal ("Could not follow symlinks for %s", pathspec);
     4774      lt_fatal (__FILE__, __LINE__,
     4775                "could not follow symlinks for %s", pathspec);
    38114776    }
    38124777  return xstrdup (tmp_pathspec);
     
    38344799}
    38354800
     4801void
     4802lt_debugprintf (const char *file, int line, const char *fmt, ...)
     4803{
     4804  va_list args;
     4805  if (lt_debug)
     4806    {
     4807      (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
     4808      va_start (args, fmt);
     4809      (void) vfprintf (stderr, fmt, args);
     4810      va_end (args);
     4811    }
     4812}
     4813
    38364814static void
    3837 lt_error_core (int exit_status, const char *mode,
     4815lt_error_core (int exit_status, const char *file,
     4816               int line, const char *mode,
    38384817               const char *message, va_list ap)
    38394818{
    3840   fprintf (stderr, "%s: %s: ", program_name, mode);
     4819  fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
    38414820  vfprintf (stderr, message, ap);
    38424821  fprintf (stderr, ".\n");
     
    38474826
    38484827void
    3849 lt_fatal (const char *message, ...)
     4828lt_fatal (const char *file, int line, const char *message, ...)
    38504829{
    38514830  va_list ap;
    38524831  va_start (ap, message);
    3853   lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
     4832  lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
    38544833  va_end (ap);
     4834}
     4835
     4836static const char *
     4837nonnull (const char *s)
     4838{
     4839  return s ? s : "(null)";
     4840}
     4841
     4842static const char *
     4843nonempty (const char *s)
     4844{
     4845  return (s && !*s) ? "(empty)" : nonnull (s);
    38554846}
    38564847
     
    38584849lt_setenv (const char *name, const char *value)
    38594850{
    3860   LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n",
    3861                           (name ? name : "<NULL>"),
    3862                           (value ? value : "<NULL>")));
     4851  lt_debugprintf (__FILE__, __LINE__,
     4852                  "(lt_setenv) setting '%s' to '%s'\n",
     4853                  nonnull (name), nonnull (value));
    38634854  {
    38644855#ifdef HAVE_SETENV
     
    39054896}
    39064897
    3907 int
    3908 lt_split_name_value (const char *arg, char** name, char** value)
    3909 {
    3910   const char *p;
    3911   int len;
    3912   if (!arg || !*arg)
    3913     return 1;
    3914 
    3915   p = strchr (arg, (int)'=');
    3916 
    3917   if (!p)
    3918     return 1;
    3919 
    3920   *value = xstrdup (++p);
    3921 
    3922   len = strlen (arg) - strlen (*value);
    3923   *name = XMALLOC (char, len);
    3924   strncpy (*name, arg, len-1);
    3925   (*name)[len - 1] = '\0';
    3926 
    3927   return 0;
    3928 }
    3929 
    3930 void
    3931 lt_opt_process_env_set (const char *arg)
    3932 {
    3933   char *name = NULL;
    3934   char *value = NULL;
    3935 
    3936   if (lt_split_name_value (arg, &name, &value) != 0)
    3937     {
    3938       XFREE (name);
    3939       XFREE (value);
    3940       lt_fatal ("bad argument for %s: '%s'", env_set_opt, arg);
    3941     }
    3942 
    3943   lt_setenv (name, value);
    3944   XFREE (name);
    3945   XFREE (value);
    3946 }
    3947 
    3948 void
    3949 lt_opt_process_env_prepend (const char *arg)
    3950 {
    3951   char *name = NULL;
    3952   char *value = NULL;
    3953   char *new_value = NULL;
    3954 
    3955   if (lt_split_name_value (arg, &name, &value) != 0)
    3956     {
    3957       XFREE (name);
    3958       XFREE (value);
    3959       lt_fatal ("bad argument for %s: '%s'", env_prepend_opt, arg);
    3960     }
    3961 
    3962   new_value = lt_extend_str (getenv (name), value, 0);
    3963   lt_setenv (name, new_value);
    3964   XFREE (new_value);
    3965   XFREE (name);
    3966   XFREE (value);
    3967 }
    3968 
    3969 void
    3970 lt_opt_process_env_append (const char *arg)
    3971 {
    3972   char *name = NULL;
    3973   char *value = NULL;
    3974   char *new_value = NULL;
    3975 
    3976   if (lt_split_name_value (arg, &name, &value) != 0)
    3977     {
    3978       XFREE (name);
    3979       XFREE (value);
    3980       lt_fatal ("bad argument for %s: '%s'", env_append_opt, arg);
    3981     }
    3982 
    3983   new_value = lt_extend_str (getenv (name), value, 1);
    3984   lt_setenv (name, new_value);
    3985   XFREE (new_value);
    3986   XFREE (name);
    3987   XFREE (value);
    3988 }
    3989 
    39904898void
    39914899lt_update_exe_path (const char *name, const char *value)
    39924900{
    3993   LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
    3994                           (name ? name : "<NULL>"),
    3995                           (value ? value : "<NULL>")));
     4901  lt_debugprintf (__FILE__, __LINE__,
     4902                  "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
     4903                  nonnull (name), nonnull (value));
    39964904
    39974905  if (name && *name && value && *value)
     
    40124920lt_update_lib_path (const char *name, const char *value)
    40134921{
    4014   LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
    4015                           (name ? name : "<NULL>"),
    4016                           (value ? value : "<NULL>")));
     4922  lt_debugprintf (__FILE__, __LINE__,
     4923                  "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
     4924                  nonnull (name), nonnull (value));
    40174925
    40184926  if (name && *name && value && *value)
     
    40244932}
    40254933
    4026 
    40274934EOF
     4935            case $host_os in
     4936              mingw*)
     4937                cat <<"EOF"
     4938
     4939/* Prepares an argument vector before calling spawn().
     4940   Note that spawn() does not by itself call the command interpreter
     4941     (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
     4942      ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
     4943         GetVersionEx(&v);
     4944         v.dwPlatformId == VER_PLATFORM_WIN32_NT;
     4945      }) ? "cmd.exe" : "command.com").
     4946   Instead it simply concatenates the arguments, separated by ' ', and calls
     4947   CreateProcess().  We must quote the arguments since Win32 CreateProcess()
     4948   interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
     4949   special way:
     4950   - Space and tab are interpreted as delimiters. They are not treated as
     4951     delimiters if they are surrounded by double quotes: "...".
     4952   - Unescaped double quotes are removed from the input. Their only effect is
     4953     that within double quotes, space and tab are treated like normal
     4954     characters.
     4955   - Backslashes not followed by double quotes are not special.
     4956   - But 2*n+1 backslashes followed by a double quote become
     4957     n backslashes followed by a double quote (n >= 0):
     4958       \" -> "
     4959       \\\" -> \"
     4960       \\\\\" -> \\"
     4961 */
     4962#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"
     4963#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"
     4964char **
     4965prepare_spawn (char **argv)
     4966{
     4967  size_t argc;
     4968  char **new_argv;
     4969  size_t i;
     4970
     4971  /* Count number of arguments.  */
     4972  for (argc = 0; argv[argc] != NULL; argc++)
     4973    ;
     4974
     4975  /* Allocate new argument vector.  */
     4976  new_argv = XMALLOC (char *, argc + 1);
     4977
     4978  /* Put quoted arguments into the new argument vector.  */
     4979  for (i = 0; i < argc; i++)
     4980    {
     4981      const char *string = argv[i];
     4982
     4983      if (string[0] == '\0')
     4984        new_argv[i] = xstrdup ("\"\"");
     4985      else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
     4986        {
     4987          int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
     4988          size_t length;
     4989          unsigned int backslashes;
     4990          const char *s;
     4991          char *quoted_string;
     4992          char *p;
     4993
     4994          length = 0;
     4995          backslashes = 0;
     4996          if (quote_around)
     4997            length++;
     4998          for (s = string; *s != '\0'; s++)
     4999            {
     5000              char c = *s;
     5001              if (c == '"')
     5002                length += backslashes + 1;
     5003              length++;
     5004              if (c == '\\')
     5005                backslashes++;
     5006              else
     5007                backslashes = 0;
     5008            }
     5009          if (quote_around)
     5010            length += backslashes + 1;
     5011
     5012          quoted_string = XMALLOC (char, length + 1);
     5013
     5014          p = quoted_string;
     5015          backslashes = 0;
     5016          if (quote_around)
     5017            *p++ = '"';
     5018          for (s = string; *s != '\0'; s++)
     5019            {
     5020              char c = *s;
     5021              if (c == '"')
     5022                {
     5023                  unsigned int j;
     5024                  for (j = backslashes + 1; j > 0; j--)
     5025                    *p++ = '\\';
     5026                }
     5027              *p++ = c;
     5028              if (c == '\\')
     5029                backslashes++;
     5030              else
     5031                backslashes = 0;
     5032            }
     5033          if (quote_around)
     5034            {
     5035              unsigned int j;
     5036              for (j = backslashes; j > 0; j--)
     5037                *p++ = '\\';
     5038              *p++ = '"';
     5039            }
     5040          *p = '\0';
     5041
     5042          new_argv[i] = quoted_string;
     5043        }
     5044      else
     5045        new_argv[i] = (char *) string;
     5046    }
     5047  new_argv[argc] = NULL;
     5048
     5049  return new_argv;
     5050}
     5051EOF
     5052                ;;
     5053            esac
     5054
     5055            cat <<"EOF"
     5056void lt_dump_script (FILE* f)
     5057{
     5058EOF
     5059            func_emit_wrapper yes |
     5060              $SED -e 's/\([\\"]\)/\\\1/g' \
     5061                   -e 's/^/  fputs ("/' -e 's/$/\\n", f);/'
     5062
     5063            cat <<"EOF"
     5064}
     5065EOF
    40285066}
    40295067# end: func_emit_cwrapperexe_src
     5068
     5069# func_win32_import_lib_p ARG
     5070# True if ARG is an import lib, as indicated by $file_magic_cmd
     5071func_win32_import_lib_p ()
     5072{
     5073    $opt_debug
     5074    case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
     5075    *import*) : ;;
     5076    *) false ;;
     5077    esac
     5078}
    40305079
    40315080# func_mode_link arg...
     
    40735122
    40745123    avoid_version=no
     5124    bindir=
    40755125    dlfiles=
    40765126    dlprefiles=
     
    41655215
    41665216        case $prev in
     5217        bindir)
     5218          bindir="$arg"
     5219          prev=
     5220          continue
     5221          ;;
    41675222        dlfiles|dlprefiles)
    41685223          if test "$preload" = no; then
     
    41965251          *)
    41975252            if test "$prev" = dlfiles; then
    4198               dlfiles="$dlfiles $arg"
     5253              func_append dlfiles " $arg"
    41995254            else
    4200               dlprefiles="$dlprefiles $arg"
     5255              func_append dlprefiles " $arg"
    42015256            fi
    42025257            prev=
     
    42225277              case "$deplibs " in
    42235278                *" $qarg.ltframework "*) ;;
    4224                 *) deplibs="$deplibs $qarg.ltframework" # this is fixed later
     5279                *) func_append deplibs " $qarg.ltframework" # this is fixed later
    42255280                   ;;
    42265281              esac
     
    42415296            for fil in `cat "$save_arg"`
    42425297            do
    4243 #             moreargs="$moreargs $fil"
     5298#             func_append moreargs " $fil"
    42445299              arg=$fil
    42455300              # A libtool-controlled object.
     
    42705325                  if test "$prev" = dlfiles; then
    42715326                    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
    4272                       dlfiles="$dlfiles $pic_object"
     5327                      func_append dlfiles " $pic_object"
    42735328                      prev=
    42745329                      continue
     
    42825337                  if test "$prev" = dlprefiles; then
    42835338                    # Preload the old-style object.
    4284                     dlprefiles="$dlprefiles $pic_object"
     5339                    func_append dlprefiles " $pic_object"
    42855340                    prev=
    42865341                  fi
     
    43525407            case "$rpath " in
    43535408            *" $arg "*) ;;
    4354             *) rpath="$rpath $arg" ;;
     5409            *) func_append rpath " $arg" ;;
    43555410            esac
    43565411          else
    43575412            case "$xrpath " in
    43585413            *" $arg "*) ;;
    4359             *) xrpath="$xrpath $arg" ;;
     5414            *) func_append xrpath " $arg" ;;
    43605415            esac
    43615416          fi
     
    43695424          ;;
    43705425        weak)
    4371           weak_libs="$weak_libs $arg"
     5426          func_append weak_libs " $arg"
    43725427          prev=
    43735428          continue
    43745429          ;;
    43755430        xcclinker)
    4376           linker_flags="$linker_flags $qarg"
    4377           compiler_flags="$compiler_flags $qarg"
     5431          func_append linker_flags " $qarg"
     5432          func_append compiler_flags " $qarg"
    43785433          prev=
    43795434          func_append compile_command " $qarg"
     
    43825437          ;;
    43835438        xcompiler)
    4384           compiler_flags="$compiler_flags $qarg"
     5439          func_append compiler_flags " $qarg"
    43855440          prev=
    43865441          func_append compile_command " $qarg"
     
    43895444          ;;
    43905445        xlinker)
    4391           linker_flags="$linker_flags $qarg"
    4392           compiler_flags="$compiler_flags $wl$qarg"
     5446          func_append linker_flags " $qarg"
     5447          func_append compiler_flags " $wl$qarg"
    43935448          prev=
    43945449          func_append compile_command " $wl$qarg"
     
    44265481        ;;
    44275482
     5483      -bindir)
     5484        prev=bindir
     5485        continue
     5486        ;;
     5487
    44285488      -dlopen)
    44295489        prev=dlfiles
     
    44765536
    44775537      -L*)
    4478         func_stripname '-L' '' "$arg"
    4479         dir=$func_stripname_result
    4480         if test -z "$dir"; then
     5538        func_stripname "-L" '' "$arg"
     5539        if test -z "$func_stripname_result"; then
    44815540          if test "$#" -gt 0; then
    44825541            func_fatal_error "require no space between \`-L' and \`$1'"
     
    44855544          fi
    44865545        fi
     5546        func_resolve_sysroot "$func_stripname_result"
     5547        dir=$func_resolve_sysroot_result
    44875548        # We need an absolute path.
    44885549        case $dir in
     
    44965557        esac
    44975558        case "$deplibs " in
    4498         *" -L$dir "*) ;;
     5559        *" -L$dir "* | *" $arg "*)
     5560          # Will only happen for absolute or sysroot arguments
     5561          ;;
    44995562        *)
    4500           deplibs="$deplibs -L$dir"
    4501           lib_search_path="$lib_search_path $dir"
     5563          # Preserve sysroot, but never include relative directories
     5564          case $dir in
     5565            [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
     5566            *) func_append deplibs " -L$dir" ;;
     5567          esac
     5568          func_append lib_search_path " $dir"
    45025569          ;;
    45035570        esac
    45045571        case $host in
    45055572        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
    4506           testbindir=`$ECHO "X$dir" | $Xsed -e 's*/lib$*/bin*'`
     5573          testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
    45075574          case :$dllsearchpath: in
    45085575          *":$dir:"*) ;;
    45095576          ::) dllsearchpath=$dir;;
    4510           *) dllsearchpath="$dllsearchpath:$dir";;
     5577          *) func_append dllsearchpath ":$dir";;
    45115578          esac
    45125579          case :$dllsearchpath: in
    45135580          *":$testbindir:"*) ;;
    45145581          ::) dllsearchpath=$testbindir;;
    4515           *) dllsearchpath="$dllsearchpath:$testbindir";;
     5582          *) func_append dllsearchpath ":$testbindir";;
    45165583          esac
    45175584          ;;
     
    45235590        if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
    45245591          case $host in
    4525           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc*)
     5592          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
    45265593            # These systems don't actually have a C or math library (as such)
    45275594            continue
     
    45375604          *-*-rhapsody* | *-*-darwin1.[012])
    45385605            # Rhapsody C and math libraries are in the System framework
    4539             deplibs="$deplibs System.ltframework"
     5606            func_append deplibs " System.ltframework"
    45405607            continue
    45415608            ;;
     
    45575624         esac
    45585625        fi
    4559         deplibs="$deplibs $arg"
     5626        func_append deplibs " $arg"
    45605627        continue
    45615628        ;;
     
    45695636      # classes, name mangling, and exception handling.
    45705637      # Darwin uses the -arch flag to determine output architecture.
    4571       -model|-arch|-isysroot)
    4572         compiler_flags="$compiler_flags $arg"
     5638      -model|-arch|-isysroot|--sysroot)
     5639        func_append compiler_flags " $arg"
    45735640        func_append compile_command " $arg"
    45745641        func_append finalize_command " $arg"
     
    45785645
    45795646      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
    4580         compiler_flags="$compiler_flags $arg"
     5647        func_append compiler_flags " $arg"
    45815648        func_append compile_command " $arg"
    45825649        func_append finalize_command " $arg"
    45835650        case "$new_inherited_linker_flags " in
    45845651            *" $arg "*) ;;
    4585             * ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
     5652            * ) func_append new_inherited_linker_flags " $arg" ;;
    45865653        esac
    45875654        continue
     
    46505717        case $dir in
    46515718        [\\/]* | [A-Za-z]:[\\/]*) ;;
     5719        =*)
     5720          func_stripname '=' '' "$dir"
     5721          dir=$lt_sysroot$func_stripname_result
     5722          ;;
    46525723        *)
    46535724          func_fatal_error "only absolute run-paths are allowed"
     
    46565727        case "$xrpath " in
    46575728        *" $dir "*) ;;
    4658         *) xrpath="$xrpath $dir" ;;
     5729        *) func_append xrpath " $dir" ;;
    46595730        esac
    46605731        continue
     
    47095780          IFS="$save_ifs"
    47105781          func_quote_for_eval "$flag"
    4711           arg="$arg $wl$func_quote_for_eval_result"
    4712           compiler_flags="$compiler_flags $func_quote_for_eval_result"
     5782          func_append arg " $func_quote_for_eval_result"
     5783          func_append compiler_flags " $func_quote_for_eval_result"
    47135784        done
    47145785        IFS="$save_ifs"
     
    47255796          IFS="$save_ifs"
    47265797          func_quote_for_eval "$flag"
    4727           arg="$arg $wl$func_quote_for_eval_result"
    4728           compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"
    4729           linker_flags="$linker_flags $func_quote_for_eval_result"
     5798          func_append arg " $wl$func_quote_for_eval_result"
     5799          func_append compiler_flags " $wl$func_quote_for_eval_result"
     5800          func_append linker_flags " $func_quote_for_eval_result"
    47305801        done
    47315802        IFS="$save_ifs"
     
    47555826        ;;
    47565827
    4757       # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
    4758       # -r[0-9][0-9]* specifies the processor on the SGI compiler
    4759       # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
    4760       # +DA*, +DD* enable 64-bit mode on the HP compiler
    4761       # -q* pass through compiler args for the IBM compiler
    4762       # -m*, -t[45]*, -txscale* pass through architecture-specific
    4763       # compiler args for GCC
    4764       # -F/path gives path to uninstalled frameworks, gcc on darwin
    4765       # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
    4766       # @file GCC response files
     5828      # Flags to be passed through unchanged, with rationale:
     5829      # -64, -mips[0-9]      enable 64-bit mode for the SGI compiler
     5830      # -r[0-9][0-9]*        specify processor for the SGI compiler
     5831      # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
     5832      # +DA*, +DD*           enable 64-bit mode for the HP compiler
     5833      # -q*                  compiler args for the IBM compiler
     5834      # -m*, -t[45]*, -txscale* architecture-specific flags for GCC
     5835      # -F/path              path to uninstalled frameworks, gcc on darwin
     5836      # -p, -pg, --coverage, -fprofile-*  profiling flags for GCC
     5837      # @file                GCC response files
     5838      # -tp=*                Portland pgcc target processor selection
     5839      # --sysroot=*          for sysroot support
     5840      # -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
    47675841      -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
    4768       -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
     5842      -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
     5843      -O*|-flto*|-fwhopr*|-fuse-linker-plugin)
    47695844        func_quote_for_eval "$arg"
    47705845        arg="$func_quote_for_eval_result"
    47715846        func_append compile_command " $arg"
    47725847        func_append finalize_command " $arg"
    4773         compiler_flags="$compiler_flags $arg"
     5848        func_append compiler_flags " $arg"
    47745849        continue
    47755850        ;;
     
    47835858      *.$objext)
    47845859        # A standard object.
    4785         objs="$objs $arg"
     5860        func_append objs " $arg"
    47865861        ;;
    47875862
     
    48145889            if test "$prev" = dlfiles; then
    48155890              if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
    4816                 dlfiles="$dlfiles $pic_object"
     5891                func_append dlfiles " $pic_object"
    48175892                prev=
    48185893                continue
     
    48265901            if test "$prev" = dlprefiles; then
    48275902              # Preload the old-style object.
    4828               dlprefiles="$dlprefiles $pic_object"
     5903              func_append dlprefiles " $pic_object"
    48295904              prev=
    48305905            fi
     
    48715946      *.$libext)
    48725947        # An archive.
    4873         deplibs="$deplibs $arg"
    4874         old_deplibs="$old_deplibs $arg"
     5948        func_append deplibs " $arg"
     5949        func_append old_deplibs " $arg"
    48755950        continue
    48765951        ;;
     
    48795954        # A libtool-controlled library.
    48805955
     5956        func_resolve_sysroot "$arg"
    48815957        if test "$prev" = dlfiles; then
    48825958          # This library was specified with -dlopen.
    4883           dlfiles="$dlfiles $arg"
     5959          func_append dlfiles " $func_resolve_sysroot_result"
    48845960          prev=
    48855961        elif test "$prev" = dlprefiles; then
    48865962          # The library was specified with -dlpreopen.
    4887           dlprefiles="$dlprefiles $arg"
     5963          func_append dlprefiles " $func_resolve_sysroot_result"
    48885964          prev=
    48895965        else
    4890           deplibs="$deplibs $arg"
     5966          func_append deplibs " $func_resolve_sysroot_result"
    48915967        fi
    48925968        continue
     
    49266002    if test -n "$shlibpath_var"; then
    49276003      # get the directories listed in $shlibpath_var
    4928       eval shlib_search_path=\`\$ECHO \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
     6004      eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
    49296005    else
    49306006      shlib_search_path=
     
    49356011    func_dirname "$output" "/" ""
    49366012    output_objdir="$func_dirname_result$objdir"
     6013    func_to_tool_file "$output_objdir/"
     6014    tool_output_objdir=$func_to_tool_file_result
    49376015    # Create the object directory.
    49386016    func_mkdir_p "$output_objdir"
     
    49556033    # that are linked more than once (e.g. -la -lb -la)
    49566034    for deplib in $deplibs; do
    4957       if $opt_duplicate_deps ; then
     6035      if $opt_preserve_dup_deps ; then
    49586036        case "$libs " in
    4959         *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
     6037        *" $deplib "*) func_append specialdeplibs " $deplib" ;;
    49606038        esac
    49616039      fi
    4962       libs="$libs $deplib"
     6040      func_append libs " $deplib"
    49636041    done
    49646042
     
    49736051        for pre_post_dep in $predeps $postdeps; do
    49746052          case "$pre_post_deps " in
    4975           *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
     6053          *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
    49766054          esac
    4977           pre_post_deps="$pre_post_deps $pre_post_dep"
     6055          func_append pre_post_deps " $pre_post_dep"
    49786056        done
    49796057      fi
     
    50426120          # Ignore non-libtool-libs
    50436121          dependency_libs=
     6122          func_resolve_sysroot "$lib"
    50446123          case $lib in
    5045           *.la) func_source "$lib" ;;
     6124          *.la) func_source "$func_resolve_sysroot_result" ;;
    50466125          esac
    50476126
     
    50496128          # has declared as weak libs
    50506129          for deplib in $dependency_libs; do
    5051             deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`
     6130            func_basename "$deplib"
     6131            deplib_base=$func_basename_result
    50526132            case " $weak_libs " in
    50536133            *" $deplib_base "*) ;;
    5054             *) deplibs="$deplibs $deplib" ;;
     6134            *) func_append deplibs " $deplib" ;;
    50556135            esac
    50566136          done
     
    50736153            finalize_deplibs="$deplib $finalize_deplibs"
    50746154          else
    5075             compiler_flags="$compiler_flags $deplib"
     6155            func_append compiler_flags " $deplib"
    50766156            if test "$linkmode" = lib ; then
    50776157                case "$new_inherited_linker_flags " in
    50786158                    *" $deplib "*) ;;
    5079                     * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
     6159                    * ) func_append new_inherited_linker_flags " $deplib" ;;
    50806160                esac
    50816161            fi
     
    51626242                case "$new_inherited_linker_flags " in
    51636243                    *" $deplib "*) ;;
    5164                     * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
     6244                    * ) func_append new_inherited_linker_flags " $deplib" ;;
    51656245                esac
    51666246            fi
     
    51756255            newdependency_libs="$deplib $newdependency_libs"
    51766256            func_stripname '-L' '' "$deplib"
    5177             newlib_search_path="$newlib_search_path $func_stripname_result"
     6257            func_resolve_sysroot "$func_stripname_result"
     6258            func_append newlib_search_path " $func_resolve_sysroot_result"
    51786259            ;;
    51796260          prog)
     
    51896270            fi
    51906271            func_stripname '-L' '' "$deplib"
    5191             newlib_search_path="$newlib_search_path $func_stripname_result"
     6272            func_resolve_sysroot "$func_stripname_result"
     6273            func_append newlib_search_path " $func_resolve_sysroot_result"
    51926274            ;;
    51936275          *)
     
    52006282          if test "$pass" = link; then
    52016283            func_stripname '-R' '' "$deplib"
    5202             dir=$func_stripname_result
     6284            func_resolve_sysroot "$func_stripname_result"
     6285            dir=$func_resolve_sysroot_result
    52036286            # Make sure the xrpath contains only unique directories.
    52046287            case "$xrpath " in
    52056288            *" $dir "*) ;;
    5206             *) xrpath="$xrpath $dir" ;;
     6289            *) func_append xrpath " $dir" ;;
    52076290            esac
    52086291          fi
     
    52106293          continue
    52116294          ;;
    5212         *.la) lib="$deplib" ;;
     6295        *.la)
     6296          func_resolve_sysroot "$deplib"
     6297          lib=$func_resolve_sysroot_result
     6298          ;;
    52136299        *.$libext)
    52146300          if test "$pass" = conv; then
     
    52286314                  set dummy $deplibs_check_method; shift
    52296315                  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
    5230                   if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \
     6316                  if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
    52316317                    | $EGREP "$match_pattern_regex" > /dev/null; then
    52326318                    valid_a_lib=yes
     
    52386324              esac
    52396325              if test "$valid_a_lib" != yes; then
    5240                 $ECHO
     6326                echo
    52416327                $ECHO "*** Warning: Trying to link with static lib archive $deplib."
    5242                 $ECHO "*** I have the capability to make that library automatically link in when"
    5243                 $ECHO "*** you link to this library.  But I can only do this if you have a"
    5244                 $ECHO "*** shared version of the library, which you do not appear to have"
    5245                 $ECHO "*** because the file extensions .$libext of this argument makes me believe"
    5246                 $ECHO "*** that it is just a static archive that I should not use here."
     6328                echo "*** I have the capability to make that library automatically link in when"
     6329                echo "*** you link to this library.  But I can only do this if you have a"
     6330                echo "*** shared version of the library, which you do not appear to have"
     6331                echo "*** because the file extensions .$libext of this argument makes me believe"
     6332                echo "*** that it is just a static archive that I should not use here."
    52476333              else
    5248                 $ECHO
     6334                echo
    52496335                $ECHO "*** Warning: Linking the shared library $output against the"
    52506336                $ECHO "*** static library $deplib is not portable!"
     
    52736359              # If there is no dlopen support or we're linking statically,
    52746360              # we need to preload.
    5275               newdlprefiles="$newdlprefiles $deplib"
     6361              func_append newdlprefiles " $deplib"
    52766362              compile_deplibs="$deplib $compile_deplibs"
    52776363              finalize_deplibs="$deplib $finalize_deplibs"
    52786364            else
    5279               newdlfiles="$newdlfiles $deplib"
     6365              func_append newdlfiles " $deplib"
    52806366            fi
    52816367          fi
     
    53196405        # Convert "-framework foo" to "foo.ltframework"
    53206406        if test -n "$inherited_linker_flags"; then
    5321           tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework \([^ $]*\)/\1.ltframework/g'`
     6407          tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
    53226408          for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
    53236409            case " $new_inherited_linker_flags " in
    53246410              *" $tmp_inherited_linker_flag "*) ;;
    5325               *) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
     6411              *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
    53266412            esac
    53276413          done
    53286414        fi
    5329         dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
     6415        dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
    53306416        if test "$linkmode,$pass" = "lib,link" ||
    53316417           test "$linkmode,$pass" = "prog,scan" ||
    53326418           { test "$linkmode" != prog && test "$linkmode" != lib; }; then
    5333           test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
    5334           test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
     6419          test -n "$dlopen" && func_append dlfiles " $dlopen"
     6420          test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
    53356421        fi
    53366422
     
    53436429            fi
    53446430            # It is a libtool convenience library, so add in its objects.
    5345             convenience="$convenience $ladir/$objdir/$old_library"
    5346             old_convenience="$old_convenience $ladir/$objdir/$old_library"
     6431            func_append convenience " $ladir/$objdir/$old_library"
     6432            func_append old_convenience " $ladir/$objdir/$old_library"
    53476433          elif test "$linkmode" != prog && test "$linkmode" != lib; then
    53486434            func_fatal_error "\`$lib' is not a convenience library"
     
    53516437          for deplib in $dependency_libs; do
    53526438            deplibs="$deplib $deplibs"
    5353             if $opt_duplicate_deps ; then
     6439            if $opt_preserve_dup_deps ; then
    53546440              case "$tmp_libs " in
    5355               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
     6441              *" $deplib "*) func_append specialdeplibs " $deplib" ;;
    53566442              esac
    53576443            fi
    5358             tmp_libs="$tmp_libs $deplib"
     6444            func_append tmp_libs " $deplib"
    53596445          done
    53606446          continue
     
    53646450        # Get the name of the library we link against.
    53656451        linklib=
    5366         for l in $old_library $library_names; do
    5367           linklib="$l"
    5368         done
     6452        if test -n "$old_library" &&
     6453           { test "$prefer_static_libs" = yes ||
     6454             test "$prefer_static_libs,$installed" = "built,no"; }; then
     6455          linklib=$old_library
     6456        else
     6457          for l in $old_library $library_names; do
     6458            linklib="$l"
     6459          done
     6460        fi
    53696461        if test -z "$linklib"; then
    53706462          func_fatal_error "cannot find name of link library for \`$lib'"
     
    53836475            # dependent libraries so libltdl's deplib preloader doesn't
    53846476            # bomb out in the load deplibs phase.
    5385             dlprefiles="$dlprefiles $lib $dependency_libs"
     6477            func_append dlprefiles " $lib $dependency_libs"
    53866478          else
    5387             newdlfiles="$newdlfiles $lib"
     6479            func_append newdlfiles " $lib"
    53886480          fi
    53896481          continue
     
    54076499        # Find the relevant object directory and library name.
    54086500        if test "X$installed" = Xyes; then
    5409           if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
     6501          if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
    54106502            func_warning "library \`$lib' was moved."
    54116503            dir="$ladir"
     
    54136505            libdir="$abs_ladir"
    54146506          else
    5415             dir="$libdir"
    5416             absdir="$libdir"
     6507            dir="$lt_sysroot$libdir"
     6508            absdir="$lt_sysroot$libdir"
    54176509          fi
    54186510          test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
     
    54226514            absdir="$abs_ladir"
    54236515            # Remove this search path later
    5424             notinst_path="$notinst_path $abs_ladir"
     6516            func_append notinst_path " $abs_ladir"
    54256517          else
    54266518            dir="$ladir/$objdir"
    54276519            absdir="$abs_ladir/$objdir"
    54286520            # Remove this search path later
    5429             notinst_path="$notinst_path $abs_ladir"
     6521            func_append notinst_path " $abs_ladir"
    54306522          fi
    54316523        fi # $installed = yes
     
    54386530            func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
    54396531          fi
    5440           # Prefer using a static library (so that no silly _DYNAMIC symbols
    5441           # are required to link).
    5442           if test -n "$old_library"; then
    5443             newdlprefiles="$newdlprefiles $dir/$old_library"
    5444             # Keep a list of preopened convenience libraries to check
    5445             # that they are being used correctly in the link pass.
    5446             test -z "$libdir" && \
    5447                 dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"
    5448           # Otherwise, use the dlname, so that lt_dlopen finds it.
    5449           elif test -n "$dlname"; then
    5450             newdlprefiles="$newdlprefiles $dir/$dlname"
    5451           else
    5452             newdlprefiles="$newdlprefiles $dir/$linklib"
    5453           fi
     6532          case "$host" in
     6533            # special handling for platforms with PE-DLLs.
     6534            *cygwin* | *mingw* | *cegcc* )
     6535              # Linker will automatically link against shared library if both
     6536              # static and shared are present.  Therefore, ensure we extract
     6537              # symbols from the import library if a shared library is present
     6538              # (otherwise, the dlopen module name will be incorrect).  We do
     6539              # this by putting the import library name into $newdlprefiles.
     6540              # We recover the dlopen module name by 'saving' the la file
     6541              # name in a special purpose variable, and (later) extracting the
     6542              # dlname from the la file.
     6543              if test -n "$dlname"; then
     6544                func_tr_sh "$dir/$linklib"
     6545                eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
     6546                func_append newdlprefiles " $dir/$linklib"
     6547              else
     6548                func_append newdlprefiles " $dir/$old_library"
     6549                # Keep a list of preopened convenience libraries to check
     6550                # that they are being used correctly in the link pass.
     6551                test -z "$libdir" && \
     6552                  func_append dlpreconveniencelibs " $dir/$old_library"
     6553              fi
     6554            ;;
     6555            * )
     6556              # Prefer using a static library (so that no silly _DYNAMIC symbols
     6557              # are required to link).
     6558              if test -n "$old_library"; then
     6559                func_append newdlprefiles " $dir/$old_library"
     6560                # Keep a list of preopened convenience libraries to check
     6561                # that they are being used correctly in the link pass.
     6562                test -z "$libdir" && \
     6563                  func_append dlpreconveniencelibs " $dir/$old_library"
     6564              # Otherwise, use the dlname, so that lt_dlopen finds it.
     6565              elif test -n "$dlname"; then
     6566                func_append newdlprefiles " $dir/$dlname"
     6567              else
     6568                func_append newdlprefiles " $dir/$linklib"
     6569              fi
     6570            ;;
     6571          esac
    54546572        fi # $pass = dlpreopen
    54556573
     
    54696587
    54706588        if test "$linkmode" = prog && test "$pass" != link; then
    5471           newlib_search_path="$newlib_search_path $ladir"
     6589          func_append newlib_search_path " $ladir"
    54726590          deplibs="$lib $deplibs"
    54736591
     
    54826600            case $deplib in
    54836601            -L*) func_stripname '-L' '' "$deplib"
    5484                  newlib_search_path="$newlib_search_path $func_stripname_result"
     6602                 func_resolve_sysroot "$func_stripname_result"
     6603                 func_append newlib_search_path " $func_resolve_sysroot_result"
    54856604                 ;;
    54866605            esac
     
    54936612              newdependency_libs="$deplib $newdependency_libs"
    54946613            fi
    5495             if $opt_duplicate_deps ; then
     6614            if $opt_preserve_dup_deps ; then
    54966615              case "$tmp_libs " in
    5497               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
     6616              *" $deplib "*) func_append specialdeplibs " $deplib" ;;
    54986617              esac
    54996618            fi
    5500             tmp_libs="$tmp_libs $deplib"
     6619            func_append tmp_libs " $deplib"
    55016620          done # for deplib
    55026621          continue
     
    55136632              case "$temp_rpath:" in
    55146633              *"$absdir:"*) ;;
    5515               *) temp_rpath="$temp_rpath$absdir:" ;;
     6634              *) func_append temp_rpath "$absdir:" ;;
    55166635              esac
    55176636            fi
     
    55256644              case "$compile_rpath " in
    55266645              *" $absdir "*) ;;
    5527               *) compile_rpath="$compile_rpath $absdir"
     6646              *) func_append compile_rpath " $absdir" ;;
    55286647              esac
    55296648              ;;
     
    55346653              case "$finalize_rpath " in
    55356654              *" $libdir "*) ;;
    5536               *) finalize_rpath="$finalize_rpath $libdir"
     6655              *) func_append finalize_rpath " $libdir" ;;
    55376656              esac
    55386657              ;;
     
    55596678          *cygwin* | *mingw* | *cegcc*)
    55606679              # No point in relinking DLLs because paths are not encoded
    5561               notinst_deplibs="$notinst_deplibs $lib"
     6680              func_append notinst_deplibs " $lib"
    55626681              need_relink=no
    55636682            ;;
    55646683          *)
    55656684            if test "$installed" = no; then
    5566               notinst_deplibs="$notinst_deplibs $lib"
     6685              func_append notinst_deplibs " $lib"
    55676686              need_relink=yes
    55686687            fi
     
    55816700          done
    55826701          if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
    5583             $ECHO
     6702            echo
    55846703            if test "$linkmode" = prog; then
    55856704              $ECHO "*** Warning: Linking the executable $output against the loadable module"
     
    55996718              case "$compile_rpath " in
    56006719              *" $absdir "*) ;;
    5601               *) compile_rpath="$compile_rpath $absdir"
     6720              *) func_append compile_rpath " $absdir" ;;
    56026721              esac
    56036722              ;;
     
    56086727              case "$finalize_rpath " in
    56096728              *" $libdir "*) ;;
    5610               *) finalize_rpath="$finalize_rpath $libdir"
     6729              *) func_append finalize_rpath " $libdir" ;;
    56116730              esac
    56126731              ;;
     
    56626781          fi # test -n "$old_archive_from_expsyms_cmds"
    56636782
    5664           if test "$linkmode" = prog || test "$mode" != relink; then
     6783          if test "$linkmode" = prog || test "$opt_mode" != relink; then
    56656784            add_shlibpath=
    56666785            add_dir=
     
    56846803                        $ECHO "*** Warning: lib $linklib is a module, not a shared library"
    56856804                        if test -z "$old_library" ; then
    5686                           $ECHO
    5687                           $ECHO "*** And there doesn't seem to be a static archive available"
    5688                           $ECHO "*** The link will probably fail, sorry"
     6805                          echo
     6806                          echo "*** And there doesn't seem to be a static archive available"
     6807                          echo "*** The link will probably fail, sorry"
    56896808                        else
    56906809                          add="$dir/$old_library"
     
    57186837                  case $libdir in
    57196838                    [\\/]*)
    5720                       add_dir="$add_dir -L$inst_prefix_dir$libdir"
     6839                      func_append add_dir " -L$inst_prefix_dir$libdir"
    57216840                      ;;
    57226841                  esac
     
    57406859              case :$compile_shlibpath: in
    57416860              *":$add_shlibpath:"*) ;;
    5742               *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
     6861              *) func_append compile_shlibpath "$add_shlibpath:" ;;
    57436862              esac
    57446863            fi
     
    57546873                case :$finalize_shlibpath: in
    57556874                *":$libdir:"*) ;;
    5756                 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
     6875                *) func_append finalize_shlibpath "$libdir:" ;;
    57576876                esac
    57586877              fi
     
    57606879          fi
    57616880
    5762           if test "$linkmode" = prog || test "$mode" = relink; then
     6881          if test "$linkmode" = prog || test "$opt_mode" = relink; then
    57636882            add_shlibpath=
    57646883            add_dir=
     
    57746893              case :$finalize_shlibpath: in
    57756894              *":$libdir:"*) ;;
    5776               *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
     6895              *) func_append finalize_shlibpath "$libdir:" ;;
    57776896              esac
    57786897              add="-l$name"
     
    57916910                case $libdir in
    57926911                  [\\/]*)
    5793                     add_dir="$add_dir -L$inst_prefix_dir$libdir"
     6912                    func_append add_dir " -L$inst_prefix_dir$libdir"
    57946913                    ;;
    57956914                esac
     
    58266945            # Just print a warning and add the library to dependency_libs so
    58276946            # that the program can be linked against the static library.
    5828             $ECHO
     6947            echo
    58296948            $ECHO "*** Warning: This system can not link to static lib archive $lib."
    5830             $ECHO "*** I have the capability to make that library automatically link in when"
    5831             $ECHO "*** you link to this library.  But I can only do this if you have a"
    5832             $ECHO "*** shared version of the library, which you do not appear to have."
     6949            echo "*** I have the capability to make that library automatically link in when"
     6950            echo "*** you link to this library.  But I can only do this if you have a"
     6951            echo "*** shared version of the library, which you do not appear to have."
    58336952            if test "$module" = yes; then
    5834               $ECHO "*** But as you try to build a module library, libtool will still create "
    5835               $ECHO "*** a static module, that should work as long as the dlopening application"
    5836               $ECHO "*** is linked with the -dlopen flag to resolve symbols at runtime."
     6953              echo "*** But as you try to build a module library, libtool will still create "
     6954              echo "*** a static module, that should work as long as the dlopening application"
     6955              echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
    58376956              if test -z "$global_symbol_pipe"; then
    5838                 $ECHO
    5839                 $ECHO "*** However, this would only work if libtool was able to extract symbol"
    5840                 $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
    5841                 $ECHO "*** not find such a program.  So, this module is probably useless."
    5842                 $ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
     6957                echo
     6958                echo "*** However, this would only work if libtool was able to extract symbol"
     6959                echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
     6960                echo "*** not find such a program.  So, this module is probably useless."
     6961                echo "*** \`nm' from GNU binutils and a full rebuild may help."
    58436962              fi
    58446963              if test "$build_old_libs" = no; then
     
    58686987                   case " $xrpath " in
    58696988                   *" $temp_xrpath "*) ;;
    5870                    *) xrpath="$xrpath $temp_xrpath";;
     6989                   *) func_append xrpath " $temp_xrpath";;
    58716990                   esac;;
    5872               *) temp_deplibs="$temp_deplibs $libdir";;
     6991              *) func_append temp_deplibs " $libdir";;
    58736992              esac
    58746993            done
     
    58766995          fi
    58776996
    5878           newlib_search_path="$newlib_search_path $absdir"
     6997          func_append newlib_search_path " $absdir"
    58796998          # Link against this library
    58806999          test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
     
    58837002          for deplib in $dependency_libs; do
    58847003            newdependency_libs="$deplib $newdependency_libs"
    5885             if $opt_duplicate_deps ; then
     7004            case $deplib in
     7005              -L*) func_stripname '-L' '' "$deplib"
     7006                   func_resolve_sysroot "$func_stripname_result";;
     7007              *) func_resolve_sysroot "$deplib" ;;
     7008            esac
     7009            if $opt_preserve_dup_deps ; then
    58867010              case "$tmp_libs " in
    5887               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
     7011              *" $func_resolve_sysroot_result "*)
     7012                func_append specialdeplibs " $func_resolve_sysroot_result" ;;
    58887013              esac
    58897014            fi
    5890             tmp_libs="$tmp_libs $deplib"
     7015            func_append tmp_libs " $func_resolve_sysroot_result"
    58917016          done
    58927017
     
    58947019            # Add the search paths of all dependency libraries
    58957020            for deplib in $dependency_libs; do
     7021              path=
    58967022              case $deplib in
    58977023              -L*) path="$deplib" ;;
    58987024              *.la)
     7025                func_resolve_sysroot "$deplib"
     7026                deplib=$func_resolve_sysroot_result
    58997027                func_dirname "$deplib" "" "."
    5900                 dir="$func_dirname_result"
     7028                dir=$func_dirname_result
    59017029                # We need an absolute path.
    59027030                case $dir in
     
    59257053                          darwin_install_name=`${OTOOL64} -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
    59267054                      fi
    5927                       compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
    5928                       linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
     7055                      func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
     7056                      func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"
    59297057                      path=
    59307058                    fi
     
    59597087          finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
    59607088        else
    5961           compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
     7089          compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
    59627090        fi
    59637091      fi
     
    59767104            case "$lib_search_path " in
    59777105            *" $dir "*) ;;
    5978             *) lib_search_path="$lib_search_path $dir" ;;
     7106            *) func_append lib_search_path " $dir" ;;
    59797107            esac
    59807108          done
     
    60347162              case " $tmp_libs " in
    60357163              *" $deplib "*) ;;
    6036               *) tmp_libs="$tmp_libs $deplib" ;;
     7164              *) func_append tmp_libs " $deplib" ;;
    60377165              esac
    60387166              ;;
    6039             *) tmp_libs="$tmp_libs $deplib" ;;
     7167            *) func_append tmp_libs " $deplib" ;;
    60407168            esac
    60417169          done
     
    60537181        esac
    60547182        if test -n "$i" ; then
    6055           tmp_libs="$tmp_libs $i"
     7183          func_append tmp_libs " $i"
    60567184        fi
    60577185      done
     
    60947222      build_libtool_libs=no
    60957223      oldlibs="$output"
    6096       objs="$objs$old_deplibs"
     7224      func_append objs "$old_deplibs"
    60977225      ;;
    60987226
     
    61277255          func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
    61287256        else
    6129           $ECHO
     7257          echo
    61307258          $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
    61317259          $ECHO "*** objects $objs is not portable!"
    6132           libobjs="$libobjs $objs"
     7260          func_append libobjs " $objs"
    61337261        fi
    61347262      fi
     
    61957323            revision="$number_revision"
    61967324            ;;
    6197           freebsd-aout|freebsd-elf|sunos)
     7325          freebsd-aout|freebsd-elf|qnx|sunos)
    61987326            current="$number_major"
    61997327            revision="$number_minor"
     
    63287456
    63297457          # Make executables depend on our current version.
    6330           verstring="$verstring:${current}.0"
     7458          func_append verstring ":${current}.0"
    63317459          ;;
    63327460
     
    63967524
    63977525      func_generate_dlsyms "$libname" "$libname" "yes"
    6398       libobjs="$libobjs $symfileobj"
     7526      func_append libobjs " $symfileobj"
    63997527      test "X$libobjs" = "X " && libobjs=
    64007528
    6401       if test "$mode" != relink; then
     7529      if test "$opt_mode" != relink; then
    64027530        # Remove our outputs, but don't remove object files since they
    64037531        # may have been created when compiling PIC objects.
     
    64157543                 fi
    64167544               fi
    6417                removelist="$removelist $p"
     7545               func_append removelist " $p"
    64187546               ;;
    64197547            *) ;;
     
    64267554      # Now set the variables for building old libraries.
    64277555      if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
    6428         oldlibs="$oldlibs $output_objdir/$libname.$libext"
     7556        func_append oldlibs " $output_objdir/$libname.$libext"
    64297557
    64307558        # Transform .lo files to .o files.
    6431         oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
     7559        oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
    64327560      fi
    64337561
    64347562      # Eliminate all temporary directories.
    64357563      #for path in $notinst_path; do
    6436       # lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`
    6437       # deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`
    6438       # dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`
     7564      # lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
     7565      # deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
     7566      # dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
    64397567      #done
    64407568
     
    64437571        temp_xrpath=
    64447572        for libdir in $xrpath; do
    6445           temp_xrpath="$temp_xrpath -R$libdir"
     7573          func_replace_sysroot "$libdir"
     7574          func_append temp_xrpath " -R$func_replace_sysroot_result"
    64467575          case "$finalize_rpath " in
    64477576          *" $libdir "*) ;;
    6448           *) finalize_rpath="$finalize_rpath $libdir" ;;
     7577          *) func_append finalize_rpath " $libdir" ;;
    64497578          esac
    64507579        done
     
    64607589        case " $dlprefiles $dlfiles " in
    64617590        *" $lib "*) ;;
    6462         *) dlfiles="$dlfiles $lib" ;;
     7591        *) func_append dlfiles " $lib" ;;
    64637592        esac
    64647593      done
     
    64707599        case "$dlprefiles " in
    64717600        *" $lib "*) ;;
    6472         *) dlprefiles="$dlprefiles $lib" ;;
     7601        *) func_append dlprefiles " $lib" ;;
    64737602        esac
    64747603      done
     
    64777606        if test -n "$rpath"; then
    64787607          case $host in
    6479           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc*)
     7608          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
    64807609            # these systems don't actually have a c library (as such)!
    64817610            ;;
    64827611          *-*-rhapsody* | *-*-darwin1.[012])
    64837612            # Rhapsody C library is in the System framework
    6484             deplibs="$deplibs System.ltframework"
     7613            func_append deplibs " System.ltframework"
    64857614            ;;
    64867615          *-*-netbsd*)
     
    64997628            # Add libc to deplibs on all other systems if necessary.
    65007629            if test "$build_libtool_need_lc" = "yes"; then
    6501               deplibs="$deplibs -lc"
     7630              func_append deplibs " -lc"
    65027631            fi
    65037632            ;;
     
    65487677                  case " $predeps $postdeps " in
    65497678                  *" $i "*)
    6550                     newdeplibs="$newdeplibs $i"
     7679                    func_append newdeplibs " $i"
    65517680                    i=""
    65527681                    ;;
     
    65597688                  deplib_match=$1
    65607689                  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
    6561                     newdeplibs="$newdeplibs $i"
     7690                    func_append newdeplibs " $i"
    65627691                  else
    65637692                    droppeddeps=yes
    6564                     $ECHO
     7693                    echo
    65657694                    $ECHO "*** Warning: dynamic linker does not accept needed library $i."
    6566                     $ECHO "*** I have the capability to make that library automatically link in when"
    6567                     $ECHO "*** you link to this library.  But I can only do this if you have a"
    6568                     $ECHO "*** shared version of the library, which I believe you do not have"
    6569                     $ECHO "*** because a test_compile did reveal that the linker did not use it for"
    6570                     $ECHO "*** its dynamic dependency list that programs get resolved with at runtime."
     7695                    echo "*** I have the capability to make that library automatically link in when"
     7696                    echo "*** you link to this library.  But I can only do this if you have a"
     7697                    echo "*** shared version of the library, which I believe you do not have"
     7698                    echo "*** because a test_compile did reveal that the linker did not use it for"
     7699                    echo "*** its dynamic dependency list that programs get resolved with at runtime."
    65717700                  fi
    65727701                fi
    65737702                ;;
    65747703              *)
    6575                 newdeplibs="$newdeplibs $i"
     7704                func_append newdeplibs " $i"
    65767705                ;;
    65777706              esac
     
    65917720                    case " $predeps $postdeps " in
    65927721                    *" $i "*)
    6593                       newdeplibs="$newdeplibs $i"
     7722                      func_append newdeplibs " $i"
    65947723                      i=""
    65957724                      ;;
     
    66027731                    deplib_match=$1
    66037732                    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
    6604                       newdeplibs="$newdeplibs $i"
     7733                      func_append newdeplibs " $i"
    66057734                    else
    66067735                      droppeddeps=yes
    6607                       $ECHO
     7736                      echo
    66087737                      $ECHO "*** Warning: dynamic linker does not accept needed library $i."
    6609                       $ECHO "*** I have the capability to make that library automatically link in when"
    6610                       $ECHO "*** you link to this library.  But I can only do this if you have a"
    6611                       $ECHO "*** shared version of the library, which you do not appear to have"
    6612                       $ECHO "*** because a test_compile did reveal that the linker did not use this one"
    6613                       $ECHO "*** as a dynamic dependency that programs can get resolved with at runtime."
     7738                      echo "*** I have the capability to make that library automatically link in when"
     7739                      echo "*** you link to this library.  But I can only do this if you have a"
     7740                      echo "*** shared version of the library, which you do not appear to have"
     7741                      echo "*** because a test_compile did reveal that the linker did not use this one"
     7742                      echo "*** as a dynamic dependency that programs can get resolved with at runtime."
    66147743                    fi
    66157744                  fi
    66167745                else
    66177746                  droppeddeps=yes
    6618                   $ECHO
     7747                  echo
    66197748                  $ECHO "*** Warning!  Library $i is needed by this library but I was not able to"
    6620                   $ECHO "*** make it link in!  You will probably need to install it or some"
    6621                   $ECHO "*** library that it depends on before this library will be fully"
    6622                   $ECHO "*** functional.  Installing it before continuing would be even better."
     7749                  echo "*** make it link in!  You will probably need to install it or some"
     7750                  echo "*** library that it depends on before this library will be fully"
     7751                  echo "*** functional.  Installing it before continuing would be even better."
    66237752                fi
    66247753                ;;
    66257754              *)
    6626                 newdeplibs="$newdeplibs $i"
     7755                func_append newdeplibs " $i"
    66277756                ;;
    66287757              esac
     
    66417770                case " $predeps $postdeps " in
    66427771                *" $a_deplib "*)
    6643                   newdeplibs="$newdeplibs $a_deplib"
     7772                  func_append newdeplibs " $a_deplib"
    66447773                  a_deplib=""
    66457774                  ;;
     
    66487777              if test -n "$a_deplib" ; then
    66497778                libname=`eval "\\$ECHO \"$libname_spec\""`
     7779                if test -n "$file_magic_glob"; then
     7780                  libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
     7781                else
     7782                  libnameglob=$libname
     7783                fi
     7784                test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`
    66507785                for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
    6651                   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
     7786                  if test "$want_nocaseglob" = yes; then
     7787                    shopt -s nocaseglob
     7788                    potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
     7789                    $nocaseglob
     7790                  else
     7791                    potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
     7792                  fi
    66527793                  for potent_lib in $potential_libs; do
    66537794                      # Follow soft links.
     
    66667807                        case $potliblink in
    66677808                        [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
    6668                         *) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
     7809                        *) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
    66697810                        esac
    66707811                      done
     
    66727813                         $SED -e 10q |
    66737814                         $EGREP "$file_magic_regex" > /dev/null; then
    6674                         newdeplibs="$newdeplibs $a_deplib"
     7815                        func_append newdeplibs " $a_deplib"
    66757816                        a_deplib=""
    66767817                        break 2
     
    66817822              if test -n "$a_deplib" ; then
    66827823                droppeddeps=yes
    6683                 $ECHO
     7824                echo
    66847825                $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
    6685                 $ECHO "*** I have the capability to make that library automatically link in when"
    6686                 $ECHO "*** you link to this library.  But I can only do this if you have a"
    6687                 $ECHO "*** shared version of the library, which you do not appear to have"
    6688                 $ECHO "*** because I did check the linker path looking for a file starting"
     7826                echo "*** I have the capability to make that library automatically link in when"
     7827                echo "*** you link to this library.  But I can only do this if you have a"
     7828                echo "*** shared version of the library, which you do not appear to have"
     7829                echo "*** because I did check the linker path looking for a file starting"
    66897830                if test -z "$potlib" ; then
    66907831                  $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
     
    66977838            *)
    66987839              # Add a -L argument.
    6699               newdeplibs="$newdeplibs $a_deplib"
     7840              func_append newdeplibs " $a_deplib"
    67007841              ;;
    67017842            esac
     
    67137854                case " $predeps $postdeps " in
    67147855                *" $a_deplib "*)
    6715                   newdeplibs="$newdeplibs $a_deplib"
     7856                  func_append newdeplibs " $a_deplib"
    67167857                  a_deplib=""
    67177858                  ;;
     
    67247865                  for potent_lib in $potential_libs; do
    67257866                    potlib="$potent_lib" # see symlink-check above in file_magic test
    6726                     if eval "\$ECHO \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \
     7867                    if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
    67277868                       $EGREP "$match_pattern_regex" > /dev/null; then
    6728                       newdeplibs="$newdeplibs $a_deplib"
     7869                      func_append newdeplibs " $a_deplib"
    67297870                      a_deplib=""
    67307871                      break 2
     
    67357876              if test -n "$a_deplib" ; then
    67367877                droppeddeps=yes
    6737                 $ECHO
     7878                echo
    67387879                $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
    6739                 $ECHO "*** I have the capability to make that library automatically link in when"
    6740                 $ECHO "*** you link to this library.  But I can only do this if you have a"
    6741                 $ECHO "*** shared version of the library, which you do not appear to have"
    6742                 $ECHO "*** because I did check the linker path looking for a file starting"
     7880                echo "*** I have the capability to make that library automatically link in when"
     7881                echo "*** you link to this library.  But I can only do this if you have a"
     7882                echo "*** shared version of the library, which you do not appear to have"
     7883                echo "*** because I did check the linker path looking for a file starting"
    67437884                if test -z "$potlib" ; then
    67447885                  $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
     
    67517892            *)
    67527893              # Add a -L argument.
    6753               newdeplibs="$newdeplibs $a_deplib"
     7894              func_append newdeplibs " $a_deplib"
    67547895              ;;
    67557896            esac
     
    67587899        none | unknown | *)
    67597900          newdeplibs=""
    6760           tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \
    6761               -e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'`
     7901          tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
    67627902          if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
    67637903            for i in $predeps $postdeps ; do
    67647904              # can't use Xsed below, because $i might contain '/'
    6765               tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`
     7905              tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
    67667906            done
    67677907          fi
    6768           if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[      ]//g' |
    6769              $GREP . >/dev/null; then
    6770             $ECHO
     7908          case $tmp_deplibs in
     7909          *[!\  \ ]*)
     7910            echo
    67717911            if test "X$deplibs_check_method" = "Xnone"; then
    6772               $ECHO "*** Warning: inter-library dependencies are not supported in this platform."
     7912              echo "*** Warning: inter-library dependencies are not supported in this platform."
    67737913            else
    6774               $ECHO "*** Warning: inter-library dependencies are not known to be supported."
     7914              echo "*** Warning: inter-library dependencies are not known to be supported."
    67757915            fi
    6776             $ECHO "*** All declared inter-library dependencies are being dropped."
     7916            echo "*** All declared inter-library dependencies are being dropped."
    67777917            droppeddeps=yes
    6778           fi
     7918            ;;
     7919          esac
    67797920          ;;
    67807921        esac
     
    67887929        *-*-rhapsody* | *-*-darwin1.[012])
    67897930          # On Rhapsody replace the C library with the System framework
    6790           newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
     7931          newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
    67917932          ;;
    67927933        esac
     
    67947935        if test "$droppeddeps" = yes; then
    67957936          if test "$module" = yes; then
    6796             $ECHO
    6797             $ECHO "*** Warning: libtool could not satisfy all declared inter-library"
     7937            echo
     7938            echo "*** Warning: libtool could not satisfy all declared inter-library"
    67987939            $ECHO "*** dependencies of module $libname.  Therefore, libtool will create"
    6799             $ECHO "*** a static module, that should work as long as the dlopening"
    6800             $ECHO "*** application is linked with the -dlopen flag."
     7940            echo "*** a static module, that should work as long as the dlopening"
     7941            echo "*** application is linked with the -dlopen flag."
    68017942            if test -z "$global_symbol_pipe"; then
    6802               $ECHO
    6803               $ECHO "*** However, this would only work if libtool was able to extract symbol"
    6804               $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
    6805               $ECHO "*** not find such a program.  So, this module is probably useless."
    6806               $ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
     7943              echo
     7944              echo "*** However, this would only work if libtool was able to extract symbol"
     7945              echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
     7946              echo "*** not find such a program.  So, this module is probably useless."
     7947              echo "*** \`nm' from GNU binutils and a full rebuild may help."
    68077948            fi
    68087949            if test "$build_old_libs" = no; then
     
    68147955            fi
    68157956          else
    6816             $ECHO "*** The inter-library dependencies that have been dropped here will be"
    6817             $ECHO "*** automatically added whenever a program is linked with this library"
    6818             $ECHO "*** or is declared to -dlopen it."
     7957            echo "*** The inter-library dependencies that have been dropped here will be"
     7958            echo "*** automatically added whenever a program is linked with this library"
     7959            echo "*** or is declared to -dlopen it."
    68197960
    68207961            if test "$allow_undefined" = no; then
    6821               $ECHO
    6822               $ECHO "*** Since this library must not contain undefined symbols,"
    6823               $ECHO "*** because either the platform does not support them or"
    6824               $ECHO "*** it was explicitly requested with -no-undefined,"
    6825               $ECHO "*** libtool will only create a static version of it."
     7962              echo
     7963              echo "*** Since this library must not contain undefined symbols,"
     7964              echo "*** because either the platform does not support them or"
     7965              echo "*** it was explicitly requested with -no-undefined,"
     7966              echo "*** libtool will only create a static version of it."
    68267967              if test "$build_old_libs" = no; then
    68277968                oldlibs="$output_objdir/$libname.$libext"
     
    68407981      case $host in
    68417982        *-*-darwin*)
    6842           newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
    6843           new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
    6844           deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
     7983          newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
     7984          new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
     7985          deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
    68457986          ;;
    68467987      esac
     
    68557996          case " $deplibs " in
    68567997          *" -L$path/$objdir "*)
    6857             new_libs="$new_libs -L$path/$objdir" ;;
     7998            func_append new_libs " -L$path/$objdir" ;;
    68587999          esac
    68598000          ;;
     
    68658006          case " $new_libs " in
    68668007          *" $deplib "*) ;;
    6867           *) new_libs="$new_libs $deplib" ;;
     8008          *) func_append new_libs " $deplib" ;;
    68688009          esac
    68698010          ;;
    6870         *) new_libs="$new_libs $deplib" ;;
     8011        *) func_append new_libs " $deplib" ;;
    68718012        esac
    68728013      done
     
    68858026          dep_rpath=
    68868027          rpath="$finalize_rpath"
    6887           test "$mode" != relink && rpath="$compile_rpath$rpath"
     8028          test "$opt_mode" != relink && rpath="$compile_rpath$rpath"
    68888029          for libdir in $rpath; do
    68898030            if test -n "$hardcode_libdir_flag_spec"; then
    68908031              if test -n "$hardcode_libdir_separator"; then
     8032                func_replace_sysroot "$libdir"
     8033                libdir=$func_replace_sysroot_result
    68918034                if test -z "$hardcode_libdirs"; then
    68928035                  hardcode_libdirs="$libdir"
     
    68978040                    ;;
    68988041                  *)
    6899                     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
     8042                    func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
    69008043                    ;;
    69018044                  esac
     
    69038046              else
    69048047                eval flag=\"$hardcode_libdir_flag_spec\"
    6905                 dep_rpath="$dep_rpath $flag"
     8048                func_append dep_rpath " $flag"
    69068049              fi
    69078050            elif test -n "$runpath_var"; then
    69088051              case "$perm_rpath " in
    69098052              *" $libdir "*) ;;
    6910               *) perm_rpath="$perm_rpath $libdir" ;;
     8053              *) func_apped perm_rpath " $libdir" ;;
    69118054              esac
    69128055            fi
     
    69268069            rpath=
    69278070            for dir in $perm_rpath; do
    6928               rpath="$rpath$dir:"
     8071              func_append rpath "$dir:"
    69298072            done
    69308073            eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
     
    69348077
    69358078        shlibpath="$finalize_shlibpath"
    6936         test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
     8079        test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
    69378080        if test -n "$shlibpath"; then
    69388081          eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
     
    69608103        for link
    69618104        do
    6962           linknames="$linknames $link"
     8105          func_append linknames " $link"
    69638106        done
    69648107
    69658108        # Use standard objects if they are pic
    6966         test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
     8109        test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
    69678110        test "X$libobjs" = "X " && libobjs=
    69688111
     
    69718114          $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
    69728115          export_symbols="$output_objdir/$libname.uexp"
    6973           delfiles="$delfiles $export_symbols"
     8116          func_append delfiles " $export_symbols"
    69748117        fi
    69758118
     
    70028145            cmds=$export_symbols_cmds
    70038146            save_ifs="$IFS"; IFS='~'
    7004             for cmd in $cmds; do
     8147            for cmd1 in $cmds; do
    70058148              IFS="$save_ifs"
    7006               eval cmd=\"$cmd\"
    7007               func_len " $cmd"
    7008               len=$func_len_result
    7009               if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
     8149              # Take the normal branch if the nm_file_list_spec branch
     8150              # doesn't work or if tool conversion is not needed.
     8151              case $nm_file_list_spec~$to_tool_file_cmd in
     8152                *~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
     8153                  try_normal_branch=yes
     8154                  eval cmd=\"$cmd1\"
     8155                  func_len " $cmd"
     8156                  len=$func_len_result
     8157                  ;;
     8158                *)
     8159                  try_normal_branch=no
     8160                  ;;
     8161              esac
     8162              if test "$try_normal_branch" = yes \
     8163                 && { test "$len" -lt "$max_cmd_len" \
     8164                      || test "$max_cmd_len" -le -1; }
     8165              then
    70108166                func_show_eval "$cmd" 'exit $?'
     8167            &nbs