"Fossies" - the Fresh Open Source Software Archive

Member "hatools-2.14/ltmain.sh" (4 Mar 2010, 243268 Bytes) of package /linux/privat/old/hatools-2.14.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.

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