"Fossies" - the Fresh Open Source Software Archive

Member "libspf2-1.2.10/config/ltmain.sh" (20 Feb 2012, 282967 Bytes) of package /linux/privat/libspf2-1.2.10.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Bash source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

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