build-scripts/ltmain.sh
author Sam Lantinga <slouken@libsdl.org>
Mon, 12 Nov 2018 16:34:58 -0800
changeset 12406 d274fa9731b1
parent 12058 1a1133e9c7d4
permissions -rwxr-xr-x
Fixed bug 4367 - compatibility version decreased between 2.0.8 and 2.0.9

Joshua Root

The change resulting from Bug 4208 changed the compatibility_version of libSDL2 from 9.0.0 to 1.0.0. This is simply wrong.

This means that programs linked against 2.0.9 are considered by the dynamic linker to be compatible with all previous versions of libSDL2. This is not the case since new public symbols have been added.

The way compatibility_version and current_version are meant to work is:
* current_version increases every time the library changes in any way.
* compatibility_version is increased to match current_version whenever new public symbols are added.

Thus both versions should only ever increase. The solution to the Xcode project and autotools not having matching versions should have been to increase the version(s) in the Xcode project.

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