"Fossies" - the Fresh Open Source Software Archive

Member "abiword-3.0.2/ltmain.sh" (21 Oct 2016, 324089 Bytes) of package /linux/misc/abiword-3.0.2.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. 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": 3.0.1_vs_3.0.2.

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