"Fossies" - the Fresh Open Source Software Archive

Member "libev-4.33/ltmain.sh" (18 Mar 2020, 327114 Bytes) of package /linux/misc/libev-4.33.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 last Fossies "Diffs" side-by-side code changes report for "ltmain.sh": 4.25_vs_4.27.

    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 Debian-2.4.6-9"
   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=2015-10-07.11; # 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     _G_rc_run_hooks=false
 1534 
 1535     case " $hookable_fns " in
 1536       *" $1 "*) ;;
 1537       *) func_fatal_error "'$1' does not support hook funcions.n" ;;
 1538     esac
 1539 
 1540     eval _G_hook_fns=\$$1_hooks; shift
 1541 
 1542     for _G_hook in $_G_hook_fns; do
 1543       if eval $_G_hook '"$@"'; then
 1544         # store returned options list back into positional
 1545         # parameters for next 'cmd' execution.
 1546         eval _G_hook_result=\$${_G_hook}_result
 1547         eval set dummy "$_G_hook_result"; shift
 1548         _G_rc_run_hooks=:
 1549       fi
 1550     done
 1551 
 1552     $_G_rc_run_hooks && func_run_hooks_result=$_G_hook_result
 1553 }
 1554 
 1555 
 1556 
 1557 ## --------------- ##
 1558 ## Option parsing. ##
 1559 ## --------------- ##
 1560 
 1561 # In order to add your own option parsing hooks, you must accept the
 1562 # full positional parameter list in your hook function, you may remove/edit
 1563 # any options that you action, and then pass back the remaining unprocessed
 1564 # options in '<hooked_function_name>_result', escaped suitably for
 1565 # 'eval'.  In this case you also must return $EXIT_SUCCESS to let the
 1566 # hook's caller know that it should pay attention to
 1567 # '<hooked_function_name>_result'.  Returning $EXIT_FAILURE signalizes that
 1568 # arguments are left untouched by the hook and therefore caller will ignore the
 1569 # result variable.
 1570 #
 1571 # Like this:
 1572 #
 1573 #    my_options_prep ()
 1574 #    {
 1575 #        $debug_cmd
 1576 #
 1577 #        # Extend the existing usage message.
 1578 #        usage_message=$usage_message'
 1579 #      -s, --silent       don'\''t print informational messages
 1580 #    '
 1581 #        # No change in '$@' (ignored completely by this hook).  There is
 1582 #        # no need to do the equivalent (but slower) action:
 1583 #        # func_quote_for_eval ${1+"$@"}
 1584 #        # my_options_prep_result=$func_quote_for_eval_result
 1585 #        false
 1586 #    }
 1587 #    func_add_hook func_options_prep my_options_prep
 1588 #
 1589 #
 1590 #    my_silent_option ()
 1591 #    {
 1592 #        $debug_cmd
 1593 #
 1594 #        args_changed=false
 1595 #
 1596 #        # Note that for efficiency, we parse as many options as we can
 1597 #        # recognise in a loop before passing the remainder back to the
 1598 #        # caller on the first unrecognised argument we encounter.
 1599 #        while test $# -gt 0; do
 1600 #          opt=$1; shift
 1601 #          case $opt in
 1602 #            --silent|-s) opt_silent=:
 1603 #                         args_changed=:
 1604 #                         ;;
 1605 #            # Separate non-argument short options:
 1606 #            -s*)         func_split_short_opt "$_G_opt"
 1607 #                         set dummy "$func_split_short_opt_name" \
 1608 #                             "-$func_split_short_opt_arg" ${1+"$@"}
 1609 #                         shift
 1610 #                         args_changed=:
 1611 #                         ;;
 1612 #            *)           # Make sure the first unrecognised option "$_G_opt"
 1613 #                         # is added back to "$@", we could need that later
 1614 #                         # if $args_changed is true.
 1615 #                         set dummy "$_G_opt" ${1+"$@"}; shift; break ;;
 1616 #          esac
 1617 #        done
 1618 #
 1619 #        if $args_changed; then
 1620 #          func_quote_for_eval ${1+"$@"}
 1621 #          my_silent_option_result=$func_quote_for_eval_result
 1622 #        fi
 1623 #
 1624 #        $args_changed
 1625 #    }
 1626 #    func_add_hook func_parse_options my_silent_option
 1627 #
 1628 #
 1629 #    my_option_validation ()
 1630 #    {
 1631 #        $debug_cmd
 1632 #
 1633 #        $opt_silent && $opt_verbose && func_fatal_help "\
 1634 #    '--silent' and '--verbose' options are mutually exclusive."
 1635 #
 1636 #        false
 1637 #    }
 1638 #    func_add_hook func_validate_options my_option_validation
 1639 #
 1640 # You'll also need to manually amend $usage_message to reflect the extra
 1641 # options you parse.  It's preferable to append if you can, so that
 1642 # multiple option parsing hooks can be added safely.
 1643 
 1644 
 1645 # func_options_finish [ARG]...
 1646 # ----------------------------
 1647 # Finishing the option parse loop (call 'func_options' hooks ATM).
 1648 func_options_finish ()
 1649 {
 1650     $debug_cmd
 1651 
 1652     _G_func_options_finish_exit=false
 1653     if func_run_hooks func_options ${1+"$@"}; then
 1654       func_options_finish_result=$func_run_hooks_result
 1655       _G_func_options_finish_exit=:
 1656     fi
 1657 
 1658     $_G_func_options_finish_exit
 1659 }
 1660 
 1661 
 1662 # func_options [ARG]...
 1663 # ---------------------
 1664 # All the functions called inside func_options are hookable. See the
 1665 # individual implementations for details.
 1666 func_hookable func_options
 1667 func_options ()
 1668 {
 1669     $debug_cmd
 1670 
 1671     _G_rc_options=false
 1672 
 1673     for my_func in options_prep parse_options validate_options options_finish
 1674     do
 1675       if eval func_$my_func '${1+"$@"}'; then
 1676         eval _G_res_var='$'"func_${my_func}_result"
 1677         eval set dummy "$_G_res_var" ; shift
 1678         _G_rc_options=:
 1679       fi
 1680     done
 1681 
 1682     # Save modified positional parameters for caller.  As a top-level
 1683     # options-parser function we always need to set the 'func_options_result'
 1684     # variable (regardless the $_G_rc_options value).
 1685     if $_G_rc_options; then
 1686       func_options_result=$_G_res_var
 1687     else
 1688       func_quote_for_eval ${1+"$@"}
 1689       func_options_result=$func_quote_for_eval_result
 1690     fi
 1691 
 1692     $_G_rc_options
 1693 }
 1694 
 1695 
 1696 # func_options_prep [ARG]...
 1697 # --------------------------
 1698 # All initialisations required before starting the option parse loop.
 1699 # Note that when calling hook functions, we pass through the list of
 1700 # positional parameters.  If a hook function modifies that list, and
 1701 # needs to propagate that back to rest of this script, then the complete
 1702 # modified list must be put in 'func_run_hooks_result' before
 1703 # returning $EXIT_SUCCESS (otherwise $EXIT_FAILURE is returned).
 1704 func_hookable func_options_prep
 1705 func_options_prep ()
 1706 {
 1707     $debug_cmd
 1708 
 1709     # Option defaults:
 1710     opt_verbose=false
 1711     opt_warning_types=
 1712 
 1713     _G_rc_options_prep=false
 1714     if func_run_hooks func_options_prep ${1+"$@"}; then
 1715       _G_rc_options_prep=:
 1716       # save modified positional parameters for caller
 1717       func_options_prep_result=$func_run_hooks_result
 1718     fi
 1719 
 1720     $_G_rc_options_prep
 1721 }
 1722 
 1723 
 1724 # func_parse_options [ARG]...
 1725 # ---------------------------
 1726 # The main option parsing loop.
 1727 func_hookable func_parse_options
 1728 func_parse_options ()
 1729 {
 1730     $debug_cmd
 1731 
 1732     func_parse_options_result=
 1733 
 1734     _G_rc_parse_options=false
 1735     # this just eases exit handling
 1736     while test $# -gt 0; do
 1737       # Defer to hook functions for initial option parsing, so they
 1738       # get priority in the event of reusing an option name.
 1739       if func_run_hooks func_parse_options ${1+"$@"}; then
 1740         eval set dummy "$func_run_hooks_result"; shift
 1741         _G_rc_parse_options=:
 1742       fi
 1743 
 1744       # Break out of the loop if we already parsed every option.
 1745       test $# -gt 0 || break
 1746 
 1747       _G_match_parse_options=:
 1748       _G_opt=$1
 1749       shift
 1750       case $_G_opt in
 1751         --debug|-x)   debug_cmd='set -x'
 1752                       func_echo "enabling shell trace mode"
 1753                       $debug_cmd
 1754                       ;;
 1755 
 1756         --no-warnings|--no-warning|--no-warn)
 1757                       set dummy --warnings none ${1+"$@"}
 1758                       shift
 1759               ;;
 1760 
 1761         --warnings|--warning|-W)
 1762                       if test $# = 0 && func_missing_arg $_G_opt; then
 1763                         _G_rc_parse_options=:
 1764                         break
 1765                       fi
 1766                       case " $warning_categories $1" in
 1767                         *" $1 "*)
 1768                           # trailing space prevents matching last $1 above
 1769                           func_append_uniq opt_warning_types " $1"
 1770                           ;;
 1771                         *all)
 1772                           opt_warning_types=$warning_categories
 1773                           ;;
 1774                         *none)
 1775                           opt_warning_types=none
 1776                           warning_func=:
 1777                           ;;
 1778                         *error)
 1779                           opt_warning_types=$warning_categories
 1780                           warning_func=func_fatal_error
 1781                           ;;
 1782                         *)
 1783                           func_fatal_error \
 1784                              "unsupported warning category: '$1'"
 1785                           ;;
 1786                       esac
 1787                       shift
 1788                       ;;
 1789 
 1790         --verbose|-v) opt_verbose=: ;;
 1791         --version)    func_version ;;
 1792         -\?|-h)       func_usage ;;
 1793         --help)       func_help ;;
 1794 
 1795     # Separate optargs to long options (plugins may need this):
 1796     --*=*)        func_split_equals "$_G_opt"
 1797                   set dummy "$func_split_equals_lhs" \
 1798                           "$func_split_equals_rhs" ${1+"$@"}
 1799                       shift
 1800                       ;;
 1801 
 1802        # Separate optargs to short options:
 1803         -W*)
 1804                       func_split_short_opt "$_G_opt"
 1805                       set dummy "$func_split_short_opt_name" \
 1806                           "$func_split_short_opt_arg" ${1+"$@"}
 1807                       shift
 1808                       ;;
 1809 
 1810         # Separate non-argument short options:
 1811         -\?*|-h*|-v*|-x*)
 1812                       func_split_short_opt "$_G_opt"
 1813                       set dummy "$func_split_short_opt_name" \
 1814                           "-$func_split_short_opt_arg" ${1+"$@"}
 1815                       shift
 1816                       ;;
 1817 
 1818         --)           _G_rc_parse_options=: ; break ;;
 1819         -*)           func_fatal_help "unrecognised option: '$_G_opt'" ;;
 1820         *)            set dummy "$_G_opt" ${1+"$@"}; shift
 1821                       _G_match_parse_options=false
 1822                       break
 1823                       ;;
 1824       esac
 1825 
 1826       $_G_match_parse_options && _G_rc_parse_options=:
 1827     done
 1828 
 1829 
 1830     if $_G_rc_parse_options; then
 1831       # save modified positional parameters for caller
 1832       func_quote_for_eval ${1+"$@"}
 1833       func_parse_options_result=$func_quote_for_eval_result
 1834     fi
 1835 
 1836     $_G_rc_parse_options
 1837 }
 1838 
 1839 
 1840 # func_validate_options [ARG]...
 1841 # ------------------------------
 1842 # Perform any sanity checks on option settings and/or unconsumed
 1843 # arguments.
 1844 func_hookable func_validate_options
 1845 func_validate_options ()
 1846 {
 1847     $debug_cmd
 1848 
 1849     _G_rc_validate_options=false
 1850 
 1851     # Display all warnings if -W was not given.
 1852     test -n "$opt_warning_types" || opt_warning_types=" $warning_categories"
 1853 
 1854     if func_run_hooks func_validate_options ${1+"$@"}; then
 1855       # save modified positional parameters for caller
 1856       func_validate_options_result=$func_run_hooks_result
 1857       _G_rc_validate_options=:
 1858     fi
 1859 
 1860     # Bail if the options were screwed!
 1861     $exit_cmd $EXIT_FAILURE
 1862 
 1863     $_G_rc_validate_options
 1864 }
 1865 
 1866 
 1867 
 1868 ## ----------------- ##
 1869 ## Helper functions. ##
 1870 ## ----------------- ##
 1871 
 1872 # This section contains the helper functions used by the rest of the
 1873 # hookable option parser framework in ascii-betical order.
 1874 
 1875 
 1876 # func_fatal_help ARG...
 1877 # ----------------------
 1878 # Echo program name prefixed message to standard error, followed by
 1879 # a help hint, and exit.
 1880 func_fatal_help ()
 1881 {
 1882     $debug_cmd
 1883 
 1884     eval \$ECHO \""Usage: $usage"\"
 1885     eval \$ECHO \""$fatal_help"\"
 1886     func_error ${1+"$@"}
 1887     exit $EXIT_FAILURE
 1888 }
 1889 
 1890 
 1891 # func_help
 1892 # ---------
 1893 # Echo long help message to standard output and exit.
 1894 func_help ()
 1895 {
 1896     $debug_cmd
 1897 
 1898     func_usage_message
 1899     $ECHO "$long_help_message"
 1900     exit 0
 1901 }
 1902 
 1903 
 1904 # func_missing_arg ARGNAME
 1905 # ------------------------
 1906 # Echo program name prefixed message to standard error and set global
 1907 # exit_cmd.
 1908 func_missing_arg ()
 1909 {
 1910     $debug_cmd
 1911 
 1912     func_error "Missing argument for '$1'."
 1913     exit_cmd=exit
 1914 }
 1915 
 1916 
 1917 # func_split_equals STRING
 1918 # ------------------------
 1919 # Set func_split_equals_lhs and func_split_equals_rhs shell variables after
 1920 # splitting STRING at the '=' sign.
 1921 test -z "$_G_HAVE_XSI_OPS" \
 1922     && (eval 'x=a/b/c;
 1923       test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \
 1924     && _G_HAVE_XSI_OPS=yes
 1925 
 1926 if test yes = "$_G_HAVE_XSI_OPS"
 1927 then
 1928   # This is an XSI compatible shell, allowing a faster implementation...
 1929   eval 'func_split_equals ()
 1930   {
 1931       $debug_cmd
 1932 
 1933       func_split_equals_lhs=${1%%=*}
 1934       func_split_equals_rhs=${1#*=}
 1935       test "x$func_split_equals_lhs" = "x$1" \
 1936         && func_split_equals_rhs=
 1937   }'
 1938 else
 1939   # ...otherwise fall back to using expr, which is often a shell builtin.
 1940   func_split_equals ()
 1941   {
 1942       $debug_cmd
 1943 
 1944       func_split_equals_lhs=`expr "x$1" : 'x\([^=]*\)'`
 1945       func_split_equals_rhs=
 1946       test "x$func_split_equals_lhs" = "x$1" \
 1947         || func_split_equals_rhs=`expr "x$1" : 'x[^=]*=\(.*\)$'`
 1948   }
 1949 fi #func_split_equals
 1950 
 1951 
 1952 # func_split_short_opt SHORTOPT
 1953 # -----------------------------
 1954 # Set func_split_short_opt_name and func_split_short_opt_arg shell
 1955 # variables after splitting SHORTOPT after the 2nd character.
 1956 if test yes = "$_G_HAVE_XSI_OPS"
 1957 then
 1958   # This is an XSI compatible shell, allowing a faster implementation...
 1959   eval 'func_split_short_opt ()
 1960   {
 1961       $debug_cmd
 1962 
 1963       func_split_short_opt_arg=${1#??}
 1964       func_split_short_opt_name=${1%"$func_split_short_opt_arg"}
 1965   }'
 1966 else
 1967   # ...otherwise fall back to using expr, which is often a shell builtin.
 1968   func_split_short_opt ()
 1969   {
 1970       $debug_cmd
 1971 
 1972       func_split_short_opt_name=`expr "x$1" : 'x-\(.\)'`
 1973       func_split_short_opt_arg=`expr "x$1" : 'x-.\(.*\)$'`
 1974   }
 1975 fi #func_split_short_opt
 1976 
 1977 
 1978 # func_usage
 1979 # ----------
 1980 # Echo short help message to standard output and exit.
 1981 func_usage ()
 1982 {
 1983     $debug_cmd
 1984 
 1985     func_usage_message
 1986     $ECHO "Run '$progname --help |${PAGER-more}' for full usage"
 1987     exit 0
 1988 }
 1989 
 1990 
 1991 # func_usage_message
 1992 # ------------------
 1993 # Echo short help message to standard output.
 1994 func_usage_message ()
 1995 {
 1996     $debug_cmd
 1997 
 1998     eval \$ECHO \""Usage: $usage"\"
 1999     echo
 2000     $SED -n 's|^# ||
 2001         /^Written by/{
 2002           x;p;x
 2003         }
 2004     h
 2005     /^Written by/q' < "$progpath"
 2006     echo
 2007     eval \$ECHO \""$usage_message"\"
 2008 }
 2009 
 2010 
 2011 # func_version
 2012 # ------------
 2013 # Echo version message to standard output and exit.
 2014 func_version ()
 2015 {
 2016     $debug_cmd
 2017 
 2018     printf '%s\n' "$progname $scriptversion"
 2019     $SED -n '
 2020         /(C)/!b go
 2021         :more
 2022         /\./!{
 2023           N
 2024           s|\n# | |
 2025           b more
 2026         }
 2027         :go
 2028         /^# Written by /,/# warranty; / {
 2029           s|^# ||
 2030           s|^# *$||
 2031           s|\((C)\)[ 0-9,-]*[ ,-]\([1-9][0-9]* \)|\1 \2|
 2032           p
 2033         }
 2034         /^# Written by / {
 2035           s|^# ||
 2036           p
 2037         }
 2038         /^warranty; /q' < "$progpath"
 2039 
 2040     exit $?
 2041 }
 2042 
 2043 
 2044 # Local variables:
 2045 # mode: shell-script
 2046 # sh-indentation: 2
 2047 # eval: (add-hook 'before-save-hook 'time-stamp)
 2048 # time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC"
 2049 # time-stamp-time-zone: "UTC"
 2050 # End:
 2051 
 2052 # Set a version string.
 2053 scriptversion='(GNU libtool) 2.4.6'
 2054 
 2055 
 2056 # func_echo ARG...
 2057 # ----------------
 2058 # Libtool also displays the current mode in messages, so override
 2059 # funclib.sh func_echo with this custom definition.
 2060 func_echo ()
 2061 {
 2062     $debug_cmd
 2063 
 2064     _G_message=$*
 2065 
 2066     func_echo_IFS=$IFS
 2067     IFS=$nl
 2068     for _G_line in $_G_message; do
 2069       IFS=$func_echo_IFS
 2070       $ECHO "$progname${opt_mode+: $opt_mode}: $_G_line"
 2071     done
 2072     IFS=$func_echo_IFS
 2073 }
 2074 
 2075 
 2076 # func_warning ARG...
 2077 # -------------------
 2078 # Libtool warnings are not categorized, so override funclib.sh
 2079 # func_warning with this simpler definition.
 2080 func_warning ()
 2081 {
 2082     $debug_cmd
 2083 
 2084     $warning_func ${1+"$@"}
 2085 }
 2086 
 2087 
 2088 ## ---------------- ##
 2089 ## Options parsing. ##
 2090 ## ---------------- ##
 2091 
 2092 # Hook in the functions to make sure our own options are parsed during
 2093 # the option parsing loop.
 2094 
 2095 usage='$progpath [OPTION]... [MODE-ARG]...'
 2096 
 2097 # Short help message in response to '-h'.
 2098 usage_message="Options:
 2099        --config             show all configuration variables
 2100        --debug              enable verbose shell tracing
 2101    -n, --dry-run            display commands without modifying any files
 2102        --features           display basic configuration information and exit
 2103        --mode=MODE          use operation mode MODE
 2104        --no-warnings        equivalent to '-Wnone'
 2105        --preserve-dup-deps  don't remove duplicate dependency libraries
 2106        --quiet, --silent    don't print informational messages
 2107        --tag=TAG            use configuration variables from tag TAG
 2108    -v, --verbose            print more informational messages than default
 2109        --version            print version information
 2110    -W, --warnings=CATEGORY  report the warnings falling in CATEGORY [all]
 2111    -h, --help, --help-all   print short, long, or detailed help message
 2112 "
 2113 
 2114 # Additional text appended to 'usage_message' in response to '--help'.
 2115 func_help ()
 2116 {
 2117     $debug_cmd
 2118 
 2119     func_usage_message
 2120     $ECHO "$long_help_message
 2121 
 2122 MODE must be one of the following:
 2123 
 2124        clean           remove files from the build directory
 2125        compile         compile a source file into a libtool object
 2126        execute         automatically set library path, then run a program
 2127        finish          complete the installation of libtool libraries
 2128        install         install libraries or executables
 2129        link            create a library or an executable
 2130        uninstall       remove libraries from an installed directory
 2131 
 2132 MODE-ARGS vary depending on the MODE.  When passed as first option,
 2133 '--mode=MODE' may be abbreviated as 'MODE' or a unique abbreviation of that.
 2134 Try '$progname --help --mode=MODE' for a more detailed description of MODE.
 2135 
 2136 When reporting a bug, please describe a test case to reproduce it and
 2137 include the following information:
 2138 
 2139        host-triplet:   $host
 2140        shell:          $SHELL
 2141        compiler:       $LTCC
 2142        compiler flags: $LTCFLAGS
 2143        linker:         $LD (gnu? $with_gnu_ld)
 2144        version:        $progname $scriptversion Debian-2.4.6-9
 2145        automake:       `($AUTOMAKE --version) 2>/dev/null |$SED 1q`
 2146        autoconf:       `($AUTOCONF --version) 2>/dev/null |$SED 1q`
 2147 
 2148 Report bugs to <bug-libtool@gnu.org>.
 2149 GNU libtool home page: <http://www.gnu.org/s/libtool/>.
 2150 General help using GNU software: <http://www.gnu.org/gethelp/>."
 2151     exit 0
 2152 }
 2153 
 2154 
 2155 # func_lo2o OBJECT-NAME
 2156 # ---------------------
 2157 # Transform OBJECT-NAME from a '.lo' suffix to the platform specific
 2158 # object suffix.
 2159 
 2160 lo2o=s/\\.lo\$/.$objext/
 2161 o2lo=s/\\.$objext\$/.lo/
 2162 
 2163 if test yes = "$_G_HAVE_XSI_OPS"; then
 2164   eval 'func_lo2o ()
 2165   {
 2166     case $1 in
 2167       *.lo) func_lo2o_result=${1%.lo}.$objext ;;
 2168       *   ) func_lo2o_result=$1               ;;
 2169     esac
 2170   }'
 2171 
 2172   # func_xform LIBOBJ-OR-SOURCE
 2173   # ---------------------------
 2174   # Transform LIBOBJ-OR-SOURCE from a '.o' or '.c' (or otherwise)
 2175   # suffix to a '.lo' libtool-object suffix.
 2176   eval 'func_xform ()
 2177   {
 2178     func_xform_result=${1%.*}.lo
 2179   }'
 2180 else
 2181   # ...otherwise fall back to using sed.
 2182   func_lo2o ()
 2183   {
 2184     func_lo2o_result=`$ECHO "$1" | $SED "$lo2o"`
 2185   }
 2186 
 2187   func_xform ()
 2188   {
 2189     func_xform_result=`$ECHO "$1" | $SED 's|\.[^.]*$|.lo|'`
 2190   }
 2191 fi
 2192 
 2193 
 2194 # func_fatal_configuration ARG...
 2195 # -------------------------------
 2196 # Echo program name prefixed message to standard error, followed by
 2197 # a configuration failure hint, and exit.
 2198 func_fatal_configuration ()
 2199 {
 2200     func__fatal_error ${1+"$@"} \
 2201       "See the $PACKAGE documentation for more information." \
 2202       "Fatal configuration error."
 2203 }
 2204 
 2205 
 2206 # func_config
 2207 # -----------
 2208 # Display the configuration for all the tags in this script.
 2209 func_config ()
 2210 {
 2211     re_begincf='^# ### BEGIN LIBTOOL'
 2212     re_endcf='^# ### END LIBTOOL'
 2213 
 2214     # Default configuration.
 2215     $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
 2216 
 2217     # Now print the configurations for the tags.
 2218     for tagname in $taglist; do
 2219       $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
 2220     done
 2221 
 2222     exit $?
 2223 }
 2224 
 2225 
 2226 # func_features
 2227 # -------------
 2228 # Display the features supported by this script.
 2229 func_features ()
 2230 {
 2231     echo "host: $host"
 2232     if test yes = "$build_libtool_libs"; then
 2233       echo "enable shared libraries"
 2234     else
 2235       echo "disable shared libraries"
 2236     fi
 2237     if test yes = "$build_old_libs"; then
 2238       echo "enable static libraries"
 2239     else
 2240       echo "disable static libraries"
 2241     fi
 2242 
 2243     exit $?
 2244 }
 2245 
 2246 
 2247 # func_enable_tag TAGNAME
 2248 # -----------------------
 2249 # Verify that TAGNAME is valid, and either flag an error and exit, or
 2250 # enable the TAGNAME tag.  We also add TAGNAME to the global $taglist
 2251 # variable here.
 2252 func_enable_tag ()
 2253 {
 2254     # Global variable:
 2255     tagname=$1
 2256 
 2257     re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
 2258     re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
 2259     sed_extractcf=/$re_begincf/,/$re_endcf/p
 2260 
 2261     # Validate tagname.
 2262     case $tagname in
 2263       *[!-_A-Za-z0-9,/]*)
 2264         func_fatal_error "invalid tag name: $tagname"
 2265         ;;
 2266     esac
 2267 
 2268     # Don't test for the "default" C tag, as we know it's
 2269     # there but not specially marked.
 2270     case $tagname in
 2271         CC) ;;
 2272     *)
 2273         if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
 2274       taglist="$taglist $tagname"
 2275 
 2276       # Evaluate the configuration.  Be careful to quote the path
 2277       # and the sed script, to avoid splitting on whitespace, but
 2278       # also don't use non-portable quotes within backquotes within
 2279       # quotes we have to do it in 2 steps:
 2280       extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
 2281       eval "$extractedcf"
 2282         else
 2283       func_error "ignoring unknown tag $tagname"
 2284         fi
 2285         ;;
 2286     esac
 2287 }
 2288 
 2289 
 2290 # func_check_version_match
 2291 # ------------------------
 2292 # Ensure that we are using m4 macros, and libtool script from the same
 2293 # release of libtool.
 2294 func_check_version_match ()
 2295 {
 2296     if test "$package_revision" != "$macro_revision"; then
 2297       if test "$VERSION" != "$macro_version"; then
 2298         if test -z "$macro_version"; then
 2299           cat >&2 <<_LT_EOF
 2300 $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
 2301 $progname: definition of this LT_INIT comes from an older release.
 2302 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
 2303 $progname: and run autoconf again.
 2304 _LT_EOF
 2305         else
 2306           cat >&2 <<_LT_EOF
 2307 $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
 2308 $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
 2309 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
 2310 $progname: and run autoconf again.
 2311 _LT_EOF
 2312         fi
 2313       else
 2314         cat >&2 <<_LT_EOF
 2315 $progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,
 2316 $progname: but the definition of this LT_INIT comes from revision $macro_revision.
 2317 $progname: You should recreate aclocal.m4 with macros from revision $package_revision
 2318 $progname: of $PACKAGE $VERSION and run autoconf again.
 2319 _LT_EOF
 2320       fi
 2321 
 2322       exit $EXIT_MISMATCH
 2323     fi
 2324 }
 2325 
 2326 
 2327 # libtool_options_prep [ARG]...
 2328 # -----------------------------
 2329 # Preparation for options parsed by libtool.
 2330 libtool_options_prep ()
 2331 {
 2332     $debug_mode
 2333 
 2334     # Option defaults:
 2335     opt_config=false
 2336     opt_dlopen=
 2337     opt_dry_run=false
 2338     opt_help=false
 2339     opt_mode=
 2340     opt_preserve_dup_deps=false
 2341     opt_quiet=false
 2342 
 2343     nonopt=
 2344     preserve_args=
 2345 
 2346     _G_rc_lt_options_prep=:
 2347 
 2348     # Shorthand for --mode=foo, only valid as the first argument
 2349     case $1 in
 2350     clean|clea|cle|cl)
 2351       shift; set dummy --mode clean ${1+"$@"}; shift
 2352       ;;
 2353     compile|compil|compi|comp|com|co|c)
 2354       shift; set dummy --mode compile ${1+"$@"}; shift
 2355       ;;
 2356     execute|execut|execu|exec|exe|ex|e)
 2357       shift; set dummy --mode execute ${1+"$@"}; shift
 2358       ;;
 2359     finish|finis|fini|fin|fi|f)
 2360       shift; set dummy --mode finish ${1+"$@"}; shift
 2361       ;;
 2362     install|instal|insta|inst|ins|in|i)
 2363       shift; set dummy --mode install ${1+"$@"}; shift
 2364       ;;
 2365     link|lin|li|l)
 2366       shift; set dummy --mode link ${1+"$@"}; shift
 2367       ;;
 2368     uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
 2369       shift; set dummy --mode uninstall ${1+"$@"}; shift
 2370       ;;
 2371     *)
 2372       _G_rc_lt_options_prep=false
 2373       ;;
 2374     esac
 2375 
 2376     if $_G_rc_lt_options_prep; then
 2377       # Pass back the list of options.
 2378       func_quote_for_eval ${1+"$@"}
 2379       libtool_options_prep_result=$func_quote_for_eval_result
 2380     fi
 2381 
 2382     $_G_rc_lt_options_prep
 2383 }
 2384 func_add_hook func_options_prep libtool_options_prep
 2385 
 2386 
 2387 # libtool_parse_options [ARG]...
 2388 # ---------------------------------
 2389 # Provide handling for libtool specific options.
 2390 libtool_parse_options ()
 2391 {
 2392     $debug_cmd
 2393 
 2394     _G_rc_lt_parse_options=false
 2395 
 2396     # Perform our own loop to consume as many options as possible in
 2397     # each iteration.
 2398     while test $# -gt 0; do
 2399       _G_match_lt_parse_options=:
 2400       _G_opt=$1
 2401       shift
 2402       case $_G_opt in
 2403         --dry-run|--dryrun|-n)
 2404                         opt_dry_run=:
 2405                         ;;
 2406 
 2407         --config)       func_config ;;
 2408 
 2409         --dlopen|-dlopen)
 2410                         opt_dlopen="${opt_dlopen+$opt_dlopen
 2411 }$1"
 2412                         shift
 2413                         ;;
 2414 
 2415         --preserve-dup-deps)
 2416                         opt_preserve_dup_deps=: ;;
 2417 
 2418         --features)     func_features ;;
 2419 
 2420         --finish)       set dummy --mode finish ${1+"$@"}; shift ;;
 2421 
 2422         --help)         opt_help=: ;;
 2423 
 2424         --help-all)     opt_help=': help-all' ;;
 2425 
 2426         --mode)         test $# = 0 && func_missing_arg $_G_opt && break
 2427                         opt_mode=$1
 2428                         case $1 in
 2429                           # Valid mode arguments:
 2430                           clean|compile|execute|finish|install|link|relink|uninstall) ;;
 2431 
 2432                           # Catch anything else as an error
 2433                           *) func_error "invalid argument for $_G_opt"
 2434                              exit_cmd=exit
 2435                              break
 2436                              ;;
 2437                         esac
 2438                         shift
 2439                         ;;
 2440 
 2441         --no-silent|--no-quiet)
 2442                         opt_quiet=false
 2443                         func_append preserve_args " $_G_opt"
 2444                         ;;
 2445 
 2446         --no-warnings|--no-warning|--no-warn)
 2447                         opt_warning=false
 2448                         func_append preserve_args " $_G_opt"
 2449                         ;;
 2450 
 2451         --no-verbose)
 2452                         opt_verbose=false
 2453                         func_append preserve_args " $_G_opt"
 2454                         ;;
 2455 
 2456         --silent|--quiet)
 2457                         opt_quiet=:
 2458                         opt_verbose=false
 2459                         func_append preserve_args " $_G_opt"
 2460                         ;;
 2461 
 2462         --tag)          test $# = 0 && func_missing_arg $_G_opt && break
 2463                         opt_tag=$1
 2464                         func_append preserve_args " $_G_opt $1"
 2465                         func_enable_tag "$1"
 2466                         shift
 2467                         ;;
 2468 
 2469         --verbose|-v)   opt_quiet=false
 2470                         opt_verbose=:
 2471                         func_append preserve_args " $_G_opt"
 2472                         ;;
 2473 
 2474         # An option not handled by this hook function:
 2475         *)              set dummy "$_G_opt" ${1+"$@"} ; shift
 2476                         _G_match_lt_parse_options=false
 2477                         break
 2478                         ;;
 2479       esac
 2480       $_G_match_lt_parse_options && _G_rc_lt_parse_options=:
 2481     done
 2482 
 2483     if $_G_rc_lt_parse_options; then
 2484       # save modified positional parameters for caller
 2485       func_quote_for_eval ${1+"$@"}
 2486       libtool_parse_options_result=$func_quote_for_eval_result
 2487     fi
 2488 
 2489     $_G_rc_lt_parse_options
 2490 }
 2491 func_add_hook func_parse_options libtool_parse_options
 2492 
 2493 
 2494 
 2495 # libtool_validate_options [ARG]...
 2496 # ---------------------------------
 2497 # Perform any sanity checks on option settings and/or unconsumed
 2498 # arguments.
 2499 libtool_validate_options ()
 2500 {
 2501     # save first non-option argument
 2502     if test 0 -lt $#; then
 2503       nonopt=$1
 2504       shift
 2505     fi
 2506 
 2507     # preserve --debug
 2508     test : = "$debug_cmd" || func_append preserve_args " --debug"
 2509 
 2510     case $host in
 2511       # Solaris2 added to fix http://debbugs.gnu.org/cgi/bugreport.cgi?bug=16452
 2512       # see also: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=59788
 2513       *cygwin* | *mingw* | *pw32* | *cegcc* | *solaris2* | *os2*)
 2514         # don't eliminate duplications in $postdeps and $predeps
 2515         opt_duplicate_compiler_generated_deps=:
 2516         ;;
 2517       *)
 2518         opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
 2519         ;;
 2520     esac
 2521 
 2522     $opt_help || {
 2523       # Sanity checks first:
 2524       func_check_version_match
 2525 
 2526       test yes != "$build_libtool_libs" \
 2527         && test yes != "$build_old_libs" \
 2528         && func_fatal_configuration "not configured to build any kind of library"
 2529 
 2530       # Darwin sucks
 2531       eval std_shrext=\"$shrext_cmds\"
 2532 
 2533       # Only execute mode is allowed to have -dlopen flags.
 2534       if test -n "$opt_dlopen" && test execute != "$opt_mode"; then
 2535         func_error "unrecognized option '-dlopen'"
 2536         $ECHO "$help" 1>&2
 2537         exit $EXIT_FAILURE
 2538       fi
 2539 
 2540       # Change the help message to a mode-specific one.
 2541       generic_help=$help
 2542       help="Try '$progname --help --mode=$opt_mode' for more information."
 2543     }
 2544 
 2545     # Pass back the unparsed argument list
 2546     func_quote_for_eval ${1+"$@"}
 2547     libtool_validate_options_result=$func_quote_for_eval_result
 2548 }
 2549 func_add_hook func_validate_options libtool_validate_options
 2550 
 2551 
 2552 # Process options as early as possible so that --help and --version
 2553 # can return quickly.
 2554 func_options ${1+"$@"}
 2555 eval set dummy "$func_options_result"; shift
 2556 
 2557 
 2558 
 2559 ## ----------- ##
 2560 ##    Main.    ##
 2561 ## ----------- ##
 2562 
 2563 magic='%%%MAGIC variable%%%'
 2564 magic_exe='%%%MAGIC EXE variable%%%'
 2565 
 2566 # Global variables.
 2567 extracted_archives=
 2568 extracted_serial=0
 2569 
 2570 # If this variable is set in any of the actions, the command in it
 2571 # will be execed at the end.  This prevents here-documents from being
 2572 # left over by shells.
 2573 exec_cmd=
 2574 
 2575 
 2576 # A function that is used when there is no print builtin or printf.
 2577 func_fallback_echo ()
 2578 {
 2579   eval 'cat <<_LTECHO_EOF
 2580 $1
 2581 _LTECHO_EOF'
 2582 }
 2583 
 2584 # func_generated_by_libtool
 2585 # True iff stdin has been generated by Libtool. This function is only
 2586 # a basic sanity check; it will hardly flush out determined imposters.
 2587 func_generated_by_libtool_p ()
 2588 {
 2589   $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
 2590 }
 2591 
 2592 # func_lalib_p file
 2593 # True iff FILE is a libtool '.la' library or '.lo' object file.
 2594 # This function is only a basic sanity check; it will hardly flush out
 2595 # determined imposters.
 2596 func_lalib_p ()
 2597 {
 2598     test -f "$1" &&
 2599       $SED -e 4q "$1" 2>/dev/null | func_generated_by_libtool_p
 2600 }
 2601 
 2602 # func_lalib_unsafe_p file
 2603 # True iff FILE is a libtool '.la' library or '.lo' object file.
 2604 # This function implements the same check as func_lalib_p without
 2605 # resorting to external programs.  To this end, it redirects stdin and
 2606 # closes it afterwards, without saving the original file descriptor.
 2607 # As a safety measure, use it only where a negative result would be
 2608 # fatal anyway.  Works if 'file' does not exist.
 2609 func_lalib_unsafe_p ()
 2610 {
 2611     lalib_p=no
 2612     if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
 2613     for lalib_p_l in 1 2 3 4
 2614     do
 2615         read lalib_p_line
 2616         case $lalib_p_line in
 2617         \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
 2618         esac
 2619     done
 2620     exec 0<&5 5<&-
 2621     fi
 2622     test yes = "$lalib_p"
 2623 }
 2624 
 2625 # func_ltwrapper_script_p file
 2626 # True iff FILE is a libtool wrapper script
 2627 # This function is only a basic sanity check; it will hardly flush out
 2628 # determined imposters.
 2629 func_ltwrapper_script_p ()
 2630 {
 2631     test -f "$1" &&
 2632       $lt_truncate_bin < "$1" 2>/dev/null | func_generated_by_libtool_p
 2633 }
 2634 
 2635 # func_ltwrapper_executable_p file
 2636 # True iff FILE is a libtool wrapper executable
 2637 # This function is only a basic sanity check; it will hardly flush out
 2638 # determined imposters.
 2639 func_ltwrapper_executable_p ()
 2640 {
 2641     func_ltwrapper_exec_suffix=
 2642     case $1 in
 2643     *.exe) ;;
 2644     *) func_ltwrapper_exec_suffix=.exe ;;
 2645     esac
 2646     $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
 2647 }
 2648 
 2649 # func_ltwrapper_scriptname file
 2650 # Assumes file is an ltwrapper_executable
 2651 # uses $file to determine the appropriate filename for a
 2652 # temporary ltwrapper_script.
 2653 func_ltwrapper_scriptname ()
 2654 {
 2655     func_dirname_and_basename "$1" "" "."
 2656     func_stripname '' '.exe' "$func_basename_result"
 2657     func_ltwrapper_scriptname_result=$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper
 2658 }
 2659 
 2660 # func_ltwrapper_p file
 2661 # True iff FILE is a libtool wrapper script or wrapper executable
 2662 # This function is only a basic sanity check; it will hardly flush out
 2663 # determined imposters.
 2664 func_ltwrapper_p ()
 2665 {
 2666     func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
 2667 }
 2668 
 2669 
 2670 # func_execute_cmds commands fail_cmd
 2671 # Execute tilde-delimited COMMANDS.
 2672 # If FAIL_CMD is given, eval that upon failure.
 2673 # FAIL_CMD may read-access the current command in variable CMD!
 2674 func_execute_cmds ()
 2675 {
 2676     $debug_cmd
 2677 
 2678     save_ifs=$IFS; IFS='~'
 2679     for cmd in $1; do
 2680       IFS=$sp$nl
 2681       eval cmd=\"$cmd\"
 2682       IFS=$save_ifs
 2683       func_show_eval "$cmd" "${2-:}"
 2684     done
 2685     IFS=$save_ifs
 2686 }
 2687 
 2688 
 2689 # func_source file
 2690 # Source FILE, adding directory component if necessary.
 2691 # Note that it is not necessary on cygwin/mingw to append a dot to
 2692 # FILE even if both FILE and FILE.exe exist: automatic-append-.exe
 2693 # behavior happens only for exec(3), not for open(2)!  Also, sourcing
 2694 # 'FILE.' does not work on cygwin managed mounts.
 2695 func_source ()
 2696 {
 2697     $debug_cmd
 2698 
 2699     case $1 in
 2700     */* | *\\*) . "$1" ;;
 2701     *)      . "./$1" ;;
 2702     esac
 2703 }
 2704 
 2705 
 2706 # func_resolve_sysroot PATH
 2707 # Replace a leading = in PATH with a sysroot.  Store the result into
 2708 # func_resolve_sysroot_result
 2709 func_resolve_sysroot ()
 2710 {
 2711   func_resolve_sysroot_result=$1
 2712   case $func_resolve_sysroot_result in
 2713   =*)
 2714     func_stripname '=' '' "$func_resolve_sysroot_result"
 2715     func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
 2716     ;;
 2717   esac
 2718 }
 2719 
 2720 # func_replace_sysroot PATH
 2721 # If PATH begins with the sysroot, replace it with = and
 2722 # store the result into func_replace_sysroot_result.
 2723 func_replace_sysroot ()
 2724 {
 2725   case $lt_sysroot:$1 in
 2726   ?*:"$lt_sysroot"*)
 2727     func_stripname "$lt_sysroot" '' "$1"
 2728     func_replace_sysroot_result='='$func_stripname_result
 2729     ;;
 2730   *)
 2731     # Including no sysroot.
 2732     func_replace_sysroot_result=$1
 2733     ;;
 2734   esac
 2735 }
 2736 
 2737 # func_infer_tag arg
 2738 # Infer tagged configuration to use if any are available and
 2739 # if one wasn't chosen via the "--tag" command line option.
 2740 # Only attempt this if the compiler in the base compile
 2741 # command doesn't match the default compiler.
 2742 # arg is usually of the form 'gcc ...'
 2743 func_infer_tag ()
 2744 {
 2745     $debug_cmd
 2746 
 2747     if test -n "$available_tags" && test -z "$tagname"; then
 2748       CC_quoted=
 2749       for arg in $CC; do
 2750     func_append_quoted CC_quoted "$arg"
 2751       done
 2752       CC_expanded=`func_echo_all $CC`
 2753       CC_quoted_expanded=`func_echo_all $CC_quoted`
 2754       case $@ in
 2755       # Blanks in the command may have been stripped by the calling shell,
 2756       # but not from the CC environment variable when configure was run.
 2757       " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
 2758       " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
 2759       # Blanks at the start of $base_compile will cause this to fail
 2760       # if we don't check for them as well.
 2761       *)
 2762     for z in $available_tags; do
 2763       if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
 2764         # Evaluate the configuration.
 2765         eval "`$SED -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
 2766         CC_quoted=
 2767         for arg in $CC; do
 2768           # Double-quote args containing other shell metacharacters.
 2769           func_append_quoted CC_quoted "$arg"
 2770         done
 2771         CC_expanded=`func_echo_all $CC`
 2772         CC_quoted_expanded=`func_echo_all $CC_quoted`
 2773         case "$@ " in
 2774         " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
 2775         " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
 2776           # The compiler in the base compile command matches
 2777           # the one in the tagged configuration.
 2778           # Assume this is the tagged configuration we want.
 2779           tagname=$z
 2780           break
 2781           ;;
 2782         esac
 2783       fi
 2784     done
 2785     # If $tagname still isn't set, then no tagged configuration
 2786     # was found and let the user know that the "--tag" command
 2787     # line option must be used.
 2788     if test -z "$tagname"; then
 2789       func_echo "unable to infer tagged configuration"
 2790       func_fatal_error "specify a tag with '--tag'"
 2791 #   else
 2792 #     func_verbose "using $tagname tagged configuration"
 2793     fi
 2794     ;;
 2795       esac
 2796     fi
 2797 }
 2798 
 2799 
 2800 
 2801 # func_write_libtool_object output_name pic_name nonpic_name
 2802 # Create a libtool object file (analogous to a ".la" file),
 2803 # but don't create it if we're doing a dry run.
 2804 func_write_libtool_object ()
 2805 {
 2806     write_libobj=$1
 2807     if test yes = "$build_libtool_libs"; then
 2808       write_lobj=\'$2\'
 2809     else
 2810       write_lobj=none
 2811     fi
 2812 
 2813     if test yes = "$build_old_libs"; then
 2814       write_oldobj=\'$3\'
 2815     else
 2816       write_oldobj=none
 2817     fi
 2818 
 2819     $opt_dry_run || {
 2820       cat >${write_libobj}T <<EOF
 2821 # $write_libobj - a libtool object file
 2822 # Generated by $PROGRAM (GNU $PACKAGE) $VERSION
 2823 #
 2824 # Please DO NOT delete this file!
 2825 # It is necessary for linking the library.
 2826 
 2827 # Name of the PIC object.
 2828 pic_object=$write_lobj
 2829 
 2830 # Name of the non-PIC object
 2831 non_pic_object=$write_oldobj
 2832 
 2833 EOF
 2834       $MV "${write_libobj}T" "$write_libobj"
 2835     }
 2836 }
 2837 
 2838 
 2839 ##################################################
 2840 # FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
 2841 ##################################################
 2842 
 2843 # func_convert_core_file_wine_to_w32 ARG
 2844 # Helper function used by file name conversion functions when $build is *nix,
 2845 # and $host is mingw, cygwin, or some other w32 environment. Relies on a
 2846 # correctly configured wine environment available, with the winepath program
 2847 # in $build's $PATH.
 2848 #
 2849 # ARG is the $build file name to be converted to w32 format.
 2850 # Result is available in $func_convert_core_file_wine_to_w32_result, and will
 2851 # be empty on error (or when ARG is empty)
 2852 func_convert_core_file_wine_to_w32 ()
 2853 {
 2854   $debug_cmd
 2855 
 2856   func_convert_core_file_wine_to_w32_result=$1
 2857   if test -n "$1"; then
 2858     # Unfortunately, winepath does not exit with a non-zero error code, so we
 2859     # are forced to check the contents of stdout. On the other hand, if the
 2860     # command is not found, the shell will set an exit code of 127 and print
 2861     # *an error message* to stdout. So we must check for both error code of
 2862     # zero AND non-empty stdout, which explains the odd construction:
 2863     func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
 2864     if test "$?" -eq 0 && test -n "$func_convert_core_file_wine_to_w32_tmp"; then
 2865       func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
 2866         $SED -e "$sed_naive_backslashify"`
 2867     else
 2868       func_convert_core_file_wine_to_w32_result=
 2869     fi
 2870   fi
 2871 }
 2872 # end: func_convert_core_file_wine_to_w32
 2873 
 2874 
 2875 # func_convert_core_path_wine_to_w32 ARG
 2876 # Helper function used by path conversion functions when $build is *nix, and
 2877 # $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
 2878 # configured wine environment available, with the winepath program in $build's
 2879 # $PATH. Assumes ARG has no leading or trailing path separator characters.
 2880 #
 2881 # ARG is path to be converted from $build format to win32.
 2882 # Result is available in $func_convert_core_path_wine_to_w32_result.
 2883 # Unconvertible file (directory) names in ARG are skipped; if no directory names
 2884 # are convertible, then the result may be empty.
 2885 func_convert_core_path_wine_to_w32 ()
 2886 {
 2887   $debug_cmd
 2888 
 2889   # unfortunately, winepath doesn't convert paths, only file names
 2890   func_convert_core_path_wine_to_w32_result=
 2891   if test -n "$1"; then
 2892     oldIFS=$IFS
 2893     IFS=:
 2894     for func_convert_core_path_wine_to_w32_f in $1; do
 2895       IFS=$oldIFS
 2896       func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
 2897       if test -n "$func_convert_core_file_wine_to_w32_result"; then
 2898         if test -z "$func_convert_core_path_wine_to_w32_result"; then
 2899           func_convert_core_path_wine_to_w32_result=$func_convert_core_file_wine_to_w32_result
 2900         else
 2901           func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
 2902         fi
 2903       fi
 2904     done
 2905     IFS=$oldIFS
 2906   fi
 2907 }
 2908 # end: func_convert_core_path_wine_to_w32
 2909 
 2910 
 2911 # func_cygpath ARGS...
 2912 # Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
 2913 # when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
 2914 # $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
 2915 # (2), returns the Cygwin file name or path in func_cygpath_result (input
 2916 # file name or path is assumed to be in w32 format, as previously converted
 2917 # from $build's *nix or MSYS format). In case (3), returns the w32 file name
 2918 # or path in func_cygpath_result (input file name or path is assumed to be in
 2919 # Cygwin format). Returns an empty string on error.
 2920 #
 2921 # ARGS are passed to cygpath, with the last one being the file name or path to
 2922 # be converted.
 2923 #
 2924 # Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
 2925 # environment variable; do not put it in $PATH.
 2926 func_cygpath ()
 2927 {
 2928   $debug_cmd
 2929 
 2930   if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
 2931     func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
 2932     if test "$?" -ne 0; then
 2933       # on failure, ensure result is empty
 2934       func_cygpath_result=
 2935     fi
 2936   else
 2937     func_cygpath_result=
 2938     func_error "LT_CYGPATH is empty or specifies non-existent file: '$LT_CYGPATH'"
 2939   fi
 2940 }
 2941 #end: func_cygpath
 2942 
 2943 
 2944 # func_convert_core_msys_to_w32 ARG
 2945 # Convert file name or path ARG from MSYS format to w32 format.  Return
 2946 # result in func_convert_core_msys_to_w32_result.
 2947 func_convert_core_msys_to_w32 ()
 2948 {
 2949   $debug_cmd
 2950 
 2951   # awkward: cmd appends spaces to result
 2952   func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
 2953     $SED -e 's/[ ]*$//' -e "$sed_naive_backslashify"`
 2954 }
 2955 #end: func_convert_core_msys_to_w32
 2956 
 2957 
 2958 # func_convert_file_check ARG1 ARG2
 2959 # Verify that ARG1 (a file name in $build format) was converted to $host
 2960 # format in ARG2. Otherwise, emit an error message, but continue (resetting
 2961 # func_to_host_file_result to ARG1).
 2962 func_convert_file_check ()
 2963 {
 2964   $debug_cmd
 2965 
 2966   if test -z "$2" && test -n "$1"; then
 2967     func_error "Could not determine host file name corresponding to"
 2968     func_error "  '$1'"
 2969     func_error "Continuing, but uninstalled executables may not work."
 2970     # Fallback:
 2971     func_to_host_file_result=$1
 2972   fi
 2973 }
 2974 # end func_convert_file_check
 2975 
 2976 
 2977 # func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
 2978 # Verify that FROM_PATH (a path in $build format) was converted to $host
 2979 # format in TO_PATH. Otherwise, emit an error message, but continue, resetting
 2980 # func_to_host_file_result to a simplistic fallback value (see below).
 2981 func_convert_path_check ()
 2982 {
 2983   $debug_cmd
 2984 
 2985   if test -z "$4" && test -n "$3"; then
 2986     func_error "Could not determine the host path corresponding to"
 2987     func_error "  '$3'"
 2988     func_error "Continuing, but uninstalled executables may not work."
 2989     # Fallback.  This is a deliberately simplistic "conversion" and
 2990     # should not be "improved".  See libtool.info.
 2991     if test "x$1" != "x$2"; then
 2992       lt_replace_pathsep_chars="s|$1|$2|g"
 2993       func_to_host_path_result=`echo "$3" |
 2994         $SED -e "$lt_replace_pathsep_chars"`
 2995     else
 2996       func_to_host_path_result=$3
 2997     fi
 2998   fi
 2999 }
 3000 # end func_convert_path_check
 3001 
 3002 
 3003 # func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
 3004 # Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
 3005 # and appending REPL if ORIG matches BACKPAT.
 3006 func_convert_path_front_back_pathsep ()
 3007 {
 3008   $debug_cmd
 3009 
 3010   case $4 in
 3011   $1 ) func_to_host_path_result=$3$func_to_host_path_result
 3012     ;;
 3013   esac
 3014   case $4 in
 3015   $2 ) func_append func_to_host_path_result "$3"
 3016     ;;
 3017   esac
 3018 }
 3019 # end func_convert_path_front_back_pathsep
 3020 
 3021 
 3022 ##################################################
 3023 # $build to $host FILE NAME CONVERSION FUNCTIONS #
 3024 ##################################################
 3025 # invoked via '$to_host_file_cmd ARG'
 3026 #
 3027 # In each case, ARG is the path to be converted from $build to $host format.
 3028 # Result will be available in $func_to_host_file_result.
 3029 
 3030 
 3031 # func_to_host_file ARG
 3032 # Converts the file name ARG from $build format to $host format. Return result
 3033 # in func_to_host_file_result.
 3034 func_to_host_file ()
 3035 {
 3036   $debug_cmd
 3037 
 3038   $to_host_file_cmd "$1"
 3039 }
 3040 # end func_to_host_file
 3041 
 3042 
 3043 # func_to_tool_file ARG LAZY
 3044 # converts the file name ARG from $build format to toolchain format. Return
 3045 # result in func_to_tool_file_result.  If the conversion in use is listed
 3046 # in (the comma separated) LAZY, no conversion takes place.
 3047 func_to_tool_file ()
 3048 {
 3049   $debug_cmd
 3050 
 3051   case ,$2, in
 3052     *,"$to_tool_file_cmd",*)
 3053       func_to_tool_file_result=$1
 3054       ;;
 3055     *)
 3056       $to_tool_file_cmd "$1"
 3057       func_to_tool_file_result=$func_to_host_file_result
 3058       ;;
 3059   esac
 3060 }
 3061 # end func_to_tool_file
 3062 
 3063 
 3064 # func_convert_file_noop ARG
 3065 # Copy ARG to func_to_host_file_result.
 3066 func_convert_file_noop ()
 3067 {
 3068   func_to_host_file_result=$1
 3069 }
 3070 # end func_convert_file_noop
 3071 
 3072 
 3073 # func_convert_file_msys_to_w32 ARG
 3074 # Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
 3075 # conversion to w32 is not available inside the cwrapper.  Returns result in
 3076 # func_to_host_file_result.
 3077 func_convert_file_msys_to_w32 ()
 3078 {
 3079   $debug_cmd
 3080 
 3081   func_to_host_file_result=$1
 3082   if test -n "$1"; then
 3083     func_convert_core_msys_to_w32 "$1"
 3084     func_to_host_file_result=$func_convert_core_msys_to_w32_result
 3085   fi
 3086   func_convert_file_check "$1" "$func_to_host_file_result"
 3087 }
 3088 # end func_convert_file_msys_to_w32
 3089 
 3090 
 3091 # func_convert_file_cygwin_to_w32 ARG
 3092 # Convert file name ARG from Cygwin to w32 format.  Returns result in
 3093 # func_to_host_file_result.
 3094 func_convert_file_cygwin_to_w32 ()
 3095 {
 3096   $debug_cmd
 3097 
 3098   func_to_host_file_result=$1
 3099   if test -n "$1"; then
 3100     # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
 3101     # LT_CYGPATH in this case.
 3102     func_to_host_file_result=`cygpath -m "$1"`
 3103   fi
 3104   func_convert_file_check "$1" "$func_to_host_file_result"
 3105 }
 3106 # end func_convert_file_cygwin_to_w32
 3107 
 3108 
 3109 # func_convert_file_nix_to_w32 ARG
 3110 # Convert file name ARG from *nix to w32 format.  Requires a wine environment
 3111 # and a working winepath. Returns result in func_to_host_file_result.
 3112 func_convert_file_nix_to_w32 ()
 3113 {
 3114   $debug_cmd
 3115 
 3116   func_to_host_file_result=$1
 3117   if test -n "$1"; then
 3118     func_convert_core_file_wine_to_w32 "$1"
 3119     func_to_host_file_result=$func_convert_core_file_wine_to_w32_result
 3120   fi
 3121   func_convert_file_check "$1" "$func_to_host_file_result"
 3122 }
 3123 # end func_convert_file_nix_to_w32
 3124 
 3125 
 3126 # func_convert_file_msys_to_cygwin ARG
 3127 # Convert file name ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
 3128 # Returns result in func_to_host_file_result.
 3129 func_convert_file_msys_to_cygwin ()
 3130 {
 3131   $debug_cmd
 3132 
 3133   func_to_host_file_result=$1
 3134   if test -n "$1"; then
 3135     func_convert_core_msys_to_w32 "$1"
 3136     func_cygpath -u "$func_convert_core_msys_to_w32_result"
 3137     func_to_host_file_result=$func_cygpath_result
 3138   fi
 3139   func_convert_file_check "$1" "$func_to_host_file_result"
 3140 }
 3141 # end func_convert_file_msys_to_cygwin
 3142 
 3143 
 3144 # func_convert_file_nix_to_cygwin ARG
 3145 # Convert file name ARG from *nix to Cygwin format.  Requires Cygwin installed
 3146 # in a wine environment, working winepath, and LT_CYGPATH set.  Returns result
 3147 # in func_to_host_file_result.
 3148 func_convert_file_nix_to_cygwin ()
 3149 {
 3150   $debug_cmd
 3151 
 3152   func_to_host_file_result=$1
 3153   if test -n "$1"; then
 3154     # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
 3155     func_convert_core_file_wine_to_w32 "$1"
 3156     func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
 3157     func_to_host_file_result=$func_cygpath_result
 3158   fi
 3159   func_convert_file_check "$1" "$func_to_host_file_result"
 3160 }
 3161 # end func_convert_file_nix_to_cygwin
 3162 
 3163 
 3164 #############################################
 3165 # $build to $host PATH CONVERSION FUNCTIONS #
 3166 #############################################
 3167 # invoked via '$to_host_path_cmd ARG'
 3168 #
 3169 # In each case, ARG is the path to be converted from $build to $host format.
 3170 # The result will be available in $func_to_host_path_result.
 3171 #
 3172 # Path separators are also converted from $build format to $host format.  If
 3173 # ARG begins or ends with a path separator character, it is preserved (but
 3174 # converted to $host format) on output.
 3175 #
 3176 # All path conversion functions are named using the following convention:
 3177 #   file name conversion function    : func_convert_file_X_to_Y ()
 3178 #   path conversion function         : func_convert_path_X_to_Y ()
 3179 # where, for any given $build/$host combination the 'X_to_Y' value is the
 3180 # same.  If conversion functions are added for new $build/$host combinations,
 3181 # the two new functions must follow this pattern, or func_init_to_host_path_cmd
 3182 # will break.
 3183 
 3184 
 3185 # func_init_to_host_path_cmd
 3186 # Ensures that function "pointer" variable $to_host_path_cmd is set to the
 3187 # appropriate value, based on the value of $to_host_file_cmd.
 3188 to_host_path_cmd=
 3189 func_init_to_host_path_cmd ()
 3190 {
 3191   $debug_cmd
 3192 
 3193   if test -z "$to_host_path_cmd"; then
 3194     func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
 3195     to_host_path_cmd=func_convert_path_$func_stripname_result
 3196   fi
 3197 }
 3198 
 3199 
 3200 # func_to_host_path ARG
 3201 # Converts the path ARG from $build format to $host format. Return result
 3202 # in func_to_host_path_result.
 3203 func_to_host_path ()
 3204 {
 3205   $debug_cmd
 3206 
 3207   func_init_to_host_path_cmd
 3208   $to_host_path_cmd "$1"
 3209 }
 3210 # end func_to_host_path
 3211 
 3212 
 3213 # func_convert_path_noop ARG
 3214 # Copy ARG to func_to_host_path_result.
 3215 func_convert_path_noop ()
 3216 {
 3217   func_to_host_path_result=$1
 3218 }
 3219 # end func_convert_path_noop
 3220 
 3221 
 3222 # func_convert_path_msys_to_w32 ARG
 3223 # Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
 3224 # conversion to w32 is not available inside the cwrapper.  Returns result in
 3225 # func_to_host_path_result.
 3226 func_convert_path_msys_to_w32 ()
 3227 {
 3228   $debug_cmd
 3229 
 3230   func_to_host_path_result=$1
 3231   if test -n "$1"; then
 3232     # Remove leading and trailing path separator characters from ARG.  MSYS
 3233     # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
 3234     # and winepath ignores them completely.
 3235     func_stripname : : "$1"
 3236     func_to_host_path_tmp1=$func_stripname_result
 3237     func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
 3238     func_to_host_path_result=$func_convert_core_msys_to_w32_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_msys_to_w32
 3245 
 3246 
 3247 # func_convert_path_cygwin_to_w32 ARG
 3248 # Convert path ARG from Cygwin to w32 format.  Returns result in
 3249 # func_to_host_file_result.
 3250 func_convert_path_cygwin_to_w32 ()
 3251 {
 3252   $debug_cmd
 3253 
 3254   func_to_host_path_result=$1
 3255   if test -n "$1"; then
 3256     # See func_convert_path_msys_to_w32:
 3257     func_stripname : : "$1"
 3258     func_to_host_path_tmp1=$func_stripname_result
 3259     func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
 3260     func_convert_path_check : ";" \
 3261       "$func_to_host_path_tmp1" "$func_to_host_path_result"
 3262     func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
 3263   fi
 3264 }
 3265 # end func_convert_path_cygwin_to_w32
 3266 
 3267 
 3268 # func_convert_path_nix_to_w32 ARG
 3269 # Convert path ARG from *nix to w32 format.  Requires a wine environment and
 3270 # a working winepath.  Returns result in func_to_host_file_result.
 3271 func_convert_path_nix_to_w32 ()
 3272 {
 3273   $debug_cmd
 3274 
 3275   func_to_host_path_result=$1
 3276   if test -n "$1"; then
 3277     # See func_convert_path_msys_to_w32:
 3278     func_stripname : : "$1"
 3279     func_to_host_path_tmp1=$func_stripname_result
 3280     func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
 3281     func_to_host_path_result=$func_convert_core_path_wine_to_w32_result
 3282     func_convert_path_check : ";" \
 3283       "$func_to_host_path_tmp1" "$func_to_host_path_result"
 3284     func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
 3285   fi
 3286 }
 3287 # end func_convert_path_nix_to_w32
 3288 
 3289 
 3290 # func_convert_path_msys_to_cygwin ARG
 3291 # Convert path ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
 3292 # Returns result in func_to_host_file_result.
 3293 func_convert_path_msys_to_cygwin ()
 3294 {
 3295   $debug_cmd
 3296 
 3297   func_to_host_path_result=$1
 3298   if test -n "$1"; then
 3299     # See func_convert_path_msys_to_w32:
 3300     func_stripname : : "$1"
 3301     func_to_host_path_tmp1=$func_stripname_result
 3302     func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
 3303     func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
 3304     func_to_host_path_result=$func_cygpath_result
 3305     func_convert_path_check : : \
 3306       "$func_to_host_path_tmp1" "$func_to_host_path_result"
 3307     func_convert_path_front_back_pathsep ":*" "*:" : "$1"
 3308   fi
 3309 }
 3310 # end func_convert_path_msys_to_cygwin
 3311 
 3312 
 3313 # func_convert_path_nix_to_cygwin ARG
 3314 # Convert path ARG from *nix to Cygwin format.  Requires Cygwin installed in a
 3315 # a wine environment, working winepath, and LT_CYGPATH set.  Returns result in
 3316 # func_to_host_file_result.
 3317 func_convert_path_nix_to_cygwin ()
 3318 {
 3319   $debug_cmd
 3320 
 3321   func_to_host_path_result=$1
 3322   if test -n "$1"; then
 3323     # Remove leading and trailing path separator characters from
 3324     # ARG. msys behavior is inconsistent here, cygpath turns them
 3325     # into '.;' and ';.', and winepath ignores them completely.
 3326     func_stripname : : "$1"
 3327     func_to_host_path_tmp1=$func_stripname_result
 3328     func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
 3329     func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
 3330     func_to_host_path_result=$func_cygpath_result
 3331     func_convert_path_check : : \
 3332       "$func_to_host_path_tmp1" "$func_to_host_path_result"
 3333     func_convert_path_front_back_pathsep ":*" "*:" : "$1"
 3334   fi
 3335 }
 3336 # end func_convert_path_nix_to_cygwin
 3337 
 3338 
 3339 # func_dll_def_p FILE
 3340 # True iff FILE is a Windows DLL '.def' file.
 3341 # Keep in sync with _LT_DLL_DEF_P in libtool.m4
 3342 func_dll_def_p ()
 3343 {
 3344   $debug_cmd
 3345 
 3346   func_dll_def_p_tmp=`$SED -n \
 3347     -e 's/^[     ]*//' \
 3348     -e '/^\(;.*\)*$/d' \
 3349     -e 's/^\(EXPORTS\|LIBRARY\)\([   ].*\)*$/DEF/p' \
 3350     -e q \
 3351     "$1"`
 3352   test DEF = "$func_dll_def_p_tmp"
 3353 }
 3354 
 3355 
 3356 # func_mode_compile arg...
 3357 func_mode_compile ()
 3358 {
 3359     $debug_cmd
 3360 
 3361     # Get the compilation command and the source file.
 3362     base_compile=
 3363     srcfile=$nonopt  #  always keep a non-empty value in "srcfile"
 3364     suppress_opt=yes
 3365     suppress_output=
 3366     arg_mode=normal
 3367     libobj=
 3368     later=
 3369     pie_flag=
 3370 
 3371     for arg
 3372     do
 3373       case $arg_mode in
 3374       arg  )
 3375     # do not "continue".  Instead, add this to base_compile
 3376     lastarg=$arg
 3377     arg_mode=normal
 3378     ;;
 3379 
 3380       target )
 3381     libobj=$arg
 3382     arg_mode=normal
 3383     continue
 3384     ;;
 3385 
 3386       normal )
 3387     # Accept any command-line options.
 3388     case $arg in
 3389     -o)
 3390       test -n "$libobj" && \
 3391         func_fatal_error "you cannot specify '-o' more than once"
 3392       arg_mode=target
 3393       continue
 3394       ;;
 3395 
 3396     -pie | -fpie | -fPIE)
 3397           func_append pie_flag " $arg"
 3398       continue
 3399       ;;
 3400 
 3401     -shared | -static | -prefer-pic | -prefer-non-pic)
 3402       func_append later " $arg"
 3403       continue
 3404       ;;
 3405 
 3406     -no-suppress)
 3407       suppress_opt=no
 3408       continue
 3409       ;;
 3410 
 3411     -Xcompiler)
 3412       arg_mode=arg  #  the next one goes into the "base_compile" arg list
 3413       continue      #  The current "srcfile" will either be retained or
 3414       ;;            #  replaced later.  I would guess that would be a bug.
 3415 
 3416     -Wc,*)
 3417       func_stripname '-Wc,' '' "$arg"
 3418       args=$func_stripname_result
 3419       lastarg=
 3420       save_ifs=$IFS; IFS=,
 3421       for arg in $args; do
 3422         IFS=$save_ifs
 3423         func_append_quoted lastarg "$arg"
 3424       done
 3425       IFS=$save_ifs
 3426       func_stripname ' ' '' "$lastarg"
 3427       lastarg=$func_stripname_result
 3428 
 3429       # Add the arguments to base_compile.
 3430       func_append base_compile " $lastarg"
 3431       continue
 3432       ;;
 3433 
 3434     *)
 3435       # Accept the current argument as the source file.
 3436       # The previous "srcfile" becomes the current argument.
 3437       #
 3438       lastarg=$srcfile
 3439       srcfile=$arg
 3440       ;;
 3441     esac  #  case $arg
 3442     ;;
 3443       esac    #  case $arg_mode
 3444 
 3445       # Aesthetically quote the previous argument.
 3446       func_append_quoted base_compile "$lastarg"
 3447     done # for arg
 3448 
 3449     case $arg_mode in
 3450     arg)
 3451       func_fatal_error "you must specify an argument for -Xcompile"
 3452       ;;
 3453     target)
 3454       func_fatal_error "you must specify a target with '-o'"
 3455       ;;
 3456     *)
 3457       # Get the name of the library object.
 3458       test -z "$libobj" && {
 3459     func_basename "$srcfile"
 3460     libobj=$func_basename_result
 3461       }
 3462       ;;
 3463     esac
 3464 
 3465     # Recognize several different file suffixes.
 3466     # If the user specifies -o file.o, it is replaced with file.lo
 3467     case $libobj in
 3468     *.[cCFSifmso] | \
 3469     *.ada | *.adb | *.ads | *.asm | \
 3470     *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
 3471     *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup)
 3472       func_xform "$libobj"
 3473       libobj=$func_xform_result
 3474       ;;
 3475     esac
 3476 
 3477     case $libobj in
 3478     *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
 3479     *)
 3480       func_fatal_error "cannot determine name of library object from '$libobj'"
 3481       ;;
 3482     esac
 3483 
 3484     func_infer_tag $base_compile
 3485 
 3486     for arg in $later; do
 3487       case $arg in
 3488       -shared)
 3489     test yes = "$build_libtool_libs" \
 3490       || func_fatal_configuration "cannot build a shared library"
 3491     build_old_libs=no
 3492     continue
 3493     ;;
 3494 
 3495       -static)
 3496     build_libtool_libs=no
 3497     build_old_libs=yes
 3498     continue
 3499     ;;
 3500 
 3501       -prefer-pic)
 3502     pic_mode=yes
 3503     continue
 3504     ;;
 3505 
 3506       -prefer-non-pic)
 3507     pic_mode=no
 3508     continue
 3509     ;;
 3510       esac
 3511     done
 3512 
 3513     func_quote_for_eval "$libobj"
 3514     test "X$libobj" != "X$func_quote_for_eval_result" \
 3515       && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'    &()|`$[]' \
 3516       && func_warning "libobj name '$libobj' may not contain shell special characters."
 3517     func_dirname_and_basename "$obj" "/" ""
 3518     objname=$func_basename_result
 3519     xdir=$func_dirname_result
 3520     lobj=$xdir$objdir/$objname
 3521 
 3522     test -z "$base_compile" && \
 3523       func_fatal_help "you must specify a compilation command"
 3524 
 3525     # Delete any leftover library objects.
 3526     if test yes = "$build_old_libs"; then
 3527       removelist="$obj $lobj $libobj ${libobj}T"
 3528     else
 3529       removelist="$lobj $libobj ${libobj}T"
 3530     fi
 3531 
 3532     # On Cygwin there's no "real" PIC flag so we must build both object types
 3533     case $host_os in
 3534     cygwin* | mingw* | pw32* | os2* | cegcc*)
 3535       pic_mode=default
 3536       ;;
 3537     esac
 3538     if test no = "$pic_mode" && test pass_all != "$deplibs_check_method"; then
 3539       # non-PIC code in shared libraries is not supported
 3540       pic_mode=default
 3541     fi
 3542 
 3543     # Calculate the filename of the output object if compiler does
 3544     # not support -o with -c
 3545     if test no = "$compiler_c_o"; then
 3546       output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.$objext
 3547       lockfile=$output_obj.lock
 3548     else
 3549       output_obj=
 3550       need_locks=no
 3551       lockfile=
 3552     fi
 3553 
 3554     # Lock this critical section if it is needed
 3555     # We use this script file to make the link, it avoids creating a new file
 3556     if test yes = "$need_locks"; then
 3557       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
 3558     func_echo "Waiting for $lockfile to be removed"
 3559     sleep 2
 3560       done
 3561     elif test warn = "$need_locks"; then
 3562       if test -f "$lockfile"; then
 3563     $ECHO "\
 3564 *** ERROR, $lockfile exists and contains:
 3565 `cat $lockfile 2>/dev/null`
 3566 
 3567 This indicates that another process is trying to use the same
 3568 temporary object file, and libtool could not work around it because
 3569 your compiler does not support '-c' and '-o' together.  If you
 3570 repeat this compilation, it may succeed, by chance, but you had better
 3571 avoid parallel builds (make -j) in this platform, or get a better
 3572 compiler."
 3573 
 3574     $opt_dry_run || $RM $removelist
 3575     exit $EXIT_FAILURE
 3576       fi
 3577       func_append removelist " $output_obj"
 3578       $ECHO "$srcfile" > "$lockfile"
 3579     fi
 3580 
 3581     $opt_dry_run || $RM $removelist
 3582     func_append removelist " $lockfile"
 3583     trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
 3584 
 3585     func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
 3586     srcfile=$func_to_tool_file_result
 3587     func_quote_for_eval "$srcfile"
 3588     qsrcfile=$func_quote_for_eval_result
 3589 
 3590     # Only build a PIC object if we are building libtool libraries.
 3591     if test yes = "$build_libtool_libs"; then
 3592       # Without this assignment, base_compile gets emptied.
 3593       fbsd_hideous_sh_bug=$base_compile
 3594 
 3595       if test no != "$pic_mode"; then
 3596     command="$base_compile $qsrcfile $pic_flag"
 3597       else
 3598     # Don't build PIC code
 3599     command="$base_compile $qsrcfile"
 3600       fi
 3601 
 3602       func_mkdir_p "$xdir$objdir"
 3603 
 3604       if test -z "$output_obj"; then
 3605     # Place PIC objects in $objdir
 3606     func_append command " -o $lobj"
 3607       fi
 3608 
 3609       func_show_eval_locale "$command"  \
 3610           'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
 3611 
 3612       if test warn = "$need_locks" &&
 3613      test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
 3614     $ECHO "\
 3615 *** ERROR, $lockfile contains:
 3616 `cat $lockfile 2>/dev/null`
 3617 
 3618 but it should contain:
 3619 $srcfile
 3620 
 3621 This indicates that another process is trying to use the same
 3622 temporary object file, and libtool could not work around it because
 3623 your compiler does not support '-c' and '-o' together.  If you
 3624 repeat this compilation, it may succeed, by chance, but you had better
 3625 avoid parallel builds (make -j) in this platform, or get a better
 3626 compiler."
 3627 
 3628     $opt_dry_run || $RM $removelist
 3629     exit $EXIT_FAILURE
 3630       fi
 3631 
 3632       # Just move the object if needed, then go on to compile the next one
 3633       if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
 3634     func_show_eval '$MV "$output_obj" "$lobj"' \
 3635       'error=$?; $opt_dry_run || $RM $removelist; exit $error'
 3636       fi
 3637 
 3638       # Allow error messages only from the first compilation.
 3639       if test yes = "$suppress_opt"; then
 3640     suppress_output=' >/dev/null 2>&1'
 3641       fi
 3642     fi
 3643 
 3644     # Only build a position-dependent object if we build old libraries.
 3645     if test yes = "$build_old_libs"; then
 3646       if test yes != "$pic_mode"; then
 3647     # Don't build PIC code
 3648     command="$base_compile $qsrcfile$pie_flag"
 3649       else
 3650     command="$base_compile $qsrcfile $pic_flag"
 3651       fi
 3652       if test yes = "$compiler_c_o"; then
 3653     func_append command " -o $obj"
 3654       fi
 3655 
 3656       # Suppress compiler output if we already did a PIC compilation.
 3657       func_append command "$suppress_output"
 3658       func_show_eval_locale "$command" \
 3659         '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
 3660 
 3661       if test warn = "$need_locks" &&
 3662      test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
 3663     $ECHO "\
 3664 *** ERROR, $lockfile contains:
 3665 `cat $lockfile 2>/dev/null`
 3666 
 3667 but it should contain:
 3668 $srcfile
 3669 
 3670 This indicates that another process is trying to use the same
 3671 temporary object file, and libtool could not work around it because
 3672 your compiler does not support '-c' and '-o' together.  If you
 3673 repeat this compilation, it may succeed, by chance, but you had better
 3674 avoid parallel builds (make -j) in this platform, or get a better
 3675 compiler."
 3676 
 3677     $opt_dry_run || $RM $removelist
 3678     exit $EXIT_FAILURE
 3679       fi
 3680 
 3681       # Just move the object if needed
 3682       if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
 3683     func_show_eval '$MV "$output_obj" "$obj"' \
 3684       'error=$?; $opt_dry_run || $RM $removelist; exit $error'
 3685       fi
 3686     fi
 3687 
 3688     $opt_dry_run || {
 3689       func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
 3690 
 3691       # Unlock the critical section if it was locked
 3692       if test no != "$need_locks"; then
 3693     removelist=$lockfile
 3694         $RM "$lockfile"
 3695       fi
 3696     }
 3697 
 3698     exit $EXIT_SUCCESS
 3699 }
 3700 
 3701 $opt_help || {
 3702   test compile = "$opt_mode" && func_mode_compile ${1+"$@"}
 3703 }
 3704 
 3705 func_mode_help ()
 3706 {
 3707     # We need to display help for each of the modes.
 3708     case $opt_mode in
 3709       "")
 3710         # Generic help is extracted from the usage comments
 3711         # at the start of this file.
 3712         func_help
 3713         ;;
 3714 
 3715       clean)
 3716         $ECHO \
 3717 "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
 3718 
 3719 Remove files from the build directory.
 3720 
 3721 RM is the name of the program to use to delete files associated with each FILE
 3722 (typically '/bin/rm').  RM-OPTIONS are options (such as '-f') to be passed
 3723 to RM.
 3724 
 3725 If FILE is a libtool library, object or program, all the files associated
 3726 with it are deleted. Otherwise, only FILE itself is deleted using RM."
 3727         ;;
 3728 
 3729       compile)
 3730       $ECHO \
 3731 "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
 3732 
 3733 Compile a source file into a libtool library object.
 3734 
 3735 This mode accepts the following additional options:
 3736 
 3737   -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
 3738   -no-suppress      do not suppress compiler output for multiple passes
 3739   -prefer-pic       try to build PIC objects only
 3740   -prefer-non-pic   try to build non-PIC objects only
 3741   -shared           do not build a '.o' file suitable for static linking
 3742   -static           only build a '.o' file suitable for static linking
 3743   -Wc,FLAG          pass FLAG directly to the compiler
 3744 
 3745 COMPILE-COMMAND is a command to be used in creating a 'standard' object file
 3746 from the given SOURCEFILE.
 3747 
 3748 The output file name is determined by removing the directory component from
 3749 SOURCEFILE, then substituting the C source code suffix '.c' with the
 3750 library object suffix, '.lo'."
 3751         ;;
 3752 
 3753       execute)
 3754         $ECHO \
 3755 "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
 3756 
 3757 Automatically set library path, then run a program.
 3758 
 3759 This mode accepts the following additional options:
 3760 
 3761   -dlopen FILE      add the directory containing FILE to the library path
 3762 
 3763 This mode sets the library path environment variable according to '-dlopen'
 3764 flags.
 3765 
 3766 If any of the ARGS are libtool executable wrappers, then they are translated
 3767 into their corresponding uninstalled binary, and any of their required library
 3768 directories are added to the library path.
 3769 
 3770 Then, COMMAND is executed, with ARGS as arguments."
 3771         ;;
 3772 
 3773       finish)
 3774         $ECHO \
 3775 "Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
 3776 
 3777 Complete the installation of libtool libraries.
 3778 
 3779 Each LIBDIR is a directory that contains libtool libraries.
 3780 
 3781 The commands that this mode executes may require superuser privileges.  Use
 3782 the '--dry-run' option if you just want to see what would be executed."
 3783         ;;
 3784 
 3785       install)
 3786         $ECHO \
 3787 "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
 3788 
 3789 Install executables or libraries.
 3790 
 3791 INSTALL-COMMAND is the installation command.  The first component should be
 3792 either the 'install' or 'cp' program.
 3793 
 3794 The following components of INSTALL-COMMAND are treated specially:
 3795 
 3796   -inst-prefix-dir PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
 3797 
 3798 The rest of the components are interpreted as arguments to that command (only
 3799 BSD-compatible install options are recognized)."
 3800         ;;
 3801 
 3802       link)
 3803         $ECHO \
 3804 "Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
 3805 
 3806 Link object files or libraries together to form another library, or to
 3807 create an executable program.
 3808 
 3809 LINK-COMMAND is a command using the C compiler that you would use to create
 3810 a program from several object files.
 3811 
 3812 The following components of LINK-COMMAND are treated specially:
 3813 
 3814   -all-static       do not do any dynamic linking at all
 3815   -avoid-version    do not add a version suffix if possible
 3816   -bindir BINDIR    specify path to binaries directory (for systems where
 3817                     libraries must be found in the PATH setting at runtime)
 3818   -dlopen FILE      '-dlpreopen' FILE if it cannot be dlopened at runtime
 3819   -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
 3820   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
 3821   -export-symbols SYMFILE
 3822                     try to export only the symbols listed in SYMFILE
 3823   -export-symbols-regex REGEX
 3824                     try to export only the symbols matching REGEX
 3825   -LLIBDIR          search LIBDIR for required installed libraries
 3826   -lNAME            OUTPUT-FILE requires the installed library libNAME
 3827   -module           build a library that can dlopened
 3828   -no-fast-install  disable the fast-install mode
 3829   -no-install       link a not-installable executable
 3830   -no-undefined     declare that a library does not refer to external symbols
 3831   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
 3832   -objectlist FILE  use a list of object files found in FILE to specify objects
 3833   -os2dllname NAME  force a short DLL name on OS/2 (no effect on other OSes)
 3834   -precious-files-regex REGEX
 3835                     don't remove output files matching REGEX
 3836   -release RELEASE  specify package release information
 3837   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
 3838   -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
 3839   -shared           only do dynamic linking of libtool libraries
 3840   -shrext SUFFIX    override the standard shared library file extension
 3841   -static           do not do any dynamic linking of uninstalled libtool libraries
 3842   -static-libtool-libs
 3843                     do not do any dynamic linking of libtool libraries
 3844   -version-info CURRENT[:REVISION[:AGE]]
 3845                     specify library version info [each variable defaults to 0]
 3846   -weak LIBNAME     declare that the target provides the LIBNAME interface
 3847   -Wc,FLAG
 3848   -Xcompiler FLAG   pass linker-specific FLAG directly to the compiler
 3849   -Wl,FLAG
 3850   -Xlinker FLAG     pass linker-specific FLAG directly to the linker
 3851   -XCClinker FLAG   pass link-specific FLAG to the compiler driver (CC)
 3852 
 3853 All other options (arguments beginning with '-') are ignored.
 3854 
 3855 Every other argument is treated as a filename.  Files ending in '.la' are
 3856 treated as uninstalled libtool libraries, other files are standard or library
 3857 object files.
 3858 
 3859 If the OUTPUT-FILE ends in '.la', then a libtool library is created,
 3860 only library objects ('.lo' files) may be specified, and '-rpath' is
 3861 required, except when creating a convenience library.
 3862 
 3863 If OUTPUT-FILE ends in '.a' or '.lib', then a standard library is created
 3864 using 'ar' and 'ranlib', or on Windows using 'lib'.
 3865 
 3866 If OUTPUT-FILE ends in '.lo' or '.$objext', then a reloadable object file
 3867 is created, otherwise an executable program is created."
 3868         ;;
 3869 
 3870       uninstall)
 3871         $ECHO \
 3872 "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
 3873 
 3874 Remove libraries from an installation directory.
 3875 
 3876 RM is the name of the program to use to delete files associated with each FILE
 3877 (typically '/bin/rm').  RM-OPTIONS are options (such as '-f') to be passed
 3878 to RM.
 3879 
 3880 If FILE is a libtool library, all the files associated with it are deleted.
 3881 Otherwise, only FILE itself is deleted using RM."
 3882         ;;
 3883 
 3884       *)
 3885         func_fatal_help "invalid operation mode '$opt_mode'"
 3886         ;;
 3887     esac
 3888 
 3889     echo
 3890     $ECHO "Try '$progname --help' for more information about other modes."
 3891 }
 3892 
 3893 # Now that we've collected a possible --mode arg, show help if necessary
 3894 if $opt_help; then
 3895   if test : = "$opt_help"; then
 3896     func_mode_help
 3897   else
 3898     {
 3899       func_help noexit
 3900       for opt_mode in compile link execute install finish uninstall clean; do
 3901     func_mode_help
 3902       done
 3903     } | $SED -n '1p; 2,$s/^Usage:/  or: /p'
 3904     {
 3905       func_help noexit
 3906       for opt_mode in compile link execute install finish uninstall clean; do
 3907     echo
 3908     func_mode_help
 3909       done
 3910     } |
 3911     $SED '1d
 3912       /^When reporting/,/^Report/{
 3913     H
 3914     d
 3915       }
 3916       $x
 3917       /information about other modes/d
 3918       /more detailed .*MODE/d
 3919       s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
 3920   fi
 3921   exit $?
 3922 fi
 3923 
 3924 
 3925 # func_mode_execute arg...
 3926 func_mode_execute ()
 3927 {
 3928     $debug_cmd
 3929 
 3930     # The first argument is the command name.
 3931     cmd=$nonopt
 3932     test -z "$cmd" && \
 3933       func_fatal_help "you must specify a COMMAND"
 3934 
 3935     # Handle -dlopen flags immediately.
 3936     for file in $opt_dlopen; do
 3937       test -f "$file" \
 3938     || func_fatal_help "'$file' is not a file"
 3939 
 3940       dir=
 3941       case $file in
 3942       *.la)
 3943     func_resolve_sysroot "$file"
 3944     file=$func_resolve_sysroot_result
 3945 
 3946     # Check to see that this really is a libtool archive.
 3947     func_lalib_unsafe_p "$file" \
 3948       || func_fatal_help "'$lib' is not a valid libtool archive"
 3949 
 3950     # Read the libtool library.
 3951     dlname=
 3952     library_names=
 3953     func_source "$file"
 3954 
 3955     # Skip this library if it cannot be dlopened.
 3956     if test -z "$dlname"; then
 3957       # Warn if it was a shared library.
 3958       test -n "$library_names" && \
 3959         func_warning "'$file' was not linked with '-export-dynamic'"
 3960       continue
 3961     fi
 3962 
 3963     func_dirname "$file" "" "."
 3964     dir=$func_dirname_result
 3965 
 3966     if test -f "$dir/$objdir/$dlname"; then
 3967       func_append dir "/$objdir"
 3968     else
 3969       if test ! -f "$dir/$dlname"; then
 3970         func_fatal_error "cannot find '$dlname' in '$dir' or '$dir/$objdir'"
 3971       fi
 3972     fi
 3973     ;;
 3974 
 3975       *.lo)
 3976     # Just add the directory containing the .lo file.
 3977     func_dirname "$file" "" "."
 3978     dir=$func_dirname_result
 3979     ;;
 3980 
 3981       *)
 3982     func_warning "'-dlopen' is ignored for non-libtool libraries and objects"
 3983     continue
 3984     ;;
 3985       esac
 3986 
 3987       # Get the absolute pathname.
 3988       absdir=`cd "$dir" && pwd`
 3989       test -n "$absdir" && dir=$absdir
 3990 
 3991       # Now add the directory to shlibpath_var.
 3992       if eval "test -z \"\$$shlibpath_var\""; then
 3993     eval "$shlibpath_var=\"\$dir\""
 3994       else
 3995     eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
 3996       fi
 3997     done
 3998 
 3999     # This variable tells wrapper scripts just to set shlibpath_var
 4000     # rather than running their programs.
 4001     libtool_execute_magic=$magic
 4002 
 4003     # Check if any of the arguments is a wrapper script.
 4004     args=
 4005     for file
 4006     do
 4007       case $file in
 4008       -* | *.la | *.lo ) ;;
 4009       *)
 4010     # Do a test to see if this is really a libtool program.
 4011     if func_ltwrapper_script_p "$file"; then
 4012       func_source "$file"
 4013       # Transform arg to wrapped name.
 4014       file=$progdir/$program
 4015     elif func_ltwrapper_executable_p "$file"; then
 4016       func_ltwrapper_scriptname "$file"
 4017       func_source "$func_ltwrapper_scriptname_result"
 4018       # Transform arg to wrapped name.
 4019       file=$progdir/$program
 4020     fi
 4021     ;;
 4022       esac
 4023       # Quote arguments (to preserve shell metacharacters).
 4024       func_append_quoted args "$file"
 4025     done
 4026 
 4027     if $opt_dry_run; then
 4028       # Display what would be done.
 4029       if test -n "$shlibpath_var"; then
 4030     eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
 4031     echo "export $shlibpath_var"
 4032       fi
 4033       $ECHO "$cmd$args"
 4034       exit $EXIT_SUCCESS
 4035     else
 4036       if test -n "$shlibpath_var"; then
 4037     # Export the shlibpath_var.
 4038     eval "export $shlibpath_var"
 4039       fi
 4040 
 4041       # Restore saved environment variables
 4042       for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
 4043       do
 4044     eval "if test \"\${save_$lt_var+set}\" = set; then
 4045                 $lt_var=\$save_$lt_var; export $lt_var
 4046           else
 4047         $lt_unset $lt_var
 4048           fi"
 4049       done
 4050 
 4051       # Now prepare to actually exec the command.
 4052       exec_cmd=\$cmd$args
 4053     fi
 4054 }
 4055 
 4056 test execute = "$opt_mode" && func_mode_execute ${1+"$@"}
 4057 
 4058 
 4059 # func_mode_finish arg...
 4060 func_mode_finish ()
 4061 {
 4062     $debug_cmd
 4063 
 4064     libs=
 4065     libdirs=
 4066     admincmds=
 4067 
 4068     for opt in "$nonopt" ${1+"$@"}
 4069     do
 4070       if test -d "$opt"; then
 4071     func_append libdirs " $opt"
 4072 
 4073       elif test -f "$opt"; then
 4074     if func_lalib_unsafe_p "$opt"; then
 4075       func_append libs " $opt"
 4076     else
 4077       func_warning "'$opt' is not a valid libtool archive"
 4078     fi
 4079 
 4080       else
 4081     func_fatal_error "invalid argument '$opt'"
 4082       fi
 4083     done
 4084 
 4085     if test -n "$libs"; then
 4086       if test -n "$lt_sysroot"; then
 4087         sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
 4088         sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
 4089       else
 4090         sysroot_cmd=
 4091       fi
 4092 
 4093       # Remove sysroot references
 4094       if $opt_dry_run; then
 4095         for lib in $libs; do
 4096           echo "removing references to $lt_sysroot and '=' prefixes from $lib"
 4097         done
 4098       else
 4099         tmpdir=`func_mktempdir`
 4100         for lib in $libs; do
 4101       $SED -e "$sysroot_cmd s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
 4102         > $tmpdir/tmp-la
 4103       mv -f $tmpdir/tmp-la $lib
 4104     done
 4105         ${RM}r "$tmpdir"
 4106       fi
 4107     fi
 4108 
 4109     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
 4110       for libdir in $libdirs; do
 4111     if test -n "$finish_cmds"; then
 4112       # Do each command in the finish commands.
 4113       func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
 4114 '"$cmd"'"'
 4115     fi
 4116     if test -n "$finish_eval"; then
 4117       # Do the single finish_eval.
 4118       eval cmds=\"$finish_eval\"
 4119       $opt_dry_run || eval "$cmds" || func_append admincmds "
 4120        $cmds"
 4121     fi
 4122       done
 4123     fi
 4124 
 4125     # Exit here if they wanted silent mode.
 4126     $opt_quiet && exit $EXIT_SUCCESS
 4127 
 4128     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
 4129       echo "----------------------------------------------------------------------"
 4130       echo "Libraries have been installed in:"
 4131       for libdir in $libdirs; do
 4132     $ECHO "   $libdir"
 4133       done
 4134       echo
 4135       echo "If you ever happen to want to link against installed libraries"
 4136       echo "in a given directory, LIBDIR, you must either use libtool, and"
 4137       echo "specify the full pathname of the library, or use the '-LLIBDIR'"
 4138       echo "flag during linking and do at least one of the following:"
 4139       if test -n "$shlibpath_var"; then
 4140     echo "   - add LIBDIR to the '$shlibpath_var' environment variable"
 4141     echo "     during execution"
 4142       fi
 4143       if test -n "$runpath_var"; then
 4144     echo "   - add LIBDIR to the '$runpath_var' environment variable"
 4145     echo "     during linking"
 4146       fi
 4147       if test -n "$hardcode_libdir_flag_spec"; then
 4148     libdir=LIBDIR
 4149     eval flag=\"$hardcode_libdir_flag_spec\"
 4150 
 4151     $ECHO "   - use the '$flag' linker flag"
 4152       fi
 4153       if test -n "$admincmds"; then
 4154     $ECHO "   - have your system administrator run these commands:$admincmds"
 4155       fi
 4156       if test -f /etc/ld.so.conf; then
 4157     echo "   - have your system administrator add LIBDIR to '/etc/ld.so.conf'"
 4158       fi
 4159       echo
 4160 
 4161       echo "See any operating system documentation about shared libraries for"
 4162       case $host in
 4163     solaris2.[6789]|solaris2.1[0-9])
 4164       echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
 4165       echo "pages."
 4166       ;;
 4167     *)
 4168       echo "more information, such as the ld(1) and ld.so(8) manual pages."
 4169       ;;
 4170       esac
 4171       echo "----------------------------------------------------------------------"
 4172     fi
 4173     exit $EXIT_SUCCESS
 4174 }
 4175 
 4176 test finish = "$opt_mode" && func_mode_finish ${1+"$@"}
 4177 
 4178 
 4179 # func_mode_install arg...
 4180 func_mode_install ()
 4181 {
 4182     $debug_cmd
 4183 
 4184     # There may be an optional sh(1) argument at the beginning of
 4185     # install_prog (especially on Windows NT).
 4186     if test "$SHELL" = "$nonopt" || test /bin/sh = "$nonopt" ||
 4187        # Allow the use of GNU shtool's install command.
 4188        case $nonopt in *shtool*) :;; *) false;; esac
 4189     then
 4190       # Aesthetically quote it.
 4191       func_quote_for_eval "$nonopt"
 4192       install_prog="$func_quote_for_eval_result "
 4193       arg=$1
 4194       shift
 4195     else
 4196       install_prog=
 4197       arg=$nonopt
 4198     fi
 4199 
 4200     # The real first argument should be the name of the installation program.
 4201     # Aesthetically quote it.
 4202     func_quote_for_eval "$arg"
 4203     func_append install_prog "$func_quote_for_eval_result"
 4204     install_shared_prog=$install_prog
 4205     case " $install_prog " in
 4206       *[\\\ /]cp\ *) install_cp=: ;;
 4207       *) install_cp=false ;;
 4208     esac
 4209 
 4210     # We need to accept at least all the BSD install flags.
 4211     dest=
 4212     files=
 4213     opts=
 4214     prev=
 4215     install_type=
 4216     isdir=false
 4217     stripme=
 4218     no_mode=:
 4219     for arg
 4220     do
 4221       arg2=
 4222       if test -n "$dest"; then
 4223     func_append files " $dest"
 4224     dest=$arg
 4225     continue
 4226       fi
 4227 
 4228       case $arg in
 4229       -d) isdir=: ;;
 4230       -f)
 4231     if $install_cp; then :; else
 4232       prev=$arg
 4233     fi
 4234     ;;
 4235       -g | -m | -o)
 4236     prev=$arg
 4237     ;;
 4238       -s)
 4239     stripme=" -s"
 4240     continue
 4241     ;;
 4242       -*)
 4243     ;;
 4244       *)
 4245     # If the previous option needed an argument, then skip it.
 4246     if test -n "$prev"; then
 4247       if test X-m = "X$prev" && test -n "$install_override_mode"; then
 4248         arg2=$install_override_mode
 4249         no_mode=false
 4250       fi
 4251       prev=
 4252     else
 4253       dest=$arg
 4254       continue
 4255     fi
 4256     ;;
 4257       esac
 4258 
 4259       # Aesthetically quote the argument.
 4260       func_quote_for_eval "$arg"
 4261       func_append install_prog " $func_quote_for_eval_result"
 4262       if test -n "$arg2"; then
 4263     func_quote_for_eval "$arg2"
 4264       fi
 4265       func_append install_shared_prog " $func_quote_for_eval_result"
 4266     done
 4267 
 4268     test -z "$install_prog" && \
 4269       func_fatal_help "you must specify an install program"
 4270 
 4271     test -n "$prev" && \
 4272       func_fatal_help "the '$prev' option requires an argument"
 4273 
 4274     if test -n "$install_override_mode" && $no_mode; then
 4275       if $install_cp; then :; else
 4276     func_quote_for_eval "$install_override_mode"
 4277     func_append install_shared_prog " -m $func_quote_for_eval_result"
 4278       fi
 4279     fi
 4280 
 4281     if test -z "$files"; then
 4282       if test -z "$dest"; then
 4283     func_fatal_help "no file or destination specified"
 4284       else
 4285     func_fatal_help "you must specify a destination"
 4286       fi
 4287     fi
 4288 
 4289     # Strip any trailing slash from the destination.
 4290     func_stripname '' '/' "$dest"
 4291     dest=$func_stripname_result
 4292 
 4293     # Check to see that the destination is a directory.
 4294     test -d "$dest" && isdir=:
 4295     if $isdir; then
 4296       destdir=$dest
 4297       destname=
 4298     else
 4299       func_dirname_and_basename "$dest" "" "."
 4300       destdir=$func_dirname_result
 4301       destname=$func_basename_result
 4302 
 4303       # Not a directory, so check to see that there is only one file specified.
 4304       set dummy $files; shift
 4305       test "$#" -gt 1 && \
 4306     func_fatal_help "'$dest' is not a directory"
 4307     fi
 4308     case $destdir in
 4309     [\\/]* | [A-Za-z]:[\\/]*) ;;
 4310     *)
 4311       for file in $files; do
 4312     case $file in
 4313     *.lo) ;;
 4314     *)
 4315       func_fatal_help "'$destdir' must be an absolute directory name"
 4316       ;;
 4317     esac
 4318       done
 4319       ;;
 4320     esac
 4321 
 4322     # This variable tells wrapper scripts just to set variables rather
 4323     # than running their programs.
 4324     libtool_install_magic=$magic
 4325 
 4326     staticlibs=
 4327     future_libdirs=
 4328     current_libdirs=
 4329     for file in $files; do
 4330 
 4331       # Do each installation.
 4332       case $file in
 4333       *.$libext)
 4334     # Do the static libraries later.
 4335     func_append staticlibs " $file"
 4336     ;;
 4337 
 4338       *.la)
 4339     func_resolve_sysroot "$file"
 4340     file=$func_resolve_sysroot_result
 4341 
 4342     # Check to see that this really is a libtool archive.
 4343     func_lalib_unsafe_p "$file" \
 4344       || func_fatal_help "'$file' is not a valid libtool archive"
 4345 
 4346     library_names=
 4347     old_library=
 4348     relink_command=
 4349     func_source "$file"
 4350 
 4351     # Add the libdir to current_libdirs if it is the destination.
 4352     if test "X$destdir" = "X$libdir"; then
 4353       case "$current_libdirs " in
 4354       *" $libdir "*) ;;
 4355       *) func_append current_libdirs " $libdir" ;;
 4356       esac
 4357     else
 4358       # Note the libdir as a future libdir.
 4359       case "$future_libdirs " in
 4360       *" $libdir "*) ;;
 4361       *) func_append future_libdirs " $libdir" ;;
 4362       esac
 4363     fi
 4364 
 4365     func_dirname "$file" "/" ""
 4366     dir=$func_dirname_result
 4367     func_append dir "$objdir"
 4368 
 4369     if test -n "$relink_command"; then
 4370       # Determine the prefix the user has applied to our future dir.
 4371       inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
 4372 
 4373       # Don't allow the user to place us outside of our expected
 4374       # location b/c this prevents finding dependent libraries that
 4375       # are installed to the same prefix.
 4376       # At present, this check doesn't affect windows .dll's that
 4377       # are installed into $libdir/../bin (currently, that works fine)
 4378       # but it's something to keep an eye on.
 4379       test "$inst_prefix_dir" = "$destdir" && \
 4380         func_fatal_error "error: cannot install '$file' to a directory not ending in $libdir"
 4381 
 4382       if test -n "$inst_prefix_dir"; then
 4383         # Stick the inst_prefix_dir data into the link command.
 4384         relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
 4385       else
 4386         relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
 4387       fi
 4388 
 4389       func_warning "relinking '$file'"
 4390       func_show_eval "$relink_command" \
 4391         'func_fatal_error "error: relink '\''$file'\'' with the above command before installing it"'
 4392     fi
 4393 
 4394     # See the names of the shared library.
 4395     set dummy $library_names; shift
 4396     if test -n "$1"; then
 4397       realname=$1
 4398       shift
 4399 
 4400       srcname=$realname
 4401       test -n "$relink_command" && srcname=${realname}T
 4402 
 4403       # Install the shared library and build the symlinks.
 4404       func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
 4405           'exit $?'
 4406       tstripme=$stripme
 4407       case $host_os in
 4408       cygwin* | mingw* | pw32* | cegcc*)
 4409         case $realname in
 4410         *.dll.a)
 4411           tstripme=
 4412           ;;
 4413         esac
 4414         ;;
 4415       os2*)
 4416         case $realname in
 4417         *_dll.a)
 4418           tstripme=
 4419           ;;
 4420         esac
 4421         ;;
 4422       esac
 4423       if test -n "$tstripme" && test -n "$striplib"; then
 4424         func_show_eval "$striplib $destdir/$realname" 'exit $?'
 4425       fi
 4426 
 4427       if test "$#" -gt 0; then
 4428         # Delete the old symlinks, and create new ones.
 4429         # Try 'ln -sf' first, because the 'ln' binary might depend on
 4430         # the symlink we replace!  Solaris /bin/ln does not understand -f,
 4431         # so we also need to try rm && ln -s.
 4432         for linkname
 4433         do
 4434           test "$linkname" != "$realname" \
 4435         && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
 4436         done
 4437       fi
 4438 
 4439       # Do each command in the postinstall commands.
 4440       lib=$destdir/$realname
 4441       func_execute_cmds "$postinstall_cmds" 'exit $?'
 4442     fi
 4443 
 4444     # Install the pseudo-library for information purposes.
 4445     func_basename "$file"
 4446     name=$func_basename_result
 4447     instname=$dir/${name}i
 4448     func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
 4449 
 4450     # Maybe install the static library, too.
 4451     test -n "$old_library" && func_append staticlibs " $dir/$old_library"
 4452     ;;
 4453 
 4454       *.lo)
 4455     # Install (i.e. copy) a libtool object.
 4456 
 4457     # Figure out destination file name, if it wasn't already specified.
 4458     if test -n "$destname"; then
 4459       destfile=$destdir/$destname
 4460     else
 4461       func_basename "$file"
 4462       destfile=$func_basename_result
 4463       destfile=$destdir/$destfile
 4464     fi
 4465 
 4466     # Deduce the name of the destination old-style object file.
 4467     case $destfile in
 4468     *.lo)
 4469       func_lo2o "$destfile"
 4470       staticdest=$func_lo2o_result
 4471       ;;
 4472     *.$objext)
 4473       staticdest=$destfile
 4474       destfile=
 4475       ;;
 4476     *)
 4477       func_fatal_help "cannot copy a libtool object to '$destfile'"
 4478       ;;
 4479     esac
 4480 
 4481     # Install the libtool object if requested.
 4482     test -n "$destfile" && \
 4483       func_show_eval "$install_prog $file $destfile" 'exit $?'
 4484 
 4485     # Install the old object if enabled.
 4486     if test yes = "$build_old_libs"; then
 4487       # Deduce the name of the old-style object file.
 4488       func_lo2o "$file"
 4489       staticobj=$func_lo2o_result
 4490       func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
 4491     fi
 4492     exit $EXIT_SUCCESS
 4493     ;;
 4494 
 4495       *)
 4496     # Figure out destination file name, if it wasn't already specified.
 4497     if test -n "$destname"; then
 4498       destfile=$destdir/$destname
 4499     else
 4500       func_basename "$file"
 4501       destfile=$func_basename_result
 4502       destfile=$destdir/$destfile
 4503     fi
 4504 
 4505     # If the file is missing, and there is a .exe on the end, strip it
 4506     # because it is most likely a libtool script we actually want to
 4507     # install
 4508     stripped_ext=
 4509     case $file in
 4510       *.exe)
 4511         if test ! -f "$file"; then
 4512           func_stripname '' '.exe' "$file"
 4513           file=$func_stripname_result
 4514           stripped_ext=.exe
 4515         fi
 4516         ;;
 4517     esac
 4518 
 4519     # Do a test to see if this is really a libtool program.
 4520     case $host in
 4521     *cygwin* | *mingw*)
 4522         if func_ltwrapper_executable_p "$file"; then
 4523           func_ltwrapper_scriptname "$file"
 4524           wrapper=$func_ltwrapper_scriptname_result
 4525         else
 4526           func_stripname '' '.exe' "$file"
 4527           wrapper=$func_stripname_result
 4528         fi
 4529         ;;
 4530     *)
 4531         wrapper=$file
 4532         ;;
 4533     esac
 4534     if func_ltwrapper_script_p "$wrapper"; then
 4535       notinst_deplibs=
 4536       relink_command=
 4537 
 4538       func_source "$wrapper"
 4539 
 4540       # Check the variables that should have been set.
 4541       test -z "$generated_by_libtool_version" && \
 4542         func_fatal_error "invalid libtool wrapper script '$wrapper'"
 4543 
 4544       finalize=:
 4545       for lib in $notinst_deplibs; do
 4546         # Check to see that each library is installed.
 4547         libdir=
 4548         if test -f "$lib"; then
 4549           func_source "$lib"
 4550         fi
 4551         libfile=$libdir/`$ECHO "$lib" | $SED 's%^.*/%%g'`
 4552         if test -n "$libdir" && test ! -f "$libfile"; then
 4553           func_warning "'$lib' has not been installed in '$libdir'"
 4554           finalize=false
 4555         fi
 4556       done
 4557 
 4558       relink_command=
 4559       func_source "$wrapper"
 4560 
 4561       outputname=
 4562       if test no = "$fast_install" && test -n "$relink_command"; then
 4563         $opt_dry_run || {
 4564           if $finalize; then
 4565             tmpdir=`func_mktempdir`
 4566         func_basename "$file$stripped_ext"
 4567         file=$func_basename_result
 4568             outputname=$tmpdir/$file
 4569             # Replace the output file specification.
 4570             relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
 4571 
 4572             $opt_quiet || {
 4573               func_quote_for_expand "$relink_command"
 4574           eval "func_echo $func_quote_for_expand_result"
 4575             }
 4576             if eval "$relink_command"; then :
 4577               else
 4578           func_error "error: relink '$file' with the above command before installing it"
 4579           $opt_dry_run || ${RM}r "$tmpdir"
 4580           continue
 4581             fi
 4582             file=$outputname
 4583           else
 4584             func_warning "cannot relink '$file'"
 4585           fi
 4586         }
 4587       else
 4588         # Install the binary that we compiled earlier.
 4589         file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
 4590       fi
 4591     fi
 4592 
 4593     # remove .exe since cygwin /usr/bin/install will append another
 4594     # one anyway
 4595     case $install_prog,$host in
 4596     */usr/bin/install*,*cygwin*)
 4597       case $file:$destfile in
 4598       *.exe:*.exe)
 4599         # this is ok
 4600         ;;
 4601       *.exe:*)
 4602         destfile=$destfile.exe
 4603         ;;
 4604       *:*.exe)
 4605         func_stripname '' '.exe' "$destfile"
 4606         destfile=$func_stripname_result
 4607         ;;
 4608       esac
 4609       ;;
 4610     esac
 4611     func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
 4612     $opt_dry_run || if test -n "$outputname"; then
 4613       ${RM}r "$tmpdir"
 4614     fi
 4615     ;;
 4616       esac
 4617     done
 4618 
 4619     for file in $staticlibs; do
 4620       func_basename "$file"
 4621       name=$func_basename_result
 4622 
 4623       # Set up the ranlib parameters.
 4624       oldlib=$destdir/$name
 4625       func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
 4626       tool_oldlib=$func_to_tool_file_result
 4627 
 4628       func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
 4629 
 4630       if test -n "$stripme" && test -n "$old_striplib"; then
 4631     func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
 4632       fi
 4633 
 4634       # Do each command in the postinstall commands.
 4635       func_execute_cmds "$old_postinstall_cmds" 'exit $?'
 4636     done
 4637 
 4638     test -n "$future_libdirs" && \
 4639       func_warning "remember to run '$progname --finish$future_libdirs'"
 4640 
 4641     if test -n "$current_libdirs"; then
 4642       # Maybe just do a dry run.
 4643       $opt_dry_run && current_libdirs=" -n$current_libdirs"
 4644       exec_cmd='$SHELL "$progpath" $preserve_args --finish$current_libdirs'
 4645     else
 4646       exit $EXIT_SUCCESS
 4647     fi
 4648 }
 4649 
 4650 test install = "$opt_mode" && func_mode_install ${1+"$@"}
 4651 
 4652 
 4653 # func_generate_dlsyms outputname originator pic_p
 4654 # Extract symbols from dlprefiles and create ${outputname}S.o with
 4655 # a dlpreopen symbol table.
 4656 func_generate_dlsyms ()
 4657 {
 4658     $debug_cmd
 4659 
 4660     my_outputname=$1
 4661     my_originator=$2
 4662     my_pic_p=${3-false}
 4663     my_prefix=`$ECHO "$my_originator" | $SED 's%[^a-zA-Z0-9]%_%g'`
 4664     my_dlsyms=
 4665 
 4666     if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
 4667       if test -n "$NM" && test -n "$global_symbol_pipe"; then
 4668     my_dlsyms=${my_outputname}S.c
 4669       else
 4670     func_error "not configured to extract global symbols from dlpreopened files"
 4671       fi
 4672     fi
 4673 
 4674     if test -n "$my_dlsyms"; then
 4675       case $my_dlsyms in
 4676       "") ;;
 4677       *.c)
 4678     # Discover the nlist of each of the dlfiles.
 4679     nlist=$output_objdir/$my_outputname.nm
 4680 
 4681     func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
 4682 
 4683     # Parse the name list into a source file.
 4684     func_verbose "creating $output_objdir/$my_dlsyms"
 4685 
 4686     $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
 4687 /* $my_dlsyms - symbol resolution table for '$my_outputname' dlsym emulation. */
 4688 /* Generated by $PROGRAM (GNU $PACKAGE) $VERSION */
 4689 
 4690 #ifdef __cplusplus
 4691 extern \"C\" {
 4692 #endif
 4693 
 4694 #if defined __GNUC__ && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
 4695 #pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
 4696 #endif
 4697 
 4698 /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
 4699 #if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE
 4700 /* DATA imports from DLLs on WIN32 can't be const, because runtime
 4701    relocations are performed -- see ld's documentation on pseudo-relocs.  */
 4702 # define LT_DLSYM_CONST
 4703 #elif defined __osf__
 4704 /* This system does not cope well with relocations in const data.  */
 4705 # define LT_DLSYM_CONST
 4706 #else
 4707 # define LT_DLSYM_CONST const
 4708 #endif
 4709 
 4710 #define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)
 4711 
 4712 /* External symbol declarations for the compiler. */\
 4713 "
 4714 
 4715     if test yes = "$dlself"; then
 4716       func_verbose "generating symbol list for '$output'"
 4717 
 4718       $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
 4719 
 4720       # Add our own program objects to the symbol list.
 4721       progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
 4722       for progfile in $progfiles; do
 4723         func_to_tool_file "$progfile" func_convert_file_msys_to_w32
 4724         func_verbose "extracting global C symbols from '$func_to_tool_file_result'"
 4725         $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
 4726       done
 4727 
 4728       if test -n "$exclude_expsyms"; then
 4729         $opt_dry_run || {
 4730           eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
 4731           eval '$MV "$nlist"T "$nlist"'
 4732         }
 4733       fi
 4734 
 4735       if test -n "$export_symbols_regex"; then
 4736         $opt_dry_run || {
 4737           eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
 4738           eval '$MV "$nlist"T "$nlist"'
 4739         }
 4740       fi
 4741 
 4742       # Prepare the list of exported symbols
 4743       if test -z "$export_symbols"; then
 4744         export_symbols=$output_objdir/$outputname.exp
 4745         $opt_dry_run || {
 4746           $RM $export_symbols
 4747           eval "$SED -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
 4748           case $host in
 4749           *cygwin* | *mingw* | *cegcc* )
 4750                 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
 4751                 eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
 4752             ;;
 4753           esac
 4754         }
 4755       else
 4756         $opt_dry_run || {
 4757           eval "$SED -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
 4758           eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
 4759           eval '$MV "$nlist"T "$nlist"'
 4760           case $host in
 4761             *cygwin* | *mingw* | *cegcc* )
 4762               eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
 4763               eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
 4764               ;;
 4765           esac
 4766         }
 4767       fi
 4768     fi
 4769 
 4770     for dlprefile in $dlprefiles; do
 4771       func_verbose "extracting global C symbols from '$dlprefile'"
 4772       func_basename "$dlprefile"
 4773       name=$func_basename_result
 4774           case $host in
 4775         *cygwin* | *mingw* | *cegcc* )
 4776           # if an import library, we need to obtain dlname
 4777           if func_win32_import_lib_p "$dlprefile"; then
 4778             func_tr_sh "$dlprefile"
 4779             eval "curr_lafile=\$libfile_$func_tr_sh_result"
 4780             dlprefile_dlbasename=
 4781             if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
 4782               # Use subshell, to avoid clobbering current variable values
 4783               dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
 4784               if test -n "$dlprefile_dlname"; then
 4785                 func_basename "$dlprefile_dlname"
 4786                 dlprefile_dlbasename=$func_basename_result
 4787               else
 4788                 # no lafile. user explicitly requested -dlpreopen <import library>.
 4789                 $sharedlib_from_linklib_cmd "$dlprefile"
 4790                 dlprefile_dlbasename=$sharedlib_from_linklib_result
 4791               fi
 4792             fi
 4793             $opt_dry_run || {
 4794               if test -n "$dlprefile_dlbasename"; then
 4795                 eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
 4796               else
 4797                 func_warning "Could not compute DLL name from $name"
 4798                 eval '$ECHO ": $name " >> "$nlist"'
 4799               fi
 4800               func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
 4801               eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
 4802                 $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
 4803             }
 4804           else # not an import lib
 4805             $opt_dry_run || {
 4806               eval '$ECHO ": $name " >> "$nlist"'
 4807               func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
 4808               eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
 4809             }
 4810           fi
 4811         ;;
 4812         *)
 4813           $opt_dry_run || {
 4814             eval '$ECHO ": $name " >> "$nlist"'
 4815             func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
 4816             eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
 4817           }
 4818         ;;
 4819           esac
 4820     done
 4821 
 4822     $opt_dry_run || {
 4823       # Make sure we have at least an empty file.
 4824       test -f "$nlist" || : > "$nlist"
 4825 
 4826       if test -n "$exclude_expsyms"; then
 4827         $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
 4828         $MV "$nlist"T "$nlist"
 4829       fi
 4830 
 4831       # Try sorting and uniquifying the output.
 4832       if $GREP -v "^: " < "$nlist" |
 4833           if sort -k 3 </dev/null >/dev/null 2>&1; then
 4834         sort -k 3
 4835           else
 4836         sort +2
 4837           fi |
 4838           uniq > "$nlist"S; then
 4839         :
 4840       else
 4841         $GREP -v "^: " < "$nlist" > "$nlist"S
 4842       fi
 4843 
 4844       if test -f "$nlist"S; then
 4845         eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
 4846       else
 4847         echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
 4848       fi
 4849 
 4850       func_show_eval '$RM "${nlist}I"'
 4851       if test -n "$global_symbol_to_import"; then
 4852         eval "$global_symbol_to_import"' < "$nlist"S > "$nlist"I'
 4853       fi
 4854 
 4855       echo >> "$output_objdir/$my_dlsyms" "\
 4856 
 4857 /* The mapping between symbol names and symbols.  */
 4858 typedef struct {
 4859   const char *name;
 4860   void *address;
 4861 } lt_dlsymlist;
 4862 extern LT_DLSYM_CONST lt_dlsymlist
 4863 lt_${my_prefix}_LTX_preloaded_symbols[];\
 4864 "
 4865 
 4866       if test -s "$nlist"I; then
 4867         echo >> "$output_objdir/$my_dlsyms" "\
 4868 static void lt_syminit(void)
 4869 {
 4870   LT_DLSYM_CONST lt_dlsymlist *symbol = lt_${my_prefix}_LTX_preloaded_symbols;
 4871   for (; symbol->name; ++symbol)
 4872     {"
 4873         $SED 's/.*/      if (STREQ (symbol->name, \"&\")) symbol->address = (void *) \&&;/' < "$nlist"I >> "$output_objdir/$my_dlsyms"
 4874         echo >> "$output_objdir/$my_dlsyms" "\
 4875     }
 4876 }"
 4877       fi
 4878       echo >> "$output_objdir/$my_dlsyms" "\
 4879 LT_DLSYM_CONST lt_dlsymlist
 4880 lt_${my_prefix}_LTX_preloaded_symbols[] =
 4881 { {\"$my_originator\", (void *) 0},"
 4882 
 4883       if test -s "$nlist"I; then
 4884         echo >> "$output_objdir/$my_dlsyms" "\
 4885   {\"@INIT@\", (void *) &lt_syminit},"
 4886       fi
 4887 
 4888       case $need_lib_prefix in
 4889       no)
 4890         eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
 4891         ;;
 4892       *)
 4893         eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
 4894         ;;
 4895       esac
 4896       echo >> "$output_objdir/$my_dlsyms" "\
 4897   {0, (void *) 0}
 4898 };
 4899 
 4900 /* This works around a problem in FreeBSD linker */
 4901 #ifdef FREEBSD_WORKAROUND
 4902 static const void *lt_preloaded_setup() {
 4903   return lt_${my_prefix}_LTX_preloaded_symbols;
 4904 }
 4905 #endif
 4906 
 4907 #ifdef __cplusplus
 4908 }
 4909 #endif\
 4910 "
 4911     } # !$opt_dry_run
 4912 
 4913     pic_flag_for_symtable=
 4914     case "$compile_command " in
 4915     *" -static "*) ;;
 4916     *)
 4917       case $host in
 4918       # compiling the symbol table file with pic_flag works around
 4919       # a FreeBSD bug that causes programs to crash when -lm is
 4920       # linked before any other PIC object.  But we must not use
 4921       # pic_flag when linking with -static.  The problem exists in
 4922       # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
 4923       *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
 4924         pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
 4925       *-*-hpux*)
 4926         pic_flag_for_symtable=" $pic_flag"  ;;
 4927       *)
 4928         $my_pic_p && pic_flag_for_symtable=" $pic_flag"
 4929         ;;
 4930       esac
 4931       ;;
 4932     esac
 4933     symtab_cflags=
 4934     for arg in $LTCFLAGS; do
 4935       case $arg in
 4936       -pie | -fpie | -fPIE) ;;
 4937       *) func_append symtab_cflags " $arg" ;;
 4938       esac
 4939     done
 4940 
 4941     # Now compile the dynamic symbol file.
 4942     func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
 4943 
 4944     # Clean up the generated files.
 4945     func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T" "${nlist}I"'
 4946 
 4947     # Transform the symbol file into the correct name.
 4948     symfileobj=$output_objdir/${my_outputname}S.$objext
 4949     case $host in
 4950     *cygwin* | *mingw* | *cegcc* )
 4951       if test -f "$output_objdir/$my_outputname.def"; then
 4952         compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
 4953         finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
 4954       else
 4955         compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
 4956         finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
 4957       fi
 4958       ;;
 4959     *)
 4960       compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
 4961       finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
 4962       ;;
 4963     esac
 4964     ;;
 4965       *)
 4966     func_fatal_error "unknown suffix for '$my_dlsyms'"
 4967     ;;
 4968       esac
 4969     else
 4970       # We keep going just in case the user didn't refer to
 4971       # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
 4972       # really was required.
 4973 
 4974       # Nullify the symbol file.
 4975       compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
 4976       finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
 4977     fi
 4978 }
 4979 
 4980 # func_cygming_gnu_implib_p ARG
 4981 # This predicate returns with zero status (TRUE) if
 4982 # ARG is a GNU/binutils-style import library. Returns
 4983 # with nonzero status (FALSE) otherwise.
 4984 func_cygming_gnu_implib_p ()
 4985 {
 4986   $debug_cmd
 4987 
 4988   func_to_tool_file "$1" func_convert_file_msys_to_w32
 4989   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)$'`
 4990   test -n "$func_cygming_gnu_implib_tmp"
 4991 }
 4992 
 4993 # func_cygming_ms_implib_p ARG
 4994 # This predicate returns with zero status (TRUE) if
 4995 # ARG is an MS-style import library. Returns
 4996 # with nonzero status (FALSE) otherwise.
 4997 func_cygming_ms_implib_p ()
 4998 {
 4999   $debug_cmd
 5000 
 5001   func_to_tool_file "$1" func_convert_file_msys_to_w32
 5002   func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
 5003   test -n "$func_cygming_ms_implib_tmp"
 5004 }
 5005 
 5006 # func_win32_libid arg
 5007 # return the library type of file 'arg'
 5008 #
 5009 # Need a lot of goo to handle *both* DLLs and import libs
 5010 # Has to be a shell function in order to 'eat' the argument
 5011 # that is supplied when $file_magic_command is called.
 5012 # Despite the name, also deal with 64 bit binaries.
 5013 func_win32_libid ()
 5014 {
 5015   $debug_cmd
 5016 
 5017   win32_libid_type=unknown
 5018   win32_fileres=`file -L $1 2>/dev/null`
 5019   case $win32_fileres in
 5020   *ar\ archive\ import\ library*) # definitely import
 5021     win32_libid_type="x86 archive import"
 5022     ;;
 5023   *ar\ archive*) # could be an import, or static
 5024     # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
 5025     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
 5026        $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
 5027       case $nm_interface in
 5028       "MS dumpbin")
 5029     if func_cygming_ms_implib_p "$1" ||
 5030        func_cygming_gnu_implib_p "$1"
 5031     then
 5032       win32_nmres=import
 5033     else
 5034       win32_nmres=
 5035     fi
 5036     ;;
 5037       *)
 5038     func_to_tool_file "$1" func_convert_file_msys_to_w32
 5039     win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
 5040       $SED -n -e '
 5041         1,100{
 5042         / I /{
 5043             s|.*|import|
 5044             p
 5045             q
 5046         }
 5047         }'`
 5048     ;;
 5049       esac
 5050       case $win32_nmres in
 5051       import*)  win32_libid_type="x86 archive import";;
 5052       *)        win32_libid_type="x86 archive static";;
 5053       esac
 5054     fi
 5055     ;;
 5056   *DLL*)
 5057     win32_libid_type="x86 DLL"
 5058     ;;
 5059   *executable*) # but shell scripts are "executable" too...
 5060     case $win32_fileres in
 5061     *MS\ Windows\ PE\ Intel*)
 5062       win32_libid_type="x86 DLL"
 5063       ;;
 5064     esac
 5065     ;;
 5066   esac
 5067   $ECHO "$win32_libid_type"
 5068 }
 5069 
 5070 # func_cygming_dll_for_implib ARG
 5071 #
 5072 # Platform-specific function to extract the
 5073 # name of the DLL associated with the specified
 5074 # import library ARG.
 5075 # Invoked by eval'ing the libtool variable
 5076 #    $sharedlib_from_linklib_cmd
 5077 # Result is available in the variable
 5078 #    $sharedlib_from_linklib_result
 5079 func_cygming_dll_for_implib ()
 5080 {
 5081   $debug_cmd
 5082 
 5083   sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
 5084 }
 5085 
 5086 # func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
 5087 #
 5088 # The is the core of a fallback implementation of a
 5089 # platform-specific function to extract the name of the
 5090 # DLL associated with the specified import library LIBNAME.
 5091 #
 5092 # SECTION_NAME is either .idata$6 or .idata$7, depending
 5093 # on the platform and compiler that created the implib.
 5094 #
 5095 # Echos the name of the DLL associated with the
 5096 # specified import library.
 5097 func_cygming_dll_for_implib_fallback_core ()
 5098 {
 5099   $debug_cmd
 5100 
 5101   match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
 5102   $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
 5103     $SED '/^Contents of section '"$match_literal"':/{
 5104       # Place marker at beginning of archive member dllname section
 5105       s/.*/====MARK====/
 5106       p
 5107       d
 5108     }
 5109     # These lines can sometimes be longer than 43 characters, but
 5110     # are always uninteresting
 5111     /:[  ]*file format pe[i]\{,1\}-/d
 5112     /^In archive [^:]*:/d
 5113     # Ensure marker is printed
 5114     /^====MARK====/p
 5115     # Remove all lines with less than 43 characters
 5116     /^.\{43\}/!d
 5117     # From remaining lines, remove first 43 characters
 5118     s/^.\{43\}//' |
 5119     $SED -n '
 5120       # Join marker and all lines until next marker into a single line
 5121       /^====MARK====/ b para
 5122       H
 5123       $ b para
 5124       b
 5125       :para
 5126       x
 5127       s/\n//g
 5128       # Remove the marker
 5129       s/^====MARK====//
 5130       # Remove trailing dots and whitespace
 5131       s/[\. \t]*$//
 5132       # Print
 5133       /./p' |
 5134     # we now have a list, one entry per line, of the stringified
 5135     # contents of the appropriate section of all members of the
 5136     # archive that possess that section. Heuristic: eliminate
 5137     # all those that have a first or second character that is
 5138     # a '.' (that is, objdump's representation of an unprintable
 5139     # character.) This should work for all archives with less than
 5140     # 0x302f exports -- but will fail for DLLs whose name actually
 5141     # begins with a literal '.' or a single character followed by
 5142     # a '.'.
 5143     #
 5144     # Of those that remain, print the first one.
 5145     $SED -e '/^\./d;/^.\./d;q'
 5146 }
 5147 
 5148 # func_cygming_dll_for_implib_fallback ARG
 5149 # Platform-specific function to extract the
 5150 # name of the DLL associated with the specified
 5151 # import library ARG.
 5152 #
 5153 # This fallback implementation is for use when $DLLTOOL
 5154 # does not support the --identify-strict option.
 5155 # Invoked by eval'ing the libtool variable
 5156 #    $sharedlib_from_linklib_cmd
 5157 # Result is available in the variable
 5158 #    $sharedlib_from_linklib_result
 5159 func_cygming_dll_for_implib_fallback ()
 5160 {
 5161   $debug_cmd
 5162 
 5163   if func_cygming_gnu_implib_p "$1"; then
 5164     # binutils import library
 5165     sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
 5166   elif func_cygming_ms_implib_p "$1"; then
 5167     # ms-generated import library
 5168     sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
 5169   else
 5170     # unknown
 5171     sharedlib_from_linklib_result=
 5172   fi
 5173 }
 5174 
 5175 
 5176 # func_extract_an_archive dir oldlib
 5177 func_extract_an_archive ()
 5178 {
 5179     $debug_cmd
 5180 
 5181     f_ex_an_ar_dir=$1; shift
 5182     f_ex_an_ar_oldlib=$1
 5183     if test yes = "$lock_old_archive_extraction"; then
 5184       lockfile=$f_ex_an_ar_oldlib.lock
 5185       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
 5186     func_echo "Waiting for $lockfile to be removed"
 5187     sleep 2
 5188       done
 5189     fi
 5190     func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
 5191            'stat=$?; rm -f "$lockfile"; exit $stat'
 5192     if test yes = "$lock_old_archive_extraction"; then
 5193       $opt_dry_run || rm -f "$lockfile"
 5194     fi
 5195     if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
 5196      :
 5197     else
 5198       func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
 5199     fi
 5200 }
 5201 
 5202 
 5203 # func_extract_archives gentop oldlib ...
 5204 func_extract_archives ()
 5205 {
 5206     $debug_cmd
 5207 
 5208     my_gentop=$1; shift
 5209     my_oldlibs=${1+"$@"}
 5210     my_oldobjs=
 5211     my_xlib=
 5212     my_xabs=
 5213     my_xdir=
 5214 
 5215     for my_xlib in $my_oldlibs; do
 5216       # Extract the objects.
 5217       case $my_xlib in
 5218     [\\/]* | [A-Za-z]:[\\/]*) my_xabs=$my_xlib ;;
 5219     *) my_xabs=`pwd`"/$my_xlib" ;;
 5220       esac
 5221       func_basename "$my_xlib"
 5222       my_xlib=$func_basename_result
 5223       my_xlib_u=$my_xlib
 5224       while :; do
 5225         case " $extracted_archives " in
 5226     *" $my_xlib_u "*)
 5227       func_arith $extracted_serial + 1
 5228       extracted_serial=$func_arith_result
 5229       my_xlib_u=lt$extracted_serial-$my_xlib ;;
 5230     *) break ;;
 5231     esac
 5232       done
 5233       extracted_archives="$extracted_archives $my_xlib_u"
 5234       my_xdir=$my_gentop/$my_xlib_u
 5235 
 5236       func_mkdir_p "$my_xdir"
 5237 
 5238       case $host in
 5239       *-darwin*)
 5240     func_verbose "Extracting $my_xabs"
 5241     # Do not bother doing anything if just a dry run
 5242     $opt_dry_run || {
 5243       darwin_orig_dir=`pwd`
 5244       cd $my_xdir || exit $?
 5245       darwin_archive=$my_xabs
 5246       darwin_curdir=`pwd`
 5247       func_basename "$darwin_archive"
 5248       darwin_base_archive=$func_basename_result
 5249       darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
 5250       if test -n "$darwin_arches"; then
 5251         darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
 5252         darwin_arch=
 5253         func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
 5254         for darwin_arch in  $darwin_arches; do
 5255           func_mkdir_p "unfat-$$/$darwin_base_archive-$darwin_arch"
 5256           $LIPO -thin $darwin_arch -output "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive" "$darwin_archive"
 5257           cd "unfat-$$/$darwin_base_archive-$darwin_arch"
 5258           func_extract_an_archive "`pwd`" "$darwin_base_archive"
 5259           cd "$darwin_curdir"
 5260           $RM "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive"
 5261         done # $darwin_arches
 5262             ## Okay now we've a bunch of thin objects, gotta fatten them up :)
 5263         darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$sed_basename" | sort -u`
 5264         darwin_file=
 5265         darwin_files=
 5266         for darwin_file in $darwin_filelist; do
 5267           darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
 5268           $LIPO -create -output "$darwin_file" $darwin_files
 5269         done # $darwin_filelist
 5270         $RM -rf unfat-$$
 5271         cd "$darwin_orig_dir"
 5272       else
 5273         cd $darwin_orig_dir
 5274         func_extract_an_archive "$my_xdir" "$my_xabs"
 5275       fi # $darwin_arches
 5276     } # !$opt_dry_run
 5277     ;;
 5278       *)
 5279         func_extract_an_archive "$my_xdir" "$my_xabs"
 5280     ;;
 5281       esac
 5282       my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
 5283     done
 5284 
 5285     func_extract_archives_result=$my_oldobjs
 5286 }
 5287 
 5288 
 5289 # func_emit_wrapper [arg=no]
 5290 #
 5291 # Emit a libtool wrapper script on stdout.
 5292 # Don't directly open a file because we may want to
 5293 # incorporate the script contents within a cygwin/mingw
 5294 # wrapper executable.  Must ONLY be called from within
 5295 # func_mode_link because it depends on a number of variables
 5296 # set therein.
 5297 #
 5298 # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
 5299 # variable will take.  If 'yes', then the emitted script
 5300 # will assume that the directory where it is stored is
 5301 # the $objdir directory.  This is a cygwin/mingw-specific
 5302 # behavior.
 5303 func_emit_wrapper ()
 5304 {
 5305     func_emit_wrapper_arg1=${1-no}
 5306 
 5307     $ECHO "\
 5308 #! $SHELL
 5309 
 5310 # $output - temporary wrapper script for $objdir/$outputname
 5311 # Generated by $PROGRAM (GNU $PACKAGE) $VERSION
 5312 #
 5313 # The $output program cannot be directly executed until all the libtool
 5314 # libraries that it depends on are installed.
 5315 #
 5316 # This wrapper script should never be moved out of the build directory.
 5317 # If it is, it will not operate correctly.
 5318 
 5319 # Sed substitution that helps us do robust quoting.  It backslashifies
 5320 # metacharacters that are still active within double-quoted strings.
 5321 sed_quote_subst='$sed_quote_subst'
 5322 
 5323 # Be Bourne compatible
 5324 if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
 5325   emulate sh
 5326   NULLCMD=:
 5327   # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
 5328   # is contrary to our usage.  Disable this feature.
 5329   alias -g '\${1+\"\$@\"}'='\"\$@\"'
 5330   setopt NO_GLOB_SUBST
 5331 else
 5332   case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
 5333 fi
 5334 BIN_SH=xpg4; export BIN_SH # for Tru64
 5335 DUALCASE=1; export DUALCASE # for MKS sh
 5336 
 5337 # The HP-UX ksh and POSIX shell print the target directory to stdout
 5338 # if CDPATH is set.
 5339 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
 5340 
 5341 relink_command=\"$relink_command\"
 5342 
 5343 # This environment variable determines our operation mode.
 5344 if test \"\$libtool_install_magic\" = \"$magic\"; then
 5345   # install mode needs the following variables:
 5346   generated_by_libtool_version='$macro_version'
 5347   notinst_deplibs='$notinst_deplibs'
 5348 else
 5349   # When we are sourced in execute mode, \$file and \$ECHO are already set.
 5350   if test \"\$libtool_execute_magic\" != \"$magic\"; then
 5351     file=\"\$0\""
 5352 
 5353     qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
 5354     $ECHO "\
 5355 
 5356 # A function that is used when there is no print builtin or printf.
 5357 func_fallback_echo ()
 5358 {
 5359   eval 'cat <<_LTECHO_EOF
 5360 \$1
 5361 _LTECHO_EOF'
 5362 }
 5363     ECHO=\"$qECHO\"
 5364   fi
 5365 
 5366 # Very basic option parsing. These options are (a) specific to
 5367 # the libtool wrapper, (b) are identical between the wrapper
 5368 # /script/ and the wrapper /executable/ that is used only on
 5369 # windows platforms, and (c) all begin with the string "--lt-"
 5370 # (application programs are unlikely to have options that match
 5371 # this pattern).
 5372 #
 5373 # There are only two supported options: --lt-debug and
 5374 # --lt-dump-script. There is, deliberately, no --lt-help.
 5375 #
 5376 # The first argument to this parsing function should be the
 5377 # script's $0 value, followed by "$@".
 5378 lt_option_debug=
 5379 func_parse_lt_options ()
 5380 {
 5381   lt_script_arg0=\$0
 5382   shift
 5383   for lt_opt
 5384   do
 5385     case \"\$lt_opt\" in
 5386     --lt-debug) lt_option_debug=1 ;;
 5387     --lt-dump-script)
 5388         lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
 5389         test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
 5390         lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
 5391         cat \"\$lt_dump_D/\$lt_dump_F\"
 5392         exit 0
 5393       ;;
 5394     --lt-*)
 5395         \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
 5396         exit 1
 5397       ;;
 5398     esac
 5399   done
 5400 
 5401   # Print the debug banner immediately:
 5402   if test -n \"\$lt_option_debug\"; then
 5403     echo \"$outputname:$output:\$LINENO: libtool wrapper (GNU $PACKAGE) $VERSION\" 1>&2
 5404   fi
 5405 }
 5406 
 5407 # Used when --lt-debug. Prints its arguments to stdout
 5408 # (redirection is the responsibility of the caller)
 5409 func_lt_dump_args ()
 5410 {
 5411   lt_dump_args_N=1;
 5412   for lt_arg
 5413   do
 5414     \$ECHO \"$outputname:$output:\$LINENO: newargv[\$lt_dump_args_N]: \$lt_arg\"
 5415     lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
 5416   done
 5417 }
 5418 
 5419 # Core function for launching the target application
 5420 func_exec_program_core ()
 5421 {
 5422 "
 5423   case $host in
 5424   # Backslashes separate directories on plain windows
 5425   *-*-mingw | *-*-os2* | *-cegcc*)
 5426     $ECHO "\
 5427       if test -n \"\$lt_option_debug\"; then
 5428         \$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir\\\\\$program\" 1>&2
 5429         func_lt_dump_args \${1+\"\$@\"} 1>&2
 5430       fi
 5431       exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
 5432 "
 5433     ;;
 5434 
 5435   *)
 5436     $ECHO "\
 5437       if test -n \"\$lt_option_debug\"; then
 5438         \$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir/\$program\" 1>&2
 5439         func_lt_dump_args \${1+\"\$@\"} 1>&2
 5440       fi
 5441       exec \"\$progdir/\$program\" \${1+\"\$@\"}
 5442 "
 5443     ;;
 5444   esac
 5445   $ECHO "\
 5446       \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
 5447       exit 1
 5448 }
 5449 
 5450 # A function to encapsulate launching the target application
 5451 # Strips options in the --lt-* namespace from \$@ and
 5452 # launches target application with the remaining arguments.
 5453 func_exec_program ()
 5454 {
 5455   case \" \$* \" in
 5456   *\\ --lt-*)
 5457     for lt_wr_arg
 5458     do
 5459       case \$lt_wr_arg in
 5460       --lt-*) ;;
 5461       *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
 5462       esac
 5463       shift
 5464     done ;;
 5465   esac
 5466   func_exec_program_core \${1+\"\$@\"}
 5467 }
 5468 
 5469   # Parse options
 5470   func_parse_lt_options \"\$0\" \${1+\"\$@\"}
 5471 
 5472   # Find the directory that this script lives in.
 5473   thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
 5474   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
 5475 
 5476   # Follow symbolic links until we get to the real thisdir.
 5477   file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
 5478   while test -n \"\$file\"; do
 5479     destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
 5480 
 5481     # If there was a directory component, then change thisdir.
 5482     if test \"x\$destdir\" != \"x\$file\"; then
 5483       case \"\$destdir\" in
 5484       [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
 5485       *) thisdir=\"\$thisdir/\$destdir\" ;;
 5486       esac
 5487     fi
 5488 
 5489     file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
 5490     file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
 5491   done
 5492 
 5493   # Usually 'no', except on cygwin/mingw when embedded into
 5494   # the cwrapper.
 5495   WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
 5496   if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
 5497     # special case for '.'
 5498     if test \"\$thisdir\" = \".\"; then
 5499       thisdir=\`pwd\`
 5500     fi
 5501     # remove .libs from thisdir
 5502     case \"\$thisdir\" in
 5503     *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
 5504     $objdir )   thisdir=. ;;
 5505     esac
 5506   fi
 5507 
 5508   # Try to get the absolute directory name.
 5509   absdir=\`cd \"\$thisdir\" && pwd\`
 5510   test -n \"\$absdir\" && thisdir=\"\$absdir\"
 5511 "
 5512 
 5513     if test yes = "$fast_install"; then
 5514       $ECHO "\
 5515   program=lt-'$outputname'$exeext
 5516   progdir=\"\$thisdir/$objdir\"
 5517 
 5518   if test ! -f \"\$progdir/\$program\" ||
 5519      { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | $SED 1q\`; \\
 5520        test \"X\$file\" != \"X\$progdir/\$program\"; }; then
 5521 
 5522     file=\"\$\$-\$program\"
 5523 
 5524     if test ! -d \"\$progdir\"; then
 5525       $MKDIR \"\$progdir\"
 5526     else
 5527       $RM \"\$progdir/\$file\"
 5528     fi"
 5529 
 5530       $ECHO "\
 5531 
 5532     # relink executable if necessary
 5533     if test -n \"\$relink_command\"; then
 5534       if relink_command_output=\`eval \$relink_command 2>&1\`; then :
 5535       else
 5536     \$ECHO \"\$relink_command_output\" >&2
 5537     $RM \"\$progdir/\$file\"
 5538     exit 1
 5539       fi
 5540     fi
 5541 
 5542     $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
 5543     { $RM \"\$progdir/\$program\";
 5544       $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
 5545     $RM \"\$progdir/\$file\"
 5546   fi"
 5547     else
 5548       $ECHO "\
 5549   program='$outputname'
 5550   progdir=\"\$thisdir/$objdir\"
 5551 "
 5552     fi
 5553 
 5554     $ECHO "\
 5555 
 5556   if test -f \"\$progdir/\$program\"; then"
 5557 
 5558     # fixup the dll searchpath if we need to.
 5559     #
 5560     # Fix the DLL searchpath if we need to.  Do this before prepending
 5561     # to shlibpath, because on Windows, both are PATH and uninstalled
 5562     # libraries must come first.
 5563     if test -n "$dllsearchpath"; then
 5564       $ECHO "\
 5565     # Add the dll search path components to the executable PATH
 5566     PATH=$dllsearchpath:\$PATH
 5567 "
 5568     fi
 5569 
 5570     # Export our shlibpath_var if we have one.
 5571     if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
 5572       $ECHO "\
 5573     # Add our own library path to $shlibpath_var
 5574     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
 5575 
 5576     # Some systems cannot cope with colon-terminated $shlibpath_var
 5577     # The second colon is a workaround for a bug in BeOS R4 sed
 5578     $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
 5579 
 5580     export $shlibpath_var
 5581 "
 5582     fi
 5583 
 5584     $ECHO "\
 5585     if test \"\$libtool_execute_magic\" != \"$magic\"; then
 5586       # Run the actual program with our arguments.
 5587       func_exec_program \${1+\"\$@\"}
 5588     fi
 5589   else
 5590     # The program doesn't exist.
 5591     \$ECHO \"\$0: error: '\$progdir/\$program' does not exist\" 1>&2
 5592     \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
 5593     \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
 5594     exit 1
 5595   fi
 5596 fi\
 5597 "
 5598 }
 5599 
 5600 
 5601 # func_emit_cwrapperexe_src
 5602 # emit the source code for a wrapper executable on stdout
 5603 # Must ONLY be called from within func_mode_link because
 5604 # it depends on a number of variable set therein.
 5605 func_emit_cwrapperexe_src ()
 5606 {
 5607     cat <<EOF
 5608 
 5609 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
 5610    Generated by $PROGRAM (GNU $PACKAGE) $VERSION
 5611 
 5612    The $output program cannot be directly executed until all the libtool
 5613    libraries that it depends on are installed.
 5614 
 5615    This wrapper executable should never be moved out of the build directory.
 5616    If it is, it will not operate correctly.
 5617 */
 5618 EOF
 5619         cat <<"EOF"
 5620 #ifdef _MSC_VER
 5621 # define _CRT_SECURE_NO_DEPRECATE 1
 5622 #endif
 5623 #include <stdio.h>
 5624 #include <stdlib.h>
 5625 #ifdef _MSC_VER
 5626 # include <direct.h>
 5627 # include <process.h>
 5628 # include <io.h>
 5629 #else
 5630 # include <unistd.h>
 5631 # include <stdint.h>
 5632 # ifdef __CYGWIN__
 5633 #  include <io.h>
 5634 # endif
 5635 #endif
 5636 #include <malloc.h>
 5637 #include <stdarg.h>
 5638 #include <assert.h>
 5639 #include <string.h>
 5640 #include <ctype.h>
 5641 #include <errno.h>
 5642 #include <fcntl.h>
 5643 #include <sys/stat.h>
 5644 
 5645 #define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)
 5646 
 5647 /* declarations of non-ANSI functions */
 5648 #if defined __MINGW32__
 5649 # ifdef __STRICT_ANSI__
 5650 int _putenv (const char *);
 5651 # endif
 5652 #elif defined __CYGWIN__
 5653 # ifdef __STRICT_ANSI__
 5654 char *realpath (const char *, char *);
 5655 int putenv (char *);
 5656 int setenv (const char *, const char *, int);
 5657 # endif
 5658 /* #elif defined other_platform || defined ... */
 5659 #endif
 5660 
 5661 /* portability defines, excluding path handling macros */
 5662 #if defined _MSC_VER
 5663 # define setmode _setmode
 5664 # define stat    _stat
 5665 # define chmod   _chmod
 5666 # define getcwd  _getcwd
 5667 # define putenv  _putenv
 5668 # define S_IXUSR _S_IEXEC
 5669 #elif defined __MINGW32__
 5670 # define setmode _setmode
 5671 # define stat    _stat
 5672 # define chmod   _chmod
 5673 # define getcwd  _getcwd
 5674 # define putenv  _putenv
 5675 #elif defined __CYGWIN__
 5676 # define HAVE_SETENV
 5677 # define FOPEN_WB "wb"
 5678 /* #elif defined other platforms ... */
 5679 #endif
 5680 
 5681 #if defined PATH_MAX
 5682 # define LT_PATHMAX PATH_MAX
 5683 #elif defined MAXPATHLEN
 5684 # define LT_PATHMAX MAXPATHLEN
 5685 #else
 5686 # define LT_PATHMAX 1024
 5687 #endif
 5688 
 5689 #ifndef S_IXOTH
 5690 # define S_IXOTH 0
 5691 #endif
 5692 #ifndef S_IXGRP
 5693 # define S_IXGRP 0
 5694 #endif
 5695 
 5696 /* path handling portability macros */
 5697 #ifndef DIR_SEPARATOR
 5698 # define DIR_SEPARATOR '/'
 5699 # define PATH_SEPARATOR ':'
 5700 #endif
 5701 
 5702 #if defined _WIN32 || defined __MSDOS__ || defined __DJGPP__ || \
 5703   defined __OS2__
 5704 # define HAVE_DOS_BASED_FILE_SYSTEM
 5705 # define FOPEN_WB "wb"
 5706 # ifndef DIR_SEPARATOR_2
 5707 #  define DIR_SEPARATOR_2 '\\'
 5708 # endif
 5709 # ifndef PATH_SEPARATOR_2
 5710 #  define PATH_SEPARATOR_2 ';'
 5711 # endif
 5712 #endif
 5713 
 5714 #ifndef DIR_SEPARATOR_2
 5715 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
 5716 #else /* DIR_SEPARATOR_2 */
 5717 # define IS_DIR_SEPARATOR(ch) \
 5718     (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
 5719 #endif /* DIR_SEPARATOR_2 */
 5720 
 5721 #ifndef PATH_SEPARATOR_2
 5722 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
 5723 #else /* PATH_SEPARATOR_2 */
 5724 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
 5725 #endif /* PATH_SEPARATOR_2 */
 5726 
 5727 #ifndef FOPEN_WB
 5728 # define FOPEN_WB "w"
 5729 #endif
 5730 #ifndef _O_BINARY
 5731 # define _O_BINARY 0
 5732 #endif
 5733 
 5734 #define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
 5735 #define XFREE(stale) do { \
 5736   if (stale) { free (stale); stale = 0; } \
 5737 } while (0)
 5738 
 5739 #if defined LT_DEBUGWRAPPER
 5740 static int lt_debug = 1;
 5741 #else
 5742 static int lt_debug = 0;
 5743 #endif
 5744 
 5745 const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
 5746 
 5747 void *xmalloc (size_t num);
 5748 char *xstrdup (const char *string);
 5749 const char *base_name (const char *name);
 5750 char *find_executable (const char *wrapper);
 5751 char *chase_symlinks (const char *pathspec);
 5752 int make_executable (const char *path);
 5753 int check_executable (const char *path);
 5754 char *strendzap (char *str, const char *pat);
 5755 void lt_debugprintf (const char *file, int line, const char *fmt, ...);
 5756 void lt_fatal (const char *file, int line, const char *message, ...);
 5757 static const char *nonnull (const char *s);
 5758 static const char *nonempty (const char *s);
 5759 void lt_setenv (const char *name, const char *value);
 5760 char *lt_extend_str (const char *orig_value, const char *add, int to_end);
 5761 void lt_update_exe_path (const char *name, const char *value);
 5762 void lt_update_lib_path (const char *name, const char *value);
 5763 char **prepare_spawn (char **argv);
 5764 void lt_dump_script (FILE *f);
 5765 EOF
 5766 
 5767         cat <<EOF
 5768 #if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5)
 5769 # define externally_visible volatile
 5770 #else
 5771 # define externally_visible __attribute__((externally_visible)) volatile
 5772 #endif
 5773 externally_visible const char * MAGIC_EXE = "$magic_exe";
 5774 const char * LIB_PATH_VARNAME = "$shlibpath_var";
 5775 EOF
 5776 
 5777         if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
 5778               func_to_host_path "$temp_rpath"
 5779           cat <<EOF
 5780 const char * LIB_PATH_VALUE   = "$func_to_host_path_result";
 5781 EOF
 5782         else
 5783           cat <<"EOF"
 5784 const char * LIB_PATH_VALUE   = "";
 5785 EOF
 5786         fi
 5787 
 5788         if test -n "$dllsearchpath"; then
 5789               func_to_host_path "$dllsearchpath:"
 5790           cat <<EOF
 5791 const char * EXE_PATH_VARNAME = "PATH";
 5792 const char * EXE_PATH_VALUE   = "$func_to_host_path_result";
 5793 EOF
 5794         else
 5795           cat <<"EOF"
 5796 const char * EXE_PATH_VARNAME = "";
 5797 const char * EXE_PATH_VALUE   = "";
 5798 EOF
 5799         fi
 5800 
 5801         if test yes = "$fast_install"; then
 5802           cat <<EOF
 5803 const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
 5804 EOF
 5805         else
 5806           cat <<EOF
 5807 const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
 5808 EOF
 5809         fi
 5810 
 5811 
 5812         cat <<"EOF"
 5813 
 5814 #define LTWRAPPER_OPTION_PREFIX         "--lt-"
 5815 
 5816 static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
 5817 static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
 5818 static const char *debug_opt            = LTWRAPPER_OPTION_PREFIX "debug";
 5819 
 5820 int
 5821 main (int argc, char *argv[])
 5822 {
 5823   char **newargz;
 5824   int  newargc;
 5825   char *tmp_pathspec;
 5826   char *actual_cwrapper_path;
 5827   char *actual_cwrapper_name;
 5828   char *target_name;
 5829   char *lt_argv_zero;
 5830   int rval = 127;
 5831 
 5832   int i;
 5833 
 5834   program_name = (char *) xstrdup (base_name (argv[0]));
 5835   newargz = XMALLOC (char *, (size_t) argc + 1);
 5836 
 5837   /* very simple arg parsing; don't want to rely on getopt
 5838    * also, copy all non cwrapper options to newargz, except
 5839    * argz[0], which is handled differently
 5840    */
 5841   newargc=0;
 5842   for (i = 1; i < argc; i++)
 5843     {
 5844       if (STREQ (argv[i], dumpscript_opt))
 5845     {
 5846 EOF
 5847         case $host in
 5848           *mingw* | *cygwin* )
 5849         # make stdout use "unix" line endings
 5850         echo "          setmode(1,_O_BINARY);"
 5851         ;;
 5852           esac
 5853 
 5854         cat <<"EOF"
 5855       lt_dump_script (stdout);
 5856       return 0;
 5857     }
 5858       if (STREQ (argv[i], debug_opt))
 5859     {
 5860           lt_debug = 1;
 5861           continue;
 5862     }
 5863       if (STREQ (argv[i], ltwrapper_option_prefix))
 5864         {
 5865           /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
 5866              namespace, but it is not one of the ones we know about and
 5867              have already dealt with, above (inluding dump-script), then
 5868              report an error. Otherwise, targets might begin to believe
 5869              they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
 5870              namespace. The first time any user complains about this, we'll
 5871              need to make LTWRAPPER_OPTION_PREFIX a configure-time option
 5872              or a configure.ac-settable value.
 5873            */
 5874           lt_fatal (__FILE__, __LINE__,
 5875             "unrecognized %s option: '%s'",
 5876                     ltwrapper_option_prefix, argv[i]);
 5877         }
 5878       /* otherwise ... */
 5879       newargz[++newargc] = xstrdup (argv[i]);
 5880     }
 5881   newargz[++newargc] = NULL;
 5882 
 5883 EOF
 5884         cat <<EOF
 5885   /* The GNU banner must be the first non-error debug message */
 5886   lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE) $VERSION\n");
 5887 EOF
 5888         cat <<"EOF"
 5889   lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
 5890   lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
 5891 
 5892   tmp_pathspec = find_executable (argv[0]);
 5893   if (tmp_pathspec == NULL)
 5894     lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
 5895   lt_debugprintf (__FILE__, __LINE__,
 5896                   "(main) found exe (before symlink chase) at: %s\n",
 5897           tmp_pathspec);
 5898 
 5899   actual_cwrapper_path = chase_symlinks (tmp_pathspec);
 5900   lt_debugprintf (__FILE__, __LINE__,
 5901                   "(main) found exe (after symlink chase) at: %s\n",
 5902           actual_cwrapper_path);
 5903   XFREE (tmp_pathspec);
 5904 
 5905   actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
 5906   strendzap (actual_cwrapper_path, actual_cwrapper_name);
 5907 
 5908   /* wrapper name transforms */
 5909   strendzap (actual_cwrapper_name, ".exe");
 5910   tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
 5911   XFREE (actual_cwrapper_name);
 5912   actual_cwrapper_name = tmp_pathspec;
 5913   tmp_pathspec = 0;
 5914 
 5915   /* target_name transforms -- use actual target program name; might have lt- prefix */
 5916   target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
 5917   strendzap (target_name, ".exe");
 5918   tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
 5919   XFREE (target_name);
 5920   target_name = tmp_pathspec;
 5921   tmp_pathspec = 0;
 5922 
 5923   lt_debugprintf (__FILE__, __LINE__,
 5924           "(main) libtool target name: %s\n",
 5925           target_name);
 5926 EOF
 5927 
 5928         cat <<EOF
 5929   newargz[0] =
 5930     XMALLOC (char, (strlen (actual_cwrapper_path) +
 5931             strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
 5932   strcpy (newargz[0], actual_cwrapper_path);
 5933   strcat (newargz[0], "$objdir");
 5934   strcat (newargz[0], "/");
 5935 EOF
 5936 
 5937         cat <<"EOF"
 5938   /* stop here, and copy so we don't have to do this twice */
 5939   tmp_pathspec = xstrdup (newargz[0]);
 5940 
 5941   /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
 5942   strcat (newargz[0], actual_cwrapper_name);
 5943 
 5944   /* DO want the lt- prefix here if it exists, so use target_name */
 5945   lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
 5946   XFREE (tmp_pathspec);
 5947   tmp_pathspec = NULL;
 5948 EOF
 5949 
 5950         case $host_os in
 5951           mingw*)
 5952         cat <<"EOF"
 5953   {
 5954     char* p;
 5955     while ((p = strchr (newargz[0], '\\')) != NULL)
 5956       {
 5957     *p = '/';
 5958       }
 5959     while ((p = strchr (lt_argv_zero, '\\')) != NULL)
 5960       {
 5961     *p = '/';
 5962       }
 5963   }
 5964 EOF
 5965         ;;
 5966         esac
 5967 
 5968         cat <<"EOF"
 5969   XFREE (target_name);
 5970   XFREE (actual_cwrapper_path);
 5971   XFREE (actual_cwrapper_name);
 5972 
 5973   lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
 5974   lt_setenv ("DUALCASE", "1");  /* for MSK sh */
 5975   /* Update the DLL searchpath.  EXE_PATH_VALUE ($dllsearchpath) must
 5976      be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
 5977      because on Windows, both *_VARNAMEs are PATH but uninstalled
 5978      libraries must come first. */
 5979   lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
 5980   lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
 5981 
 5982   lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
 5983           nonnull (lt_argv_zero));
 5984   for (i = 0; i < newargc; i++)
 5985     {
 5986       lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
 5987               i, nonnull (newargz[i]));
 5988     }
 5989 
 5990 EOF
 5991 
 5992         case $host_os in
 5993           mingw*)
 5994         cat <<"EOF"
 5995   /* execv doesn't actually work on mingw as expected on unix */
 5996   newargz = prepare_spawn (newargz);
 5997   rval = (int) _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
 5998   if (rval == -1)
 5999     {
 6000       /* failed to start process */
 6001       lt_debugprintf (__FILE__, __LINE__,
 6002               "(main) failed to launch target \"%s\": %s\n",
 6003               lt_argv_zero, nonnull (strerror (errno)));
 6004       return 127;
 6005     }
 6006   return rval;
 6007 EOF
 6008         ;;
 6009           *)
 6010         cat <<"EOF"
 6011   execv (lt_argv_zero, newargz);
 6012   return rval; /* =127, but avoids unused variable warning */
 6013 EOF
 6014         ;;
 6015         esac
 6016 
 6017         cat <<"EOF"
 6018 }
 6019 
 6020 void *
 6021 xmalloc (size_t num)
 6022 {
 6023   void *p = (void *) malloc (num);
 6024   if (!p)
 6025     lt_fatal (__FILE__, __LINE__, "memory exhausted");
 6026 
 6027   return p;
 6028 }
 6029 
 6030 char *
 6031 xstrdup (const char *string)
 6032 {
 6033   return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
 6034               string) : NULL;
 6035 }
 6036 
 6037 const char *
 6038 base_name (const char *name)
 6039 {
 6040   const char *base;
 6041 
 6042 #if defined HAVE_DOS_BASED_FILE_SYSTEM
 6043   /* Skip over the disk name in MSDOS pathnames. */
 6044   if (isalpha ((unsigned char) name[0]) && name[1] == ':')
 6045     name += 2;
 6046 #endif
 6047 
 6048   for (base = name; *name; name++)
 6049     if (IS_DIR_SEPARATOR (*name))
 6050       base = name + 1;
 6051   return base;
 6052 }
 6053 
 6054 int
 6055 check_executable (const char *path)
 6056 {
 6057   struct stat st;
 6058 
 6059   lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
 6060                   nonempty (path));
 6061   if ((!path) || (!*path))
 6062     return 0;
 6063 
 6064   if ((stat (path, &st) >= 0)
 6065       && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
 6066     return 1;
 6067   else
 6068     return 0;
 6069 }
 6070 
 6071 int
 6072 make_executable (const char *path)
 6073 {
 6074   int rval = 0;
 6075   struct stat st;
 6076 
 6077   lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
 6078                   nonempty (path));
 6079   if ((!path) || (!*path))
 6080     return 0;
 6081 
 6082   if (stat (path, &st) >= 0)
 6083     {
 6084       rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
 6085     }
 6086   return rval;
 6087 }
 6088 
 6089 /* Searches for the full path of the wrapper.  Returns
 6090    newly allocated full path name if found, NULL otherwise
 6091    Does not chase symlinks, even on platforms that support them.
 6092 */
 6093 char *
 6094 find_executable (const char *wrapper)
 6095 {
 6096   int has_slash = 0;
 6097   const char *p;
 6098   const char *p_next;
 6099   /* static buffer for getcwd */
 6100   char tmp[LT_PATHMAX + 1];
 6101   size_t tmp_len;
 6102   char *concat_name;
 6103 
 6104   lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
 6105                   nonempty (wrapper));
 6106 
 6107   if ((wrapper == NULL) || (*wrapper == '\0'))
 6108     return NULL;
 6109 
 6110   /* Absolute path? */
 6111 #if defined HAVE_DOS_BASED_FILE_SYSTEM
 6112   if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
 6113     {
 6114       concat_name = xstrdup (wrapper);
 6115       if (check_executable (concat_name))
 6116     return concat_name;
 6117       XFREE (concat_name);
 6118     }
 6119   else
 6120     {
 6121 #endif
 6122       if (IS_DIR_SEPARATOR (wrapper[0]))
 6123     {
 6124       concat_name = xstrdup (wrapper);
 6125       if (check_executable (concat_name))
 6126         return concat_name;
 6127       XFREE (concat_name);
 6128     }
 6129 #if defined HAVE_DOS_BASED_FILE_SYSTEM
 6130     }
 6131 #endif
 6132 
 6133   for (p = wrapper; *p; p++)
 6134     if (*p == '/')
 6135       {
 6136     has_slash = 1;
 6137     break;
 6138       }
 6139   if (!has_slash)
 6140     {
 6141       /* no slashes; search PATH */
 6142       const char *path = getenv ("PATH");
 6143       if (path != NULL)
 6144     {
 6145       for (p = path; *p; p = p_next)
 6146         {
 6147           const char *q;
 6148           size_t p_len;
 6149           for (q = p; *q; q++)
 6150         if (IS_PATH_SEPARATOR (*q))
 6151           break;
 6152           p_len = (size_t) (q - p);
 6153           p_next = (*q == '\0' ? q : q + 1);
 6154           if (p_len == 0)
 6155         {
 6156           /* empty path: current directory */
 6157           if (getcwd (tmp, LT_PATHMAX) == NULL)
 6158             lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
 6159                               nonnull (strerror (errno)));
 6160           tmp_len = strlen (tmp);
 6161           concat_name =
 6162             XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
 6163           memcpy (concat_name, tmp, tmp_len);
 6164           concat_name[tmp_len] = '/';
 6165           strcpy (concat_name + tmp_len + 1, wrapper);
 6166         }
 6167           else
 6168         {
 6169           concat_name =
 6170             XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
 6171           memcpy (concat_name, p, p_len);
 6172           concat_name[p_len] = '/';
 6173           strcpy (concat_name + p_len + 1, wrapper);
 6174         }
 6175           if (check_executable (concat_name))
 6176         return concat_name;
 6177           XFREE (concat_name);
 6178         }
 6179     }
 6180       /* not found in PATH; assume curdir */
 6181     }
 6182   /* Relative path | not found in path: prepend cwd */
 6183   if (getcwd (tmp, LT_PATHMAX) == NULL)
 6184     lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
 6185               nonnull (strerror (errno)));
 6186   tmp_len = strlen (tmp);
 6187   concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
 6188   memcpy (concat_name, tmp, tmp_len);
 6189   concat_name[tmp_len] = '/';
 6190   strcpy (concat_name + tmp_len + 1, wrapper);
 6191 
 6192   if (check_executable (concat_name))
 6193     return concat_name;
 6194   XFREE (concat_name);
 6195   return NULL;
 6196 }
 6197 
 6198 char *
 6199 chase_symlinks (const char *pathspec)
 6200 {
 6201 #ifndef S_ISLNK
 6202   return xstrdup (pathspec);
 6203 #else
 6204   char buf[LT_PATHMAX];
 6205   struct stat s;
 6206   char *tmp_pathspec = xstrdup (pathspec);
 6207   char *p;
 6208   int has_symlinks = 0;
 6209   while (strlen (tmp_pathspec) && !has_symlinks)
 6210     {
 6211       lt_debugprintf (__FILE__, __LINE__,
 6212               "checking path component for symlinks: %s\n",
 6213               tmp_pathspec);
 6214       if (lstat (tmp_pathspec, &s) == 0)
 6215     {
 6216       if (S_ISLNK (s.st_mode) != 0)
 6217         {
 6218           has_symlinks = 1;
 6219           break;
 6220         }
 6221 
 6222       /* search backwards for last DIR_SEPARATOR */
 6223       p = tmp_pathspec + strlen (tmp_pathspec) - 1;
 6224       while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
 6225         p--;
 6226       if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
 6227         {
 6228           /* no more DIR_SEPARATORS left */
 6229           break;
 6230         }
 6231       *p = '\0';
 6232     }
 6233       else
 6234     {
 6235       lt_fatal (__FILE__, __LINE__,
 6236             "error accessing file \"%s\": %s",
 6237             tmp_pathspec, nonnull (strerror (errno)));
 6238     }
 6239     }
 6240   XFREE (tmp_pathspec);
 6241 
 6242   if (!has_symlinks)
 6243     {
 6244       return xstrdup (pathspec);
 6245     }
 6246 
 6247   tmp_pathspec = realpath (pathspec, buf);
 6248   if (tmp_pathspec == 0)
 6249     {
 6250       lt_fatal (__FILE__, __LINE__,
 6251         "could not follow symlinks for %s", pathspec);
 6252     }
 6253   return xstrdup (tmp_pathspec);
 6254 #endif
 6255 }
 6256 
 6257 char *
 6258 strendzap (char *str, const char *pat)
 6259 {
 6260   size_t len, patlen;
 6261 
 6262   assert (str != NULL);
 6263   assert (pat != NULL);
 6264 
 6265   len = strlen (str);
 6266   patlen = strlen (pat);
 6267 
 6268   if (patlen <= len)
 6269     {
 6270       str += len - patlen;
 6271       if (STREQ (str, pat))
 6272     *str = '\0';
 6273     }
 6274   return str;
 6275 }
 6276 
 6277 void
 6278 lt_debugprintf (const char *file, int line, const char *fmt, ...)
 6279 {
 6280   va_list args;
 6281   if (lt_debug)
 6282     {
 6283       (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
 6284       va_start (args, fmt);
 6285       (void) vfprintf (stderr, fmt, args);
 6286       va_end (args);
 6287     }
 6288 }
 6289 
 6290 static void
 6291 lt_error_core (int exit_status, const char *file,
 6292            int line, const char *mode,
 6293            const char *message, va_list ap)
 6294 {
 6295   fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
 6296   vfprintf (stderr, message, ap);
 6297   fprintf (stderr, ".\n");
 6298 
 6299   if (exit_status >= 0)
 6300     exit (exit_status);
 6301 }
 6302 
 6303 void
 6304 lt_fatal (const char *file, int line, const char *message, ...)
 6305 {
 6306   va_list ap;
 6307   va_start (ap, message);
 6308   lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
 6309   va_end (ap);
 6310 }
 6311 
 6312 static const char *
 6313 nonnull (const char *s)
 6314 {
 6315   return s ? s : "(null)";
 6316 }
 6317 
 6318 static const char *
 6319 nonempty (const char *s)
 6320 {
 6321   return (s && !*s) ? "(empty)" : nonnull (s);
 6322 }
 6323 
 6324 void
 6325 lt_setenv (const char *name, const char *value)
 6326 {
 6327   lt_debugprintf (__FILE__, __LINE__,
 6328           "(lt_setenv) setting '%s' to '%s'\n",
 6329                   nonnull (name), nonnull (value));
 6330   {
 6331 #ifdef HAVE_SETENV
 6332     /* always make a copy, for consistency with !HAVE_SETENV */
 6333     char *str = xstrdup (value);
 6334     setenv (name, str, 1);
 6335 #else
 6336     size_t len = strlen (name) + 1 + strlen (value) + 1;
 6337     char *str = XMALLOC (char, len);
 6338     sprintf (str, "%s=%s", name, value);
 6339     if (putenv (str) != EXIT_SUCCESS)
 6340       {
 6341         XFREE (str);
 6342       }
 6343 #endif
 6344   }
 6345 }
 6346 
 6347 char *
 6348 lt_extend_str (const char *orig_value, const char *add, int to_end)
 6349 {
 6350   char *new_value;
 6351   if (orig_value