"Fossies" - the Fresh Open Source Software Archive

Member "userinfo-2.5/build/ltmain.sh" (18 Jan 2015, 283672 Bytes) of package /linux/privat/userinfo-2.5.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. See also the latest Fossies "Diffs" side-by-side code changes report for "ltmain.sh": 2.4_vs_2.5.

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