Changeset 2807 for icXML


Ignore:
Timestamp:
Jan 12, 2013, 12:21:29 PM (6 years ago)
Author:
cameron
Message:

Fixes default attribute+namespace resolution; hashing

Location:
icXML/icXML-devel
Files:
5 added
2 deleted
57 edited

Legend:

Unmodified
Added
Removed
  • icXML/icXML-devel/Makefile.in

    r2777 r2807  
    4141        $(top_srcdir)/src/xercesc/util/MsgLoaders/MsgCatalog/Makefile.in \
    4242        $(top_srcdir)/src/xercesc/util/Xerces_autoconf_config.hpp.in \
    43         COPYING INSTALL config/compile config/config.guess \
    44         config/config.sub config/depcomp config/install-sh \
    45         config/ltmain.sh config/missing
     43        config/compile config/config.guess config/config.sub \
     44        config/depcomp config/install-sh config/ltmain.sh \
     45        config/missing
    4646ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
    4747am__aclocal_m4_deps = $(top_srcdir)/m4/acx_pthread.m4 \
     
    218218MAINT = @MAINT@
    219219MAKEINFO = @MAKEINFO@
     220MANIFEST_TOOL = @MANIFEST_TOOL@
    220221MKDIR_P = @MKDIR_P@
    221222NM = @NM@
     
    247248abs_top_builddir = @abs_top_builddir@
    248249abs_top_srcdir = @abs_top_srcdir@
     250ac_ct_AR = @ac_ct_AR@
    249251ac_ct_CC = @ac_ct_CC@
    250252ac_ct_CXX = @ac_ct_CXX@
     
    283285localedir = @localedir@
    284286localstatedir = @localstatedir@
    285 lt_ECHO = @lt_ECHO@
    286287mandir = @mandir@
    287288mkdir_p = @mkdir_p@
  • icXML/icXML-devel/config/ltmain.sh

    r2723 r2807  
    1 # Generated from ltmain.m4sh.
    2 
    3 # ltmain.sh (GNU libtool) 2.2.6
     1
     2# libtool (GNU libtool) 2.4.2
    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, 2011 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#       --no-warn            don't display warning messages
     45#       --tag=TAG            use configuration variables from tag TAG
     46#   -v, --verbose            print more informational messages than default
     47#       --no-verbose         don't print the extra informational messages
     48#       --version            print version information
     49#   -h, --help, --help-all   print short, long, or detailed help message
    4650#
    4751# MODE must be one of the following:
    4852#
    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
     53#         clean              remove files from the build directory
     54#         compile            compile a source file into a libtool object
     55#         execute            automatically set library path, then run a program
     56#         finish             complete the installation of libtool libraries
     57#         install            install libraries or executables
     58#         link               create a library or an executable
     59#         uninstall          remove libraries from an installed directory
    5660#
    57 # MODE-ARGS vary depending on the MODE.
     61# MODE-ARGS vary depending on the MODE.  When passed as first option,
     62# `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
    5863# Try `$progname --help --mode=MODE' for a more detailed description of MODE.
    5964#
     
    6166# include the following information:
    6267#
    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.6 Debian-2.2.6a-4
    69 #       automake:               $automake_version
    70 #       autoconf:               $autoconf_version
     68#         host-triplet: $host
     69#         shell:                $SHELL
     70#         compiler:             $LTCC
     71#         compiler flags:               $LTCFLAGS
     72#         linker:               $LD (gnu? $with_gnu_ld)
     73#         $progname:    (GNU libtool) 2.4.2 Debian-2.4.2-1ubuntu1
     74#         automake:     $automake_version
     75#         autoconf:     $autoconf_version
    7176#
    7277# Report bugs to <bug-libtool@gnu.org>.
    73 
    74 PROGRAM=ltmain.sh
     78# GNU libtool home page: <http://www.gnu.org/software/libtool/>.
     79# General help using GNU software: <http://www.gnu.org/gethelp/>.
     80
     81PROGRAM=libtool
    7582PACKAGE=libtool
    76 VERSION="2.2.6 Debian-2.2.6a-4"
     83VERSION="2.4.2 Debian-2.4.2-1ubuntu1"
    7784TIMESTAMP=""
    78 package_revision=1.3012
     85package_revision=1.3337
    7986
    8087# Be Bourne compatible
     
    9299DUALCASE=1; export DUALCASE # for MKS sh
    93100
     101# A function that is used when there is no print builtin or printf.
     102func_fallback_echo ()
     103{
     104  eval 'cat <<_LTECHO_EOF
     105$1
     106_LTECHO_EOF'
     107}
     108
    94109# 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).
    98110lt_user_locale=
    99111lt_safe_locale=
     
    108120        fi"
    109121done
     122LC_ALL=C
     123LANGUAGE=C
     124export LANGUAGE LC_ALL
    110125
    111126$lt_unset CDPATH
    112127
    113128
     129# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
     130# is ksh but when the shell is invoked as "sh" and the current value of
     131# the _XPG environment variable is not equal to 1 (one), the special
     132# positional parameter $0, within a function call, is the name of the
     133# function.
     134progpath="$0"
    114135
    115136
    116137
    117138: ${CP="cp -f"}
    118 : ${ECHO="echo"}
    119 : ${EGREP="/bin/grep -E"}
    120 : ${FGREP="/bin/grep -F"}
    121 : ${GREP="/bin/grep"}
    122 : ${LN_S="ln -s"}
     139test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
    123140: ${MAKE="make"}
    124141: ${MKDIR="mkdir"}
    125142: ${MV="mv -f"}
    126143: ${RM="rm -f"}
    127 : ${SED="/bin/sed"}
    128144: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
    129145: ${Xsed="$SED -e 1s/^X//"}
     
    144160dirname="s,/[^/]*$,,"
    145161basename="s,^.*/,,"
     162
     163# func_dirname file append nondir_replacement
     164# Compute the dirname of FILE.  If nonempty, add APPEND to the result,
     165# otherwise set result to NONDIR_REPLACEMENT.
     166func_dirname ()
     167{
     168    func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`
     169    if test "X$func_dirname_result" = "X${1}"; then
     170      func_dirname_result="${3}"
     171    else
     172      func_dirname_result="$func_dirname_result${2}"
     173    fi
     174} # func_dirname may be replaced by extended shell implementation
     175
     176
     177# func_basename file
     178func_basename ()
     179{
     180    func_basename_result=`$ECHO "${1}" | $SED "$basename"`
     181} # func_basename may be replaced by extended shell implementation
     182
    146183
    147184# func_dirname_and_basename file append nondir_replacement
     
    159196func_dirname_and_basename ()
    160197{
    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}"
     198    # Extract subdirectory from the argument.
     199    func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
     200    if test "X$func_dirname_result" = "X${1}"; then
     201      func_dirname_result="${3}"
     202    else
     203      func_dirname_result="$func_dirname_result${2}"
     204    fi
     205    func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
     206} # func_dirname_and_basename may be replaced by extended shell implementation
     207
     208
     209# func_stripname prefix suffix name
     210# strip PREFIX and SUFFIX off of NAME.
     211# PREFIX and SUFFIX must not contain globbing or regex special
     212# characters, hashes, percent signs, but SUFFIX may contain a leading
     213# dot (in which case that matches only a dot).
     214# func_strip_suffix prefix name
     215func_stripname ()
     216{
     217    case ${2} in
     218      .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
     219      *)  func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
     220    esac
     221} # func_stripname may be replaced by extended shell implementation
     222
     223
     224# These SED scripts presuppose an absolute path with a trailing slash.
     225pathcar='s,^/\([^/]*\).*$,\1,'
     226pathcdr='s,^/[^/]*,,'
     227removedotparts=':dotsl
     228                s@/\./@/@g
     229                t dotsl
     230                s,/\.$,/,'
     231collapseslashes='s@/\{1,\}@/@g'
     232finalslash='s,/*$,/,'
     233
     234# func_normal_abspath PATH
     235# Remove doubled-up and trailing slashes, "." path components,
     236# and cancel out any ".." path components in PATH after making
     237# it an absolute path.
     238#             value returned in "$func_normal_abspath_result"
     239func_normal_abspath ()
     240{
     241  # Start from root dir and reassemble the path.
     242  func_normal_abspath_result=
     243  func_normal_abspath_tpath=$1
     244  func_normal_abspath_altnamespace=
     245  case $func_normal_abspath_tpath in
     246    "")
     247      # Empty path, that just means $cwd.
     248      func_stripname '' '/' "`pwd`"
     249      func_normal_abspath_result=$func_stripname_result
     250      return
     251    ;;
     252    # The next three entries are used to spot a run of precisely
     253    # two leading slashes without using negated character classes;
     254    # we take advantage of case's first-match behaviour.
     255    ///*)
     256      # Unusual form of absolute path, do nothing.
     257    ;;
     258    //*)
     259      # Not necessarily an ordinary path; POSIX reserves leading '//'
     260      # and for example Cygwin uses it to access remote file shares
     261      # over CIFS/SMB, so we conserve a leading double slash if found.
     262      func_normal_abspath_altnamespace=/
     263    ;;
     264    /*)
     265      # Absolute path, do nothing.
     266    ;;
     267    *)
     268      # Relative path, prepend $cwd.
     269      func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
     270    ;;
     271  esac
     272  # Cancel out all the simple stuff to save iterations.  We also want
     273  # the path to end with a slash for ease of parsing, so make sure
     274  # there is one (and only one) here.
     275  func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
     276        -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
     277  while :; do
     278    # Processed it all yet?
     279    if test "$func_normal_abspath_tpath" = / ; then
     280      # If we ascended to the root using ".." the result may be empty now.
     281      if test -z "$func_normal_abspath_result" ; then
     282        func_normal_abspath_result=/
     283      fi
     284      break
     285    fi
     286    func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
     287        -e "$pathcar"`
     288    func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
     289        -e "$pathcdr"`
     290    # Figure out what to do with it
     291    case $func_normal_abspath_tcomponent in
     292      "")
     293        # Trailing empty path component, ignore it.
     294      ;;
     295      ..)
     296        # Parent dir; strip last assembled component from result.
     297        func_dirname "$func_normal_abspath_result"
     298        func_normal_abspath_result=$func_dirname_result
     299      ;;
     300      *)
     301        # Actual path component, append it.
     302        func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
     303      ;;
     304    esac
     305  done
     306  # Restore leading double-slash if one was found on entry.
     307  func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
     308}
     309
     310# func_relative_path SRCDIR DSTDIR
     311# generates a relative path from SRCDIR to DSTDIR, with a trailing
     312# slash if non-empty, suitable for immediately appending a filename
     313# without needing to append a separator.
     314#             value returned in "$func_relative_path_result"
     315func_relative_path ()
     316{
     317  func_relative_path_result=
     318  func_normal_abspath "$1"
     319  func_relative_path_tlibdir=$func_normal_abspath_result
     320  func_normal_abspath "$2"
     321  func_relative_path_tbindir=$func_normal_abspath_result
     322
     323  # Ascend the tree starting from libdir
     324  while :; do
     325    # check if we have found a prefix of bindir
     326    case $func_relative_path_tbindir in
     327      $func_relative_path_tlibdir)
     328        # found an exact match
     329        func_relative_path_tcancelled=
     330        break
     331        ;;
     332      $func_relative_path_tlibdir*)
     333        # found a matching prefix
     334        func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
     335        func_relative_path_tcancelled=$func_stripname_result
     336        if test -z "$func_relative_path_result"; then
     337          func_relative_path_result=.
     338        fi
     339        break
     340        ;;
     341      *)
     342        func_dirname $func_relative_path_tlibdir
     343        func_relative_path_tlibdir=${func_dirname_result}
     344        if test "x$func_relative_path_tlibdir" = x ; then
     345          # Have to descend all the way to the root!
     346          func_relative_path_result=../$func_relative_path_result
     347          func_relative_path_tcancelled=$func_relative_path_tbindir
     348          break
     349        fi
     350        func_relative_path_result=../$func_relative_path_result
     351        ;;
     352    esac
     353  done
     354
     355  # Now calculate path; take care to avoid doubling-up slashes.
     356  func_stripname '' '/' "$func_relative_path_result"
     357  func_relative_path_result=$func_stripname_result
     358  func_stripname '/' '/' "$func_relative_path_tcancelled"
     359  if test "x$func_stripname_result" != x ; then
     360    func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
    167361  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"
     362
     363  # Normalisation. If bindir is libdir, return empty string,
     364  # else relative path ending with a slash; either way, target
     365  # file name can be directly appended.
     366  if test ! -z "$func_relative_path_result"; then
     367    func_stripname './' '' "$func_relative_path_result/"
     368    func_relative_path_result=$func_stripname_result
     369  fi
     370}
    179371
    180372# 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:
    183373func_dirname_and_basename "$progpath"
    184374progname=$func_basename_result
    185 case $progname in
    186   -*) progname=./$progname ;;
    187 esac
    188375
    189376# Make sure we have an absolute path for reexecution:
     
    197384  *)
    198385     save_IFS="$IFS"
    199      IFS=:
     386     IFS=${PATH_SEPARATOR-:}
    200387     for progdir in $PATH; do
    201388       IFS="$save_IFS"
     
    215402# Same as above, but do not quote variable references.
    216403double_quote_subst='s/\(["`\\]\)/\\\1/g'
     404
     405# Sed substitution that turns a string into a regex matching for the
     406# string literally.
     407sed_make_literal_regex='s,[].[^$\\*\/],\\&,g'
     408
     409# Sed substitution that converts a w32 file name or path
     410# which contains forward slashes, into one that contains
     411# (escaped) backslashes.  A very naive implementation.
     412lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
    217413
    218414# Re-`\' parameter expansions in output of double_quote_subst that were
     
    244440func_echo ()
    245441{
    246     $ECHO "$progname${mode+: }$mode: $*"
     442    $ECHO "$progname: ${opt_mode+$opt_mode: }$*"
    247443}
    248444
     
    259455}
    260456
     457# func_echo_all arg...
     458# Invoke $ECHO with all args, space-separated.
     459func_echo_all ()
     460{
     461    $ECHO "$*"
     462}
     463
    261464# func_error arg...
    262465# Echo program name prefixed message to standard error.
    263466func_error ()
    264467{
    265     $ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
     468    $ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
    266469}
    267470
     
    270473func_warning ()
    271474{
    272     $opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
     475    $opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
    273476
    274477    # bash bug again:
     
    327530
    328531        # ...otherwise throw away the child directory and loop
    329         my_directory_path=`$ECHO "X$my_directory_path" | $Xsed -e "$dirname"`
     532        my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
    330533      done
    331       my_dir_list=`$ECHO "X$my_dir_list" | $Xsed -e 's,:*$,,'`
     534      my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
    332535
    333536      save_mkdir_p_IFS="$IFS"; IFS=':'
     
    379582    fi
    380583
    381     $ECHO "X$my_tmpdir" | $Xsed
     584    $ECHO "$my_tmpdir"
    382585}
    383586
     
    393596    case $1 in
    394597      *[\\\`\"\$]*)
    395         func_quote_for_eval_unquoted_result=`$ECHO "X$1" | $Xsed -e "$sed_quote_subst"` ;;
     598        func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
    396599      *)
    397600        func_quote_for_eval_unquoted_result="$1" ;;
     
    420623    case $1 in
    421624      *[\\\`\"]*)
    422         my_arg=`$ECHO "X$1" | $Xsed \
     625        my_arg=`$ECHO "$1" | $SED \
    423626            -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
    424627      *)
     
    489692}
    490693
    491 
    492 
     694# func_tr_sh
     695# Turn $1 into a string suitable for a shell variable name.
     696# Result is stored in $func_tr_sh_result.  All characters
     697# not in the set a-zA-Z0-9_ are replaced with '_'. Further,
     698# if $1 begins with a digit, a '_' is prepended as well.
     699func_tr_sh ()
     700{
     701  case $1 in
     702  [0-9]* | *[!a-zA-Z0-9_]*)
     703    func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'`
     704    ;;
     705  * )
     706    func_tr_sh_result=$1
     707    ;;
     708  esac
     709}
    493710
    494711
     
    497714func_version ()
    498715{
    499     $SED -n '/^# '$PROGRAM' (GNU /,/# warranty; / {
     716    $opt_debug
     717
     718    $SED -n '/(C)/!b go
     719        :more
     720        /\./!{
     721          N
     722          s/\n# / /
     723          b more
     724        }
     725        :go
     726        /^# '$PROGRAM' (GNU /,/# warranty; / {
    500727        s/^# //
    501728        s/^# *$//
     
    510737func_usage ()
    511738{
    512     $SED -n '/^# Usage:/,/# -h/ {
     739    $opt_debug
     740
     741    $SED -n '/^# Usage:/,/^#  *.*--help/ {
    513742        s/^# //
    514743        s/^# *$//
     
    516745        p
    517746    }' < "$progpath"
    518     $ECHO
     747    echo
    519748    $ECHO "run \`$progname --help | more' for full usage"
    520749    exit $?
    521750}
    522751
    523 # func_help
    524 # Echo long help message to standard output and exit.
     752# func_help [NOEXIT]
     753# Echo long help message to standard output and exit,
     754# unless 'noexit' is passed as argument.
    525755func_help ()
    526756{
     757    $opt_debug
     758
    527759    $SED -n '/^# Usage:/,/# Report bugs to/ {
     760        :print
    528761        s/^# //
    529762        s/^# *$//
     
    535768        s*\$LD*'"$LD"'*
    536769        s/\$with_gnu_ld/'"$with_gnu_ld"'/
    537         s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
    538         s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
     770        s/\$automake_version/'"`(${AUTOMAKE-automake} --version) 2>/dev/null |$SED 1q`"'/
     771        s/\$autoconf_version/'"`(${AUTOCONF-autoconf} --version) 2>/dev/null |$SED 1q`"'/
    539772        p
    540      }' < "$progpath"
    541     exit $?
     773        d
     774     }
     775     /^# .* home page:/b print
     776     /^# General help using/b print
     777     ' < "$progpath"
     778    ret=$?
     779    if test -z "$1"; then
     780      exit $ret
     781    fi
    542782}
    543783
     
    547787func_missing_arg ()
    548788{
    549     func_error "missing argument for $1"
     789    $opt_debug
     790
     791    func_error "missing argument for $1."
    550792    exit_cmd=exit
    551793}
    552794
     795
     796# func_split_short_opt shortopt
     797# Set func_split_short_opt_name and func_split_short_opt_arg shell
     798# variables after splitting SHORTOPT after the 2nd character.
     799func_split_short_opt ()
     800{
     801    my_sed_short_opt='1s/^\(..\).*$/\1/;q'
     802    my_sed_short_rest='1s/^..\(.*\)$/\1/;q'
     803
     804    func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`
     805    func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`
     806} # func_split_short_opt may be replaced by extended shell implementation
     807
     808
     809# func_split_long_opt longopt
     810# Set func_split_long_opt_name and func_split_long_opt_arg shell
     811# variables after splitting LONGOPT at the `=' sign.
     812func_split_long_opt ()
     813{
     814    my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q'
     815    my_sed_long_arg='1s/^--[^=]*=//'
     816
     817    func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`
     818    func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`
     819} # func_split_long_opt may be replaced by extended shell implementation
     820
    553821exit_cmd=:
    554822
     
    556824
    557825
    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
    582826
    583827magic="%%%MAGIC variable%%%"
     
    585829
    586830# Global variables.
    587 # $mode is unset
    588831nonopt=
    589 execute_dlfiles=
    590832preserve_args=
    591833lo2o="s/\\.lo\$/.${objext}/"
     
    594836extracted_serial=0
    595837
    596 opt_dry_run=false
    597 opt_duplicate_deps=false
    598 opt_silent=false
    599 opt_debug=:
    600 
    601838# If this variable is set in any of the actions, the command in it
    602839# will be execed at the end.  This prevents here-documents from being
     
    604841exec_cmd=
    605842
     843# func_append var value
     844# Append VALUE to the end of shell variable VAR.
     845func_append ()
     846{
     847    eval "${1}=\$${1}\${2}"
     848} # func_append may be replaced by extended shell implementation
     849
     850# func_append_quoted var value
     851# Quote VALUE and append to the end of shell variable VAR, separated
     852# by a space.
     853func_append_quoted ()
     854{
     855    func_quote_for_eval "${2}"
     856    eval "${1}=\$${1}\\ \$func_quote_for_eval_result"
     857} # func_append_quoted may be replaced by extended shell implementation
     858
     859
     860# func_arith arithmetic-term...
     861func_arith ()
     862{
     863    func_arith_result=`expr "${@}"`
     864} # func_arith may be replaced by extended shell implementation
     865
     866
     867# func_len string
     868# STRING may not start with a hyphen.
     869func_len ()
     870{
     871    func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len`
     872} # func_len may be replaced by extended shell implementation
     873
     874
     875# func_lo2o object
     876func_lo2o ()
     877{
     878    func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`
     879} # func_lo2o may be replaced by extended shell implementation
     880
     881
     882# func_xform libobj-or-source
     883func_xform ()
     884{
     885    func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`
     886} # func_xform may be replaced by extended shell implementation
     887
     888
    606889# func_fatal_configuration arg...
    607890# Echo program name prefixed message to standard error, followed by
     
    637920func_features ()
    638921{
    639     $ECHO "host: $host"
     922    echo "host: $host"
    640923    if test "$build_libtool_libs" = yes; then
    641       $ECHO "enable shared libraries"
     924      echo "enable shared libraries"
    642925    else
    643       $ECHO "disable shared libraries"
     926      echo "disable shared libraries"
    644927    fi
    645928    if test "$build_old_libs" = yes; then
    646       $ECHO "enable static libraries"
     929      echo "enable static libraries"
    647930    else
    648       $ECHO "disable static libraries"
     931      echo "disable static libraries"
    649932    fi
    650933
     
    691974      ;;
    692975  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
    820976}
    821977
     
    8561012
    8571013
     1014# Shorthand for --mode=foo, only valid as the first argument
     1015case $1 in
     1016clean|clea|cle|cl)
     1017  shift; set dummy --mode clean ${1+"$@"}; shift
     1018  ;;
     1019compile|compil|compi|comp|com|co|c)
     1020  shift; set dummy --mode compile ${1+"$@"}; shift
     1021  ;;
     1022execute|execut|execu|exec|exe|ex|e)
     1023  shift; set dummy --mode execute ${1+"$@"}; shift
     1024  ;;
     1025finish|finis|fini|fin|fi|f)
     1026  shift; set dummy --mode finish ${1+"$@"}; shift
     1027  ;;
     1028install|instal|insta|inst|ins|in|i)
     1029  shift; set dummy --mode install ${1+"$@"}; shift
     1030  ;;
     1031link|lin|li|l)
     1032  shift; set dummy --mode link ${1+"$@"}; shift
     1033  ;;
     1034uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
     1035  shift; set dummy --mode uninstall ${1+"$@"}; shift
     1036  ;;
     1037esac
     1038
     1039
     1040
     1041# Option defaults:
     1042opt_debug=:
     1043opt_dry_run=false
     1044opt_config=false
     1045opt_preserve_dup_deps=false
     1046opt_features=false
     1047opt_finish=false
     1048opt_help=false
     1049opt_help_all=false
     1050opt_silent=:
     1051opt_warning=:
     1052opt_verbose=:
     1053opt_silent=false
     1054opt_verbose=false
     1055
     1056
     1057# Parse options once, thoroughly.  This comes as soon as possible in the
     1058# script to make things like `--version' happen as quickly as we can.
     1059{
     1060  # this just eases exit handling
     1061  while test $# -gt 0; do
     1062    opt="$1"
     1063    shift
     1064    case $opt in
     1065      --debug|-x)       opt_debug='set -x'
     1066                        func_echo "enabling shell trace mode"
     1067                        $opt_debug
     1068                        ;;
     1069      --dry-run|--dryrun|-n)
     1070                        opt_dry_run=:
     1071                        ;;
     1072      --config)
     1073                        opt_config=:
     1074func_config
     1075                        ;;
     1076      --dlopen|-dlopen)
     1077                        optarg="$1"
     1078                        opt_dlopen="${opt_dlopen+$opt_dlopen
     1079}$optarg"
     1080                        shift
     1081                        ;;
     1082      --preserve-dup-deps)
     1083                        opt_preserve_dup_deps=:
     1084                        ;;
     1085      --features)
     1086                        opt_features=:
     1087func_features
     1088                        ;;
     1089      --finish)
     1090                        opt_finish=:
     1091set dummy --mode finish ${1+"$@"}; shift
     1092                        ;;
     1093      --help)
     1094                        opt_help=:
     1095                        ;;
     1096      --help-all)
     1097                        opt_help_all=:
     1098opt_help=': help-all'
     1099                        ;;
     1100      --mode)
     1101                        test $# = 0 && func_missing_arg $opt && break
     1102                        optarg="$1"
     1103                        opt_mode="$optarg"
     1104case $optarg in
     1105  # Valid mode arguments:
     1106  clean|compile|execute|finish|install|link|relink|uninstall) ;;
     1107
     1108  # Catch anything else as an error
     1109  *) func_error "invalid argument for $opt"
     1110     exit_cmd=exit
     1111     break
     1112     ;;
     1113esac
     1114                        shift
     1115                        ;;
     1116      --no-silent|--no-quiet)
     1117                        opt_silent=false
     1118func_append preserve_args " $opt"
     1119                        ;;
     1120      --no-warning|--no-warn)
     1121                        opt_warning=false
     1122func_append preserve_args " $opt"
     1123                        ;;
     1124      --no-verbose)
     1125                        opt_verbose=false
     1126func_append preserve_args " $opt"
     1127                        ;;
     1128      --silent|--quiet)
     1129                        opt_silent=:
     1130func_append preserve_args " $opt"
     1131        opt_verbose=false
     1132                        ;;
     1133      --verbose|-v)
     1134                        opt_verbose=:
     1135func_append preserve_args " $opt"
     1136opt_silent=false
     1137                        ;;
     1138      --tag)
     1139                        test $# = 0 && func_missing_arg $opt && break
     1140                        optarg="$1"
     1141                        opt_tag="$optarg"
     1142func_append preserve_args " $opt $optarg"
     1143func_enable_tag "$optarg"
     1144                        shift
     1145                        ;;
     1146
     1147      -\?|-h)           func_usage                              ;;
     1148      --help)           func_help                               ;;
     1149      --version)        func_version                            ;;
     1150
     1151      # Separate optargs to long options:
     1152      --*=*)
     1153                        func_split_long_opt "$opt"
     1154                        set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}
     1155                        shift
     1156                        ;;
     1157
     1158      # Separate non-argument short options:
     1159      -\?*|-h*|-n*|-v*)
     1160                        func_split_short_opt "$opt"
     1161                        set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}
     1162                        shift
     1163                        ;;
     1164
     1165      --)               break                                   ;;
     1166      -*)               func_fatal_help "unrecognized option \`$opt'" ;;
     1167      *)                set dummy "$opt" ${1+"$@"};     shift; break  ;;
     1168    esac
     1169  done
     1170
     1171  # Validate options:
     1172
     1173  # save first non-option argument
     1174  if test "$#" -gt 0; then
     1175    nonopt="$opt"
     1176    shift
     1177  fi
     1178
     1179  # preserve --debug
     1180  test "$opt_debug" = : || func_append preserve_args " --debug"
     1181
     1182  case $host in
     1183    *cygwin* | *mingw* | *pw32* | *cegcc*)
     1184      # don't eliminate duplications in $postdeps and $predeps
     1185      opt_duplicate_compiler_generated_deps=:
     1186      ;;
     1187    *)
     1188      opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
     1189      ;;
     1190  esac
     1191
     1192  $opt_help || {
     1193    # Sanity checks first:
     1194    func_check_version_match
     1195
     1196    if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
     1197      func_fatal_configuration "not configured to build any kind of library"
     1198    fi
     1199
     1200    # Darwin sucks
     1201    eval std_shrext=\"$shrext_cmds\"
     1202
     1203    # Only execute mode is allowed to have -dlopen flags.
     1204    if test -n "$opt_dlopen" && test "$opt_mode" != execute; then
     1205      func_error "unrecognized option \`-dlopen'"
     1206      $ECHO "$help" 1>&2
     1207      exit $EXIT_FAILURE
     1208    fi
     1209
     1210    # Change the help message to a mode-specific one.
     1211    generic_help="$help"
     1212    help="Try \`$progname --help --mode=$opt_mode' for more information."
     1213  }
     1214
     1215
     1216  # Bail if the options were screwed
     1217  $exit_cmd $EXIT_FAILURE
     1218}
     1219
     1220
     1221
     1222
    8581223## ----------- ##
    8591224##    Main.    ##
    8601225## ----------- ##
    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 
    8891226
    8901227# func_lalib_p file
     
    9511288func_ltwrapper_scriptname ()
    9521289{
    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
     1290    func_dirname_and_basename "$1" "" "."
     1291    func_stripname '' '.exe' "$func_basename_result"
     1292    func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
    9591293}
    9601294
     
    10021336
    10031337
     1338# func_resolve_sysroot PATH
     1339# Replace a leading = in PATH with a sysroot.  Store the result into
     1340# func_resolve_sysroot_result
     1341func_resolve_sysroot ()
     1342{
     1343  func_resolve_sysroot_result=$1
     1344  case $func_resolve_sysroot_result in
     1345  =*)
     1346    func_stripname '=' '' "$func_resolve_sysroot_result"
     1347    func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
     1348    ;;
     1349  esac
     1350}
     1351
     1352# func_replace_sysroot PATH
     1353# If PATH begins with the sysroot, replace it with = and
     1354# store the result into func_replace_sysroot_result.
     1355func_replace_sysroot ()
     1356{
     1357  case "$lt_sysroot:$1" in
     1358  ?*:"$lt_sysroot"*)
     1359    func_stripname "$lt_sysroot" '' "$1"
     1360    func_replace_sysroot_result="=$func_stripname_result"
     1361    ;;
     1362  *)
     1363    # Including no sysroot.
     1364    func_replace_sysroot_result=$1
     1365    ;;
     1366  esac
     1367}
     1368
    10041369# func_infer_tag arg
    10051370# Infer tagged configuration to use if any are available and
     
    10141379      CC_quoted=
    10151380      for arg in $CC; do
    1016         func_quote_for_eval "$arg"
    1017         CC_quoted="$CC_quoted $func_quote_for_eval_result"
     1381        func_append_quoted CC_quoted "$arg"
    10181382      done
     1383      CC_expanded=`func_echo_all $CC`
     1384      CC_quoted_expanded=`func_echo_all $CC_quoted`
    10191385      case $@ in
    10201386      # Blanks in the command may have been stripped by the calling shell,
    10211387      # 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` "*) ;;
     1388      " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
     1389      " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
    10231390      # Blanks at the start of $base_compile will cause this to fail
    10241391      # if we don't check for them as well.
     
    10311398            for arg in $CC; do
    10321399              # Double-quote args containing other shell metacharacters.
    1033               func_quote_for_eval "$arg"
    1034               CC_quoted="$CC_quoted $func_quote_for_eval_result"
     1400              func_append_quoted CC_quoted "$arg"
    10351401            done
     1402            CC_expanded=`func_echo_all $CC`
     1403            CC_quoted_expanded=`func_echo_all $CC_quoted`
    10361404            case "$@ " in
    1037               " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*)
     1405            " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
     1406            " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
    10381407              # The compiler in the base compile command matches
    10391408              # the one in the tagged configuration.
     
    10981467}
    10991468
     1469
     1470##################################################
     1471# FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
     1472##################################################
     1473
     1474# func_convert_core_file_wine_to_w32 ARG
     1475# Helper function used by file name conversion functions when $build is *nix,
     1476# and $host is mingw, cygwin, or some other w32 environment. Relies on a
     1477# correctly configured wine environment available, with the winepath program
     1478# in $build's $PATH.
     1479#
     1480# ARG is the $build file name to be converted to w32 format.
     1481# Result is available in $func_convert_core_file_wine_to_w32_result, and will
     1482# be empty on error (or when ARG is empty)
     1483func_convert_core_file_wine_to_w32 ()
     1484{
     1485  $opt_debug
     1486  func_convert_core_file_wine_to_w32_result="$1"
     1487  if test -n "$1"; then
     1488    # Unfortunately, winepath does not exit with a non-zero error code, so we
     1489    # are forced to check the contents of stdout. On the other hand, if the
     1490    # command is not found, the shell will set an exit code of 127 and print
     1491    # *an error message* to stdout. So we must check for both error code of
     1492    # zero AND non-empty stdout, which explains the odd construction:
     1493    func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
     1494    if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then
     1495      func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
     1496        $SED -e "$lt_sed_naive_backslashify"`
     1497    else
     1498      func_convert_core_file_wine_to_w32_result=
     1499    fi
     1500  fi
     1501}
     1502# end: func_convert_core_file_wine_to_w32
     1503
     1504
     1505# func_convert_core_path_wine_to_w32 ARG
     1506# Helper function used by path conversion functions when $build is *nix, and
     1507# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
     1508# configured wine environment available, with the winepath program in $build's
     1509# $PATH. Assumes ARG has no leading or trailing path separator characters.
     1510#
     1511# ARG is path to be converted from $build format to win32.
     1512# Result is available in $func_convert_core_path_wine_to_w32_result.
     1513# Unconvertible file (directory) names in ARG are skipped; if no directory names
     1514# are convertible, then the result may be empty.
     1515func_convert_core_path_wine_to_w32 ()
     1516{
     1517  $opt_debug
     1518  # unfortunately, winepath doesn't convert paths, only file names
     1519  func_convert_core_path_wine_to_w32_result=""
     1520  if test -n "$1"; then
     1521    oldIFS=$IFS
     1522    IFS=:
     1523    for func_convert_core_path_wine_to_w32_f in $1; do
     1524      IFS=$oldIFS
     1525      func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
     1526      if test -n "$func_convert_core_file_wine_to_w32_result" ; then
     1527        if test -z "$func_convert_core_path_wine_to_w32_result"; then
     1528          func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"
     1529        else
     1530          func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
     1531        fi
     1532      fi
     1533    done
     1534    IFS=$oldIFS
     1535  fi
     1536}
     1537# end: func_convert_core_path_wine_to_w32
     1538
     1539
     1540# func_cygpath ARGS...
     1541# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
     1542# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
     1543# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
     1544# (2), returns the Cygwin file name or path in func_cygpath_result (input
     1545# file name or path is assumed to be in w32 format, as previously converted
     1546# from $build's *nix or MSYS format). In case (3), returns the w32 file name
     1547# or path in func_cygpath_result (input file name or path is assumed to be in
     1548# Cygwin format). Returns an empty string on error.
     1549#
     1550# ARGS are passed to cygpath, with the last one being the file name or path to
     1551# be converted.
     1552#
     1553# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
     1554# environment variable; do not put it in $PATH.
     1555func_cygpath ()
     1556{
     1557  $opt_debug
     1558  if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
     1559    func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
     1560    if test "$?" -ne 0; then
     1561      # on failure, ensure result is empty
     1562      func_cygpath_result=
     1563    fi
     1564  else
     1565    func_cygpath_result=
     1566    func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"
     1567  fi
     1568}
     1569#end: func_cygpath
     1570
     1571
     1572# func_convert_core_msys_to_w32 ARG
     1573# Convert file name or path ARG from MSYS format to w32 format.  Return
     1574# result in func_convert_core_msys_to_w32_result.
     1575func_convert_core_msys_to_w32 ()
     1576{
     1577  $opt_debug
     1578  # awkward: cmd appends spaces to result
     1579  func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
     1580    $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
     1581}
     1582#end: func_convert_core_msys_to_w32
     1583
     1584
     1585# func_convert_file_check ARG1 ARG2
     1586# Verify that ARG1 (a file name in $build format) was converted to $host
     1587# format in ARG2. Otherwise, emit an error message, but continue (resetting
     1588# func_to_host_file_result to ARG1).
     1589func_convert_file_check ()
     1590{
     1591  $opt_debug
     1592  if test -z "$2" && test -n "$1" ; then
     1593    func_error "Could not determine host file name corresponding to"
     1594    func_error "  \`$1'"
     1595    func_error "Continuing, but uninstalled executables may not work."
     1596    # Fallback:
     1597    func_to_host_file_result="$1"
     1598  fi
     1599}
     1600# end func_convert_file_check
     1601
     1602
     1603# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
     1604# Verify that FROM_PATH (a path in $build format) was converted to $host
     1605# format in TO_PATH. Otherwise, emit an error message, but continue, resetting
     1606# func_to_host_file_result to a simplistic fallback value (see below).
     1607func_convert_path_check ()
     1608{
     1609  $opt_debug
     1610  if test -z "$4" && test -n "$3"; then
     1611    func_error "Could not determine the host path corresponding to"
     1612    func_error "  \`$3'"
     1613    func_error "Continuing, but uninstalled executables may not work."
     1614    # Fallback.  This is a deliberately simplistic "conversion" and
     1615    # should not be "improved".  See libtool.info.
     1616    if test "x$1" != "x$2"; then
     1617      lt_replace_pathsep_chars="s|$1|$2|g"
     1618      func_to_host_path_result=`echo "$3" |
     1619        $SED -e "$lt_replace_pathsep_chars"`
     1620    else
     1621      func_to_host_path_result="$3"
     1622    fi
     1623  fi
     1624}
     1625# end func_convert_path_check
     1626
     1627
     1628# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
     1629# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
     1630# and appending REPL if ORIG matches BACKPAT.
     1631func_convert_path_front_back_pathsep ()
     1632{
     1633  $opt_debug
     1634  case $4 in
     1635  $1 ) func_to_host_path_result="$3$func_to_host_path_result"
     1636    ;;
     1637  esac
     1638  case $4 in
     1639  $2 ) func_append func_to_host_path_result "$3"
     1640    ;;
     1641  esac
     1642}
     1643# end func_convert_path_front_back_pathsep
     1644
     1645
     1646##################################################
     1647# $build to $host FILE NAME CONVERSION FUNCTIONS #
     1648##################################################
     1649# invoked via `$to_host_file_cmd ARG'
     1650#
     1651# In each case, ARG is the path to be converted from $build to $host format.
     1652# Result will be available in $func_to_host_file_result.
     1653
     1654
     1655# func_to_host_file ARG
     1656# Converts the file name ARG from $build format to $host format. Return result
     1657# in func_to_host_file_result.
     1658func_to_host_file ()
     1659{
     1660  $opt_debug
     1661  $to_host_file_cmd "$1"
     1662}
     1663# end func_to_host_file
     1664
     1665
     1666# func_to_tool_file ARG LAZY
     1667# converts the file name ARG from $build format to toolchain format. Return
     1668# result in func_to_tool_file_result.  If the conversion in use is listed
     1669# in (the comma separated) LAZY, no conversion takes place.
     1670func_to_tool_file ()
     1671{
     1672  $opt_debug
     1673  case ,$2, in
     1674    *,"$to_tool_file_cmd",*)
     1675      func_to_tool_file_result=$1
     1676      ;;
     1677    *)
     1678      $to_tool_file_cmd "$1"
     1679      func_to_tool_file_result=$func_to_host_file_result
     1680      ;;
     1681  esac
     1682}
     1683# end func_to_tool_file
     1684
     1685
     1686# func_convert_file_noop ARG
     1687# Copy ARG to func_to_host_file_result.
     1688func_convert_file_noop ()
     1689{
     1690  func_to_host_file_result="$1"
     1691}
     1692# end func_convert_file_noop
     1693
     1694
     1695# func_convert_file_msys_to_w32 ARG
     1696# Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
     1697# conversion to w32 is not available inside the cwrapper.  Returns result in
     1698# func_to_host_file_result.
     1699func_convert_file_msys_to_w32 ()
     1700{
     1701  $opt_debug
     1702  func_to_host_file_result="$1"
     1703  if test -n "$1"; then
     1704    func_convert_core_msys_to_w32 "$1"
     1705    func_to_host_file_result="$func_convert_core_msys_to_w32_result"
     1706  fi
     1707  func_convert_file_check "$1" "$func_to_host_file_result"
     1708}
     1709# end func_convert_file_msys_to_w32
     1710
     1711
     1712# func_convert_file_cygwin_to_w32 ARG
     1713# Convert file name ARG from Cygwin to w32 format.  Returns result in
     1714# func_to_host_file_result.
     1715func_convert_file_cygwin_to_w32 ()
     1716{
     1717  $opt_debug
     1718  func_to_host_file_result="$1"
     1719  if test -n "$1"; then
     1720    # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
     1721    # LT_CYGPATH in this case.
     1722    func_to_host_file_result=`cygpath -m "$1"`
     1723  fi
     1724  func_convert_file_check "$1" "$func_to_host_file_result"
     1725}
     1726# end func_convert_file_cygwin_to_w32
     1727
     1728
     1729# func_convert_file_nix_to_w32 ARG
     1730# Convert file name ARG from *nix to w32 format.  Requires a wine environment
     1731# and a working winepath. Returns result in func_to_host_file_result.
     1732func_convert_file_nix_to_w32 ()
     1733{
     1734  $opt_debug
     1735  func_to_host_file_result="$1"
     1736  if test -n "$1"; then
     1737    func_convert_core_file_wine_to_w32 "$1"
     1738    func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"
     1739  fi
     1740  func_convert_file_check "$1" "$func_to_host_file_result"
     1741}
     1742# end func_convert_file_nix_to_w32
     1743
     1744
     1745# func_convert_file_msys_to_cygwin ARG
     1746# Convert file name ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
     1747# Returns result in func_to_host_file_result.
     1748func_convert_file_msys_to_cygwin ()
     1749{
     1750  $opt_debug
     1751  func_to_host_file_result="$1"
     1752  if test -n "$1"; then
     1753    func_convert_core_msys_to_w32 "$1"
     1754    func_cygpath -u "$func_convert_core_msys_to_w32_result"
     1755    func_to_host_file_result="$func_cygpath_result"
     1756  fi
     1757  func_convert_file_check "$1" "$func_to_host_file_result"
     1758}
     1759# end func_convert_file_msys_to_cygwin
     1760
     1761
     1762# func_convert_file_nix_to_cygwin ARG
     1763# Convert file name ARG from *nix to Cygwin format.  Requires Cygwin installed
     1764# in a wine environment, working winepath, and LT_CYGPATH set.  Returns result
     1765# in func_to_host_file_result.
     1766func_convert_file_nix_to_cygwin ()
     1767{
     1768  $opt_debug
     1769  func_to_host_file_result="$1"
     1770  if test -n "$1"; then
     1771    # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
     1772    func_convert_core_file_wine_to_w32 "$1"
     1773    func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
     1774    func_to_host_file_result="$func_cygpath_result"
     1775  fi
     1776  func_convert_file_check "$1" "$func_to_host_file_result"
     1777}
     1778# end func_convert_file_nix_to_cygwin
     1779
     1780
     1781#############################################
     1782# $build to $host PATH CONVERSION FUNCTIONS #
     1783#############################################
     1784# invoked via `$to_host_path_cmd ARG'
     1785#
     1786# In each case, ARG is the path to be converted from $build to $host format.
     1787# The result will be available in $func_to_host_path_result.
     1788#
     1789# Path separators are also converted from $build format to $host format.  If
     1790# ARG begins or ends with a path separator character, it is preserved (but
     1791# converted to $host format) on output.
     1792#
     1793# All path conversion functions are named using the following convention:
     1794#   file name conversion function    : func_convert_file_X_to_Y ()
     1795#   path conversion function         : func_convert_path_X_to_Y ()
     1796# where, for any given $build/$host combination the 'X_to_Y' value is the
     1797# same.  If conversion functions are added for new $build/$host combinations,
     1798# the two new functions must follow this pattern, or func_init_to_host_path_cmd
     1799# will break.
     1800
     1801
     1802# func_init_to_host_path_cmd
     1803# Ensures that function "pointer" variable $to_host_path_cmd is set to the
     1804# appropriate value, based on the value of $to_host_file_cmd.
     1805to_host_path_cmd=
     1806func_init_to_host_path_cmd ()
     1807{
     1808  $opt_debug
     1809  if test -z "$to_host_path_cmd"; then
     1810    func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
     1811    to_host_path_cmd="func_convert_path_${func_stripname_result}"
     1812  fi
     1813}
     1814
     1815
     1816# func_to_host_path ARG
     1817# Converts the path ARG from $build format to $host format. Return result
     1818# in func_to_host_path_result.
     1819func_to_host_path ()
     1820{
     1821  $opt_debug
     1822  func_init_to_host_path_cmd
     1823  $to_host_path_cmd "$1"
     1824}
     1825# end func_to_host_path
     1826
     1827
     1828# func_convert_path_noop ARG
     1829# Copy ARG to func_to_host_path_result.
     1830func_convert_path_noop ()
     1831{
     1832  func_to_host_path_result="$1"
     1833}
     1834# end func_convert_path_noop
     1835
     1836
     1837# func_convert_path_msys_to_w32 ARG
     1838# Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
     1839# conversion to w32 is not available inside the cwrapper.  Returns result in
     1840# func_to_host_path_result.
     1841func_convert_path_msys_to_w32 ()
     1842{
     1843  $opt_debug
     1844  func_to_host_path_result="$1"
     1845  if test -n "$1"; then
     1846    # Remove leading and trailing path separator characters from ARG.  MSYS
     1847    # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
     1848    # and winepath ignores them completely.
     1849    func_stripname : : "$1"
     1850    func_to_host_path_tmp1=$func_stripname_result
     1851    func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
     1852    func_to_host_path_result="$func_convert_core_msys_to_w32_result"
     1853    func_convert_path_check : ";" \
     1854      "$func_to_host_path_tmp1" "$func_to_host_path_result"
     1855    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
     1856  fi
     1857}
     1858# end func_convert_path_msys_to_w32
     1859
     1860
     1861# func_convert_path_cygwin_to_w32 ARG
     1862# Convert path ARG from Cygwin to w32 format.  Returns result in
     1863# func_to_host_file_result.
     1864func_convert_path_cygwin_to_w32 ()
     1865{
     1866  $opt_debug
     1867  func_to_host_path_result="$1"
     1868  if test -n "$1"; then
     1869    # See func_convert_path_msys_to_w32:
     1870    func_stripname : : "$1"
     1871    func_to_host_path_tmp1=$func_stripname_result
     1872    func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
     1873    func_convert_path_check : ";" \
     1874      "$func_to_host_path_tmp1" "$func_to_host_path_result"
     1875    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
     1876  fi
     1877}
     1878# end func_convert_path_cygwin_to_w32
     1879
     1880
     1881# func_convert_path_nix_to_w32 ARG
     1882# Convert path ARG from *nix to w32 format.  Requires a wine environment and
     1883# a working winepath.  Returns result in func_to_host_file_result.
     1884func_convert_path_nix_to_w32 ()
     1885{
     1886  $opt_debug
     1887  func_to_host_path_result="$1"
     1888  if test -n "$1"; then
     1889    # See func_convert_path_msys_to_w32:
     1890    func_stripname : : "$1"
     1891    func_to_host_path_tmp1=$func_stripname_result
     1892    func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
     1893    func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"
     1894    func_convert_path_check : ";" \
     1895      "$func_to_host_path_tmp1" "$func_to_host_path_result"
     1896    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
     1897  fi
     1898}
     1899# end func_convert_path_nix_to_w32
     1900
     1901
     1902# func_convert_path_msys_to_cygwin ARG
     1903# Convert path ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
     1904# Returns result in func_to_host_file_result.
     1905func_convert_path_msys_to_cygwin ()
     1906{
     1907  $opt_debug
     1908  func_to_host_path_result="$1"
     1909  if test -n "$1"; then
     1910    # See func_convert_path_msys_to_w32:
     1911    func_stripname : : "$1"
     1912    func_to_host_path_tmp1=$func_stripname_result
     1913    func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
     1914    func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
     1915    func_to_host_path_result="$func_cygpath_result"
     1916    func_convert_path_check : : \
     1917      "$func_to_host_path_tmp1" "$func_to_host_path_result"
     1918    func_convert_path_front_back_pathsep ":*" "*:" : "$1"
     1919  fi
     1920}
     1921# end func_convert_path_msys_to_cygwin
     1922
     1923
     1924# func_convert_path_nix_to_cygwin ARG
     1925# Convert path ARG from *nix to Cygwin format.  Requires Cygwin installed in a
     1926# a wine environment, working winepath, and LT_CYGPATH set.  Returns result in
     1927# func_to_host_file_result.
     1928func_convert_path_nix_to_cygwin ()
     1929{
     1930  $opt_debug
     1931  func_to_host_path_result="$1"
     1932  if test -n "$1"; then
     1933    # Remove leading and trailing path separator characters from
     1934    # ARG. msys behavior is inconsistent here, cygpath turns them
     1935    # into '.;' and ';.', and winepath ignores them completely.
     1936    func_stripname : : "$1"
     1937    func_to_host_path_tmp1=$func_stripname_result
     1938    func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
     1939    func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
     1940    func_to_host_path_result="$func_cygpath_result"
     1941    func_convert_path_check : : \
     1942      "$func_to_host_path_tmp1" "$func_to_host_path_result"
     1943    func_convert_path_front_back_pathsep ":*" "*:" : "$1"
     1944  fi
     1945}
     1946# end func_convert_path_nix_to_cygwin
     1947
     1948
    11001949# func_mode_compile arg...
    11011950func_mode_compile ()
     
    11381987
    11391988        -pie | -fpie | -fPIE)
    1140           pie_flag="$pie_flag $arg"
     1989          func_append pie_flag " $arg"
    11411990          continue
    11421991          ;;
    11431992
    11441993        -shared | -static | -prefer-pic | -prefer-non-pic)
    1145           later="$later $arg"
     1994          func_append later " $arg"
    11461995          continue
    11471996          ;;
     
    11642013          for arg in $args; do
    11652014            IFS="$save_ifs"
    1166             func_quote_for_eval "$arg"
    1167             lastarg="$lastarg $func_quote_for_eval_result"
     2015            func_append_quoted lastarg "$arg"
    11682016          done
    11692017          IFS="$save_ifs"
     
    11722020
    11732021          # Add the arguments to base_compile.
    1174           base_compile="$base_compile $lastarg"
     2022          func_append base_compile " $lastarg"
    11752023          continue
    11762024          ;;
     
    11882036
    11892037      # Aesthetically quote the previous argument.
    1190       func_quote_for_eval "$lastarg"
    1191       base_compile="$base_compile $func_quote_for_eval_result"
     2038      func_append_quoted base_compile "$lastarg"
    11922039    done # for arg
    11932040
     
    12142061    *.ada | *.adb | *.ads | *.asm | \
    12152062    *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
    1216     *.[fF][09]? | *.for | *.java | *.obj | *.sx)
     2063    *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup)
    12172064      func_xform "$libobj"
    12182065      libobj=$func_xform_result
     
    12892136    # not support -o with -c
    12902137    if test "$compiler_c_o" = no; then
    1291       output_obj=`$ECHO "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
     2138      output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
    12922139      lockfile="$output_obj.lock"
    12932140    else
     
    13202167        exit $EXIT_FAILURE
    13212168      fi
    1322       removelist="$removelist $output_obj"
     2169      func_append removelist " $output_obj"
    13232170      $ECHO "$srcfile" > "$lockfile"
    13242171    fi
    13252172
    13262173    $opt_dry_run || $RM $removelist
    1327     removelist="$removelist $lockfile"
     2174    func_append removelist " $lockfile"
    13282175    trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
    13292176
    1330     if test -n "$fix_srcfile_path"; then
    1331       eval srcfile=\"$fix_srcfile_path\"
    1332     fi
     2177    func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
     2178    srcfile=$func_to_tool_file_result
    13332179    func_quote_for_eval "$srcfile"
    13342180    qsrcfile=$func_quote_for_eval_result
     
    13502196      if test -z "$output_obj"; then
    13512197        # Place PIC objects in $objdir
    1352         command="$command -o $lobj"
     2198        func_append command " -o $lobj"
    13532199      fi
    13542200
     
    13972243      fi
    13982244      if test "$compiler_c_o" = yes; then
    1399         command="$command -o $obj"
     2245        func_append command " -o $obj"
    14002246      fi
    14012247
    14022248      # Suppress compiler output if we already did a PIC compilation.
    1403       command="$command$suppress_output"
     2249      func_append command "$suppress_output"
    14042250      func_show_eval_locale "$command" \
    14052251        '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
     
    14462292
    14472293$opt_help || {
    1448 test "$mode" = compile && func_mode_compile ${1+"$@"}
     2294  test "$opt_mode" = compile && func_mode_compile ${1+"$@"}
    14492295}
    14502296
     
    14522298{
    14532299    # We need to display help for each of the modes.
    1454     case $mode in
     2300    case $opt_mode in
    14552301      "")
    14562302        # Generic help is extracted from the usage comments
     
    14832329  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
    14842330  -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
     2331  -prefer-pic       try to build PIC objects only
     2332  -prefer-non-pic   try to build non-PIC objects only
    14872333  -shared           do not build a \`.o' file suitable for static linking
    14882334  -static           only build a \`.o' file suitable for static linking
     2335  -Wc,FLAG          pass FLAG directly to the compiler
    14892336
    14902337COMPILE-COMMAND is a command to be used in creating a \`standard' object file
     
    15392386The following components of INSTALL-COMMAND are treated specially:
    15402387
    1541   -inst-prefix PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
     2388  -inst-prefix-dir PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
    15422389
    15432390The rest of the components are interpreted as arguments to that command (only
     
    15592406  -all-static       do not do any dynamic linking at all
    15602407  -avoid-version    do not add a version suffix if possible
     2408  -bindir BINDIR    specify path to binaries directory (for systems where
     2409                    libraries must be found in the PATH setting at runtime)
    15612410  -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
    15622411  -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
     
    15872436                    specify library version info [each variable defaults to 0]
    15882437  -weak LIBNAME     declare that the target provides the LIBNAME interface
     2438  -Wc,FLAG
     2439  -Xcompiler FLAG   pass linker-specific FLAG directly to the compiler
     2440  -Wl,FLAG
     2441  -Xlinker FLAG     pass linker-specific FLAG directly to the linker
     2442  -XCClinker FLAG   pass link-specific FLAG to the compiler driver (CC)
    15892443
    15902444All other options (arguments beginning with \`-') are ignored.
     
    16202474
    16212475      *)
    1622         func_fatal_help "invalid operation mode \`$mode'"
     2476        func_fatal_help "invalid operation mode \`$opt_mode'"
    16232477        ;;
    16242478    esac
    16252479
    1626     $ECHO
     2480    echo
    16272481    $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
     2482}
     2483
     2484# Now that we've collected a possible --mode arg, show help if necessary
     2485if $opt_help; then
     2486  if test "$opt_help" = :; then
     2487    func_mode_help
     2488  else
     2489    {
     2490      func_help noexit
     2491      for opt_mode in compile link execute install finish uninstall clean; do
     2492        func_mode_help
     2493      done
     2494    } | sed -n '1p; 2,$s/^Usage:/  or: /p'
     2495    {
     2496      func_help noexit
     2497      for opt_mode in compile link execute install finish uninstall clean; do
     2498        echo
     2499        func_mode_help
     2500      done
     2501    } |
     2502    sed '1d
     2503      /^When reporting/,/^Report/{
     2504        H
     2505        d
     2506      }
     2507      $x
     2508      /information about other modes/d
     2509      /more detailed .*MODE/d
     2510      s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
     2511  fi
     2512  exit $?
     2513fi
    16342514
    16352515
     
    16442524
    16452525    # Handle -dlopen flags immediately.
    1646     for file in $execute_dlfiles; do
     2526    for file in $opt_dlopen; do
    16472527      test -f "$file" \
    16482528        || func_fatal_help "\`$file' is not a file"
     
    16512531      case $file in
    16522532      *.la)
     2533        func_resolve_sysroot "$file"
     2534        file=$func_resolve_sysroot_result
     2535
    16532536        # Check to see that this really is a libtool archive.
    16542537        func_lalib_unsafe_p "$file" \
     
    16722555
    16732556        if test -f "$dir/$objdir/$dlname"; then
    1674           dir="$dir/$objdir"
     2557          func_append dir "/$objdir"
    16752558        else
    16762559          if test ! -f "$dir/$dlname"; then
     
    17132596    do
    17142597      case $file in
    1715       -*) ;;
     2598      -* | *.la | *.lo ) ;;
    17162599      *)
    17172600        # Do a test to see if this is really a libtool program.
     
    17292612      esac
    17302613      # Quote arguments (to preserve shell metacharacters).
    1731       func_quote_for_eval "$file"
    1732       args="$args $func_quote_for_eval_result"
     2614      func_append_quoted args "$file"
    17332615    done
    17342616
     
    17552637      if test -n "$shlibpath_var"; then
    17562638        eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
    1757         $ECHO "export $shlibpath_var"
     2639        echo "export $shlibpath_var"
    17582640      fi
    17592641      $ECHO "$cmd$args"
     
    17622644}
    17632645
    1764 test "$mode" = execute && func_mode_execute ${1+"$@"}
     2646test "$opt_mode" = execute && func_mode_execute ${1+"$@"}
    17652647
    17662648
     
    17692651{
    17702652    $opt_debug
    1771     libdirs="$nonopt"
     2653    libs=
     2654    libdirs=
    17722655    admincmds=
    17732656
     2657    for opt in "$nonopt" ${1+"$@"}
     2658    do
     2659      if test -d "$opt"; then
     2660        func_append libdirs " $opt"
     2661
     2662      elif test -f "$opt"; then
     2663        if func_lalib_unsafe_p "$opt"; then
     2664          func_append libs " $opt"
     2665        else
     2666          func_warning "\`$opt' is not a valid libtool archive"
     2667        fi
     2668
     2669      else
     2670        func_fatal_error "invalid argument \`$opt'"
     2671      fi
     2672    done
     2673
     2674    if test -n "$libs"; then
     2675      if test -n "$lt_sysroot"; then
     2676        sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
     2677        sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
     2678      else
     2679        sysroot_cmd=
     2680      fi
     2681
     2682      # Remove sysroot references
     2683      if $opt_dry_run; then
     2684        for lib in $libs; do
     2685          echo "removing references to $lt_sysroot and \`=' prefixes from $lib"
     2686        done
     2687      else
     2688        tmpdir=`func_mktempdir`
     2689        for lib in $libs; do
     2690          sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
     2691            > $tmpdir/tmp-la
     2692          mv -f $tmpdir/tmp-la $lib
     2693        done
     2694        ${RM}r "$tmpdir"
     2695      fi
     2696    fi
     2697
    17742698    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
    1775       for dir
    1776       do
    1777         libdirs="$libdirs $dir"
    1778       done
    1779 
    17802699      for libdir in $libdirs; do
    17812700        if test -n "$finish_cmds"; then
     
    17872706          # Do the single finish_eval.
    17882707          eval cmds=\"$finish_eval\"
    1789           $opt_dry_run || eval "$cmds" || admincmds="$admincmds
     2708          $opt_dry_run || eval "$cmds" || func_append admincmds "
    17902709       $cmds"
    17912710        fi
     
    17962715    $opt_silent && exit $EXIT_SUCCESS
    17972716
    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"
     2717    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
     2718      echo "----------------------------------------------------------------------"
     2719      echo "Libraries have been installed in:"
     2720      for libdir in $libdirs; do
     2721        $ECHO "   $libdir"
     2722      done
     2723      echo
     2724      echo "If you ever happen to want to link against installed libraries"
     2725      echo "in a given directory, LIBDIR, you must either use libtool, and"
     2726      echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
     2727      echo "flag during linking and do at least one of the following:"
     2728      if test -n "$shlibpath_var"; then
     2729        echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
     2730        echo "     during execution"
     2731      fi
     2732      if test -n "$runpath_var"; then
     2733        echo "   - add LIBDIR to the \`$runpath_var' environment variable"
     2734        echo "     during linking"
     2735      fi
     2736      if test -n "$hardcode_libdir_flag_spec"; then
     2737        libdir=LIBDIR
     2738        eval flag=\"$hardcode_libdir_flag_spec\"
     2739
     2740        $ECHO "   - use the \`$flag' linker flag"
     2741      fi
     2742      if test -n "$admincmds"; then
     2743        $ECHO "   - have your system administrator run these commands:$admincmds"
     2744      fi
     2745      if test -f /etc/ld.so.conf; then
     2746        echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
     2747      fi
     2748      echo
     2749
     2750      echo "See any operating system documentation about shared libraries for"
     2751      case $host in
     2752        solaris2.[6789]|solaris2.1[0-9])
     2753          echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
     2754          echo "pages."
     2755          ;;
     2756        *)
     2757          echo "more information, such as the ld(1) and ld.so(8) manual pages."
     2758          ;;
     2759      esac
     2760      echo "----------------------------------------------------------------------"
    18112761    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
    18412762    exit $EXIT_SUCCESS
    18422763}
    18432764
    1844 test "$mode" = finish && func_mode_finish ${1+"$@"}
     2765test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
    18452766
    18462767
     
    18532774    if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
    18542775       # Allow the use of GNU shtool's install command.
    1855        $ECHO "X$nonopt" | $GREP shtool >/dev/null; then
     2776       case $nonopt in *shtool*) :;; *) false;; esac; then
    18562777      # Aesthetically quote it.
    18572778      func_quote_for_eval "$nonopt"
     
    18672788    # Aesthetically quote it.
    18682789    func_quote_for_eval "$arg"
    1869     install_prog="$install_prog$func_quote_for_eval_result"
     2790    func_append install_prog "$func_quote_for_eval_result"
     2791    install_shared_prog=$install_prog
     2792    case " $install_prog " in
     2793      *[\\\ /]cp\ *) install_cp=: ;;
     2794      *) install_cp=false ;;
     2795    esac
    18702796
    18712797    # We need to accept at least all the BSD install flags.
     
    18772803    isdir=no
    18782804    stripme=
     2805    no_mode=:
    18792806    for arg
    18802807    do
     2808      arg2=
    18812809      if test -n "$dest"; then
    1882         files="$files $dest"
     2810        func_append files " $dest"
    18832811        dest=$arg
    18842812        continue
     
    18882816      -d) isdir=yes ;;
    18892817      -f)
    1890         case " $install_prog " in
    1891         *[\\\ /]cp\ *) ;;
    1892         *) prev=$arg ;;
    1893         esac
     2818        if $install_cp; then :; else
     2819          prev=$arg
     2820        fi
    18942821        ;;
    18952822      -g | -m | -o)
     
    19052832        # If the previous option needed an argument, then skip it.
    19062833        if test -n "$prev"; then
     2834          if test "x$prev" = x-m && test -n "$install_override_mode"; then
     2835            arg2=$install_override_mode
     2836            no_mode=false
     2837          fi
    19072838          prev=
    19082839        else
     
    19152846      # Aesthetically quote the argument.
    19162847      func_quote_for_eval "$arg"
    1917       install_prog="$install_prog $func_quote_for_eval_result"
     2848      func_append install_prog " $func_quote_for_eval_result"
     2849      if test -n "$arg2"; then
     2850        func_quote_for_eval "$arg2"
     2851      fi
     2852      func_append install_shared_prog " $func_quote_for_eval_result"
    19182853    done
    19192854
     
    19232858    test -n "$prev" && \
    19242859      func_fatal_help "the \`$prev' option requires an argument"
     2860
     2861    if test -n "$install_override_mode" && $no_mode; then
     2862      if $install_cp; then :; else
     2863        func_quote_for_eval "$install_override_mode"
     2864        func_append install_shared_prog " -m $func_quote_for_eval_result"
     2865      fi
     2866    fi
    19252867
    19262868    if test -z "$files"; then
     
    19782920      *.$libext)
    19792921        # Do the static libraries later.
    1980         staticlibs="$staticlibs $file"
     2922        func_append staticlibs " $file"
    19812923        ;;
    19822924
    19832925      *.la)
     2926        func_resolve_sysroot "$file"
     2927        file=$func_resolve_sysroot_result
     2928
    19842929        # Check to see that this really is a libtool archive.
    19852930        func_lalib_unsafe_p "$file" \
     
    19952940          case "$current_libdirs " in
    19962941          *" $libdir "*) ;;
    1997           *) current_libdirs="$current_libdirs $libdir" ;;
     2942          *) func_append current_libdirs " $libdir" ;;
    19982943          esac
    19992944        else
     
    20012946          case "$future_libdirs " in
    20022947          *" $libdir "*) ;;
    2003           *) future_libdirs="$future_libdirs $libdir" ;;
     2948          *) func_append future_libdirs " $libdir" ;;
    20042949          esac
    20052950        fi
     
    20072952        func_dirname "$file" "/" ""
    20082953        dir="$func_dirname_result"
    2009         dir="$dir$objdir"
     2954        func_append dir "$objdir"
    20102955
    20112956        if test -n "$relink_command"; then
    20122957          # Determine the prefix the user has applied to our future dir.
    2013           inst_prefix_dir=`$ECHO "X$destdir" | $Xsed -e "s%$libdir\$%%"`
     2958          inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
    20142959
    20152960          # Don't allow the user to place us outside of our expected
     
    20242969          if test -n "$inst_prefix_dir"; then
    20252970            # 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%"`
     2971            relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
    20272972          else
    2028             relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%%"`
     2973            relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
    20292974          fi
    20302975
     
    20442989
    20452990          # Install the shared library and build the symlinks.
    2046           func_show_eval "$install_prog $dir/$srcname $destdir/$realname" \
     2991          func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
    20472992              'exit $?'
    20482993          tstripme="$stripme"
     
    20843029
    20853030        # Maybe install the static library, too.
    2086         test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
     3031        test -n "$old_library" && func_append staticlibs " $dir/$old_library"
    20873032        ;;
    20883033
     
    21843129              func_source "$lib"
    21853130            fi
    2186             libfile="$libdir/"`$ECHO "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
     3131            libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
    21873132            if test -n "$libdir" && test ! -f "$libfile"; then
    21883133              func_warning "\`$lib' has not been installed in \`$libdir'"
     
    22033148                outputname="$tmpdir/$file"
    22043149                # Replace the output file specification.
    2205                 relink_command=`$ECHO "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
     3150                relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
    22063151
    22073152                $opt_silent || {
     
    22223167          else
    22233168            # Install the binary that we compiled earlier.
    2224             file=`$ECHO "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
     3169            file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
    22253170          fi
    22263171        fi
     
    22583203      # Set up the ranlib parameters.
    22593204      oldlib="$destdir/$name"
     3205      func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
     3206      tool_oldlib=$func_to_tool_file_result
    22603207
    22613208      func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
    22623209
    22633210      if test -n "$stripme" && test -n "$old_striplib"; then
    2264         func_show_eval "$old_striplib $oldlib" 'exit $?'
     3211        func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
    22653212      fi
    22663213
     
    22813228}
    22823229
    2283 test "$mode" = install && func_mode_install ${1+"$@"}
     3230test "$opt_mode" = install && func_mode_install ${1+"$@"}
    22843231
    22853232
     
    23243271#endif
    23253272
     3273#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
     3274#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
     3275#endif
     3276
     3277/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
     3278#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
     3279/* DATA imports from DLLs on WIN32 con't be const, because runtime
     3280   relocations are performed -- see ld's documentation on pseudo-relocs.  */
     3281# define LT_DLSYM_CONST
     3282#elif defined(__osf__)
     3283/* This system does not cope well with relocations in const data.  */
     3284# define LT_DLSYM_CONST
     3285#else
     3286# define LT_DLSYM_CONST const
     3287#endif
     3288
    23263289/* External symbol declarations for the compiler. */\
    23273290"
     
    23333296
    23343297          # Add our own program objects to the symbol list.
    2335           progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
     3298          progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
    23363299          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'"
     3300            func_to_tool_file "$progfile" func_convert_file_msys_to_w32
     3301            func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"
     3302            $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
    23393303          done
    23403304
     
    23723336              eval '$MV "$nlist"T "$nlist"'
    23733337              case $host in
    2374                 *cygwin | *mingw* | *cegcc* )
     3338                *cygwin* | *mingw* | *cegcc* )
    23753339                  eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
    23763340                  eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
     
    23853349          func_basename "$dlprefile"
    23863350          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           }
     3351          case $host in
     3352            *cygwin* | *mingw* | *cegcc* )
     3353              # if an import library, we need to obtain dlname
     3354              if func_win32_import_lib_p "$dlprefile"; then
     3355                func_tr_sh "$dlprefile"
     3356                eval "curr_lafile=\$libfile_$func_tr_sh_result"
     3357                dlprefile_dlbasename=""
     3358                if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
     3359                  # Use subshell, to avoid clobbering current variable values
     3360                  dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
     3361                  if test -n "$dlprefile_dlname" ; then
     3362                    func_basename "$dlprefile_dlname"
     3363                    dlprefile_dlbasename="$func_basename_result"
     3364                  else
     3365                    # no lafile. user explicitly requested -dlpreopen <import library>.
     3366                    $sharedlib_from_linklib_cmd "$dlprefile"
     3367                    dlprefile_dlbasename=$sharedlib_from_linklib_result
     3368                  fi
     3369                fi
     3370                $opt_dry_run || {
     3371                  if test -n "$dlprefile_dlbasename" ; then
     3372                    eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
     3373                  else
     3374                    func_warning "Could not compute DLL name from $name"
     3375                    eval '$ECHO ": $name " >> "$nlist"'
     3376                  fi
     3377                  func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
     3378                  eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
     3379                    $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
     3380                }
     3381              else # not an import lib
     3382                $opt_dry_run || {
     3383                  eval '$ECHO ": $name " >> "$nlist"'
     3384                  func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
     3385                  eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
     3386                }
     3387              fi
     3388            ;;
     3389            *)
     3390              $opt_dry_run || {
     3391                eval '$ECHO ": $name " >> "$nlist"'
     3392                func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
     3393                eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
     3394              }
     3395            ;;
     3396          esac
    23913397        done
    23923398
     
    24163422            eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
    24173423          else
    2418             $ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms"
     3424            echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
    24193425          fi
    24203426
    2421           $ECHO >> "$output_objdir/$my_dlsyms" "\
     3427          echo >> "$output_objdir/$my_dlsyms" "\
    24223428
    24233429/* The mapping between symbol names and symbols.  */
     
    24263432  void *address;
    24273433} 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
     3434extern LT_DLSYM_CONST lt_dlsymlist
    24463435lt_${my_prefix}_LTX_preloaded_symbols[];
    2447 $lt_dlsym_const lt_dlsymlist
     3436LT_DLSYM_CONST lt_dlsymlist
    24483437lt_${my_prefix}_LTX_preloaded_symbols[] =
    24493438{\
     
    24583447            ;;
    24593448          esac
    2460           $ECHO >> "$output_objdir/$my_dlsyms" "\
     3449          echo >> "$output_objdir/$my_dlsyms" "\
    24613450  {0, (void *) 0}
    24623451};
     
    24853474          # pic_flag when linking with -static.  The problem exists in
    24863475          # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
    2487           *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
     3476          *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
    24883477            pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
    24893478          *-*-hpux*)
     
    25013490          case $arg in
    25023491          -pie | -fpie | -fPIE) ;;
    2503           *) symtab_cflags="$symtab_cflags $arg" ;;
     3492          *) func_append symtab_cflags " $arg" ;;
    25043493          esac
    25053494        done
     
    25163505        *cygwin* | *mingw* | *cegcc* )
    25173506          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%"`
     3507            compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
     3508            finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
    25203509          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%"`
     3510            compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
     3511            finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
    25233512          fi
    25243513          ;;
    25253514        *)
    2526           compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
    2527           finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
     3515          compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
     3516          finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
    25283517          ;;
    25293518        esac
     
    25393528
    25403529      # 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@%%"`
     3530      compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
     3531      finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
    25433532    fi
    25443533}
     
    25503539# Has to be a shell function in order to 'eat' the argument
    25513540# that is supplied when $file_magic_command is called.
     3541# Despite the name, also deal with 64 bit binaries.
    25523542func_win32_libid ()
    25533543{
     
    25603550    ;;
    25613551  *ar\ archive*) # could be an import, or static
     3552    # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
    25623553    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 |
     3554       $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
     3555      func_to_tool_file "$1" func_convert_file_msys_to_w32
     3556      win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
    25653557        $SED -n -e '
    25663558            1,100{
     
    25913583}
    25923584
     3585# func_cygming_dll_for_implib ARG
     3586#
     3587# Platform-specific function to extract the
     3588# name of the DLL associated with the specified
     3589# import library ARG.
     3590# Invoked by eval'ing the libtool variable
     3591#    $sharedlib_from_linklib_cmd
     3592# Result is available in the variable
     3593#    $sharedlib_from_linklib_result
     3594func_cygming_dll_for_implib ()
     3595{
     3596  $opt_debug
     3597  sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
     3598}
     3599
     3600# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
     3601#
     3602# The is the core of a fallback implementation of a
     3603# platform-specific function to extract the name of the
     3604# DLL associated with the specified import library LIBNAME.
     3605#
     3606# SECTION_NAME is either .idata$6 or .idata$7, depending
     3607# on the platform and compiler that created the implib.
     3608#
     3609# Echos the name of the DLL associated with the
     3610# specified import library.
     3611func_cygming_dll_for_implib_fallback_core ()
     3612{
     3613  $opt_debug
     3614  match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
     3615  $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
     3616    $SED '/^Contents of section '"$match_literal"':/{
     3617      # Place marker at beginning of archive member dllname section
     3618      s/.*/====MARK====/
     3619      p
     3620      d
     3621    }
     3622    # These lines can sometimes be longer than 43 characters, but
     3623    # are always uninteresting
     3624    /:[  ]*file format pe[i]\{,1\}-/d
     3625    /^In archive [^:]*:/d
     3626    # Ensure marker is printed
     3627    /^====MARK====/p
     3628    # Remove all lines with less than 43 characters
     3629    /^.\{43\}/!d
     3630    # From remaining lines, remove first 43 characters
     3631    s/^.\{43\}//' |
     3632    $SED -n '
     3633      # Join marker and all lines until next marker into a single line
     3634      /^====MARK====/ b para
     3635      H
     3636      $ b para
     3637      b
     3638      :para
     3639      x
     3640      s/\n//g
     3641      # Remove the marker
     3642      s/^====MARK====//
     3643      # Remove trailing dots and whitespace
     3644      s/[\. \t]*$//
     3645      # Print
     3646      /./p' |
     3647    # we now have a list, one entry per line, of the stringified
     3648    # contents of the appropriate section of all members of the
     3649    # archive which possess that section. Heuristic: eliminate
     3650    # all those which have a first or second character that is
     3651    # a '.' (that is, objdump's representation of an unprintable
     3652    # character.) This should work for all archives with less than
     3653    # 0x302f exports -- but will fail for DLLs whose name actually
     3654    # begins with a literal '.' or a single character followed by
     3655    # a '.'.
     3656    #
     3657    # Of those that remain, print the first one.
     3658    $SED -e '/^\./d;/^.\./d;q'
     3659}
     3660
     3661# func_cygming_gnu_implib_p ARG
     3662# This predicate returns with zero status (TRUE) if
     3663# ARG is a GNU/binutils-style import library. Returns
     3664# with nonzero status (FALSE) otherwise.
     3665func_cygming_gnu_implib_p ()
     3666{
     3667  $opt_debug
     3668  func_to_tool_file "$1" func_convert_file_msys_to_w32
     3669  func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'`
     3670  test -n "$func_cygming_gnu_implib_tmp"
     3671}
     3672
     3673# func_cygming_ms_implib_p ARG
     3674# This predicate returns with zero status (TRUE) if
     3675# ARG is an MS-style import library. Returns
     3676# with nonzero status (FALSE) otherwise.
     3677func_cygming_ms_implib_p ()
     3678{
     3679  $opt_debug
     3680  func_to_tool_file "$1" func_convert_file_msys_to_w32
     3681  func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
     3682  test -n "$func_cygming_ms_implib_tmp"
     3683}
     3684
     3685# func_cygming_dll_for_implib_fallback ARG
     3686# Platform-specific function to extract the
     3687# name of the DLL associated with the specified
     3688# import library ARG.
     3689#
     3690# This fallback implementation is for use when $DLLTOOL
     3691# does not support the --identify-strict option.
     3692# Invoked by eval'ing the libtool variable
     3693#    $sharedlib_from_linklib_cmd
     3694# Result is available in the variable
     3695#    $sharedlib_from_linklib_result
     3696func_cygming_dll_for_implib_fallback ()
     3697{
     3698  $opt_debug
     3699  if func_cygming_gnu_implib_p "$1" ; then
     3700    # binutils import library
     3701    sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
     3702  elif func_cygming_ms_implib_p "$1" ; then
     3703    # ms-generated import library
     3704    sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
     3705  else
     3706    # unknown
     3707    sharedlib_from_linklib_result=""
     3708  fi
     3709}
    25933710
    25943711
     
    25993716    f_ex_an_ar_dir="$1"; shift
    26003717    f_ex_an_ar_oldlib="$1"
    2601     func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" 'exit $?'
     3718    if test "$lock_old_archive_extraction" = yes; then
     3719      lockfile=$f_ex_an_ar_oldlib.lock
     3720      until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
     3721        func_echo "Waiting for $lockfile to be removed"
     3722        sleep 2
     3723      done
     3724    fi
     3725    func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
     3726                   'stat=$?; rm -f "$lockfile"; exit $stat'
     3727    if test "$lock_old_archive_extraction" = yes; then
     3728      $opt_dry_run || rm -f "$lockfile"
     3729    fi
    26023730    if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
    26033731     :
     
    26703798            darwin_files=
    26713799            for darwin_file in $darwin_filelist; do
    2672               darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
     3800              darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
    26733801              $LIPO -create -output "$darwin_file" $darwin_files
    26743802            done # $darwin_filelist
     
    26853813        ;;
    26863814      esac
    2687       my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
     3815      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
    26883816    done
    26893817
    26903818    func_extract_archives_result="$my_oldobjs"
    26913819}
    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
    29273820
    29283821
     
    29433836func_emit_wrapper ()
    29443837{
    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
     3838        func_emit_wrapper_arg1=${1-no}
     3839
     3840        $ECHO "\
     3841#! $SHELL
     3842
     3843# $output - temporary wrapper script for $objdir/$outputname
     3844# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
    29583845#
    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.
     3846# The $output program cannot be directly executed until all the libtool
     3847# libraries that it depends on are installed.
    29743848#
    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         ;;
     3849# This wrapper script should never be moved out of the build directory.
     3850# If it is, it will not operate correctly.
     3851
     3852# Sed substitution that helps us do robust quoting.  It backslashifies
     3853# metacharacters that are still active within double-quoted strings.
     3854sed_quote_subst='$sed_quote_subst'
     3855
     3856# Be Bourne compatible
     3857if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
     3858  emulate sh
     3859  NULLCMD=:
     3860  # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
     3861  # is contrary to our usage.  Disable this feature.
     3862  alias -g '\${1+\"\$@\"}'='\"\$@\"'
     3863  setopt NO_GLOB_SUBST
     3864else
     3865  case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
     3866fi
     3867BIN_SH=xpg4; export BIN_SH # for Tru64
     3868DUALCASE=1; export DUALCASE # for MKS sh
     3869
     3870# The HP-UX ksh and POSIX shell print the target directory to stdout
     3871# if CDPATH is set.
     3872(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
     3873
     3874relink_command=\"$relink_command\"
     3875
     3876# This environment variable determines our operation mode.
     3877if test \"\$libtool_install_magic\" = \"$magic\"; then
     3878  # install mode needs the following variables:
     3879  generated_by_libtool_version='$macro_version'
     3880  notinst_deplibs='$notinst_deplibs'
     3881else
     3882  # When we are sourced in execute mode, \$file and \$ECHO are already set.
     3883  if test \"\$libtool_execute_magic\" != \"$magic\"; then
     3884    file=\"\$0\""
     3885
     3886    qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
     3887    $ECHO "\
     3888
     3889# A function that is used when there is no print builtin or printf.
     3890func_fallback_echo ()
     3891{
     3892  eval 'cat <<_LTECHO_EOF
     3893\$1
     3894_LTECHO_EOF'
     3895}
     3896    ECHO=\"$qECHO\"
     3897  fi
     3898
     3899# Very basic option parsing. These options are (a) specific to
     3900# the libtool wrapper, (b) are identical between the wrapper
     3901# /script/ and the wrapper /executable/ which is used only on
     3902# windows platforms, and (c) all begin with the string "--lt-"
     3903# (application programs are unlikely to have options which match
     3904# this pattern).
     3905#
     3906# There are only two supported options: --lt-debug and
     3907# --lt-dump-script. There is, deliberately, no --lt-help.
     3908#
     3909# The first argument to this parsing function should be the
     3910# script's $0 value, followed by "$@".
     3911lt_option_debug=
     3912func_parse_lt_options ()
     3913{
     3914  lt_script_arg0=\$0
     3915  shift
     3916  for lt_opt
     3917  do
     3918    case \"\$lt_opt\" in
     3919    --lt-debug) lt_option_debug=1 ;;
     3920    --lt-dump-script)
     3921        lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
     3922        test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
     3923        lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
     3924        cat \"\$lt_dump_D/\$lt_dump_F\"
     3925        exit 0
     3926      ;;
     3927    --lt-*)
     3928        \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
     3929        exit 1
     3930      ;;
     3931    esac
     3932  done
     3933
     3934  # Print the debug banner immediately:
     3935  if test -n \"\$lt_option_debug\"; then
     3936    echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
     3937  fi
     3938}
     3939
     3940# Used when --lt-debug. Prints its arguments to stdout
     3941# (redirection is the responsibility of the caller)
     3942func_lt_dump_args ()
     3943{
     3944  lt_dump_args_N=1;
     3945  for lt_arg
     3946  do
     3947    \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
     3948    lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
     3949  done
     3950}
     3951
     3952# Core function for launching the target application
     3953func_exec_program_core ()
     3954{
     3955"
     3956  case $host in
     3957  # Backslashes separate directories on plain windows
     3958  *-*-mingw | *-*-os2* | *-cegcc*)
     3959    $ECHO "\
     3960      if test -n \"\$lt_option_debug\"; then
     3961        \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
     3962        func_lt_dump_args \${1+\"\$@\"} 1>&2
     3963      fi
     3964      exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
     3965"
     3966    ;;
     3967
     3968  *)
     3969    $ECHO "\
     3970      if test -n \"\$lt_option_debug\"; then
     3971        \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
     3972        func_lt_dump_args \${1+\"\$@\"} 1>&2
     3973      fi
     3974      exec \"\$progdir/\$program\" \${1+\"\$@\"}
     3975"
     3976    ;;
     3977  esac
     3978  $ECHO "\
     3979      \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
     3980      exit 1
     3981}
     3982
     3983# A function to encapsulate launching the target application
     3984# Strips options in the --lt-* namespace from \$@ and
     3985# launches target application with the remaining arguments.
     3986func_exec_program ()
     3987{
     3988  case \" \$* \" in
     3989  *\\ --lt-*)
     3990    for lt_wr_arg
     3991    do
     3992      case \$lt_wr_arg in
     3993      --lt-*) ;;
     3994      *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
     3995      esac
     3996      shift
     3997    done ;;
     3998  esac
     3999  func_exec_program_core \${1+\"\$@\"}
     4000}
     4001
     4002  # Parse options
     4003  func_parse_lt_options \"\$0\" \${1+\"\$@\"}
     4004
     4005  # Find the directory that this script lives in.
     4006  thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
     4007  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
     4008
     4009  # Follow symbolic links until we get to the real thisdir.
     4010  file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
     4011  while test -n \"\$file\"; do
     4012    destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
     4013
     4014    # If there was a directory component, then change thisdir.
     4015    if test \"x\$destdir\" != \"x\$file\"; then
     4016      case \"\$destdir\" in
     4017      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
     4018      *) thisdir=\"\$thisdir/\$destdir\" ;;
     4019      esac
     4020    fi
     4021
     4022    file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
     4023    file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
     4024  done
     4025
     4026  # Usually 'no', except on cygwin/mingw when embedded into
     4027  # the cwrapper.
     4028  WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
     4029  if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
     4030    # special case for '.'
     4031    if test \"\$thisdir\" = \".\"; then
     4032      thisdir=\`pwd\`
     4033    fi
     4034    # remove .libs from thisdir
     4035    case \"\$thisdir\" in
     4036    *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
     4037    $objdir )   thisdir=. ;;
    30254038    esac
    30264039  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
     4040
     4041  # Try to get the absolute directory name.
     4042  absdir=\`cd \"\$thisdir\" && pwd\`
     4043  test -n \"\$absdir\" && thisdir=\"\$absdir\"
     4044"
     4045
     4046        if test "$fast_install" = yes; then
     4047          $ECHO "\
     4048  program=lt-'$outputname'$exeext
     4049  progdir=\"\$thisdir/$objdir\"
     4050
     4051  if test ! -f \"\$progdir/\$program\" ||
     4052     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
     4053       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
     4054
     4055    file=\"\$\$-\$program\"
     4056
     4057    if test ! -d \"\$progdir\"; then
     4058      $MKDIR \"\$progdir\"
     4059    else
     4060      $RM \"\$progdir/\$file\"
     4061    fi"
     4062
     4063          $ECHO "\
     4064
     4065    # relink executable if necessary
     4066    if test -n \"\$relink_command\"; then
     4067      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
     4068      else
     4069        $ECHO \"\$relink_command_output\" >&2
     4070        $RM \"\$progdir/\$file\"
     4071        exit 1
     4072      fi
     4073    fi
     4074
     4075    $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
     4076    { $RM \"\$progdir/\$program\";
     4077      $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
     4078    $RM \"\$progdir/\$file\"
     4079  fi"
     4080        else
     4081          $ECHO "\
     4082  program='$outputname'
     4083  progdir=\"\$thisdir/$objdir\"
     4084"
     4085        fi
     4086
     4087        $ECHO "\
     4088
     4089  if test -f \"\$progdir/\$program\"; then"
     4090
     4091        # fixup the dll searchpath if we need to.
     4092        #
     4093        # Fix the DLL searchpath if we need to.  Do this before prepending
     4094        # to shlibpath, because on Windows, both are PATH and uninstalled
     4095        # libraries must come first.
     4096        if test -n "$dllsearchpath"; then
     4097          $ECHO "\
     4098    # Add the dll search path components to the executable PATH
     4099    PATH=$dllsearchpath:\$PATH
     4100"
     4101        fi
     4102
     4103        # Export our shlibpath_var if we have one.
     4104        if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
     4105          $ECHO "\
     4106    # Add our own library path to $shlibpath_var
     4107    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
     4108
     4109    # Some systems cannot cope with colon-terminated $shlibpath_var
     4110    # The second colon is a workaround for a bug in BeOS R4 sed
     4111    $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
     4112
     4113    export $shlibpath_var
     4114"
     4115        fi
     4116
     4117        $ECHO "\
     4118    if test \"\$libtool_execute_magic\" != \"$magic\"; then
     4119      # Run the actual program with our arguments.
     4120      func_exec_program \${1+\"\$@\"}
     4121    fi
     4122  else
     4123    # The program doesn't exist.
     4124    \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
     4125    \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
     4126    \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
     4127    exit 1
    31244128  fi
    3125 }
    3126 # end: func_to_host_pathlist
     4129fi\
     4130"
     4131}
     4132
    31274133
    31284134# func_emit_cwrapperexe_src
     
    31424148   This wrapper executable should never be moved out of the build directory.
    31434149   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.
    31484150*/
    31494151EOF
    31504152            cat <<"EOF"
     4153#ifdef _MSC_VER
     4154# define _CRT_SECURE_NO_DEPRECATE 1
     4155#endif
    31514156#include <stdio.h>
    31524157#include <stdlib.h>
     
    31554160# include <process.h>
    31564161# include <io.h>
    3157 # define setmode _setmode
    31584162#else
    31594163# include <unistd.h>
     
    31614165# ifdef __CYGWIN__
    31624166#  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
    31694167# endif
    31704168#endif
     
    31784176#include <sys/stat.h>
    31794177
     4178/* declarations of non-ANSI functions */
     4179#if defined(__MINGW32__)
     4180# ifdef __STRICT_ANSI__
     4181int _putenv (const char *);
     4182# endif
     4183#elif defined(__CYGWIN__)
     4184# ifdef __STRICT_ANSI__
     4185char *realpath (const char *, char *);
     4186int putenv (char *);
     4187int setenv (const char *, const char *, int);
     4188# endif
     4189/* #elif defined (other platforms) ... */
     4190#endif
     4191
     4192/* portability defines, excluding path handling macros */
     4193#if defined(_MSC_VER)
     4194# define setmode _setmode
     4195# define stat    _stat
     4196# define chmod   _chmod
     4197# define getcwd  _getcwd
     4198# define putenv  _putenv
     4199# define S_IXUSR _S_IEXEC
     4200# ifndef _INTPTR_T_DEFINED
     4201#  define _INTPTR_T_DEFINED
     4202#  define intptr_t int
     4203# endif
     4204#elif defined(__MINGW32__)
     4205# define setmode _setmode
     4206# define stat    _stat
     4207# define chmod   _chmod
     4208# define getcwd  _getcwd
     4209# define putenv  _putenv
     4210#elif defined(__CYGWIN__)
     4211# define HAVE_SETENV
     4212# define FOPEN_WB "wb"
     4213/* #elif defined (other platforms) ... */
     4214#endif
     4215
    31804216#if defined(PATH_MAX)
    31814217# define LT_PATHMAX PATH_MAX
     
    31934229#endif
    31944230
    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 
     4231/* path handling portability macros */
    32034232#ifndef DIR_SEPARATOR
    32044233# define DIR_SEPARATOR '/'
     
    32314260#endif /* PATH_SEPARATOR_2 */
    32324261
    3233 #ifdef __CYGWIN__
    3234 # define FOPEN_WB "wb"
    3235 #endif
    3236 
    32374262#ifndef FOPEN_WB
    32384263# define FOPEN_WB "w"
     
    32474272} while (0)
    32484273
    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 }
     4274#if defined(LT_DEBUGWRAPPER)
     4275static int lt_debug = 1;
    32604276#else
    3261 # define LTWRAPPER_DEBUGPRINTF(args)
     4277static int lt_debug = 0;
    32624278#endif
    32634279
    3264 const char *program_name = NULL;
     4280const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
    32654281
    32664282void *xmalloc (size_t num);
     
    32724288int check_executable (const char *path);
    32734289char *strendzap (char *str, const char *pat);
    3274 void lt_fatal (const char *message, ...);
     4290void lt_debugprintf (const char *file, int line, const char *fmt, ...);
     4291void lt_fatal (const char *file, int line, const char *message, ...);
     4292static const char *nonnull (const char *s);
     4293static const char *nonempty (const char *s);
    32754294void lt_setenv (const char *name, const char *value);
    32764295char *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);
    32814296void lt_update_exe_path (const char *name, const char *value);
    32824297void lt_update_lib_path (const char *name, const char *value);
    3283 
    3284 static const char *script_text_part1 =
     4298char **prepare_spawn (char **argv);
     4299void lt_dump_script (FILE *f);
    32854300EOF
    32864301
    3287             func_emit_wrapper_part1 yes |
    3288                 $SED -e 's/\([\\"]\)/\\\1/g' \
    3289                      -e 's/^/  "/' -e 's/$/\\n"/'
    3290             echo ";"
    32914302            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";
     4303volatile const char * MAGIC_EXE = "$magic_exe";
    33024304const char * LIB_PATH_VARNAME = "$shlibpath_var";
    33034305EOF
    33044306
    33054307            if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
    3306               func_to_host_pathlist "$temp_rpath"
     4308              func_to_host_path "$temp_rpath"
    33074309              cat <<EOF
    3308 const char * LIB_PATH_VALUE   = "$func_to_host_pathlist_result";
     4310const char * LIB_PATH_VALUE   = "$func_to_host_path_result";
    33094311EOF
    33104312            else
     
    33154317
    33164318            if test -n "$dllsearchpath"; then
    3317               func_to_host_pathlist "$dllsearchpath:"
     4319              func_to_host_path "$dllsearchpath:"
    33184320              cat <<EOF
    33194321const char * EXE_PATH_VARNAME = "PATH";
    3320 const char * EXE_PATH_VALUE   = "$func_to_host_pathlist_result";
     4322const char * EXE_PATH_VALUE   = "$func_to_host_path_result";
    33214323EOF
    33224324            else
     
    33414343
    33424344#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;
     4345
    33464346static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
    3347 
    33484347static 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 */
     4348static const char *debug_opt            = LTWRAPPER_OPTION_PREFIX "debug";
    33614349
    33624350int
     
    33754363
    33764364  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 */
     4365  newargz = XMALLOC (char *, argc + 1);
     4366
     4367  /* very simple arg parsing; don't want to rely on getopt
     4368   * also, copy all non cwrapper options to newargz, except
     4369   * argz[0], which is handled differently
     4370   */
     4371  newargc=0;
    33814372  for (i = 1; i < argc; i++)
    33824373    {
     
    33924383
    33934384            cat <<"EOF"
    3394           printf ("%s", script_text_part1);
    3395           printf ("%s", script_text_part2);
     4385          lt_dump_script (stdout);
    33964386          return 0;
    33974387        }
     4388      if (strcmp (argv[i], debug_opt) == 0)
     4389        {
     4390          lt_debug = 1;
     4391          continue;
     4392        }
     4393      if (strcmp (argv[i], ltwrapper_option_prefix) == 0)
     4394        {
     4395          /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
     4396             namespace, but it is not one of the ones we know about and
     4397             have already dealt with, above (inluding dump-script), then
     4398             report an error. Otherwise, targets might begin to believe
     4399             they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
     4400             namespace. The first time any user complains about this, we'll
     4401             need to make LTWRAPPER_OPTION_PREFIX a configure-time option
     4402             or a configure.ac-settable value.
     4403           */
     4404          lt_fatal (__FILE__, __LINE__,
     4405                    "unrecognized %s option: '%s'",
     4406                    ltwrapper_option_prefix, argv[i]);
     4407        }
     4408      /* otherwise ... */
     4409      newargz[++newargc] = xstrdup (argv[i]);
    33984410    }
    3399 
    3400   newargz = XMALLOC (char *, argc + 1);
     4411  newargz[++newargc] = NULL;
     4412
     4413EOF
     4414            cat <<EOF
     4415  /* The GNU banner must be the first non-error debug message */
     4416  lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");
     4417EOF
     4418            cat <<"EOF"
     4419  lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
     4420  lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
     4421
    34014422  tmp_pathspec = find_executable (argv[0]);
    34024423  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));
     4424    lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
     4425  lt_debugprintf (__FILE__, __LINE__,
     4426                  "(main) found exe (before symlink chase) at: %s\n",
     4427                  tmp_pathspec);
    34064428
    34074429  actual_cwrapper_path = chase_symlinks (tmp_pathspec);
    3408   LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",
    3409                           actual_cwrapper_path));
     4430  lt_debugprintf (__FILE__, __LINE__,
     4431                  "(main) found exe (after symlink chase) at: %s\n",
     4432                  actual_cwrapper_path);
    34104433  XFREE (tmp_pathspec);
    34114434
    3412   actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));
     4435  actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
    34134436  strendzap (actual_cwrapper_path, actual_cwrapper_name);
    34144437
     
    34284451  tmp_pathspec = 0;
    34294452
    3430   LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n",
    3431                           target_name));
     4453  lt_debugprintf (__FILE__, __LINE__,
     4454                  "(main) libtool target name: %s\n",
     4455                  target_name);
    34324456EOF
    34334457
     
    34794503  lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
    34804504  lt_setenv ("DUALCASE", "1");  /* for MSK sh */
     4505  /* Update the DLL searchpath.  EXE_PATH_VALUE ($dllsearchpath) must
     4506     be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
     4507     because on Windows, both *_VARNAMEs are PATH but uninstalled
     4508     libraries must come first. */
     4509  lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
    34814510  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>")));
     4511
     4512  lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
     4513                  nonnull (lt_argv_zero));
    35524514  for (i = 0; i < newargc; i++)
    35534515    {
    3554       LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d]   : %s\n", i, (newargz[i] ? newargz[i] : "<NULL>")));
     4516      lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
     4517                      i, nonnull (newargz[i]));
    35554518    }
    35564519
     
    35614524                cat <<"EOF"
    35624525  /* execv doesn't actually work on mingw as expected on unix */
     4526  newargz = prepare_spawn (newargz);
    35634527  rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
    35644528  if (rval == -1)
    35654529    {
    35664530      /* failed to start process */
    3567       LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno));
     4531      lt_debugprintf (__FILE__, __LINE__,
     4532                      "(main) failed to launch target \"%s\": %s\n",
     4533                      lt_argv_zero, nonnull (strerror (errno)));
    35684534      return 127;
    35694535    }
     
    35874553  void *p = (void *) malloc (num);
    35884554  if (!p)
    3589     lt_fatal ("Memory exhausted");
     4555    lt_fatal (__FILE__, __LINE__, "memory exhausted");
    35904556
    35914557  return p;
     
    36214587  struct stat st;
    36224588
    3623   LTWRAPPER_DEBUGPRINTF (("(check_executable)  : %s\n",
    3624                           path ? (*path ? path : "EMPTY!") : "NULL!"));
     4589  lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
     4590                  nonempty (path));
    36254591  if ((!path) || (!*path))
    36264592    return 0;
     
    36394605  struct stat st;
    36404606
    3641   LTWRAPPER_DEBUGPRINTF (("(make_executable)   : %s\n",
    3642                           path ? (*path ? path : "EMPTY!") : "NULL!"));
     4607  lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
     4608                  nonempty (path));
    36434609  if ((!path) || (!*path))
    36444610    return 0;
     
    36664632  char *concat_name;
    36674633
    3668   LTWRAPPER_DEBUGPRINTF (("(find_executable)   : %s\n",
    3669                           wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));
     4634  lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
     4635                  nonempty (wrapper));
    36704636
    36714637  if ((wrapper == NULL) || (*wrapper == '\0'))
     
    37204686                  /* empty path: current directory */
    37214687                  if (getcwd (tmp, LT_PATHMAX) == NULL)
    3722                     lt_fatal ("getcwd failed");
     4688                    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
     4689                              nonnull (strerror (errno)));
    37234690                  tmp_len = strlen (tmp);
    37244691                  concat_name =
     
    37454712  /* Relative path | not found in path: prepend cwd */
    37464713  if (getcwd (tmp, LT_PATHMAX) == NULL)
    3747     lt_fatal ("getcwd failed");
     4714    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
     4715              nonnull (strerror (errno)));
    37484716  tmp_len = strlen (tmp);
    37494717  concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
     
    37714739  while (strlen (tmp_pathspec) && !has_symlinks)
    37724740    {
    3773       LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",
    3774                               tmp_pathspec));
     4741      lt_debugprintf (__FILE__, __LINE__,
     4742                      "checking path component for symlinks: %s\n",
     4743                      tmp_pathspec);
    37754744      if (lstat (tmp_pathspec, &s) == 0)
    37764745        {
     
    37944763      else
    37954764        {
    3796           char *errstr = strerror (errno);
    3797           lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);
     4765          lt_fatal (__FILE__, __LINE__,
     4766                    "error accessing file \"%s\": %s",
     4767                    tmp_pathspec, nonnull (strerror (errno)));
    37984768        }
    37994769    }
     
    38084778  if (tmp_pathspec == 0)
    38094779    {
    3810       lt_fatal ("Could not follow symlinks for %s", pathspec);
     4780      lt_fatal (__FILE__, __LINE__,
     4781                "could not follow symlinks for %s", pathspec);
    38114782    }
    38124783  return xstrdup (tmp_pathspec);
     
    38344805}
    38354806
     4807void
     4808lt_debugprintf (const char *file, int line, const char *fmt, ...)
     4809{
     4810  va_list args;
     4811  if (lt_debug)
     4812    {
     4813      (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
     4814      va_start (args, fmt);
     4815      (void) vfprintf (stderr, fmt, args);
     4816      va_end (args);
     4817    }
     4818}
     4819
    38364820static void
    3837 lt_error_core (int exit_status, const char *mode,
     4821lt_error_core (int exit_status, const char *file,
     4822               int line, const char *mode,
    38384823               const char *message, va_list ap)
    38394824{
    3840   fprintf (stderr, "%s: %s: ", program_name, mode);
     4825  fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
    38414826  vfprintf (stderr, message, ap);
    38424827  fprintf (stderr, ".\n");
     
    38474832
    38484833void
    3849 lt_fatal (const char *message, ...)
     4834lt_fatal (const char *file, int line, const char *message, ...)
    38504835{
    38514836  va_list ap;
    38524837  va_start (ap, message);
    3853   lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
     4838  lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
    38544839  va_end (ap);
     4840}
     4841
     4842static const char *
     4843nonnull (const char *s)
     4844{
     4845  return s ? s : "(null)";
     4846}
     4847
     4848static const char *
     4849nonempty (const char *s)
     4850{
     4851  return (s && !*s) ? "(empty)" : nonnull (s);
    38554852}
    38564853
     
    38584855lt_setenv (const char *name, const char *value)
    38594856{
    3860   LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n",
    3861                           (name ? name : "<NULL>"),
    3862                           (value ? value : "<NULL>")));
     4857  lt_debugprintf (__FILE__, __LINE__,
     4858                  "(lt_setenv) setting '%s' to '%s'\n",
     4859                  nonnull (name), nonnull (value));
    38634860  {
    38644861#ifdef HAVE_SETENV
     
    39054902}
    39064903
    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 
    39904904void
    39914905lt_update_exe_path (const char *name, const char *value)
    39924906{
    3993   LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
    3994                           (name ? name : "<NULL>"),
    3995                           (value ? value : "<NULL>")));
     4907  lt_debugprintf (__FILE__, __LINE__,
     4908                  "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
     4909                  nonnull (name), nonnull (value));
    39964910
    39974911  if (name && *name && value && *value)
     
    40124926lt_update_lib_path (const char *name, const char *value)
    40134927{
    4014   LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
    4015                           (name ? name : "<NULL>"),
    4016                           (value ? value : "<NULL>")));
     4928  lt_debugprintf (__FILE__, __LINE__,
     4929                  "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
     4930                  nonnull (name), nonnull (value));
    40174931
    40184932  if (name && *name && value && *value)
     
    40244938}
    40254939
    4026 
    40274940EOF
     4941            case $host_os in
     4942              mingw*)
     4943                cat <<"EOF"
     4944
     4945/* Prepares an argument vector before calling spawn().
     4946   Note that spawn() does not by itself call the command interpreter
     4947     (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
     4948      ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
     4949         GetVersionEx(&v);
     4950         v.dwPlatformId == VER_PLATFORM_WIN32_NT;
     4951      }) ? "cmd.exe" : "command.com").
     4952   Instead it simply concatenates the arguments, separated by ' ', and calls
     4953   CreateProcess().  We must quote the arguments since Win32 CreateProcess()
     4954   interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
     4955   special way:
     4956   - Space and tab are interpreted as delimiters. They are not treated as
     4957     delimiters if they are surrounded by double quotes: "...".
     4958   - Unescaped double quotes are removed from the input. Their only effect is
     4959     that within double quotes, space and tab are treated like normal
     4960     characters.
     4961   - Backslashes not followed by double quotes are not special.
     4962   - But 2*n+1 backslashes followed by a double quote become
     4963     n backslashes followed by a double quote (n >= 0):
     4964       \" -> "
     4965       \\\" -> \"
     4966       \\\\\" -> \\"
     4967 */
     4968#define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
     4969#define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
     4970char **
     4971prepare_spawn (char **argv)
     4972{
     4973  size_t argc;
     4974  char **new_argv;
     4975  size_t i;
     4976
     4977  /* Count number of arguments.  */
     4978  for (argc = 0; argv[argc] != NULL; argc++)
     4979    ;
     4980
     4981  /* Allocate new argument vector.  */
     4982  new_argv = XMALLOC (char *, argc + 1);
     4983
     4984  /* Put quoted arguments into the new argument vector.  */
     4985  for (i = 0; i < argc; i++)
     4986    {
     4987      const char *string = argv[i];
     4988
     4989      if (string[0] == '\0')
     4990        new_argv[i] = xstrdup ("\"\"");
     4991      else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
     4992        {
     4993          int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
     4994          size_t length;
     4995          unsigned int backslashes;
     4996          const char *s;
     4997          char *quoted_string;
     4998          char *p;
     4999
     5000          length = 0;
     5001          backslashes = 0;
     5002          if (quote_around)
     5003            length++;
     5004          for (s = string; *s != '\0'; s++)
     5005            {
     5006              char c = *s;
     5007              if (c == '"')
     5008                length += backslashes + 1;
     5009              length++;
     5010              if (c == '\\')
     5011                backslashes++;
     5012              else
     5013                backslashes = 0;
     5014            }
     5015          if (quote_around)
     5016            length += backslashes + 1;
     5017
     5018          quoted_string = XMALLOC (char, length + 1);
     5019
     5020          p = quoted_string;
     5021          backslashes = 0;
     5022          if (quote_around)
     5023            *p++ = '"';
     5024          for (s = string; *s != '\0'; s++)
     5025            {
     5026              char c = *s;
     5027              if (c == '"')
     5028                {
     5029                  unsigned int j;
     5030                  for (j = backslashes + 1; j > 0; j--)
     5031                    *p++ = '\\';
     5032                }
     5033              *p++ = c;
     5034              if (c == '\\')
     5035                backslashes++;
     5036              else
     5037                backslashes = 0;
     5038            }
     5039          if (quote_around)
     5040            {
     5041              unsigned int j;
     5042              for (j = backslashes; j > 0; j--)
     5043                *p++ = '\\';
     5044              *p++ = '"';
     5045            }
     5046          *p = '\0';
     5047
     5048          new_argv[i] = quoted_string;
     5049        }
     5050      else
     5051        new_argv[i] = (char *) string;
     5052    }
     5053  new_argv[argc] = NULL;
     5054
     5055  return new_argv;
     5056}
     5057EOF
     5058                ;;
     5059            esac
     5060
     5061            cat <<"EOF"
     5062void lt_dump_script (FILE* f)
     5063{
     5064EOF
     5065            func_emit_wrapper yes |
     5066              $SED -n -e '
     5067s/^\(.\{79\}\)\(..*\)/\1\
     5068\2/
     5069h
     5070s/\([\\"]\)/\\\1/g
     5071s/$/\\n/
     5072s/\([^\n]*\).*/  fputs ("\1", f);/p
     5073g
     5074D'
     5075            cat <<"EOF"
     5076}
     5077EOF
    40285078}
    40295079# end: func_emit_cwrapperexe_src
     5080
     5081# func_win32_import_lib_p ARG
     5082# True if ARG is an import lib, as indicated by $file_magic_cmd
     5083func_win32_import_lib_p ()
     5084{
     5085    $opt_debug
     5086    case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
     5087    *import*) : ;;
     5088    *) false ;;
     5089    esac
     5090}
    40305091
    40315092# func_mode_link arg...
     
    40735134
    40745135    avoid_version=no
     5136    bindir=
    40755137    dlfiles=
    40765138    dlprefiles=
     
    41655227
    41665228        case $prev in
     5229        bindir)
     5230          bindir="$arg"
     5231          prev=
     5232          continue
     5233          ;;
    41675234        dlfiles|dlprefiles)
    41685235          if test "$preload" = no; then
     
    41965263          *)
    41975264            if test "$prev" = dlfiles; then
    4198               dlfiles="$dlfiles $arg"
     5265              func_append dlfiles " $arg"
    41995266            else
    4200               dlprefiles="$dlprefiles $arg"
     5267              func_append dlprefiles " $arg"
    42015268            fi
    42025269            prev=
     
    42225289              case "$deplibs " in
    42235290                *" $qarg.ltframework "*) ;;
    4224                 *) deplibs="$deplibs $qarg.ltframework" # this is fixed later
     5291                *) func_append deplibs " $qarg.ltframework" # this is fixed later
    42255292                   ;;
    42265293              esac
     
    42415308            for fil in `cat "$save_arg"`
    42425309            do
    4243 #             moreargs="$moreargs $fil"
     5310#             func_append moreargs " $fil"
    42445311              arg=$fil
    42455312              # A libtool-controlled object.
     
    42705337                  if test "$prev" = dlfiles; then
    42715338                    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
    4272                       dlfiles="$dlfiles $pic_object"
     5339                      func_append dlfiles " $pic_object"
    42735340                      prev=
    42745341                      continue
     
    42825349                  if test "$prev" = dlprefiles; then
    42835350                    # Preload the old-style object.
    4284                     dlprefiles="$dlprefiles $pic_object"
     5351                    func_append dlprefiles " $pic_object"
    42855352                    prev=
    42865353                  fi
     
    43525419            case "$rpath " in
    43535420            *" $arg "*) ;;
    4354             *) rpath="$rpath $arg" ;;
     5421            *) func_append rpath " $arg" ;;
    43555422            esac
    43565423          else
    43575424            case "$xrpath " in
    43585425            *" $arg "*) ;;
    4359             *) xrpath="$xrpath $arg" ;;
     5426            *) func_append xrpath " $arg" ;;
    43605427            esac
    43615428          fi
     
    43695436          ;;
    43705437        weak)
    4371           weak_libs="$weak_libs $arg"
     5438          func_append weak_libs " $arg"
    43725439          prev=
    43735440          continue
    43745441          ;;
    43755442        xcclinker)
    4376           linker_flags="$linker_flags $qarg"
    4377           compiler_flags="$compiler_flags $qarg"
     5443          func_append linker_flags " $qarg"
     5444          func_append compiler_flags " $qarg"
    43785445          prev=
    43795446          func_append compile_command " $qarg"
     
    43825449          ;;
    43835450        xcompiler)
    4384           compiler_flags="$compiler_flags $qarg"
     5451          func_append compiler_flags " $qarg"
    43855452          prev=
    43865453          func_append compile_command " $qarg"
     
    43895456          ;;
    43905457        xlinker)
    4391           linker_flags="$linker_flags $qarg"
    4392           compiler_flags="$compiler_flags $wl$qarg"
     5458          func_append linker_flags " $qarg"
     5459          func_append compiler_flags " $wl$qarg"
    43935460          prev=
    43945461          func_append compile_command " $wl$qarg"
     
    44265493        ;;
    44275494
     5495      -bindir)
     5496        prev=bindir
     5497        continue
     5498        ;;
     5499
    44285500      -dlopen)
    44295501        prev=dlfiles
     
    44765548
    44775549      -L*)
    4478         func_stripname '-L' '' "$arg"
    4479         dir=$func_stripname_result
    4480         if test -z "$dir"; then
     5550        func_stripname "-L" '' "$arg"
     5551        if test -z "$func_stripname_result"; then
    44815552          if test "$#" -gt 0; then
    44825553            func_fatal_error "require no space between \`-L' and \`$1'"
     
    44855556          fi
    44865557        fi
     5558        func_resolve_sysroot "$func_stripname_result"
     5559        dir=$func_resolve_sysroot_result
    44875560        # We need an absolute path.
    44885561        case $dir in
     
    44965569        esac
    44975570        case "$deplibs " in
    4498         *" -L$dir "*) ;;
     5571        *" -L$dir "* | *" $arg "*)
     5572          # Will only happen for absolute or sysroot arguments
     5573          ;;
    44995574        *)
    4500           deplibs="$deplibs -L$dir"
    4501           lib_search_path="$lib_search_path $dir"
     5575          # Preserve sysroot, but never include relative directories
     5576          case $dir in
     5577            [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
     5578            *) func_append deplibs " -L$dir" ;;
     5579          esac
     5580          func_append lib_search_path " $dir"
    45025581          ;;
    45035582        esac
    45045583        case $host in
    45055584        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
    4506           testbindir=`$ECHO "X$dir" | $Xsed -e 's*/lib$*/bin*'`
     5585          testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
    45075586          case :$dllsearchpath: in
    45085587          *":$dir:"*) ;;
    45095588          ::) dllsearchpath=$dir;;
    4510           *) dllsearchpath="$dllsearchpath:$dir";;
     5589          *) func_append dllsearchpath ":$dir";;
    45115590          esac
    45125591          case :$dllsearchpath: in
    45135592          *":$testbindir:"*) ;;
    45145593          ::) dllsearchpath=$testbindir;;
    4515           *) dllsearchpath="$dllsearchpath:$testbindir";;
     5594          *) func_append dllsearchpath ":$testbindir";;
    45165595          esac
    45175596          ;;
     
    45235602        if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
    45245603          case $host in
    4525           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc*)
     5604          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
    45265605            # These systems don't actually have a C or math library (as such)
    45275606            continue
     
    45375616          *-*-rhapsody* | *-*-darwin1.[012])
    45385617            # Rhapsody C and math libraries are in the System framework
    4539             deplibs="$deplibs System.ltframework"
     5618            func_append deplibs " System.ltframework"
    45405619            continue
    45415620            ;;
     
    45575636         esac
    45585637        fi
    4559         deplibs="$deplibs $arg"
     5638        func_append deplibs " $arg"
    45605639        continue
    45615640        ;;
     
    45695648      # classes, name mangling, and exception handling.
    45705649      # Darwin uses the -arch flag to determine output architecture.
    4571       -model|-arch|-isysroot)
    4572         compiler_flags="$compiler_flags $arg"
     5650      -model|-arch|-isysroot|--sysroot)
     5651        func_append compiler_flags " $arg"
    45735652        func_append compile_command " $arg"
    45745653        func_append finalize_command " $arg"
     
    45775656        ;;
    45785657
    4579       -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
    4580         compiler_flags="$compiler_flags $arg"
     5658      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
     5659      |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
     5660        func_append compiler_flags " $arg"
    45815661        func_append compile_command " $arg"
    45825662        func_append finalize_command " $arg"
    45835663        case "$new_inherited_linker_flags " in
    45845664            *" $arg "*) ;;
    4585             * ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
     5665            * ) func_append new_inherited_linker_flags " $arg" ;;
    45865666        esac
    45875667        continue
     
    46505730        case $dir in
    46515731        [\\/]* | [A-Za-z]:[\\/]*) ;;
     5732        =*)
     5733          func_stripname '=' '' "$dir"
     5734          dir=$lt_sysroot$func_stripname_result
     5735          ;;
    46525736        *)
    46535737          func_fatal_error "only absolute run-paths are allowed"
     
    46565740        case "$xrpath " in
    46575741        *" $dir "*) ;;
    4658         *) xrpath="$xrpath $dir" ;;
     5742        *) func_append xrpath " $dir" ;;
    46595743        esac
    46605744        continue
     
    47095793          IFS="$save_ifs"
    47105794          func_quote_for_eval "$flag"
    4711           arg="$arg $wl$func_quote_for_eval_result"
    4712           compiler_flags="$compiler_flags $func_quote_for_eval_result"
     5795          func_append arg " $func_quote_for_eval_result"
     5796          func_append compiler_flags " $func_quote_for_eval_result"
    47135797        done
    47145798        IFS="$save_ifs"
     
    47255809          IFS="$save_ifs"
    47265810          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"
     5811          func_append arg " $wl$func_quote_for_eval_result"
     5812          func_append compiler_flags " $wl$func_quote_for_eval_result"
     5813          func_append linker_flags " $func_quote_for_eval_result"
    47305814        done
    47315815        IFS="$save_ifs"
     
    47555839        ;;
    47565840
    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
     5841      # Flags to be passed through unchanged, with rationale:
     5842      # -64, -mips[0-9]      enable 64-bit mode for the SGI compiler
     5843      # -r[0-9][0-9]*        specify processor for the SGI compiler
     5844      # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
     5845      # +DA*, +DD*           enable 64-bit mode for the HP compiler
     5846      # -q*                  compiler args for the IBM compiler
     5847      # -m*, -t[45]*, -txscale* architecture-specific flags for GCC
     5848      # -F/path              path to uninstalled frameworks, gcc on darwin
     5849      # -p, -pg, --coverage, -fprofile-*  profiling flags for GCC
     5850      # @file                GCC response files
     5851      # -tp=*                Portland pgcc target processor selection
     5852      # --sysroot=*          for sysroot support
     5853      # -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
    47675854      -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
    4768       -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
     5855      -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
     5856      -O*|-flto*|-fwhopr*|-fuse-linker-plugin)
    47695857        func_quote_for_eval "$arg"
    47705858        arg="$func_quote_for_eval_result"
    47715859        func_append compile_command " $arg"
    47725860        func_append finalize_command " $arg"
    4773         compiler_flags="$compiler_flags $arg"
     5861        func_append compiler_flags " $arg"
    47745862        continue
    47755863        ;;
     
    47835871      *.$objext)
    47845872        # A standard object.
    4785         objs="$objs $arg"
     5873        func_append objs " $arg"
    47865874        ;;
    47875875
     
    48145902            if test "$prev" = dlfiles; then
    48155903              if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
    4816                 dlfiles="$dlfiles $pic_object"
     5904                func_append dlfiles " $pic_object"
    48175905                prev=
    48185906                continue
     
    48265914            if test "$prev" = dlprefiles; then
    48275915              # Preload the old-style object.
    4828               dlprefiles="$dlprefiles $pic_object"
     5916              func_append dlprefiles " $pic_object"
    48295917              prev=
    48305918            fi
     
    48715959      *.$libext)
    48725960        # An archive.
    4873         deplibs="$deplibs $arg"
    4874         old_deplibs="$old_deplibs $arg"
     5961        func_append deplibs " $arg"
     5962        func_append old_deplibs " $arg"
    48755963        continue
    48765964        ;;
     
    48795967        # A libtool-controlled library.
    48805968
     5969        func_resolve_sysroot "$arg"
    48815970        if test "$prev" = dlfiles; then
    48825971          # This library was specified with -dlopen.
    4883           dlfiles="$dlfiles $arg"
     5972          func_append dlfiles " $func_resolve_sysroot_result"
    48845973          prev=
    48855974        elif test "$prev" = dlprefiles; then
    48865975          # The library was specified with -dlpreopen.
    4887           dlprefiles="$dlprefiles $arg"
     5976          func_append dlprefiles " $func_resolve_sysroot_result"
    48885977          prev=
    48895978        else
    4890           deplibs="$deplibs $arg"
     5979          func_append deplibs " $func_resolve_sysroot_result"
    48915980        fi
    48925981        continue
     
    49266015    if test -n "$shlibpath_var"; then
    49276016      # get the directories listed in $shlibpath_var
    4928       eval shlib_search_path=\`\$ECHO \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
     6017      eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
    49296018    else
    49306019      shlib_search_path=
     
    49356024    func_dirname "$output" "/" ""
    49366025    output_objdir="$func_dirname_result$objdir"
     6026    func_to_tool_file "$output_objdir/"
     6027    tool_output_objdir=$func_to_tool_file_result
    49376028    # Create the object directory.
    49386029    func_mkdir_p "$output_objdir"
     
    49556046    # that are linked more than once (e.g. -la -lb -la)
    49566047    for deplib in $deplibs; do
    4957       if $opt_duplicate_deps ; then
     6048      if $opt_preserve_dup_deps ; then
    49586049        case "$libs " in
    4959         *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
     6050        *" $deplib "*) func_append specialdeplibs " $deplib" ;;
    49606051        esac
    49616052      fi
    4962       libs="$libs $deplib"
     6053      func_append libs " $deplib"
    49636054    done
    49646055
     
    49736064        for pre_post_dep in $predeps $postdeps; do
    49746065          case "$pre_post_deps " in
    4975           *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
     6066          *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
    49766067          esac
    4977           pre_post_deps="$pre_post_deps $pre_post_dep"
     6068          func_append pre_post_deps " $pre_post_dep"
    49786069        done
    49796070      fi
     
    50456136          # Ignore non-libtool-libs
    50466137          dependency_libs=
     6138          func_resolve_sysroot "$lib"
    50476139          case $lib in
    5048           *.la) func_source "$lib" ;;
     6140          *.la) func_source "$func_resolve_sysroot_result" ;;
    50496141          esac
    50506142
     
    50526144          # has declared as weak libs
    50536145          for deplib in $dependency_libs; do
    5054             deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`
     6146            func_basename "$deplib"
     6147            deplib_base=$func_basename_result
    50556148            case " $weak_libs " in
    50566149            *" $deplib_base "*) ;;
    5057             *) deplibs="$deplibs $deplib" ;;
     6150            *) func_append deplibs " $deplib" ;;
    50586151            esac
    50596152          done
     
    50716164        found=no
    50726165        case $deplib in
    5073         -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
     6166        -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
     6167        |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
    50746168          if test "$linkmode,$pass" = "prog,link"; then
    50756169            compile_deplibs="$deplib $compile_deplibs"
    50766170            finalize_deplibs="$deplib $finalize_deplibs"
    50776171          else
    5078             compiler_flags="$compiler_flags $deplib"
     6172            func_append compiler_flags " $deplib"
    50796173            if test "$linkmode" = lib ; then
    50806174                case "$new_inherited_linker_flags " in
    50816175                    *" $deplib "*) ;;
    5082                     * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
     6176                    * ) func_append new_inherited_linker_flags " $deplib" ;;
    50836177                esac
    50846178            fi
     
    51656259                case "$new_inherited_linker_flags " in
    51666260                    *" $deplib "*) ;;
    5167                     * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
     6261                    * ) func_append new_inherited_linker_flags " $deplib" ;;
    51686262                esac
    51696263            fi
     
    51786272            newdependency_libs="$deplib $newdependency_libs"
    51796273            func_stripname '-L' '' "$deplib"
    5180             newlib_search_path="$newlib_search_path $func_stripname_result"
     6274            func_resolve_sysroot "$func_stripname_result"
     6275            func_append newlib_search_path " $func_resolve_sysroot_result"
    51816276            ;;
    51826277          prog)
     
    51926287            fi
    51936288            func_stripname '-L' '' "$deplib"
    5194             newlib_search_path="$newlib_search_path $func_stripname_result"
     6289            func_resolve_sysroot "$func_stripname_result"
     6290            func_append newlib_search_path " $func_resolve_sysroot_result"
    51956291            ;;
    51966292          *)
     
    52036299          if test "$pass" = link; then
    52046300            func_stripname '-R' '' "$deplib"
    5205             dir=$func_stripname_result
     6301            func_resolve_sysroot "$func_stripname_result"
     6302            dir=$func_resolve_sysroot_result
    52066303            # Make sure the xrpath contains only unique directories.
    52076304            case "$xrpath " in
    52086305            *" $dir "*) ;;
    5209             *) xrpath="$xrpath $dir" ;;
     6306            *) func_append xrpath " $dir" ;;
    52106307            esac
    52116308          fi
     
    52136310          continue
    52146311          ;;
    5215         *.la) lib="$deplib" ;;
     6312        *.la)
     6313          func_resolve_sysroot "$deplib"
     6314          lib=$func_resolve_sysroot_result
     6315          ;;
    52166316        *.$libext)
    52176317          if test "$pass" = conv; then
     
    52316331                  set dummy $deplibs_check_method; shift
    52326332                  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
    5233                   if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \
     6333                  if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
    52346334                    | $EGREP "$match_pattern_regex" > /dev/null; then
    52356335                    valid_a_lib=yes
     
    52416341              esac
    52426342              if test "$valid_a_lib" != yes; then
    5243                 $ECHO
     6343                echo
    52446344                $ECHO "*** Warning: Trying to link with static lib archive $deplib."
    5245                 $ECHO "*** I have the capability to make that library automatically link in when"
    5246                 $ECHO "*** you link to this library.  But I can only do this if you have a"
    5247                 $ECHO "*** shared version of the library, which you do not appear to have"
    5248                 $ECHO "*** because the file extensions .$libext of this argument makes me believe"
    5249                 $ECHO "*** that it is just a static archive that I should not use here."
     6345                echo "*** I have the capability to make that library automatically link in when"
     6346                echo "*** you link to this library.  But I can only do this if you have a"
     6347                echo "*** shared version of the library, which you do not appear to have"
     6348                echo "*** because the file extensions .$libext of this argument makes me believe"
     6349                echo "*** that it is just a static archive that I should not use here."
    52506350              else
    5251                 $ECHO
     6351                echo
    52526352                $ECHO "*** Warning: Linking the shared library $output against the"
    52536353                $ECHO "*** static library $deplib is not portable!"
     
    52766376              # If there is no dlopen support or we're linking statically,
    52776377              # we need to preload.
    5278               newdlprefiles="$newdlprefiles $deplib"
     6378              func_append newdlprefiles " $deplib"
    52796379              compile_deplibs="$deplib $compile_deplibs"
    52806380              finalize_deplibs="$deplib $finalize_deplibs"
    52816381            else
    5282               newdlfiles="$newdlfiles $deplib"
     6382              func_append newdlfiles " $deplib"
    52836383            fi
    52846384          fi
     
    53226422        # Convert "-framework foo" to "foo.ltframework"
    53236423        if test -n "$inherited_linker_flags"; then
    5324           tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework \([^ $]*\)/\1.ltframework/g'`
     6424          tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
    53256425          for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
    53266426            case " $new_inherited_linker_flags " in
    53276427              *" $tmp_inherited_linker_flag "*) ;;
    5328               *) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
     6428              *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
    53296429            esac
    53306430          done
    53316431        fi
    5332         dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
     6432        dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
    53336433        if test "$linkmode,$pass" = "lib,link" ||
    53346434           test "$linkmode,$pass" = "prog,scan" ||
    53356435           { test "$linkmode" != prog && test "$linkmode" != lib; }; then
    5336           test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
    5337           test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
     6436          test -n "$dlopen" && func_append dlfiles " $dlopen"
     6437          test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
    53386438        fi
    53396439
     
    53466446            fi
    53476447            # It is a libtool convenience library, so add in its objects.
    5348             convenience="$convenience $ladir/$objdir/$old_library"
    5349             old_convenience="$old_convenience $ladir/$objdir/$old_library"
     6448            func_append convenience " $ladir/$objdir/$old_library"
     6449            func_append old_convenience " $ladir/$objdir/$old_library"
    53506450            tmp_libs=
    53516451            for deplib in $dependency_libs; do
    53526452              deplibs="$deplib $deplibs"
    5353               if $opt_duplicate_deps ; then
     6453              if $opt_preserve_dup_deps ; then
    53546454                case "$tmp_libs " in
    5355                 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
     6455                *" $deplib "*) func_append specialdeplibs " $deplib" ;;
    53566456                esac
    53576457              fi
    5358               tmp_libs="$tmp_libs $deplib"
     6458              func_append tmp_libs " $deplib"
    53596459            done
    53606460          elif test "$linkmode" != prog && test "$linkmode" != lib; then
     
    53676467        # Get the name of the library we link against.
    53686468        linklib=
    5369         for l in $old_library $library_names; do
    5370           linklib="$l"
    5371         done
     6469        if test -n "$old_library" &&
     6470           { test "$prefer_static_libs" = yes ||
     6471             test "$prefer_static_libs,$installed" = "built,no"; }; then
     6472          linklib=$old_library
     6473        else
     6474          for l in $old_library $library_names; do
     6475            linklib="$l"
     6476          done
     6477        fi
    53726478        if test -z "$linklib"; then
    53736479          func_fatal_error "cannot find name of link library for \`$lib'"
     
    53866492            # dependent libraries so libltdl's deplib preloader doesn't
    53876493            # bomb out in the load deplibs phase.
    5388             dlprefiles="$dlprefiles $lib $dependency_libs"
     6494            func_append dlprefiles " $lib $dependency_libs"
    53896495          else
    5390             newdlfiles="$newdlfiles $lib"
     6496            func_append newdlfiles " $lib"
    53916497          fi
    53926498          continue
     
    54106516        # Find the relevant object directory and library name.
    54116517        if test "X$installed" = Xyes; then
    5412           if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
     6518          if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
    54136519            func_warning "library \`$lib' was moved."
    54146520            dir="$ladir"
     
    54166522            libdir="$abs_ladir"
    54176523          else
    5418             dir="$libdir"
    5419             absdir="$libdir"
     6524            dir="$lt_sysroot$libdir"
     6525            absdir="$lt_sysroot$libdir"
    54206526          fi
    54216527          test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
     
    54256531            absdir="$abs_ladir"
    54266532            # Remove this search path later
    5427             notinst_path="$notinst_path $abs_ladir"
     6533            func_append notinst_path " $abs_ladir"
    54286534          else
    54296535            dir="$ladir/$objdir"
    54306536            absdir="$abs_ladir/$objdir"
    54316537            # Remove this search path later
    5432             notinst_path="$notinst_path $abs_ladir"
     6538            func_append notinst_path " $abs_ladir"
    54336539          fi
    54346540        fi # $installed = yes
     
    54416547            func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
    54426548          fi
    5443           # Prefer using a static library (so that no silly _DYNAMIC symbols
    5444           # are required to link).
    5445           if test -n "$old_library"; then
    5446             newdlprefiles="$newdlprefiles $dir/$old_library"
    5447             # Keep a list of preopened convenience libraries to check
    5448             # that they are being used correctly in the link pass.
    5449             test -z "$libdir" && \
    5450                 dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"
    5451           # Otherwise, use the dlname, so that lt_dlopen finds it.
    5452           elif test -n "$dlname"; then
    5453             newdlprefiles="$newdlprefiles $dir/$dlname"
    5454           else
    5455             newdlprefiles="$newdlprefiles $dir/$linklib"
    5456           fi
     6549          case "$host" in
     6550            # special handling for platforms with PE-DLLs.
     6551            *cygwin* | *mingw* | *cegcc* )
     6552              # Linker will automatically link against shared library if both
     6553              # static and shared are present.  Therefore, ensure we extract
     6554              # symbols from the import library if a shared library is present
     6555              # (otherwise, the dlopen module name will be incorrect).  We do
     6556              # this by putting the import library name into $newdlprefiles.
     6557              # We recover the dlopen module name by 'saving' the la file
     6558              # name in a special purpose variable, and (later) extracting the
     6559              # dlname from the la file.
     6560              if test -n "$dlname"; then
     6561                func_tr_sh "$dir/$linklib"
     6562                eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
     6563                func_append newdlprefiles " $dir/$linklib"
     6564              else
     6565                func_append newdlprefiles " $dir/$old_library"
     6566                # Keep a list of preopened convenience libraries to check
     6567                # that they are being used correctly in the link pass.
     6568                test -z "$libdir" && \
     6569                  func_append dlpreconveniencelibs " $dir/$old_library"
     6570              fi
     6571            ;;
     6572            * )
     6573              # Prefer using a static library (so that no silly _DYNAMIC symbols
     6574              # are required to link).
     6575              if test -n "$old_library"; then
     6576                func_append newdlprefiles " $dir/$old_library"
     6577                # Keep a list of preopened convenience libraries to check
     6578                # that they are being used correctly in the link pass.
     6579                test -z "$libdir" && \
     6580                  func_append dlpreconveniencelibs " $dir/$old_library"
     6581              # Otherwise, use the dlname, so that lt_dlopen finds it.
     6582              elif test -n "$dlname"; then
     6583                func_append newdlprefiles " $dir/$dlname"
     6584              else
     6585                func_append newdlprefiles " $dir/$linklib"
     6586              fi
     6587            ;;
     6588          esac
    54576589        fi # $pass = dlpreopen
    54586590
     
    54726604
    54736605        if test "$linkmode" = prog && test "$pass" != link; then
    5474           newlib_search_path="$newlib_search_path $ladir"
     6606          func_append newlib_search_path " $ladir"
    54756607          deplibs="$lib $deplibs"
    54766608
     
    54856617            case $deplib in
    54866618            -L*) func_stripname '-L' '' "$deplib"
    5487                  newlib_search_path="$newlib_search_path $func_stripname_result"
     6619                 func_resolve_sysroot "$func_stripname_result"
     6620                 func_append newlib_search_path " $func_resolve_sysroot_result"
    54886621                 ;;
    54896622            esac
     
    54966629              newdependency_libs="$deplib $newdependency_libs"
    54976630            fi
    5498             if $opt_duplicate_deps ; then
     6631            if $opt_preserve_dup_deps ; then
    54996632              case "$tmp_libs " in
    5500               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
     6633              *" $deplib "*) func_append specialdeplibs " $deplib" ;;
    55016634              esac
    55026635            fi
    5503             tmp_libs="$tmp_libs $deplib"
     6636            func_append tmp_libs " $deplib"
    55046637          done # for deplib
    55056638          continue
     
    55166649              case "$temp_rpath:" in
    55176650              *"$absdir:"*) ;;
    5518               *) temp_rpath="$temp_rpath$absdir:" ;;
     6651              *) func_append temp_rpath "$absdir:" ;;
    55196652              esac
    55206653            fi
     
    55286661              case "$compile_rpath " in
    55296662              *" $absdir "*) ;;
    5530               *) compile_rpath="$compile_rpath $absdir"
     6663              *) func_append compile_rpath " $absdir" ;;
    55316664              esac
    55326665              ;;
     
    55376670              case "$finalize_rpath " in
    55386671              *" $libdir "*) ;;
    5539               *) finalize_rpath="$finalize_rpath $libdir"
     6672              *) func_append finalize_rpath " $libdir" ;;
    55406673              esac
    55416674              ;;
     
    55626695          *cygwin* | *mingw* | *cegcc*)
    55636696              # No point in relinking DLLs because paths are not encoded
    5564               notinst_deplibs="$notinst_deplibs $lib"
     6697              func_append notinst_deplibs " $lib"
    55656698              need_relink=no
    55666699            ;;
    55676700          *)
    55686701            if test "$installed" = no; then
    5569               notinst_deplibs="$notinst_deplibs $lib"
     6702              func_append notinst_deplibs " $lib"
    55706703              need_relink=yes
    55716704            fi
     
    55846717          done
    55856718          if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
    5586             $ECHO
     6719            echo
    55876720            if test "$linkmode" = prog; then
    55886721              $ECHO "*** Warning: Linking the executable $output against the loadable module"
     
    56026735              case "$compile_rpath " in
    56036736              *" $absdir "*) ;;
    5604               *) compile_rpath="$compile_rpath $absdir"
     6737              *) func_append compile_rpath " $absdir" ;;
    56056738              esac
    56066739              ;;
     
    56116744              case "$finalize_rpath " in
    56126745              *" $libdir "*) ;;
    5613               *) finalize_rpath="$finalize_rpath $libdir"
     6746              *) func_append finalize_rpath " $libdir" ;;
    56146747              esac
    56156748              ;;
     
    56656798          fi # test -n "$old_archive_from_expsyms_cmds"
    56666799
    5667           if test "$linkmode" = prog || test "$mode" != relink; then
     6800          if test "$linkmode" = prog || test "$opt_mode" != relink; then
    56686801            add_shlibpath=
    56696802            add_dir=
     
    56876820                        $ECHO "*** Warning: lib $linklib is a module, not a shared library"
    56886821                        if test -z "$old_library" ; then
    5689                           $ECHO
    5690                           $ECHO "*** And there doesn't seem to be a static archive available"
    5691                           $ECHO "*** The link will probably fail, sorry"
     6822                          echo
     6823                          echo "*** And there doesn't seem to be a static archive available"
     6824                          echo "*** The link will probably fail, sorry"
    56926825                        else
    56936826                          add="$dir/$old_library"
     
    57166849                add="$dir/$linklib"
    57176850              elif test "$hardcode_minus_L" = yes; then
    5718                 add_dir="-L$dir"
     6851                add_dir="-L$absdir"
    57196852                # Try looking first in the location we're being installed to.
    57206853                if test -n "$inst_prefix_dir"; then
    57216854                  case $libdir in
    57226855                    [\\/]*)
    5723                       add_dir="$add_dir -L$inst_prefix_dir$libdir"
     6856                      func_append add_dir " -L$inst_prefix_dir$libdir"
    57246857                      ;;
    57256858                  esac
     
    57436876              case :$compile_shlibpath: in
    57446877              *":$add_shlibpath:"*) ;;
    5745               *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
     6878              *) func_append compile_shlibpath "$add_shlibpath:" ;;
    57466879              esac
    57476880            fi
     
    57576890                case :$finalize_shlibpath: in
    57586891                *":$libdir:"*) ;;
    5759                 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
     6892                *) func_append finalize_shlibpath "$libdir:" ;;
    57606893                esac
    57616894              fi
     
    57636896          fi
    57646897
    5765           if test "$linkmode" = prog || test "$mode" = relink; then
     6898          if test "$linkmode" = prog || test "$opt_mode" = relink; then
    57666899            add_shlibpath=
    57676900            add_dir=
     
    57776910              case :$finalize_shlibpath: in
    57786911              *":$libdir:"*) ;;
    5779               *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
     6912              *) func_append finalize_shlibpath "$libdir:" ;;
    57806913              esac
    57816914              add="-l$name"
     
    57946927                case $libdir in
    57956928                  [\\/]*)
    5796                     add_dir="$add_dir -L$inst_prefix_dir$libdir"
     6929                    func_append add_dir " -L$inst_prefix_dir$libdir"
    57976930                    ;;
    57986931                esac
     
    58296962            # Just print a warning and add the library to dependency_libs so
    58306963            # that the program can be linked against the static library.
    5831             $ECHO
     6964            echo
    58326965            $ECHO "*** Warning: This system can not link to static lib archive $lib."
    5833             $ECHO "*** I have the capability to make that library automatically link in when"
    5834             $ECHO "*** you link to this library.  But I can only do this if you have a"
    5835             $ECHO "*** shared version of the library, which you do not appear to have."
     6966            echo "*** I have the capability to make that library automatically link in when"
     6967            echo "*** you link to this library.  But I can only do this if you have a"
     6968            echo "*** shared version of the library, which you do not appear to have."
    58366969            if test "$module" = yes; then
    5837               $ECHO "*** But as you try to build a module library, libtool will still create "
    5838               $ECHO "*** a static module, that should work as long as the dlopening application"
    5839               $ECHO "*** is linked with the -dlopen flag to resolve symbols at runtime."
     6970              echo "*** But as you try to build a module library, libtool will still create "
     6971              echo "*** a static module, that should work as long as the dlopening application"
     6972              echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
    58406973              if test -z "$global_symbol_pipe"; then
    5841                 $ECHO
    5842                 $ECHO "*** However, this would only work if libtool was able to extract symbol"
    5843                 $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
    5844                 $ECHO "*** not find such a program.  So, this module is probably useless."
    5845                 $ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
     6974                echo
     6975                echo "*** However, this would only work if libtool was able to extract symbol"
     6976                echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
     6977                echo "*** not find such a program.  So, this module is probably useless."
     6978                echo "*** \`nm' from GNU binutils and a full rebuild may help."
    58466979              fi
    58476980              if test "$build_old_libs" = no; then
     
    58717004                   case " $xrpath " in
    58727005                   *" $temp_xrpath "*) ;;
    5873                    *) xrpath="$xrpath $temp_xrpath";;
     7006                   *) func_append xrpath " $temp_xrpath";;
    58747007                   esac;;
    5875               *) temp_deplibs="$temp_deplibs $libdir";;
     7008              *) func_append temp_deplibs " $libdir";;
    58767009              esac
    58777010            done
     
    58797012          fi
    58807013
    5881           newlib_search_path="$newlib_search_path $absdir"
     7014          func_append newlib_search_path " $absdir"
    58827015          # Link against this library
    58837016          test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
     
    58867019          for deplib in $dependency_libs; do
    58877020            newdependency_libs="$deplib $newdependency_libs"
    5888             if $opt_duplicate_deps ; then
     7021            case $deplib in
     7022              -L*) func_stripname '-L' '' "$deplib"
     7023                   func_resolve_sysroot "$func_stripname_result";;
     7024              *) func_resolve_sysroot "$deplib" ;;
     7025            esac
     7026            if $opt_preserve_dup_deps ; then
    58897027              case "$tmp_libs " in
    5890               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
     7028              *" $func_resolve_sysroot_result "*)
     7029                func_append specialdeplibs " $func_resolve_sysroot_result" ;;
    58917030              esac
    58927031            fi
    5893             tmp_libs="$tmp_libs $deplib"
     7032            func_append tmp_libs " $func_resolve_sysroot_result"
    58947033          done
    58957034
     
    59017040              -L*) path="$deplib" ;;
    59027041              *.la)
     7042                func_resolve_sysroot "$deplib"
     7043                deplib=$func_resolve_sysroot_result
    59037044                func_dirname "$deplib" "" "."
    5904                 dir="$func_dirname_result"
     7045                dir=$func_dirname_result
    59057046                # We need an absolute path.
    59067047                case $dir in
     
    59297070                          darwin_install_name=`${OTOOL64} -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
    59307071                      fi
    5931                       compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
    5932                       linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
     7072                      func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
     7073                      func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"
    59337074                      path=
    59347075                    fi
     
    59637104          finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
    59647105        else
    5965           compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
     7106          compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
    59667107        fi
    59677108      fi
     
    59807121            case "$lib_search_path " in
    59817122            *" $dir "*) ;;
    5982             *) lib_search_path="$lib_search_path $dir" ;;
     7123            *) func_append lib_search_path " $dir" ;;
    59837124            esac
    59847125          done
     
    60387179              case " $tmp_libs " in
    60397180              *" $deplib "*) ;;
    6040               *) tmp_libs="$tmp_libs $deplib" ;;
     7181              *) func_append tmp_libs " $deplib" ;;
    60417182              esac
    60427183              ;;
    6043             *) tmp_libs="$tmp_libs $deplib" ;;
     7184            *) func_append tmp_libs " $deplib" ;;
    60447185            esac
    60457186          done
     
    60577198        esac
    60587199        if test -n "$i" ; then
    6059           tmp_libs="$tmp_libs $i"
     7200          func_append tmp_libs " $i"
    60607201        fi
    60617202      done
     
    60987239      build_libtool_libs=no
    60997240      oldlibs="$output"
    6100       objs="$objs$old_deplibs"
     7241      func_append objs "$old_deplibs"
    61017242      ;;
    61027243
     
    61317272          func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
    61327273        else
    6133           $ECHO
     7274          echo
    61347275          $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
    61357276          $ECHO "*** objects $objs is not portable!"
    6136           libobjs="$libobjs $objs"
     7277          func_append libobjs " $objs"
    61377278        fi
    61387279      fi
     
    61937334          #
    61947335          case $version_type in
     7336          # correct linux to gnu/linux during the next big refactor
    61957337          darwin|linux|osf|windows|none)
    61967338            func_arith $number_major + $number_minor
     
    61997341            revision="$number_revision"
    62007342            ;;
    6201           freebsd-aout|freebsd-elf|sunos)
     7343          freebsd-aout|freebsd-elf|qnx|sunos)
    62027344            current="$number_major"
    62037345            revision="$number_minor"
     
    63127454          ;;
    63137455
    6314         linux)
     7456        linux) # correct to gnu/linux during the next big refactor
    63157457          func_arith $current - $age
    63167458          major=.$func_arith_result
     
    63357477
    63367478          # Make executables depend on our current version.
    6337           verstring="$verstring:${current}.0"
     7479          func_append verstring ":${current}.0"
    63387480          ;;
    63397481
     
    64037545
    64047546      func_generate_dlsyms "$libname" "$libname" "yes"
    6405       libobjs="$libobjs $symfileobj"
     7547      func_append libobjs " $symfileobj"
    64067548      test "X$libobjs" = "X " && libobjs=
    64077549
    6408       if test "$mode" != relink; then
     7550      if test "$opt_mode" != relink; then
    64097551        # Remove our outputs, but don't remove object files since they
    64107552        # may have been created when compiling PIC objects.
     
    64227564                 fi
    64237565               fi
    6424                removelist="$removelist $p"
     7566               func_append removelist " $p"
    64257567               ;;
    64267568            *) ;;
     
    64337575      # Now set the variables for building old libraries.
    64347576      if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
    6435         oldlibs="$oldlibs $output_objdir/$libname.$libext"
     7577        func_append oldlibs " $output_objdir/$libname.$libext"
    64367578
    64377579        # Transform .lo files to .o files.
    6438         oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
     7580        oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
    64397581      fi
    64407582
    64417583      # Eliminate all temporary directories.
    64427584      #for path in $notinst_path; do
    6443       # lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`
    6444       # deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`
    6445       # dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`
     7585      # lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
     7586      # deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
     7587      # dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
    64467588      #done
    64477589
     
    64507592        temp_xrpath=
    64517593        for libdir in $xrpath; do
    6452           temp_xrpath="$temp_xrpath -R$libdir"
     7594          func_replace_sysroot "$libdir"
     7595          func_append temp_xrpath " -R$func_replace_sysroot_result"
    64537596          case "$finalize_rpath " in
    64547597          *" $libdir "*) ;;
    6455           *) finalize_rpath="$finalize_rpath $libdir" ;;
     7598          *) func_append finalize_rpath " $libdir" ;;
    64567599          esac
    64577600        done
     
    64677610        case " $dlprefiles $dlfiles " in
    64687611        *" $lib "*) ;;
    6469         *) dlfiles="$dlfiles $lib" ;;
     7612        *) func_append dlfiles " $lib" ;;
    64707613        esac
    64717614      done
     
    64777620        case "$dlprefiles " in
    64787621        *" $lib "*) ;;
    6479         *) dlprefiles="$dlprefiles $lib" ;;
     7622        *) func_append dlprefiles " $lib" ;;
    64807623        esac
    64817624      done
     
    64847627        if test -n "$rpath"; then
    64857628          case $host in
    6486           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc*)
     7629          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
    64877630            # these systems don't actually have a c library (as such)!
    64887631            ;;
    64897632          *-*-rhapsody* | *-*-darwin1.[012])
    64907633            # Rhapsody C library is in the System framework
    6491             deplibs="$deplibs System.ltframework"
     7634            func_append deplibs " System.ltframework"
    64927635            ;;
    64937636          *-*-netbsd*)
     
    65067649            # Add libc to deplibs on all other systems if necessary.
    65077650            if test "$build_libtool_need_lc" = "yes"; then
    6508               deplibs="$deplibs -lc"
     7651              func_append deplibs " -lc"
    65097652            fi
    65107653            ;;
     
    65557698                  case " $predeps $postdeps " in
    65567699                  *" $i "*)
    6557                     newdeplibs="$newdeplibs $i"
     7700                    func_append newdeplibs " $i"
    65587701                    i=""
    65597702                    ;;
     
    65667709                  deplib_match=$1
    65677710                  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
    6568                     newdeplibs="$newdeplibs $i"
     7711                    func_append newdeplibs " $i"
    65697712                  else
    65707713                    droppeddeps=yes
    6571                     $ECHO
     7714                    echo
    65727715                    $ECHO "*** Warning: dynamic linker does not accept needed library $i."
    6573                     $ECHO "*** I have the capability to make that library automatically link in when"
    6574                     $ECHO "*** you link to this library.  But I can only do this if you have a"
    6575                     $ECHO "*** shared version of the library, which I believe you do not have"
    6576                     $ECHO "*** because a test_compile did reveal that the linker did not use it for"
    6577                     $ECHO "*** its dynamic dependency list that programs get resolved with at runtime."
     7716                    echo "*** I have the capability to make that library automatically link in when"
     7717                    echo "*** you link to this library.  But I can only do this if you have a"
     7718                    echo "*** shared version of the library, which I believe you do not have"
     7719                    echo "*** because a test_compile did reveal that the linker did not use it for"
     7720                    echo "*** its dynamic dependency list that programs get resolved with at runtime."
    65787721                  fi
    65797722                fi
    65807723                ;;
    65817724              *)
    6582                 newdeplibs="$newdeplibs $i"
     7725                func_append newdeplibs " $i"
    65837726                ;;
    65847727              esac
     
    65987741                    case " $predeps $postdeps " in
    65997742                    *" $i "*)
    6600                       newdeplibs="$newdeplibs $i"
     7743                      func_append newdeplibs " $i"
    66017744                      i=""
    66027745                      ;;
     
    66097752                    deplib_match=$1
    66107753                    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
    6611                       newdeplibs="$newdeplibs $i"
     7754                      func_append newdeplibs " $i"
    66127755                    else
    66137756                      droppeddeps=yes
    6614                       $ECHO
     7757                      echo
    66157758                      $ECHO "*** Warning: dynamic linker does not accept needed library $i."
    6616                       $ECHO "*** I have the capability to make that library automatically link in when"
    6617                       $ECHO "*** you link to this library.  But I can only do this if you have a"
    6618                       $ECHO "*** shared version of the library, which you do not appear to have"
    6619                       $ECHO "*** because a test_compile did reveal that the linker did not use this one"
    6620                       $ECHO "*** as a dynamic dependency that programs can get resolved with at runtime."
     7759                      echo "*** I have the capability to make that library automatically link in when"
     7760                      echo "*** you link to this library.  But I can only do this if you have a"
     7761                      echo "*** shared version of the library, which you do not appear to have"
     7762                      echo "*** because a test_compile did reveal that the linker did not use this one"
     7763                      echo "*** as a dynamic dependency that programs can get resolved with at runtime."
    66217764                    fi
    66227765                  fi
    66237766                else
    66247767                  droppeddeps=yes
    6625                   $ECHO
     7768                  echo
    66267769                  $ECHO "*** Warning!  Library $i is needed by this library but I was not able to"
    6627                   $ECHO "*** make it link in!  You will probably need to install it or some"
    6628                   $ECHO "*** library that it depends on before this library will be fully"
    6629                   $ECHO "*** functional.  Installing it before continuing would be even better."
     7770                  echo "*** make it link in!  You will probably need to install it or some"
     7771                  echo "*** library that it depends on before this library will be fully"
     7772                  echo "*** functional.  Installing it before continuing would be even better."
    66307773                fi
    66317774                ;;
    66327775              *)
    6633                 newdeplibs="$newdeplibs $i"
     7776                func_append newdeplibs " $i"
    66347777                ;;
    66357778              esac
     
    66487791                case " $predeps $postdeps " in
    66497792                *" $a_deplib "*)
    6650                   newdeplibs="$newdeplibs $a_deplib"
     7793                  func_append newdeplibs " $a_deplib"
    66517794                  a_deplib=""
    66527795                  ;;
     
    66557798              if test -n "$a_deplib" ; then
    66567799                libname=`eval "\\$ECHO \"$libname_spec\""`
     7800                if test -n "$file_magic_glob"; then
     7801                  libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
     7802                else
     7803                  libnameglob=$libname
     7804                fi
     7805                test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`
    66577806                for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
    6658                   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
     7807                  if test "$want_nocaseglob" = yes; then
     7808                    shopt -s nocaseglob
     7809                    potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
     7810                    $nocaseglob
     7811                  else
     7812                    potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
     7813                  fi
    66597814                  for potent_lib in $potential_libs; do
    66607815                      # Follow soft links.
     
    66737828                        case $potliblink in
    66747829                        [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
    6675                         *) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
     7830                        *) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
    66767831                        esac
    66777832                      done
     
    66797834                         $SED -e 10q |
    66807835                         $EGREP "$file_magic_regex" > /dev/null; then
    6681                         newdeplibs="$newdeplibs $a_deplib"
     7836                        func_append newdeplibs " $a_deplib"
    66827837                        a_deplib=""
    66837838                        break 2
     
    66887843              if test -n "$a_deplib" ; then
    66897844                droppeddeps=yes
    6690                 $ECHO
     7845                echo
    66917846                $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
    6692                 $ECHO "*** I have the capability to make that library automatically link in when"
    6693                 $ECHO "*** you link to this library.  But I can only do this if you have a"
    6694                 $ECHO "*** shared version of the library, which you do not appear to have"
    6695                 $ECHO "*** because I did check the linker path looking for a file starting"
     7847                echo "*** I have the capability to make that library automatically link in when"
     7848                echo "*** you link to this library.  But I can only do this if you have a"
     7849                echo "*** shared version of the library, which you do not appear to have"
     7850                echo "*** because I did check the linker path looking for a file starting"
    66967851                if test -z "$potlib" ; then
    66977852                  $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
     
    67047859            *)
    67057860              # Add a -L argument.
    6706               newdeplibs="$newdeplibs $a_deplib"
     7861              func_append newdeplibs " $a_deplib"
    67077862              ;;
    67087863            esac
     
    67207875                case " $predeps $postdeps " in
    67217876                *" $a_deplib "*)
    6722                   newdeplibs="$newdeplibs $a_deplib"
     7877                  func_append newdeplibs " $a_deplib"
    67237878                  a_deplib=""
    67247879                  ;;
     
    67317886                  for potent_lib in $potential_libs; do
    67327887                    potlib="$potent_lib" # see symlink-check above in file_magic test
    6733                     if eval "\$ECHO \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \
     7888                    if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
    67347889                       $EGREP "$match_pattern_regex" > /dev/null; then
    6735                       newdeplibs="$newdeplibs $a_deplib"
     7890                      func_append newdeplibs " $a_deplib"
    67367891                      a_deplib=""
    67377892                      break 2
     
    67427897              if test -n "$a_deplib" ; then
    67437898                droppeddeps=yes
    6744                 $ECHO
     7899                echo
    67457900                $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
    6746                 $ECHO "*** I have the capability to make that library automatically link in when"
    6747                 $ECHO "*** you link to this library.  But I can only do this if you have a"
    6748                 $ECHO "*** shared version of the library, which you do not appear to have"
    6749                 $ECHO "*** because I did check the linker path looking for a file starting"
     7901                echo "*** I have the capability to make that library automatically link in when"
     7902                echo "*** you link to this library.  But I can only do this if you have a"
     7903                echo "*** shared version of the library, which you do not appear to have"
     7904                echo "*** because I did check the linker path looking for a file starting"
    67507905                if test -z "$potlib" ; then
    67517906                  $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
     
    67587913            *)
    67597914              # Add a -L argument.
    6760               newdeplibs="$newdeplibs $a_deplib"
     7915              func_append newdeplibs " $a_deplib"
    67617916              ;;
    67627917            esac
     
    67657920        none | unknown | *)
    67667921          newdeplibs=""
    6767           tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \
    6768               -e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'`
     7922          tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
    67697923          if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
    67707924            for i in $predeps $postdeps ; do
    67717925              # can't use Xsed below, because $i might contain '/'
    6772               tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`
     7926              tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
    67737927            done
    67747928          fi
    6775           if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[      ]//g' |
    6776              $GREP . >/dev/null; then
    6777             $ECHO
     7929          case $tmp_deplibs in
     7930          *[!\  \ ]*)
     7931            echo
    67787932            if test "X$deplibs_check_method" = "Xnone"; then
    6779               $ECHO "*** Warning: inter-library dependencies are not supported in this platform."
     7933              echo "*** Warning: inter-library dependencies are not supported in this platform."
    67807934  &