Annotation of embedaddon/lighttpd/ltmain.sh, revision 1.1.1.2

1.1       misho       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)
1.1.1.2 ! misho      73: #         $progname:   (GNU libtool) 2.4.2 Debian-2.4.2-1.7
1.1       misho      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
1.1.1.2 ! misho      83: VERSION="2.4.2 Debian-2.4.2-1.7"
1.1       misho      84: TIMESTAMP=""
                     85: package_revision=1.3337
                     86: 
                     87: # Be Bourne compatible
                     88: if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
                     89:   emulate sh
                     90:   NULLCMD=:
                     91:   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
                     92:   # is contrary to our usage.  Disable this feature.
                     93:   alias -g '${1+"$@"}'='"$@"'
                     94:   setopt NO_GLOB_SUBST
                     95: else
                     96:   case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
                     97: fi
                     98: BIN_SH=xpg4; export BIN_SH # for Tru64
                     99: DUALCASE=1; export DUALCASE # for MKS sh
                    100: 
                    101: # A function that is used when there is no print builtin or printf.
                    102: func_fallback_echo ()
                    103: {
                    104:   eval 'cat <<_LTECHO_EOF
                    105: $1
                    106: _LTECHO_EOF'
                    107: }
                    108: 
                    109: # NLS nuisances: We save the old values to restore during execute mode.
                    110: lt_user_locale=
                    111: lt_safe_locale=
                    112: for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
                    113: do
                    114:   eval "if test \"\${$lt_var+set}\" = set; then
                    115:           save_$lt_var=\$$lt_var
                    116:           $lt_var=C
                    117:          export $lt_var
                    118:          lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
                    119:          lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
                    120:        fi"
                    121: done
                    122: LC_ALL=C
                    123: LANGUAGE=C
                    124: export LANGUAGE LC_ALL
                    125: 
                    126: $lt_unset CDPATH
                    127: 
                    128: 
                    129: # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
                    130: # is ksh but when the shell is invoked as "sh" and the current value of
                    131: # the _XPG environment variable is not equal to 1 (one), the special
                    132: # positional parameter $0, within a function call, is the name of the
                    133: # function.
                    134: progpath="$0"
                    135: 
                    136: 
                    137: 
                    138: : ${CP="cp -f"}
                    139: test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
                    140: : ${MAKE="make"}
                    141: : ${MKDIR="mkdir"}
                    142: : ${MV="mv -f"}
                    143: : ${RM="rm -f"}
                    144: : ${SHELL="${CONFIG_SHELL-/bin/sh}"}
                    145: : ${Xsed="$SED -e 1s/^X//"}
                    146: 
                    147: # Global variables:
                    148: EXIT_SUCCESS=0
                    149: EXIT_FAILURE=1
                    150: EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.
                    151: EXIT_SKIP=77     # $? = 77 is used to indicate a skipped test to automake.
                    152: 
                    153: exit_status=$EXIT_SUCCESS
                    154: 
                    155: # Make sure IFS has a sensible default
                    156: lt_nl='
                    157: '
                    158: IFS="  $lt_nl"
                    159: 
                    160: dirname="s,/[^/]*$,,"
                    161: basename="s,^.*/,,"
                    162: 
                    163: # func_dirname file append nondir_replacement
                    164: # Compute the dirname of FILE.  If nonempty, add APPEND to the result,
                    165: # otherwise set result to NONDIR_REPLACEMENT.
                    166: func_dirname ()
                    167: {
                    168:     func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`
                    169:     if test "X$func_dirname_result" = "X${1}"; then
                    170:       func_dirname_result="${3}"
                    171:     else
                    172:       func_dirname_result="$func_dirname_result${2}"
                    173:     fi
                    174: } # func_dirname may be replaced by extended shell implementation
                    175: 
                    176: 
                    177: # func_basename file
                    178: func_basename ()
                    179: {
                    180:     func_basename_result=`$ECHO "${1}" | $SED "$basename"`
                    181: } # func_basename may be replaced by extended shell implementation
                    182: 
                    183: 
                    184: # func_dirname_and_basename file append nondir_replacement
                    185: # perform func_basename and func_dirname in a single function
                    186: # call:
                    187: #   dirname:  Compute the dirname of FILE.  If nonempty,
                    188: #             add APPEND to the result, otherwise set result
                    189: #             to NONDIR_REPLACEMENT.
                    190: #             value returned in "$func_dirname_result"
                    191: #   basename: Compute filename of FILE.
                    192: #             value retuned in "$func_basename_result"
                    193: # Implementation must be kept synchronized with func_dirname
                    194: # and func_basename. For efficiency, we do not delegate to
                    195: # those functions but instead duplicate the functionality here.
                    196: func_dirname_and_basename ()
                    197: {
                    198:     # Extract subdirectory from the argument.
                    199:     func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
                    200:     if test "X$func_dirname_result" = "X${1}"; then
                    201:       func_dirname_result="${3}"
                    202:     else
                    203:       func_dirname_result="$func_dirname_result${2}"
                    204:     fi
                    205:     func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
                    206: } # func_dirname_and_basename may be replaced by extended shell implementation
                    207: 
                    208: 
                    209: # func_stripname prefix suffix name
                    210: # strip PREFIX and SUFFIX off of NAME.
                    211: # PREFIX and SUFFIX must not contain globbing or regex special
                    212: # characters, hashes, percent signs, but SUFFIX may contain a leading
                    213: # dot (in which case that matches only a dot).
                    214: # func_strip_suffix prefix name
                    215: func_stripname ()
                    216: {
                    217:     case ${2} in
                    218:       .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
                    219:       *)  func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
                    220:     esac
                    221: } # func_stripname may be replaced by extended shell implementation
                    222: 
                    223: 
                    224: # These SED scripts presuppose an absolute path with a trailing slash.
                    225: pathcar='s,^/\([^/]*\).*$,\1,'
                    226: pathcdr='s,^/[^/]*,,'
                    227: removedotparts=':dotsl
                    228:                s@/\./@/@g
                    229:                t dotsl
                    230:                s,/\.$,/,'
                    231: collapseslashes='s@/\{1,\}@/@g'
                    232: finalslash='s,/*$,/,'
                    233: 
                    234: # func_normal_abspath PATH
                    235: # Remove doubled-up and trailing slashes, "." path components,
                    236: # and cancel out any ".." path components in PATH after making
                    237: # it an absolute path.
                    238: #             value returned in "$func_normal_abspath_result"
                    239: func_normal_abspath ()
                    240: {
                    241:   # Start from root dir and reassemble the path.
                    242:   func_normal_abspath_result=
                    243:   func_normal_abspath_tpath=$1
                    244:   func_normal_abspath_altnamespace=
                    245:   case $func_normal_abspath_tpath in
                    246:     "")
                    247:       # Empty path, that just means $cwd.
                    248:       func_stripname '' '/' "`pwd`"
                    249:       func_normal_abspath_result=$func_stripname_result
                    250:       return
                    251:     ;;
                    252:     # The next three entries are used to spot a run of precisely
                    253:     # two leading slashes without using negated character classes;
                    254:     # we take advantage of case's first-match behaviour.
                    255:     ///*)
                    256:       # Unusual form of absolute path, do nothing.
                    257:     ;;
                    258:     //*)
                    259:       # Not necessarily an ordinary path; POSIX reserves leading '//'
                    260:       # and for example Cygwin uses it to access remote file shares
                    261:       # over CIFS/SMB, so we conserve a leading double slash if found.
                    262:       func_normal_abspath_altnamespace=/
                    263:     ;;
                    264:     /*)
                    265:       # Absolute path, do nothing.
                    266:     ;;
                    267:     *)
                    268:       # Relative path, prepend $cwd.
                    269:       func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
                    270:     ;;
                    271:   esac
                    272:   # Cancel out all the simple stuff to save iterations.  We also want
                    273:   # the path to end with a slash for ease of parsing, so make sure
                    274:   # there is one (and only one) here.
                    275:   func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
                    276:         -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
                    277:   while :; do
                    278:     # Processed it all yet?
                    279:     if test "$func_normal_abspath_tpath" = / ; then
                    280:       # If we ascended to the root using ".." the result may be empty now.
                    281:       if test -z "$func_normal_abspath_result" ; then
                    282:         func_normal_abspath_result=/
                    283:       fi
                    284:       break
                    285:     fi
                    286:     func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
                    287:         -e "$pathcar"`
                    288:     func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
                    289:         -e "$pathcdr"`
                    290:     # Figure out what to do with it
                    291:     case $func_normal_abspath_tcomponent in
                    292:       "")
                    293:         # Trailing empty path component, ignore it.
                    294:       ;;
                    295:       ..)
                    296:         # Parent dir; strip last assembled component from result.
                    297:         func_dirname "$func_normal_abspath_result"
                    298:         func_normal_abspath_result=$func_dirname_result
                    299:       ;;
                    300:       *)
                    301:         # Actual path component, append it.
                    302:         func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
                    303:       ;;
                    304:     esac
                    305:   done
                    306:   # Restore leading double-slash if one was found on entry.
                    307:   func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
                    308: }
                    309: 
                    310: # func_relative_path SRCDIR DSTDIR
                    311: # generates a relative path from SRCDIR to DSTDIR, with a trailing
                    312: # slash if non-empty, suitable for immediately appending a filename
                    313: # without needing to append a separator.
                    314: #             value returned in "$func_relative_path_result"
                    315: func_relative_path ()
                    316: {
                    317:   func_relative_path_result=
                    318:   func_normal_abspath "$1"
                    319:   func_relative_path_tlibdir=$func_normal_abspath_result
                    320:   func_normal_abspath "$2"
                    321:   func_relative_path_tbindir=$func_normal_abspath_result
                    322: 
                    323:   # Ascend the tree starting from libdir
                    324:   while :; do
                    325:     # check if we have found a prefix of bindir
                    326:     case $func_relative_path_tbindir in
                    327:       $func_relative_path_tlibdir)
                    328:         # found an exact match
                    329:         func_relative_path_tcancelled=
                    330:         break
                    331:         ;;
                    332:       $func_relative_path_tlibdir*)
                    333:         # found a matching prefix
                    334:         func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
                    335:         func_relative_path_tcancelled=$func_stripname_result
                    336:         if test -z "$func_relative_path_result"; then
                    337:           func_relative_path_result=.
                    338:         fi
                    339:         break
                    340:         ;;
                    341:       *)
                    342:         func_dirname $func_relative_path_tlibdir
                    343:         func_relative_path_tlibdir=${func_dirname_result}
                    344:         if test "x$func_relative_path_tlibdir" = x ; then
                    345:           # Have to descend all the way to the root!
                    346:           func_relative_path_result=../$func_relative_path_result
                    347:           func_relative_path_tcancelled=$func_relative_path_tbindir
                    348:           break
                    349:         fi
                    350:         func_relative_path_result=../$func_relative_path_result
                    351:         ;;
                    352:     esac
                    353:   done
                    354: 
                    355:   # Now calculate path; take care to avoid doubling-up slashes.
                    356:   func_stripname '' '/' "$func_relative_path_result"
                    357:   func_relative_path_result=$func_stripname_result
                    358:   func_stripname '/' '/' "$func_relative_path_tcancelled"
                    359:   if test "x$func_stripname_result" != x ; then
                    360:     func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
                    361:   fi
                    362: 
                    363:   # Normalisation. If bindir is libdir, return empty string,
                    364:   # else relative path ending with a slash; either way, target
                    365:   # file name can be directly appended.
                    366:   if test ! -z "$func_relative_path_result"; then
                    367:     func_stripname './' '' "$func_relative_path_result/"
                    368:     func_relative_path_result=$func_stripname_result
                    369:   fi
                    370: }
                    371: 
                    372: # The name of this program:
                    373: func_dirname_and_basename "$progpath"
                    374: progname=$func_basename_result
                    375: 
                    376: # Make sure we have an absolute path for reexecution:
                    377: case $progpath in
                    378:   [\\/]*|[A-Za-z]:\\*) ;;
                    379:   *[\\/]*)
                    380:      progdir=$func_dirname_result
                    381:      progdir=`cd "$progdir" && pwd`
                    382:      progpath="$progdir/$progname"
                    383:      ;;
                    384:   *)
                    385:      save_IFS="$IFS"
                    386:      IFS=${PATH_SEPARATOR-:}
                    387:      for progdir in $PATH; do
                    388:        IFS="$save_IFS"
                    389:        test -x "$progdir/$progname" && break
                    390:      done
                    391:      IFS="$save_IFS"
                    392:      test -n "$progdir" || progdir=`pwd`
                    393:      progpath="$progdir/$progname"
                    394:      ;;
                    395: esac
                    396: 
                    397: # Sed substitution that helps us do robust quoting.  It backslashifies
                    398: # metacharacters that are still active within double-quoted strings.
                    399: Xsed="${SED}"' -e 1s/^X//'
                    400: sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
                    401: 
                    402: # Same as above, but do not quote variable references.
                    403: double_quote_subst='s/\(["`\\]\)/\\\1/g'
                    404: 
                    405: # Sed substitution that turns a string into a regex matching for the
                    406: # string literally.
                    407: sed_make_literal_regex='s,[].[^$\\*\/],\\&,g'
                    408: 
                    409: # Sed substitution that converts a w32 file name or path
                    410: # which contains forward slashes, into one that contains
                    411: # (escaped) backslashes.  A very naive implementation.
                    412: lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
                    413: 
                    414: # Re-`\' parameter expansions in output of double_quote_subst that were
                    415: # `\'-ed in input to the same.  If an odd number of `\' preceded a '$'
                    416: # in input to double_quote_subst, that '$' was protected from expansion.
                    417: # Since each input `\' is now two `\'s, look for any number of runs of
                    418: # four `\'s followed by two `\'s and then a '$'.  `\' that '$'.
                    419: bs='\\'
                    420: bs2='\\\\'
                    421: bs4='\\\\\\\\'
                    422: dollar='\$'
                    423: sed_double_backslash="\
                    424:   s/$bs4/&\\
                    425: /g
                    426:   s/^$bs2$dollar/$bs&/
                    427:   s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
                    428:   s/\n//g"
                    429: 
                    430: # Standard options:
                    431: opt_dry_run=false
                    432: opt_help=false
                    433: opt_quiet=false
                    434: opt_verbose=false
                    435: opt_warning=:
                    436: 
                    437: # func_echo arg...
                    438: # Echo program name prefixed message, along with the current mode
                    439: # name if it has been set yet.
                    440: func_echo ()
                    441: {
                    442:     $ECHO "$progname: ${opt_mode+$opt_mode: }$*"
                    443: }
                    444: 
                    445: # func_verbose arg...
                    446: # Echo program name prefixed message in verbose mode only.
                    447: func_verbose ()
                    448: {
                    449:     $opt_verbose && func_echo ${1+"$@"}
                    450: 
                    451:     # A bug in bash halts the script if the last line of a function
                    452:     # fails when set -e is in force, so we need another command to
                    453:     # work around that:
                    454:     :
                    455: }
                    456: 
                    457: # func_echo_all arg...
                    458: # Invoke $ECHO with all args, space-separated.
                    459: func_echo_all ()
                    460: {
                    461:     $ECHO "$*"
                    462: }
                    463: 
                    464: # func_error arg...
                    465: # Echo program name prefixed message to standard error.
                    466: func_error ()
                    467: {
                    468:     $ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
                    469: }
                    470: 
                    471: # func_warning arg...
                    472: # Echo program name prefixed warning message to standard error.
                    473: func_warning ()
                    474: {
                    475:     $opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
                    476: 
                    477:     # bash bug again:
                    478:     :
                    479: }
                    480: 
                    481: # func_fatal_error arg...
                    482: # Echo program name prefixed message to standard error, and exit.
                    483: func_fatal_error ()
                    484: {
                    485:     func_error ${1+"$@"}
                    486:     exit $EXIT_FAILURE
                    487: }
                    488: 
                    489: # func_fatal_help arg...
                    490: # Echo program name prefixed message to standard error, followed by
                    491: # a help hint, and exit.
                    492: func_fatal_help ()
                    493: {
                    494:     func_error ${1+"$@"}
                    495:     func_fatal_error "$help"
                    496: }
                    497: help="Try \`$progname --help' for more information."  ## default
                    498: 
                    499: 
                    500: # func_grep expression filename
                    501: # Check whether EXPRESSION matches any line of FILENAME, without output.
                    502: func_grep ()
                    503: {
                    504:     $GREP "$1" "$2" >/dev/null 2>&1
                    505: }
                    506: 
                    507: 
                    508: # func_mkdir_p directory-path
                    509: # Make sure the entire path to DIRECTORY-PATH is available.
                    510: func_mkdir_p ()
                    511: {
                    512:     my_directory_path="$1"
                    513:     my_dir_list=
                    514: 
                    515:     if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
                    516: 
                    517:       # Protect directory names starting with `-'
                    518:       case $my_directory_path in
                    519:         -*) my_directory_path="./$my_directory_path" ;;
                    520:       esac
                    521: 
                    522:       # While some portion of DIR does not yet exist...
                    523:       while test ! -d "$my_directory_path"; do
                    524:         # ...make a list in topmost first order.  Use a colon delimited
                    525:        # list incase some portion of path contains whitespace.
                    526:         my_dir_list="$my_directory_path:$my_dir_list"
                    527: 
                    528:         # If the last portion added has no slash in it, the list is done
                    529:         case $my_directory_path in */*) ;; *) break ;; esac
                    530: 
                    531:         # ...otherwise throw away the child directory and loop
                    532:         my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
                    533:       done
                    534:       my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
                    535: 
                    536:       save_mkdir_p_IFS="$IFS"; IFS=':'
                    537:       for my_dir in $my_dir_list; do
                    538:        IFS="$save_mkdir_p_IFS"
                    539:         # mkdir can fail with a `File exist' error if two processes
                    540:         # try to create one of the directories concurrently.  Don't
                    541:         # stop in that case!
                    542:         $MKDIR "$my_dir" 2>/dev/null || :
                    543:       done
                    544:       IFS="$save_mkdir_p_IFS"
                    545: 
                    546:       # Bail out if we (or some other process) failed to create a directory.
                    547:       test -d "$my_directory_path" || \
                    548:         func_fatal_error "Failed to create \`$1'"
                    549:     fi
                    550: }
                    551: 
                    552: 
                    553: # func_mktempdir [string]
                    554: # Make a temporary directory that won't clash with other running
                    555: # libtool processes, and avoids race conditions if possible.  If
                    556: # given, STRING is the basename for that directory.
                    557: func_mktempdir ()
                    558: {
                    559:     my_template="${TMPDIR-/tmp}/${1-$progname}"
                    560: 
                    561:     if test "$opt_dry_run" = ":"; then
                    562:       # Return a directory name, but don't create it in dry-run mode
                    563:       my_tmpdir="${my_template}-$$"
                    564:     else
                    565: 
                    566:       # If mktemp works, use that first and foremost
                    567:       my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
                    568: 
                    569:       if test ! -d "$my_tmpdir"; then
                    570:         # Failing that, at least try and use $RANDOM to avoid a race
                    571:         my_tmpdir="${my_template}-${RANDOM-0}$$"
                    572: 
                    573:         save_mktempdir_umask=`umask`
                    574:         umask 0077
                    575:         $MKDIR "$my_tmpdir"
                    576:         umask $save_mktempdir_umask
                    577:       fi
                    578: 
                    579:       # If we're not in dry-run mode, bomb out on failure
                    580:       test -d "$my_tmpdir" || \
                    581:         func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
                    582:     fi
                    583: 
                    584:     $ECHO "$my_tmpdir"
                    585: }
                    586: 
                    587: 
                    588: # func_quote_for_eval arg
                    589: # Aesthetically quote ARG to be evaled later.
                    590: # This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
                    591: # is double-quoted, suitable for a subsequent eval, whereas
                    592: # FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
                    593: # which are still active within double quotes backslashified.
                    594: func_quote_for_eval ()
                    595: {
                    596:     case $1 in
                    597:       *[\\\`\"\$]*)
                    598:        func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
                    599:       *)
                    600:         func_quote_for_eval_unquoted_result="$1" ;;
                    601:     esac
                    602: 
                    603:     case $func_quote_for_eval_unquoted_result in
                    604:       # Double-quote args containing shell metacharacters to delay
                    605:       # word splitting, command substitution and and variable
                    606:       # expansion for a subsequent eval.
                    607:       # Many Bourne shells cannot handle close brackets correctly
                    608:       # in scan sets, so we specify it separately.
                    609:       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \    ]*|*]*|"")
                    610:         func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
                    611:         ;;
                    612:       *)
                    613:         func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
                    614:     esac
                    615: }
                    616: 
                    617: 
                    618: # func_quote_for_expand arg
                    619: # Aesthetically quote ARG to be evaled later; same as above,
                    620: # but do not quote variable references.
                    621: func_quote_for_expand ()
                    622: {
                    623:     case $1 in
                    624:       *[\\\`\"]*)
                    625:        my_arg=`$ECHO "$1" | $SED \
                    626:            -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
                    627:       *)
                    628:         my_arg="$1" ;;
                    629:     esac
                    630: 
                    631:     case $my_arg in
                    632:       # Double-quote args containing shell metacharacters to delay
                    633:       # word splitting and command substitution for a subsequent eval.
                    634:       # Many Bourne shells cannot handle close brackets correctly
                    635:       # in scan sets, so we specify it separately.
                    636:       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \    ]*|*]*|"")
                    637:         my_arg="\"$my_arg\""
                    638:         ;;
                    639:     esac
                    640: 
                    641:     func_quote_for_expand_result="$my_arg"
                    642: }
                    643: 
                    644: 
                    645: # func_show_eval cmd [fail_exp]
                    646: # Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
                    647: # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
                    648: # is given, then evaluate it.
                    649: func_show_eval ()
                    650: {
                    651:     my_cmd="$1"
                    652:     my_fail_exp="${2-:}"
                    653: 
                    654:     ${opt_silent-false} || {
                    655:       func_quote_for_expand "$my_cmd"
                    656:       eval "func_echo $func_quote_for_expand_result"
                    657:     }
                    658: 
                    659:     if ${opt_dry_run-false}; then :; else
                    660:       eval "$my_cmd"
                    661:       my_status=$?
                    662:       if test "$my_status" -eq 0; then :; else
                    663:        eval "(exit $my_status); $my_fail_exp"
                    664:       fi
                    665:     fi
                    666: }
                    667: 
                    668: 
                    669: # func_show_eval_locale cmd [fail_exp]
                    670: # Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
                    671: # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
                    672: # is given, then evaluate it.  Use the saved locale for evaluation.
                    673: func_show_eval_locale ()
                    674: {
                    675:     my_cmd="$1"
                    676:     my_fail_exp="${2-:}"
                    677: 
                    678:     ${opt_silent-false} || {
                    679:       func_quote_for_expand "$my_cmd"
                    680:       eval "func_echo $func_quote_for_expand_result"
                    681:     }
                    682: 
                    683:     if ${opt_dry_run-false}; then :; else
                    684:       eval "$lt_user_locale
                    685:            $my_cmd"
                    686:       my_status=$?
                    687:       eval "$lt_safe_locale"
                    688:       if test "$my_status" -eq 0; then :; else
                    689:        eval "(exit $my_status); $my_fail_exp"
                    690:       fi
                    691:     fi
                    692: }
                    693: 
                    694: # func_tr_sh
                    695: # Turn $1 into a string suitable for a shell variable name.
                    696: # Result is stored in $func_tr_sh_result.  All characters
                    697: # not in the set a-zA-Z0-9_ are replaced with '_'. Further,
                    698: # if $1 begins with a digit, a '_' is prepended as well.
                    699: func_tr_sh ()
                    700: {
                    701:   case $1 in
                    702:   [0-9]* | *[!a-zA-Z0-9_]*)
                    703:     func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'`
                    704:     ;;
                    705:   * )
                    706:     func_tr_sh_result=$1
                    707:     ;;
                    708:   esac
                    709: }
                    710: 
                    711: 
                    712: # func_version
                    713: # Echo version message to standard output and exit.
                    714: func_version ()
                    715: {
                    716:     $opt_debug
                    717: 
                    718:     $SED -n '/(C)/!b go
                    719:        :more
                    720:        /\./!{
                    721:          N
                    722:          s/\n# / /
                    723:          b more
                    724:        }
                    725:        :go
                    726:        /^# '$PROGRAM' (GNU /,/# warranty; / {
                    727:         s/^# //
                    728:        s/^# *$//
                    729:         s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
                    730:         p
                    731:      }' < "$progpath"
                    732:      exit $?
                    733: }
                    734: 
                    735: # func_usage
                    736: # Echo short help message to standard output and exit.
                    737: func_usage ()
                    738: {
                    739:     $opt_debug
                    740: 
                    741:     $SED -n '/^# Usage:/,/^#  *.*--help/ {
                    742:         s/^# //
                    743:        s/^# *$//
                    744:        s/\$progname/'$progname'/
                    745:        p
                    746:     }' < "$progpath"
                    747:     echo
                    748:     $ECHO "run \`$progname --help | more' for full usage"
                    749:     exit $?
                    750: }
                    751: 
                    752: # func_help [NOEXIT]
                    753: # Echo long help message to standard output and exit,
                    754: # unless 'noexit' is passed as argument.
                    755: func_help ()
                    756: {
                    757:     $opt_debug
                    758: 
                    759:     $SED -n '/^# Usage:/,/# Report bugs to/ {
                    760:        :print
                    761:         s/^# //
                    762:        s/^# *$//
                    763:        s*\$progname*'$progname'*
                    764:        s*\$host*'"$host"'*
                    765:        s*\$SHELL*'"$SHELL"'*
                    766:        s*\$LTCC*'"$LTCC"'*
                    767:        s*\$LTCFLAGS*'"$LTCFLAGS"'*
                    768:        s*\$LD*'"$LD"'*
                    769:        s/\$with_gnu_ld/'"$with_gnu_ld"'/
                    770:        s/\$automake_version/'"`(${AUTOMAKE-automake} --version) 2>/dev/null |$SED 1q`"'/
                    771:        s/\$autoconf_version/'"`(${AUTOCONF-autoconf} --version) 2>/dev/null |$SED 1q`"'/
                    772:        p
                    773:        d
                    774:      }
                    775:      /^# .* home page:/b print
                    776:      /^# General help using/b print
                    777:      ' < "$progpath"
                    778:     ret=$?
                    779:     if test -z "$1"; then
                    780:       exit $ret
                    781:     fi
                    782: }
                    783: 
                    784: # func_missing_arg argname
                    785: # Echo program name prefixed message to standard error and set global
                    786: # exit_cmd.
                    787: func_missing_arg ()
                    788: {
                    789:     $opt_debug
                    790: 
                    791:     func_error "missing argument for $1."
                    792:     exit_cmd=exit
                    793: }
                    794: 
                    795: 
                    796: # func_split_short_opt shortopt
                    797: # Set func_split_short_opt_name and func_split_short_opt_arg shell
                    798: # variables after splitting SHORTOPT after the 2nd character.
                    799: func_split_short_opt ()
                    800: {
                    801:     my_sed_short_opt='1s/^\(..\).*$/\1/;q'
                    802:     my_sed_short_rest='1s/^..\(.*\)$/\1/;q'
                    803: 
                    804:     func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`
                    805:     func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`
                    806: } # func_split_short_opt may be replaced by extended shell implementation
                    807: 
                    808: 
                    809: # func_split_long_opt longopt
                    810: # Set func_split_long_opt_name and func_split_long_opt_arg shell
                    811: # variables after splitting LONGOPT at the `=' sign.
                    812: func_split_long_opt ()
                    813: {
                    814:     my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q'
                    815:     my_sed_long_arg='1s/^--[^=]*=//'
                    816: 
                    817:     func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`
                    818:     func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`
                    819: } # func_split_long_opt may be replaced by extended shell implementation
                    820: 
                    821: exit_cmd=:
                    822: 
                    823: 
                    824: 
                    825: 
                    826: 
                    827: magic="%%%MAGIC variable%%%"
                    828: magic_exe="%%%MAGIC EXE variable%%%"
                    829: 
                    830: # Global variables.
                    831: nonopt=
                    832: preserve_args=
                    833: lo2o="s/\\.lo\$/.${objext}/"
                    834: o2lo="s/\\.${objext}\$/.lo/"
                    835: extracted_archives=
                    836: extracted_serial=0
                    837: 
                    838: # If this variable is set in any of the actions, the command in it
                    839: # will be execed at the end.  This prevents here-documents from being
                    840: # left over by shells.
                    841: exec_cmd=
                    842: 
                    843: # func_append var value
                    844: # Append VALUE to the end of shell variable VAR.
                    845: func_append ()
                    846: {
                    847:     eval "${1}=\$${1}\${2}"
                    848: } # func_append may be replaced by extended shell implementation
                    849: 
                    850: # func_append_quoted var value
                    851: # Quote VALUE and append to the end of shell variable VAR, separated
                    852: # by a space.
                    853: func_append_quoted ()
                    854: {
                    855:     func_quote_for_eval "${2}"
                    856:     eval "${1}=\$${1}\\ \$func_quote_for_eval_result"
                    857: } # func_append_quoted may be replaced by extended shell implementation
                    858: 
                    859: 
                    860: # func_arith arithmetic-term...
                    861: func_arith ()
                    862: {
                    863:     func_arith_result=`expr "${@}"`
                    864: } # func_arith may be replaced by extended shell implementation
                    865: 
                    866: 
                    867: # func_len string
                    868: # STRING may not start with a hyphen.
                    869: func_len ()
                    870: {
                    871:     func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len`
                    872: } # func_len may be replaced by extended shell implementation
                    873: 
                    874: 
                    875: # func_lo2o object
                    876: func_lo2o ()
                    877: {
                    878:     func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`
                    879: } # func_lo2o may be replaced by extended shell implementation
                    880: 
                    881: 
                    882: # func_xform libobj-or-source
                    883: func_xform ()
                    884: {
                    885:     func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`
                    886: } # func_xform may be replaced by extended shell implementation
                    887: 
                    888: 
                    889: # func_fatal_configuration arg...
                    890: # Echo program name prefixed message to standard error, followed by
                    891: # a configuration failure hint, and exit.
                    892: func_fatal_configuration ()
                    893: {
                    894:     func_error ${1+"$@"}
                    895:     func_error "See the $PACKAGE documentation for more information."
                    896:     func_fatal_error "Fatal configuration error."
                    897: }
                    898: 
                    899: 
                    900: # func_config
                    901: # Display the configuration for all the tags in this script.
                    902: func_config ()
                    903: {
                    904:     re_begincf='^# ### BEGIN LIBTOOL'
                    905:     re_endcf='^# ### END LIBTOOL'
                    906: 
                    907:     # Default configuration.
                    908:     $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
                    909: 
                    910:     # Now print the configurations for the tags.
                    911:     for tagname in $taglist; do
                    912:       $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
                    913:     done
                    914: 
                    915:     exit $?
                    916: }
                    917: 
                    918: # func_features
                    919: # Display the features supported by this script.
                    920: func_features ()
                    921: {
                    922:     echo "host: $host"
                    923:     if test "$build_libtool_libs" = yes; then
                    924:       echo "enable shared libraries"
                    925:     else
                    926:       echo "disable shared libraries"
                    927:     fi
                    928:     if test "$build_old_libs" = yes; then
                    929:       echo "enable static libraries"
                    930:     else
                    931:       echo "disable static libraries"
                    932:     fi
                    933: 
                    934:     exit $?
                    935: }
                    936: 
                    937: # func_enable_tag tagname
                    938: # Verify that TAGNAME is valid, and either flag an error and exit, or
                    939: # enable the TAGNAME tag.  We also add TAGNAME to the global $taglist
                    940: # variable here.
                    941: func_enable_tag ()
                    942: {
                    943:   # Global variable:
                    944:   tagname="$1"
                    945: 
                    946:   re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
                    947:   re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
                    948:   sed_extractcf="/$re_begincf/,/$re_endcf/p"
                    949: 
                    950:   # Validate tagname.
                    951:   case $tagname in
                    952:     *[!-_A-Za-z0-9,/]*)
                    953:       func_fatal_error "invalid tag name: $tagname"
                    954:       ;;
                    955:   esac
                    956: 
                    957:   # Don't test for the "default" C tag, as we know it's
                    958:   # there but not specially marked.
                    959:   case $tagname in
                    960:     CC) ;;
                    961:     *)
                    962:       if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
                    963:        taglist="$taglist $tagname"
                    964: 
                    965:        # Evaluate the configuration.  Be careful to quote the path
                    966:        # and the sed script, to avoid splitting on whitespace, but
                    967:        # also don't use non-portable quotes within backquotes within
                    968:        # quotes we have to do it in 2 steps:
                    969:        extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
                    970:        eval "$extractedcf"
                    971:       else
                    972:        func_error "ignoring unknown tag $tagname"
                    973:       fi
                    974:       ;;
                    975:   esac
                    976: }
                    977: 
                    978: # func_check_version_match
                    979: # Ensure that we are using m4 macros, and libtool script from the same
                    980: # release of libtool.
                    981: func_check_version_match ()
                    982: {
                    983:   if test "$package_revision" != "$macro_revision"; then
                    984:     if test "$VERSION" != "$macro_version"; then
                    985:       if test -z "$macro_version"; then
                    986:         cat >&2 <<_LT_EOF
                    987: $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
                    988: $progname: definition of this LT_INIT comes from an older release.
                    989: $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
                    990: $progname: and run autoconf again.
                    991: _LT_EOF
                    992:       else
                    993:         cat >&2 <<_LT_EOF
                    994: $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
                    995: $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
                    996: $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
                    997: $progname: and run autoconf again.
                    998: _LT_EOF
                    999:       fi
                   1000:     else
                   1001:       cat >&2 <<_LT_EOF
                   1002: $progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,
                   1003: $progname: but the definition of this LT_INIT comes from revision $macro_revision.
                   1004: $progname: You should recreate aclocal.m4 with macros from revision $package_revision
                   1005: $progname: of $PACKAGE $VERSION and run autoconf again.
                   1006: _LT_EOF
                   1007:     fi
                   1008: 
                   1009:     exit $EXIT_MISMATCH
                   1010:   fi
                   1011: }
                   1012: 
                   1013: 
                   1014: # Shorthand for --mode=foo, only valid as the first argument
                   1015: case $1 in
                   1016: clean|clea|cle|cl)
                   1017:   shift; set dummy --mode clean ${1+"$@"}; shift
                   1018:   ;;
                   1019: compile|compil|compi|comp|com|co|c)
                   1020:   shift; set dummy --mode compile ${1+"$@"}; shift
                   1021:   ;;
                   1022: execute|execut|execu|exec|exe|ex|e)
                   1023:   shift; set dummy --mode execute ${1+"$@"}; shift
                   1024:   ;;
                   1025: finish|finis|fini|fin|fi|f)
                   1026:   shift; set dummy --mode finish ${1+"$@"}; shift
                   1027:   ;;
                   1028: install|instal|insta|inst|ins|in|i)
                   1029:   shift; set dummy --mode install ${1+"$@"}; shift
                   1030:   ;;
                   1031: link|lin|li|l)
                   1032:   shift; set dummy --mode link ${1+"$@"}; shift
                   1033:   ;;
                   1034: uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
                   1035:   shift; set dummy --mode uninstall ${1+"$@"}; shift
                   1036:   ;;
                   1037: esac
                   1038: 
                   1039: 
                   1040: 
                   1041: # Option defaults:
                   1042: opt_debug=:
                   1043: opt_dry_run=false
                   1044: opt_config=false
                   1045: opt_preserve_dup_deps=false
                   1046: opt_features=false
                   1047: opt_finish=false
                   1048: opt_help=false
                   1049: opt_help_all=false
                   1050: opt_silent=:
                   1051: opt_warning=:
                   1052: opt_verbose=:
                   1053: opt_silent=false
                   1054: opt_verbose=false
                   1055: 
                   1056: 
                   1057: # Parse options once, thoroughly.  This comes as soon as possible in the
                   1058: # script to make things like `--version' happen as quickly as we can.
                   1059: {
                   1060:   # this just eases exit handling
                   1061:   while test $# -gt 0; do
                   1062:     opt="$1"
                   1063:     shift
                   1064:     case $opt in
                   1065:       --debug|-x)      opt_debug='set -x'
                   1066:                        func_echo "enabling shell trace mode"
                   1067:                        $opt_debug
                   1068:                        ;;
                   1069:       --dry-run|--dryrun|-n)
                   1070:                        opt_dry_run=:
                   1071:                        ;;
                   1072:       --config)
                   1073:                        opt_config=:
                   1074: func_config
                   1075:                        ;;
                   1076:       --dlopen|-dlopen)
                   1077:                        optarg="$1"
                   1078:                        opt_dlopen="${opt_dlopen+$opt_dlopen
                   1079: }$optarg"
                   1080:                        shift
                   1081:                        ;;
                   1082:       --preserve-dup-deps)
                   1083:                        opt_preserve_dup_deps=:
                   1084:                        ;;
                   1085:       --features)
                   1086:                        opt_features=:
                   1087: func_features
                   1088:                        ;;
                   1089:       --finish)
                   1090:                        opt_finish=:
                   1091: set dummy --mode finish ${1+"$@"}; shift
                   1092:                        ;;
                   1093:       --help)
                   1094:                        opt_help=:
                   1095:                        ;;
                   1096:       --help-all)
                   1097:                        opt_help_all=:
                   1098: opt_help=': help-all'
                   1099:                        ;;
                   1100:       --mode)
                   1101:                        test $# = 0 && func_missing_arg $opt && break
                   1102:                        optarg="$1"
                   1103:                        opt_mode="$optarg"
                   1104: case $optarg in
                   1105:   # Valid mode arguments:
                   1106:   clean|compile|execute|finish|install|link|relink|uninstall) ;;
                   1107: 
                   1108:   # Catch anything else as an error
                   1109:   *) func_error "invalid argument for $opt"
                   1110:      exit_cmd=exit
                   1111:      break
                   1112:      ;;
                   1113: esac
                   1114:                        shift
                   1115:                        ;;
                   1116:       --no-silent|--no-quiet)
                   1117:                        opt_silent=false
                   1118: func_append preserve_args " $opt"
                   1119:                        ;;
                   1120:       --no-warning|--no-warn)
                   1121:                        opt_warning=false
                   1122: func_append preserve_args " $opt"
                   1123:                        ;;
                   1124:       --no-verbose)
                   1125:                        opt_verbose=false
                   1126: func_append preserve_args " $opt"
                   1127:                        ;;
                   1128:       --silent|--quiet)
                   1129:                        opt_silent=:
                   1130: func_append preserve_args " $opt"
                   1131:         opt_verbose=false
                   1132:                        ;;
                   1133:       --verbose|-v)
                   1134:                        opt_verbose=:
                   1135: func_append preserve_args " $opt"
                   1136: opt_silent=false
                   1137:                        ;;
                   1138:       --tag)
                   1139:                        test $# = 0 && func_missing_arg $opt && break
                   1140:                        optarg="$1"
                   1141:                        opt_tag="$optarg"
                   1142: func_append preserve_args " $opt $optarg"
                   1143: func_enable_tag "$optarg"
                   1144:                        shift
                   1145:                        ;;
                   1146: 
                   1147:       -\?|-h)          func_usage                              ;;
                   1148:       --help)          func_help                               ;;
                   1149:       --version)       func_version                            ;;
                   1150: 
                   1151:       # Separate optargs to long options:
                   1152:       --*=*)
                   1153:                        func_split_long_opt "$opt"
                   1154:                        set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}
                   1155:                        shift
                   1156:                        ;;
                   1157: 
                   1158:       # Separate non-argument short options:
                   1159:       -\?*|-h*|-n*|-v*)
                   1160:                        func_split_short_opt "$opt"
                   1161:                        set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}
                   1162:                        shift
                   1163:                        ;;
                   1164: 
                   1165:       --)              break                                   ;;
                   1166:       -*)              func_fatal_help "unrecognized option \`$opt'" ;;
                   1167:       *)               set dummy "$opt" ${1+"$@"};     shift; break  ;;
                   1168:     esac
                   1169:   done
                   1170: 
                   1171:   # Validate options:
                   1172: 
                   1173:   # save first non-option argument
                   1174:   if test "$#" -gt 0; then
                   1175:     nonopt="$opt"
                   1176:     shift
                   1177:   fi
                   1178: 
                   1179:   # preserve --debug
                   1180:   test "$opt_debug" = : || func_append preserve_args " --debug"
                   1181: 
                   1182:   case $host in
                   1183:     *cygwin* | *mingw* | *pw32* | *cegcc*)
                   1184:       # don't eliminate duplications in $postdeps and $predeps
                   1185:       opt_duplicate_compiler_generated_deps=:
                   1186:       ;;
                   1187:     *)
                   1188:       opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
                   1189:       ;;
                   1190:   esac
                   1191: 
                   1192:   $opt_help || {
                   1193:     # Sanity checks first:
                   1194:     func_check_version_match
                   1195: 
                   1196:     if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
                   1197:       func_fatal_configuration "not configured to build any kind of library"
                   1198:     fi
                   1199: 
                   1200:     # Darwin sucks
                   1201:     eval std_shrext=\"$shrext_cmds\"
                   1202: 
                   1203:     # Only execute mode is allowed to have -dlopen flags.
                   1204:     if test -n "$opt_dlopen" && test "$opt_mode" != execute; then
                   1205:       func_error "unrecognized option \`-dlopen'"
                   1206:       $ECHO "$help" 1>&2
                   1207:       exit $EXIT_FAILURE
                   1208:     fi
                   1209: 
                   1210:     # Change the help message to a mode-specific one.
                   1211:     generic_help="$help"
                   1212:     help="Try \`$progname --help --mode=$opt_mode' for more information."
                   1213:   }
                   1214: 
                   1215: 
                   1216:   # Bail if the options were screwed
                   1217:   $exit_cmd $EXIT_FAILURE
                   1218: }
                   1219: 
                   1220: 
                   1221: 
                   1222: 
                   1223: ## ----------- ##
                   1224: ##    Main.    ##
                   1225: ## ----------- ##
                   1226: 
                   1227: # func_lalib_p file
                   1228: # True iff FILE is a libtool `.la' library or `.lo' object file.
                   1229: # This function is only a basic sanity check; it will hardly flush out
                   1230: # determined imposters.
                   1231: func_lalib_p ()
                   1232: {
                   1233:     test -f "$1" &&
                   1234:       $SED -e 4q "$1" 2>/dev/null \
                   1235:         | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
                   1236: }
                   1237: 
                   1238: # func_lalib_unsafe_p file
                   1239: # True iff FILE is a libtool `.la' library or `.lo' object file.
                   1240: # This function implements the same check as func_lalib_p without
                   1241: # resorting to external programs.  To this end, it redirects stdin and
                   1242: # closes it afterwards, without saving the original file descriptor.
                   1243: # As a safety measure, use it only where a negative result would be
                   1244: # fatal anyway.  Works if `file' does not exist.
                   1245: func_lalib_unsafe_p ()
                   1246: {
                   1247:     lalib_p=no
                   1248:     if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
                   1249:        for lalib_p_l in 1 2 3 4
                   1250:        do
                   1251:            read lalib_p_line
                   1252:            case "$lalib_p_line" in
                   1253:                \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
                   1254:            esac
                   1255:        done
                   1256:        exec 0<&5 5<&-
                   1257:     fi
                   1258:     test "$lalib_p" = yes
                   1259: }
                   1260: 
                   1261: # func_ltwrapper_script_p file
                   1262: # True iff FILE is a libtool wrapper script
                   1263: # This function is only a basic sanity check; it will hardly flush out
                   1264: # determined imposters.
                   1265: func_ltwrapper_script_p ()
                   1266: {
                   1267:     func_lalib_p "$1"
                   1268: }
                   1269: 
                   1270: # func_ltwrapper_executable_p file
                   1271: # True iff FILE is a libtool wrapper executable
                   1272: # This function is only a basic sanity check; it will hardly flush out
                   1273: # determined imposters.
                   1274: func_ltwrapper_executable_p ()
                   1275: {
                   1276:     func_ltwrapper_exec_suffix=
                   1277:     case $1 in
                   1278:     *.exe) ;;
                   1279:     *) func_ltwrapper_exec_suffix=.exe ;;
                   1280:     esac
                   1281:     $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
                   1282: }
                   1283: 
                   1284: # func_ltwrapper_scriptname file
                   1285: # Assumes file is an ltwrapper_executable
                   1286: # uses $file to determine the appropriate filename for a
                   1287: # temporary ltwrapper_script.
                   1288: func_ltwrapper_scriptname ()
                   1289: {
                   1290:     func_dirname_and_basename "$1" "" "."
                   1291:     func_stripname '' '.exe' "$func_basename_result"
                   1292:     func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
                   1293: }
                   1294: 
                   1295: # func_ltwrapper_p file
                   1296: # True iff FILE is a libtool wrapper script or wrapper executable
                   1297: # This function is only a basic sanity check; it will hardly flush out
                   1298: # determined imposters.
                   1299: func_ltwrapper_p ()
                   1300: {
                   1301:     func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
                   1302: }
                   1303: 
                   1304: 
                   1305: # func_execute_cmds commands fail_cmd
                   1306: # Execute tilde-delimited COMMANDS.
                   1307: # If FAIL_CMD is given, eval that upon failure.
                   1308: # FAIL_CMD may read-access the current command in variable CMD!
                   1309: func_execute_cmds ()
                   1310: {
                   1311:     $opt_debug
                   1312:     save_ifs=$IFS; IFS='~'
                   1313:     for cmd in $1; do
                   1314:       IFS=$save_ifs
                   1315:       eval cmd=\"$cmd\"
                   1316:       func_show_eval "$cmd" "${2-:}"
                   1317:     done
                   1318:     IFS=$save_ifs
                   1319: }
                   1320: 
                   1321: 
                   1322: # func_source file
                   1323: # Source FILE, adding directory component if necessary.
                   1324: # Note that it is not necessary on cygwin/mingw to append a dot to
                   1325: # FILE even if both FILE and FILE.exe exist: automatic-append-.exe
                   1326: # behavior happens only for exec(3), not for open(2)!  Also, sourcing
                   1327: # `FILE.' does not work on cygwin managed mounts.
                   1328: func_source ()
                   1329: {
                   1330:     $opt_debug
                   1331:     case $1 in
                   1332:     */* | *\\*)        . "$1" ;;
                   1333:     *)         . "./$1" ;;
                   1334:     esac
                   1335: }
                   1336: 
                   1337: 
                   1338: # func_resolve_sysroot PATH
                   1339: # Replace a leading = in PATH with a sysroot.  Store the result into
                   1340: # func_resolve_sysroot_result
                   1341: func_resolve_sysroot ()
                   1342: {
                   1343:   func_resolve_sysroot_result=$1
                   1344:   case $func_resolve_sysroot_result in
                   1345:   =*)
                   1346:     func_stripname '=' '' "$func_resolve_sysroot_result"
                   1347:     func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
                   1348:     ;;
                   1349:   esac
                   1350: }
                   1351: 
                   1352: # func_replace_sysroot PATH
                   1353: # If PATH begins with the sysroot, replace it with = and
                   1354: # store the result into func_replace_sysroot_result.
                   1355: func_replace_sysroot ()
                   1356: {
                   1357:   case "$lt_sysroot:$1" in
                   1358:   ?*:"$lt_sysroot"*)
                   1359:     func_stripname "$lt_sysroot" '' "$1"
                   1360:     func_replace_sysroot_result="=$func_stripname_result"
                   1361:     ;;
                   1362:   *)
                   1363:     # Including no sysroot.
                   1364:     func_replace_sysroot_result=$1
                   1365:     ;;
                   1366:   esac
                   1367: }
                   1368: 
                   1369: # func_infer_tag arg
                   1370: # Infer tagged configuration to use if any are available and
                   1371: # if one wasn't chosen via the "--tag" command line option.
                   1372: # Only attempt this if the compiler in the base compile
                   1373: # command doesn't match the default compiler.
                   1374: # arg is usually of the form 'gcc ...'
                   1375: func_infer_tag ()
                   1376: {
                   1377:     $opt_debug
                   1378:     if test -n "$available_tags" && test -z "$tagname"; then
                   1379:       CC_quoted=
                   1380:       for arg in $CC; do
                   1381:        func_append_quoted CC_quoted "$arg"
                   1382:       done
                   1383:       CC_expanded=`func_echo_all $CC`
                   1384:       CC_quoted_expanded=`func_echo_all $CC_quoted`
                   1385:       case $@ in
                   1386:       # Blanks in the command may have been stripped by the calling shell,
                   1387:       # but not from the CC environment variable when configure was run.
                   1388:       " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
                   1389:       " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
                   1390:       # Blanks at the start of $base_compile will cause this to fail
                   1391:       # if we don't check for them as well.
                   1392:       *)
                   1393:        for z in $available_tags; do
                   1394:          if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
                   1395:            # Evaluate the configuration.
                   1396:            eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
                   1397:            CC_quoted=
                   1398:            for arg in $CC; do
                   1399:              # Double-quote args containing other shell metacharacters.
                   1400:              func_append_quoted CC_quoted "$arg"
                   1401:            done
                   1402:            CC_expanded=`func_echo_all $CC`
                   1403:            CC_quoted_expanded=`func_echo_all $CC_quoted`
                   1404:            case "$@ " in
                   1405:            " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
                   1406:            " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
                   1407:              # The compiler in the base compile command matches
                   1408:              # the one in the tagged configuration.
                   1409:              # Assume this is the tagged configuration we want.
                   1410:              tagname=$z
                   1411:              break
                   1412:              ;;
                   1413:            esac
                   1414:          fi
                   1415:        done
                   1416:        # If $tagname still isn't set, then no tagged configuration
                   1417:        # was found and let the user know that the "--tag" command
                   1418:        # line option must be used.
                   1419:        if test -z "$tagname"; then
                   1420:          func_echo "unable to infer tagged configuration"
                   1421:          func_fatal_error "specify a tag with \`--tag'"
                   1422: #      else
                   1423: #        func_verbose "using $tagname tagged configuration"
                   1424:        fi
                   1425:        ;;
                   1426:       esac
                   1427:     fi
                   1428: }
                   1429: 
                   1430: 
                   1431: 
                   1432: # func_write_libtool_object output_name pic_name nonpic_name
                   1433: # Create a libtool object file (analogous to a ".la" file),
                   1434: # but don't create it if we're doing a dry run.
                   1435: func_write_libtool_object ()
                   1436: {
                   1437:     write_libobj=${1}
                   1438:     if test "$build_libtool_libs" = yes; then
                   1439:       write_lobj=\'${2}\'
                   1440:     else
                   1441:       write_lobj=none
                   1442:     fi
                   1443: 
                   1444:     if test "$build_old_libs" = yes; then
                   1445:       write_oldobj=\'${3}\'
                   1446:     else
                   1447:       write_oldobj=none
                   1448:     fi
                   1449: 
                   1450:     $opt_dry_run || {
                   1451:       cat >${write_libobj}T <<EOF
                   1452: # $write_libobj - a libtool object file
                   1453: # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
                   1454: #
                   1455: # Please DO NOT delete this file!
                   1456: # It is necessary for linking the library.
                   1457: 
                   1458: # Name of the PIC object.
                   1459: pic_object=$write_lobj
                   1460: 
                   1461: # Name of the non-PIC object
                   1462: non_pic_object=$write_oldobj
                   1463: 
                   1464: EOF
                   1465:       $MV "${write_libobj}T" "${write_libobj}"
                   1466:     }
                   1467: }
                   1468: 
                   1469: 
                   1470: ##################################################
                   1471: # FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
                   1472: ##################################################
                   1473: 
                   1474: # func_convert_core_file_wine_to_w32 ARG
                   1475: # Helper function used by file name conversion functions when $build is *nix,
                   1476: # and $host is mingw, cygwin, or some other w32 environment. Relies on a
                   1477: # correctly configured wine environment available, with the winepath program
                   1478: # in $build's $PATH.
                   1479: #
                   1480: # ARG is the $build file name to be converted to w32 format.
                   1481: # Result is available in $func_convert_core_file_wine_to_w32_result, and will
                   1482: # be empty on error (or when ARG is empty)
                   1483: func_convert_core_file_wine_to_w32 ()
                   1484: {
                   1485:   $opt_debug
                   1486:   func_convert_core_file_wine_to_w32_result="$1"
                   1487:   if test -n "$1"; then
                   1488:     # Unfortunately, winepath does not exit with a non-zero error code, so we
                   1489:     # are forced to check the contents of stdout. On the other hand, if the
                   1490:     # command is not found, the shell will set an exit code of 127 and print
                   1491:     # *an error message* to stdout. So we must check for both error code of
                   1492:     # zero AND non-empty stdout, which explains the odd construction:
                   1493:     func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
                   1494:     if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then
                   1495:       func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
                   1496:         $SED -e "$lt_sed_naive_backslashify"`
                   1497:     else
                   1498:       func_convert_core_file_wine_to_w32_result=
                   1499:     fi
                   1500:   fi
                   1501: }
                   1502: # end: func_convert_core_file_wine_to_w32
                   1503: 
                   1504: 
                   1505: # func_convert_core_path_wine_to_w32 ARG
                   1506: # Helper function used by path conversion functions when $build is *nix, and
                   1507: # $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
                   1508: # configured wine environment available, with the winepath program in $build's
                   1509: # $PATH. Assumes ARG has no leading or trailing path separator characters.
                   1510: #
                   1511: # ARG is path to be converted from $build format to win32.
                   1512: # Result is available in $func_convert_core_path_wine_to_w32_result.
                   1513: # Unconvertible file (directory) names in ARG are skipped; if no directory names
                   1514: # are convertible, then the result may be empty.
                   1515: func_convert_core_path_wine_to_w32 ()
                   1516: {
                   1517:   $opt_debug
                   1518:   # unfortunately, winepath doesn't convert paths, only file names
                   1519:   func_convert_core_path_wine_to_w32_result=""
                   1520:   if test -n "$1"; then
                   1521:     oldIFS=$IFS
                   1522:     IFS=:
                   1523:     for func_convert_core_path_wine_to_w32_f in $1; do
                   1524:       IFS=$oldIFS
                   1525:       func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
                   1526:       if test -n "$func_convert_core_file_wine_to_w32_result" ; then
                   1527:         if test -z "$func_convert_core_path_wine_to_w32_result"; then
                   1528:           func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"
                   1529:         else
                   1530:           func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
                   1531:         fi
                   1532:       fi
                   1533:     done
                   1534:     IFS=$oldIFS
                   1535:   fi
                   1536: }
                   1537: # end: func_convert_core_path_wine_to_w32
                   1538: 
                   1539: 
                   1540: # func_cygpath ARGS...
                   1541: # Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
                   1542: # when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
                   1543: # $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
                   1544: # (2), returns the Cygwin file name or path in func_cygpath_result (input
                   1545: # file name or path is assumed to be in w32 format, as previously converted
                   1546: # from $build's *nix or MSYS format). In case (3), returns the w32 file name
                   1547: # or path in func_cygpath_result (input file name or path is assumed to be in
                   1548: # Cygwin format). Returns an empty string on error.
                   1549: #
                   1550: # ARGS are passed to cygpath, with the last one being the file name or path to
                   1551: # be converted.
                   1552: #
                   1553: # Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
                   1554: # environment variable; do not put it in $PATH.
                   1555: func_cygpath ()
                   1556: {
                   1557:   $opt_debug
                   1558:   if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
                   1559:     func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
                   1560:     if test "$?" -ne 0; then
                   1561:       # on failure, ensure result is empty
                   1562:       func_cygpath_result=
                   1563:     fi
                   1564:   else
                   1565:     func_cygpath_result=
                   1566:     func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"
                   1567:   fi
                   1568: }
                   1569: #end: func_cygpath
                   1570: 
                   1571: 
                   1572: # func_convert_core_msys_to_w32 ARG
                   1573: # Convert file name or path ARG from MSYS format to w32 format.  Return
                   1574: # result in func_convert_core_msys_to_w32_result.
                   1575: func_convert_core_msys_to_w32 ()
                   1576: {
                   1577:   $opt_debug
                   1578:   # awkward: cmd appends spaces to result
                   1579:   func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
                   1580:     $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
                   1581: }
                   1582: #end: func_convert_core_msys_to_w32
                   1583: 
                   1584: 
                   1585: # func_convert_file_check ARG1 ARG2
                   1586: # Verify that ARG1 (a file name in $build format) was converted to $host
                   1587: # format in ARG2. Otherwise, emit an error message, but continue (resetting
                   1588: # func_to_host_file_result to ARG1).
                   1589: func_convert_file_check ()
                   1590: {
                   1591:   $opt_debug
                   1592:   if test -z "$2" && test -n "$1" ; then
                   1593:     func_error "Could not determine host file name corresponding to"
                   1594:     func_error "  \`$1'"
                   1595:     func_error "Continuing, but uninstalled executables may not work."
                   1596:     # Fallback:
                   1597:     func_to_host_file_result="$1"
                   1598:   fi
                   1599: }
                   1600: # end func_convert_file_check
                   1601: 
                   1602: 
                   1603: # func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
                   1604: # Verify that FROM_PATH (a path in $build format) was converted to $host
                   1605: # format in TO_PATH. Otherwise, emit an error message, but continue, resetting
                   1606: # func_to_host_file_result to a simplistic fallback value (see below).
                   1607: func_convert_path_check ()
                   1608: {
                   1609:   $opt_debug
                   1610:   if test -z "$4" && test -n "$3"; then
                   1611:     func_error "Could not determine the host path corresponding to"
                   1612:     func_error "  \`$3'"
                   1613:     func_error "Continuing, but uninstalled executables may not work."
                   1614:     # Fallback.  This is a deliberately simplistic "conversion" and
                   1615:     # should not be "improved".  See libtool.info.
                   1616:     if test "x$1" != "x$2"; then
                   1617:       lt_replace_pathsep_chars="s|$1|$2|g"
                   1618:       func_to_host_path_result=`echo "$3" |
                   1619:         $SED -e "$lt_replace_pathsep_chars"`
                   1620:     else
                   1621:       func_to_host_path_result="$3"
                   1622:     fi
                   1623:   fi
                   1624: }
                   1625: # end func_convert_path_check
                   1626: 
                   1627: 
                   1628: # func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
                   1629: # Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
                   1630: # and appending REPL if ORIG matches BACKPAT.
                   1631: func_convert_path_front_back_pathsep ()
                   1632: {
                   1633:   $opt_debug
                   1634:   case $4 in
                   1635:   $1 ) func_to_host_path_result="$3$func_to_host_path_result"
                   1636:     ;;
                   1637:   esac
                   1638:   case $4 in
                   1639:   $2 ) func_append func_to_host_path_result "$3"
                   1640:     ;;
                   1641:   esac
                   1642: }
                   1643: # end func_convert_path_front_back_pathsep
                   1644: 
                   1645: 
                   1646: ##################################################
                   1647: # $build to $host FILE NAME CONVERSION FUNCTIONS #
                   1648: ##################################################
                   1649: # invoked via `$to_host_file_cmd ARG'
                   1650: #
                   1651: # In each case, ARG is the path to be converted from $build to $host format.
                   1652: # Result will be available in $func_to_host_file_result.
                   1653: 
                   1654: 
                   1655: # func_to_host_file ARG
                   1656: # Converts the file name ARG from $build format to $host format. Return result
                   1657: # in func_to_host_file_result.
                   1658: func_to_host_file ()
                   1659: {
                   1660:   $opt_debug
                   1661:   $to_host_file_cmd "$1"
                   1662: }
                   1663: # end func_to_host_file
                   1664: 
                   1665: 
                   1666: # func_to_tool_file ARG LAZY
                   1667: # converts the file name ARG from $build format to toolchain format. Return
                   1668: # result in func_to_tool_file_result.  If the conversion in use is listed
                   1669: # in (the comma separated) LAZY, no conversion takes place.
                   1670: func_to_tool_file ()
                   1671: {
                   1672:   $opt_debug
                   1673:   case ,$2, in
                   1674:     *,"$to_tool_file_cmd",*)
                   1675:       func_to_tool_file_result=$1
                   1676:       ;;
                   1677:     *)
                   1678:       $to_tool_file_cmd "$1"
                   1679:       func_to_tool_file_result=$func_to_host_file_result
                   1680:       ;;
                   1681:   esac
                   1682: }
                   1683: # end func_to_tool_file
                   1684: 
                   1685: 
                   1686: # func_convert_file_noop ARG
                   1687: # Copy ARG to func_to_host_file_result.
                   1688: func_convert_file_noop ()
                   1689: {
                   1690:   func_to_host_file_result="$1"
                   1691: }
                   1692: # end func_convert_file_noop
                   1693: 
                   1694: 
                   1695: # func_convert_file_msys_to_w32 ARG
                   1696: # Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
                   1697: # conversion to w32 is not available inside the cwrapper.  Returns result in
                   1698: # func_to_host_file_result.
                   1699: func_convert_file_msys_to_w32 ()
                   1700: {
                   1701:   $opt_debug
                   1702:   func_to_host_file_result="$1"
                   1703:   if test -n "$1"; then
                   1704:     func_convert_core_msys_to_w32 "$1"
                   1705:     func_to_host_file_result="$func_convert_core_msys_to_w32_result"
                   1706:   fi
                   1707:   func_convert_file_check "$1" "$func_to_host_file_result"
                   1708: }
                   1709: # end func_convert_file_msys_to_w32
                   1710: 
                   1711: 
                   1712: # func_convert_file_cygwin_to_w32 ARG
                   1713: # Convert file name ARG from Cygwin to w32 format.  Returns result in
                   1714: # func_to_host_file_result.
                   1715: func_convert_file_cygwin_to_w32 ()
                   1716: {
                   1717:   $opt_debug
                   1718:   func_to_host_file_result="$1"
                   1719:   if test -n "$1"; then
                   1720:     # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
                   1721:     # LT_CYGPATH in this case.
                   1722:     func_to_host_file_result=`cygpath -m "$1"`
                   1723:   fi
                   1724:   func_convert_file_check "$1" "$func_to_host_file_result"
                   1725: }
                   1726: # end func_convert_file_cygwin_to_w32
                   1727: 
                   1728: 
                   1729: # func_convert_file_nix_to_w32 ARG
                   1730: # Convert file name ARG from *nix to w32 format.  Requires a wine environment
                   1731: # and a working winepath. Returns result in func_to_host_file_result.
                   1732: func_convert_file_nix_to_w32 ()
                   1733: {
                   1734:   $opt_debug
                   1735:   func_to_host_file_result="$1"
                   1736:   if test -n "$1"; then
                   1737:     func_convert_core_file_wine_to_w32 "$1"
                   1738:     func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"
                   1739:   fi
                   1740:   func_convert_file_check "$1" "$func_to_host_file_result"
                   1741: }
                   1742: # end func_convert_file_nix_to_w32
                   1743: 
                   1744: 
                   1745: # func_convert_file_msys_to_cygwin ARG
                   1746: # Convert file name ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
                   1747: # Returns result in func_to_host_file_result.
                   1748: func_convert_file_msys_to_cygwin ()
                   1749: {
                   1750:   $opt_debug
                   1751:   func_to_host_file_result="$1"
                   1752:   if test -n "$1"; then
                   1753:     func_convert_core_msys_to_w32 "$1"
                   1754:     func_cygpath -u "$func_convert_core_msys_to_w32_result"
                   1755:     func_to_host_file_result="$func_cygpath_result"
                   1756:   fi
                   1757:   func_convert_file_check "$1" "$func_to_host_file_result"
                   1758: }
                   1759: # end func_convert_file_msys_to_cygwin
                   1760: 
                   1761: 
                   1762: # func_convert_file_nix_to_cygwin ARG
                   1763: # Convert file name ARG from *nix to Cygwin format.  Requires Cygwin installed
                   1764: # in a wine environment, working winepath, and LT_CYGPATH set.  Returns result
                   1765: # in func_to_host_file_result.
                   1766: func_convert_file_nix_to_cygwin ()
                   1767: {
                   1768:   $opt_debug
                   1769:   func_to_host_file_result="$1"
                   1770:   if test -n "$1"; then
                   1771:     # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
                   1772:     func_convert_core_file_wine_to_w32 "$1"
                   1773:     func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
                   1774:     func_to_host_file_result="$func_cygpath_result"
                   1775:   fi
                   1776:   func_convert_file_check "$1" "$func_to_host_file_result"
                   1777: }
                   1778: # end func_convert_file_nix_to_cygwin
                   1779: 
                   1780: 
                   1781: #############################################
                   1782: # $build to $host PATH CONVERSION FUNCTIONS #
                   1783: #############################################
                   1784: # invoked via `$to_host_path_cmd ARG'
                   1785: #
                   1786: # In each case, ARG is the path to be converted from $build to $host format.
                   1787: # The result will be available in $func_to_host_path_result.
                   1788: #
                   1789: # Path separators are also converted from $build format to $host format.  If
                   1790: # ARG begins or ends with a path separator character, it is preserved (but
                   1791: # converted to $host format) on output.
                   1792: #
                   1793: # All path conversion functions are named using the following convention:
                   1794: #   file name conversion function    : func_convert_file_X_to_Y ()
                   1795: #   path conversion function         : func_convert_path_X_to_Y ()
                   1796: # where, for any given $build/$host combination the 'X_to_Y' value is the
                   1797: # same.  If conversion functions are added for new $build/$host combinations,
                   1798: # the two new functions must follow this pattern, or func_init_to_host_path_cmd
                   1799: # will break.
                   1800: 
                   1801: 
                   1802: # func_init_to_host_path_cmd
                   1803: # Ensures that function "pointer" variable $to_host_path_cmd is set to the
                   1804: # appropriate value, based on the value of $to_host_file_cmd.
                   1805: to_host_path_cmd=
                   1806: func_init_to_host_path_cmd ()
                   1807: {
                   1808:   $opt_debug
                   1809:   if test -z "$to_host_path_cmd"; then
                   1810:     func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
                   1811:     to_host_path_cmd="func_convert_path_${func_stripname_result}"
                   1812:   fi
                   1813: }
                   1814: 
                   1815: 
                   1816: # func_to_host_path ARG
                   1817: # Converts the path ARG from $build format to $host format. Return result
                   1818: # in func_to_host_path_result.
                   1819: func_to_host_path ()
                   1820: {
                   1821:   $opt_debug
                   1822:   func_init_to_host_path_cmd
                   1823:   $to_host_path_cmd "$1"
                   1824: }
                   1825: # end func_to_host_path
                   1826: 
                   1827: 
                   1828: # func_convert_path_noop ARG
                   1829: # Copy ARG to func_to_host_path_result.
                   1830: func_convert_path_noop ()
                   1831: {
                   1832:   func_to_host_path_result="$1"
                   1833: }
                   1834: # end func_convert_path_noop
                   1835: 
                   1836: 
                   1837: # func_convert_path_msys_to_w32 ARG
                   1838: # Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
                   1839: # conversion to w32 is not available inside the cwrapper.  Returns result in
                   1840: # func_to_host_path_result.
                   1841: func_convert_path_msys_to_w32 ()
                   1842: {
                   1843:   $opt_debug
                   1844:   func_to_host_path_result="$1"
                   1845:   if test -n "$1"; then
                   1846:     # Remove leading and trailing path separator characters from ARG.  MSYS
                   1847:     # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
                   1848:     # and winepath ignores them completely.
                   1849:     func_stripname : : "$1"
                   1850:     func_to_host_path_tmp1=$func_stripname_result
                   1851:     func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
                   1852:     func_to_host_path_result="$func_convert_core_msys_to_w32_result"
                   1853:     func_convert_path_check : ";" \
                   1854:       "$func_to_host_path_tmp1" "$func_to_host_path_result"
                   1855:     func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
                   1856:   fi
                   1857: }
                   1858: # end func_convert_path_msys_to_w32
                   1859: 
                   1860: 
                   1861: # func_convert_path_cygwin_to_w32 ARG
                   1862: # Convert path ARG from Cygwin to w32 format.  Returns result in
                   1863: # func_to_host_file_result.
                   1864: func_convert_path_cygwin_to_w32 ()
                   1865: {
                   1866:   $opt_debug
                   1867:   func_to_host_path_result="$1"
                   1868:   if test -n "$1"; then
                   1869:     # See func_convert_path_msys_to_w32:
                   1870:     func_stripname : : "$1"
                   1871:     func_to_host_path_tmp1=$func_stripname_result
                   1872:     func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
                   1873:     func_convert_path_check : ";" \
                   1874:       "$func_to_host_path_tmp1" "$func_to_host_path_result"
                   1875:     func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
                   1876:   fi
                   1877: }
                   1878: # end func_convert_path_cygwin_to_w32
                   1879: 
                   1880: 
                   1881: # func_convert_path_nix_to_w32 ARG
                   1882: # Convert path ARG from *nix to w32 format.  Requires a wine environment and
                   1883: # a working winepath.  Returns result in func_to_host_file_result.
                   1884: func_convert_path_nix_to_w32 ()
                   1885: {
                   1886:   $opt_debug
                   1887:   func_to_host_path_result="$1"
                   1888:   if test -n "$1"; then
                   1889:     # See func_convert_path_msys_to_w32:
                   1890:     func_stripname : : "$1"
                   1891:     func_to_host_path_tmp1=$func_stripname_result
                   1892:     func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
                   1893:     func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"
                   1894:     func_convert_path_check : ";" \
                   1895:       "$func_to_host_path_tmp1" "$func_to_host_path_result"
                   1896:     func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
                   1897:   fi
                   1898: }
                   1899: # end func_convert_path_nix_to_w32
                   1900: 
                   1901: 
                   1902: # func_convert_path_msys_to_cygwin ARG
                   1903: # Convert path ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
                   1904: # Returns result in func_to_host_file_result.
                   1905: func_convert_path_msys_to_cygwin ()
                   1906: {
                   1907:   $opt_debug
                   1908:   func_to_host_path_result="$1"
                   1909:   if test -n "$1"; then
                   1910:     # See func_convert_path_msys_to_w32:
                   1911:     func_stripname : : "$1"
                   1912:     func_to_host_path_tmp1=$func_stripname_result
                   1913:     func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
                   1914:     func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
                   1915:     func_to_host_path_result="$func_cygpath_result"
                   1916:     func_convert_path_check : : \
                   1917:       "$func_to_host_path_tmp1" "$func_to_host_path_result"
                   1918:     func_convert_path_front_back_pathsep ":*" "*:" : "$1"
                   1919:   fi
                   1920: }
                   1921: # end func_convert_path_msys_to_cygwin
                   1922: 
                   1923: 
                   1924: # func_convert_path_nix_to_cygwin ARG
                   1925: # Convert path ARG from *nix to Cygwin format.  Requires Cygwin installed in a
                   1926: # a wine environment, working winepath, and LT_CYGPATH set.  Returns result in
                   1927: # func_to_host_file_result.
                   1928: func_convert_path_nix_to_cygwin ()
                   1929: {
                   1930:   $opt_debug
                   1931:   func_to_host_path_result="$1"
                   1932:   if test -n "$1"; then
                   1933:     # Remove leading and trailing path separator characters from
                   1934:     # ARG. msys behavior is inconsistent here, cygpath turns them
                   1935:     # into '.;' and ';.', and winepath ignores them completely.
                   1936:     func_stripname : : "$1"
                   1937:     func_to_host_path_tmp1=$func_stripname_result
                   1938:     func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
                   1939:     func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
                   1940:     func_to_host_path_result="$func_cygpath_result"
                   1941:     func_convert_path_check : : \
                   1942:       "$func_to_host_path_tmp1" "$func_to_host_path_result"
                   1943:     func_convert_path_front_back_pathsep ":*" "*:" : "$1"
                   1944:   fi
                   1945: }
                   1946: # end func_convert_path_nix_to_cygwin
                   1947: 
                   1948: 
                   1949: # func_mode_compile arg...
                   1950: func_mode_compile ()
                   1951: {
                   1952:     $opt_debug
                   1953:     # Get the compilation command and the source file.
                   1954:     base_compile=
                   1955:     srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
                   1956:     suppress_opt=yes
                   1957:     suppress_output=
                   1958:     arg_mode=normal
                   1959:     libobj=
                   1960:     later=
                   1961:     pie_flag=
                   1962: 
                   1963:     for arg
                   1964:     do
                   1965:       case $arg_mode in
                   1966:       arg  )
                   1967:        # do not "continue".  Instead, add this to base_compile
                   1968:        lastarg="$arg"
                   1969:        arg_mode=normal
                   1970:        ;;
                   1971: 
                   1972:       target )
                   1973:        libobj="$arg"
                   1974:        arg_mode=normal
                   1975:        continue
                   1976:        ;;
                   1977: 
                   1978:       normal )
                   1979:        # Accept any command-line options.
                   1980:        case $arg in
                   1981:        -o)
                   1982:          test -n "$libobj" && \
                   1983:            func_fatal_error "you cannot specify \`-o' more than once"
                   1984:          arg_mode=target
                   1985:          continue
                   1986:          ;;
                   1987: 
                   1988:        -pie | -fpie | -fPIE)
                   1989:           func_append pie_flag " $arg"
                   1990:          continue
                   1991:          ;;
                   1992: 
                   1993:        -shared | -static | -prefer-pic | -prefer-non-pic)
                   1994:          func_append later " $arg"
                   1995:          continue
                   1996:          ;;
                   1997: 
                   1998:        -no-suppress)
                   1999:          suppress_opt=no
                   2000:          continue
                   2001:          ;;
                   2002: 
                   2003:        -Xcompiler)
                   2004:          arg_mode=arg  #  the next one goes into the "base_compile" arg list
                   2005:          continue      #  The current "srcfile" will either be retained or
                   2006:          ;;            #  replaced later.  I would guess that would be a bug.
                   2007: 
                   2008:        -Wc,*)
                   2009:          func_stripname '-Wc,' '' "$arg"
                   2010:          args=$func_stripname_result
                   2011:          lastarg=
                   2012:          save_ifs="$IFS"; IFS=','
                   2013:          for arg in $args; do
                   2014:            IFS="$save_ifs"
                   2015:            func_append_quoted lastarg "$arg"
                   2016:          done
                   2017:          IFS="$save_ifs"
                   2018:          func_stripname ' ' '' "$lastarg"
                   2019:          lastarg=$func_stripname_result
                   2020: 
                   2021:          # Add the arguments to base_compile.
                   2022:          func_append base_compile " $lastarg"
                   2023:          continue
                   2024:          ;;
                   2025: 
                   2026:        *)
                   2027:          # Accept the current argument as the source file.
                   2028:          # The previous "srcfile" becomes the current argument.
                   2029:          #
                   2030:          lastarg="$srcfile"
                   2031:          srcfile="$arg"
                   2032:          ;;
                   2033:        esac  #  case $arg
                   2034:        ;;
                   2035:       esac    #  case $arg_mode
                   2036: 
                   2037:       # Aesthetically quote the previous argument.
                   2038:       func_append_quoted base_compile "$lastarg"
                   2039:     done # for arg
                   2040: 
                   2041:     case $arg_mode in
                   2042:     arg)
                   2043:       func_fatal_error "you must specify an argument for -Xcompile"
                   2044:       ;;
                   2045:     target)
                   2046:       func_fatal_error "you must specify a target with \`-o'"
                   2047:       ;;
                   2048:     *)
                   2049:       # Get the name of the library object.
                   2050:       test -z "$libobj" && {
                   2051:        func_basename "$srcfile"
                   2052:        libobj="$func_basename_result"
                   2053:       }
                   2054:       ;;
                   2055:     esac
                   2056: 
                   2057:     # Recognize several different file suffixes.
                   2058:     # If the user specifies -o file.o, it is replaced with file.lo
                   2059:     case $libobj in
                   2060:     *.[cCFSifmso] | \
                   2061:     *.ada | *.adb | *.ads | *.asm | \
                   2062:     *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
                   2063:     *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup)
                   2064:       func_xform "$libobj"
                   2065:       libobj=$func_xform_result
                   2066:       ;;
                   2067:     esac
                   2068: 
                   2069:     case $libobj in
                   2070:     *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
                   2071:     *)
                   2072:       func_fatal_error "cannot determine name of library object from \`$libobj'"
                   2073:       ;;
                   2074:     esac
                   2075: 
                   2076:     func_infer_tag $base_compile
                   2077: 
                   2078:     for arg in $later; do
                   2079:       case $arg in
                   2080:       -shared)
                   2081:        test "$build_libtool_libs" != yes && \
                   2082:          func_fatal_configuration "can not build a shared library"
                   2083:        build_old_libs=no
                   2084:        continue
                   2085:        ;;
                   2086: 
                   2087:       -static)
                   2088:        build_libtool_libs=no
                   2089:        build_old_libs=yes
                   2090:        continue
                   2091:        ;;
                   2092: 
                   2093:       -prefer-pic)
                   2094:        pic_mode=yes
                   2095:        continue
                   2096:        ;;
                   2097: 
                   2098:       -prefer-non-pic)
                   2099:        pic_mode=no
                   2100:        continue
                   2101:        ;;
                   2102:       esac
                   2103:     done
                   2104: 
                   2105:     func_quote_for_eval "$libobj"
                   2106:     test "X$libobj" != "X$func_quote_for_eval_result" \
                   2107:       && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'   &()|`$[]' \
                   2108:       && func_warning "libobj name \`$libobj' may not contain shell special characters."
                   2109:     func_dirname_and_basename "$obj" "/" ""
                   2110:     objname="$func_basename_result"
                   2111:     xdir="$func_dirname_result"
                   2112:     lobj=${xdir}$objdir/$objname
                   2113: 
                   2114:     test -z "$base_compile" && \
                   2115:       func_fatal_help "you must specify a compilation command"
                   2116: 
                   2117:     # Delete any leftover library objects.
                   2118:     if test "$build_old_libs" = yes; then
                   2119:       removelist="$obj $lobj $libobj ${libobj}T"
                   2120:     else
                   2121:       removelist="$lobj $libobj ${libobj}T"
                   2122:     fi
                   2123: 
                   2124:     # On Cygwin there's no "real" PIC flag so we must build both object types
                   2125:     case $host_os in
                   2126:     cygwin* | mingw* | pw32* | os2* | cegcc*)
                   2127:       pic_mode=default
                   2128:       ;;
                   2129:     esac
                   2130:     if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
                   2131:       # non-PIC code in shared libraries is not supported
                   2132:       pic_mode=default
                   2133:     fi
                   2134: 
                   2135:     # Calculate the filename of the output object if compiler does
                   2136:     # not support -o with -c
                   2137:     if test "$compiler_c_o" = no; then
                   2138:       output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
                   2139:       lockfile="$output_obj.lock"
                   2140:     else
                   2141:       output_obj=
                   2142:       need_locks=no
                   2143:       lockfile=
                   2144:     fi
                   2145: 
                   2146:     # Lock this critical section if it is needed
                   2147:     # We use this script file to make the link, it avoids creating a new file
                   2148:     if test "$need_locks" = yes; then
                   2149:       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
                   2150:        func_echo "Waiting for $lockfile to be removed"
                   2151:        sleep 2
                   2152:       done
                   2153:     elif test "$need_locks" = warn; then
                   2154:       if test -f "$lockfile"; then
                   2155:        $ECHO "\
                   2156: *** ERROR, $lockfile exists and contains:
                   2157: `cat $lockfile 2>/dev/null`
                   2158: 
                   2159: This indicates that another process is trying to use the same
                   2160: temporary object file, and libtool could not work around it because
                   2161: your compiler does not support \`-c' and \`-o' together.  If you
                   2162: repeat this compilation, it may succeed, by chance, but you had better
                   2163: avoid parallel builds (make -j) in this platform, or get a better
                   2164: compiler."
                   2165: 
                   2166:        $opt_dry_run || $RM $removelist
                   2167:        exit $EXIT_FAILURE
                   2168:       fi
                   2169:       func_append removelist " $output_obj"
                   2170:       $ECHO "$srcfile" > "$lockfile"
                   2171:     fi
                   2172: 
                   2173:     $opt_dry_run || $RM $removelist
                   2174:     func_append removelist " $lockfile"
                   2175:     trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
                   2176: 
                   2177:     func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
                   2178:     srcfile=$func_to_tool_file_result
                   2179:     func_quote_for_eval "$srcfile"
                   2180:     qsrcfile=$func_quote_for_eval_result
                   2181: 
                   2182:     # Only build a PIC object if we are building libtool libraries.
                   2183:     if test "$build_libtool_libs" = yes; then
                   2184:       # Without this assignment, base_compile gets emptied.
                   2185:       fbsd_hideous_sh_bug=$base_compile
                   2186: 
                   2187:       if test "$pic_mode" != no; then
                   2188:        command="$base_compile $qsrcfile $pic_flag"
                   2189:       else
                   2190:        # Don't build PIC code
                   2191:        command="$base_compile $qsrcfile"
                   2192:       fi
                   2193: 
                   2194:       func_mkdir_p "$xdir$objdir"
                   2195: 
                   2196:       if test -z "$output_obj"; then
                   2197:        # Place PIC objects in $objdir
                   2198:        func_append command " -o $lobj"
                   2199:       fi
                   2200: 
                   2201:       func_show_eval_locale "$command" \
                   2202:           'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
                   2203: 
                   2204:       if test "$need_locks" = warn &&
                   2205:         test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
                   2206:        $ECHO "\
                   2207: *** ERROR, $lockfile contains:
                   2208: `cat $lockfile 2>/dev/null`
                   2209: 
                   2210: but it should contain:
                   2211: $srcfile
                   2212: 
                   2213: This indicates that another process is trying to use the same
                   2214: temporary object file, and libtool could not work around it because
                   2215: your compiler does not support \`-c' and \`-o' together.  If you
                   2216: repeat this compilation, it may succeed, by chance, but you had better
                   2217: avoid parallel builds (make -j) in this platform, or get a better
                   2218: compiler."
                   2219: 
                   2220:        $opt_dry_run || $RM $removelist
                   2221:        exit $EXIT_FAILURE
                   2222:       fi
                   2223: 
                   2224:       # Just move the object if needed, then go on to compile the next one
                   2225:       if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
                   2226:        func_show_eval '$MV "$output_obj" "$lobj"' \
                   2227:          'error=$?; $opt_dry_run || $RM $removelist; exit $error'
                   2228:       fi
                   2229: 
                   2230:       # Allow error messages only from the first compilation.
                   2231:       if test "$suppress_opt" = yes; then
                   2232:        suppress_output=' >/dev/null 2>&1'
                   2233:       fi
                   2234:     fi
                   2235: 
                   2236:     # Only build a position-dependent object if we build old libraries.
                   2237:     if test "$build_old_libs" = yes; then
                   2238:       if test "$pic_mode" != yes; then
                   2239:        # Don't build PIC code
                   2240:        command="$base_compile $qsrcfile$pie_flag"
                   2241:       else
                   2242:        command="$base_compile $qsrcfile $pic_flag"
                   2243:       fi
                   2244:       if test "$compiler_c_o" = yes; then
                   2245:        func_append command " -o $obj"
                   2246:       fi
                   2247: 
                   2248:       # Suppress compiler output if we already did a PIC compilation.
                   2249:       func_append command "$suppress_output"
                   2250:       func_show_eval_locale "$command" \
                   2251:         '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
                   2252: 
                   2253:       if test "$need_locks" = warn &&
                   2254:         test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
                   2255:        $ECHO "\
                   2256: *** ERROR, $lockfile contains:
                   2257: `cat $lockfile 2>/dev/null`
                   2258: 
                   2259: but it should contain:
                   2260: $srcfile
                   2261: 
                   2262: This indicates that another process is trying to use the same
                   2263: temporary object file, and libtool could not work around it because
                   2264: your compiler does not support \`-c' and \`-o' together.  If you
                   2265: repeat this compilation, it may succeed, by chance, but you had better
                   2266: avoid parallel builds (make -j) in this platform, or get a better
                   2267: compiler."
                   2268: 
                   2269:        $opt_dry_run || $RM $removelist
                   2270:        exit $EXIT_FAILURE
                   2271:       fi
                   2272: 
                   2273:       # Just move the object if needed
                   2274:       if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
                   2275:        func_show_eval '$MV "$output_obj" "$obj"' \
                   2276:          'error=$?; $opt_dry_run || $RM $removelist; exit $error'
                   2277:       fi
                   2278:     fi
                   2279: 
                   2280:     $opt_dry_run || {
                   2281:       func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
                   2282: 
                   2283:       # Unlock the critical section if it was locked
                   2284:       if test "$need_locks" != no; then
                   2285:        removelist=$lockfile
                   2286:         $RM "$lockfile"
                   2287:       fi
                   2288:     }
                   2289: 
                   2290:     exit $EXIT_SUCCESS
                   2291: }
                   2292: 
                   2293: $opt_help || {
                   2294:   test "$opt_mode" = compile && func_mode_compile ${1+"$@"}
                   2295: }
                   2296: 
                   2297: func_mode_help ()
                   2298: {
                   2299:     # We need to display help for each of the modes.
                   2300:     case $opt_mode in
                   2301:       "")
                   2302:         # Generic help is extracted from the usage comments
                   2303:         # at the start of this file.
                   2304:         func_help
                   2305:         ;;
                   2306: 
                   2307:       clean)
                   2308:         $ECHO \
                   2309: "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
                   2310: 
                   2311: Remove files from the build directory.
                   2312: 
                   2313: RM is the name of the program to use to delete files associated with each FILE
                   2314: (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
                   2315: to RM.
                   2316: 
                   2317: If FILE is a libtool library, object or program, all the files associated
                   2318: with it are deleted. Otherwise, only FILE itself is deleted using RM."
                   2319:         ;;
                   2320: 
                   2321:       compile)
                   2322:       $ECHO \
                   2323: "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
                   2324: 
                   2325: Compile a source file into a libtool library object.
                   2326: 
                   2327: This mode accepts the following additional options:
                   2328: 
                   2329:   -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
                   2330:   -no-suppress      do not suppress compiler output for multiple passes
                   2331:   -prefer-pic       try to build PIC objects only
                   2332:   -prefer-non-pic   try to build non-PIC objects only
                   2333:   -shared           do not build a \`.o' file suitable for static linking
                   2334:   -static           only build a \`.o' file suitable for static linking
                   2335:   -Wc,FLAG          pass FLAG directly to the compiler
                   2336: 
                   2337: COMPILE-COMMAND is a command to be used in creating a \`standard' object file
                   2338: from the given SOURCEFILE.
                   2339: 
                   2340: The output file name is determined by removing the directory component from
                   2341: SOURCEFILE, then substituting the C source code suffix \`.c' with the
                   2342: library object suffix, \`.lo'."
                   2343:         ;;
                   2344: 
                   2345:       execute)
                   2346:         $ECHO \
                   2347: "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
                   2348: 
                   2349: Automatically set library path, then run a program.
                   2350: 
                   2351: This mode accepts the following additional options:
                   2352: 
                   2353:   -dlopen FILE      add the directory containing FILE to the library path
                   2354: 
                   2355: This mode sets the library path environment variable according to \`-dlopen'
                   2356: flags.
                   2357: 
                   2358: If any of the ARGS are libtool executable wrappers, then they are translated
                   2359: into their corresponding uninstalled binary, and any of their required library
                   2360: directories are added to the library path.
                   2361: 
                   2362: Then, COMMAND is executed, with ARGS as arguments."
                   2363:         ;;
                   2364: 
                   2365:       finish)
                   2366:         $ECHO \
                   2367: "Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
                   2368: 
                   2369: Complete the installation of libtool libraries.
                   2370: 
                   2371: Each LIBDIR is a directory that contains libtool libraries.
                   2372: 
                   2373: The commands that this mode executes may require superuser privileges.  Use
                   2374: the \`--dry-run' option if you just want to see what would be executed."
                   2375:         ;;
                   2376: 
                   2377:       install)
                   2378:         $ECHO \
                   2379: "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
                   2380: 
                   2381: Install executables or libraries.
                   2382: 
                   2383: INSTALL-COMMAND is the installation command.  The first component should be
                   2384: either the \`install' or \`cp' program.
                   2385: 
                   2386: The following components of INSTALL-COMMAND are treated specially:
                   2387: 
                   2388:   -inst-prefix-dir PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
                   2389: 
                   2390: The rest of the components are interpreted as arguments to that command (only
                   2391: BSD-compatible install options are recognized)."
                   2392:         ;;
                   2393: 
                   2394:       link)
                   2395:         $ECHO \
                   2396: "Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
                   2397: 
                   2398: Link object files or libraries together to form another library, or to
                   2399: create an executable program.
                   2400: 
                   2401: LINK-COMMAND is a command using the C compiler that you would use to create
                   2402: a program from several object files.
                   2403: 
                   2404: The following components of LINK-COMMAND are treated specially:
                   2405: 
                   2406:   -all-static       do not do any dynamic linking at all
                   2407:   -avoid-version    do not add a version suffix if possible
                   2408:   -bindir BINDIR    specify path to binaries directory (for systems where
                   2409:                     libraries must be found in the PATH setting at runtime)
                   2410:   -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
                   2411:   -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
                   2412:   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
                   2413:   -export-symbols SYMFILE
                   2414:                     try to export only the symbols listed in SYMFILE
                   2415:   -export-symbols-regex REGEX
                   2416:                     try to export only the symbols matching REGEX
                   2417:   -LLIBDIR          search LIBDIR for required installed libraries
                   2418:   -lNAME            OUTPUT-FILE requires the installed library libNAME
                   2419:   -module           build a library that can dlopened
                   2420:   -no-fast-install  disable the fast-install mode
                   2421:   -no-install       link a not-installable executable
                   2422:   -no-undefined     declare that a library does not refer to external symbols
                   2423:   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
                   2424:   -objectlist FILE  Use a list of object files found in FILE to specify objects
                   2425:   -precious-files-regex REGEX
                   2426:                     don't remove output files matching REGEX
                   2427:   -release RELEASE  specify package release information
                   2428:   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
                   2429:   -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
                   2430:   -shared           only do dynamic linking of libtool libraries
                   2431:   -shrext SUFFIX    override the standard shared library file extension
                   2432:   -static           do not do any dynamic linking of uninstalled libtool libraries
                   2433:   -static-libtool-libs
                   2434:                     do not do any dynamic linking of libtool libraries
                   2435:   -version-info CURRENT[:REVISION[:AGE]]
                   2436:                     specify library version info [each variable defaults to 0]
                   2437:   -weak LIBNAME     declare that the target provides the LIBNAME interface
                   2438:   -Wc,FLAG
                   2439:   -Xcompiler FLAG   pass linker-specific FLAG directly to the compiler
                   2440:   -Wl,FLAG
                   2441:   -Xlinker FLAG     pass linker-specific FLAG directly to the linker
                   2442:   -XCClinker FLAG   pass link-specific FLAG to the compiler driver (CC)
                   2443: 
                   2444: All other options (arguments beginning with \`-') are ignored.
                   2445: 
                   2446: Every other argument is treated as a filename.  Files ending in \`.la' are
                   2447: treated as uninstalled libtool libraries, other files are standard or library
                   2448: object files.
                   2449: 
                   2450: If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
                   2451: only library objects (\`.lo' files) may be specified, and \`-rpath' is
                   2452: required, except when creating a convenience library.
                   2453: 
                   2454: If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
                   2455: using \`ar' and \`ranlib', or on Windows using \`lib'.
                   2456: 
                   2457: If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
                   2458: is created, otherwise an executable program is created."
                   2459:         ;;
                   2460: 
                   2461:       uninstall)
                   2462:         $ECHO \
                   2463: "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
                   2464: 
                   2465: Remove libraries from an installation directory.
                   2466: 
                   2467: RM is the name of the program to use to delete files associated with each FILE
                   2468: (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
                   2469: to RM.
                   2470: 
                   2471: If FILE is a libtool library, all the files associated with it are deleted.
                   2472: Otherwise, only FILE itself is deleted using RM."
                   2473:         ;;
                   2474: 
                   2475:       *)
                   2476:         func_fatal_help "invalid operation mode \`$opt_mode'"
                   2477:         ;;
                   2478:     esac
                   2479: 
                   2480:     echo
                   2481:     $ECHO "Try \`$progname --help' for more information about other modes."
                   2482: }
                   2483: 
                   2484: # Now that we've collected a possible --mode arg, show help if necessary
                   2485: if $opt_help; then
                   2486:   if test "$opt_help" = :; then
                   2487:     func_mode_help
                   2488:   else
                   2489:     {
                   2490:       func_help noexit
                   2491:       for opt_mode in compile link execute install finish uninstall clean; do
                   2492:        func_mode_help
                   2493:       done
                   2494:     } | sed -n '1p; 2,$s/^Usage:/  or: /p'
                   2495:     {
                   2496:       func_help noexit
                   2497:       for opt_mode in compile link execute install finish uninstall clean; do
                   2498:        echo
                   2499:        func_mode_help
                   2500:       done
                   2501:     } |
                   2502:     sed '1d
                   2503:       /^When reporting/,/^Report/{
                   2504:        H
                   2505:        d
                   2506:       }
                   2507:       $x
                   2508:       /information about other modes/d
                   2509:       /more detailed .*MODE/d
                   2510:       s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
                   2511:   fi
                   2512:   exit $?
                   2513: fi
                   2514: 
                   2515: 
                   2516: # func_mode_execute arg...
                   2517: func_mode_execute ()
                   2518: {
                   2519:     $opt_debug
                   2520:     # The first argument is the command name.
                   2521:     cmd="$nonopt"
                   2522:     test -z "$cmd" && \
                   2523:       func_fatal_help "you must specify a COMMAND"
                   2524: 
                   2525:     # Handle -dlopen flags immediately.
                   2526:     for file in $opt_dlopen; do
                   2527:       test -f "$file" \
                   2528:        || func_fatal_help "\`$file' is not a file"
                   2529: 
                   2530:       dir=
                   2531:       case $file in
                   2532:       *.la)
                   2533:        func_resolve_sysroot "$file"
                   2534:        file=$func_resolve_sysroot_result
                   2535: 
                   2536:        # Check to see that this really is a libtool archive.
                   2537:        func_lalib_unsafe_p "$file" \
                   2538:          || func_fatal_help "\`$lib' is not a valid libtool archive"
                   2539: 
                   2540:        # Read the libtool library.
                   2541:        dlname=
                   2542:        library_names=
                   2543:        func_source "$file"
                   2544: 
                   2545:        # Skip this library if it cannot be dlopened.
                   2546:        if test -z "$dlname"; then
                   2547:          # Warn if it was a shared library.
                   2548:          test -n "$library_names" && \
                   2549:            func_warning "\`$file' was not linked with \`-export-dynamic'"
                   2550:          continue
                   2551:        fi
                   2552: 
                   2553:        func_dirname "$file" "" "."
                   2554:        dir="$func_dirname_result"
                   2555: 
                   2556:        if test -f "$dir/$objdir/$dlname"; then
                   2557:          func_append dir "/$objdir"
                   2558:        else
                   2559:          if test ! -f "$dir/$dlname"; then
                   2560:            func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
                   2561:          fi
                   2562:        fi
                   2563:        ;;
                   2564: 
                   2565:       *.lo)
                   2566:        # Just add the directory containing the .lo file.
                   2567:        func_dirname "$file" "" "."
                   2568:        dir="$func_dirname_result"
                   2569:        ;;
                   2570: 
                   2571:       *)
                   2572:        func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
                   2573:        continue
                   2574:        ;;
                   2575:       esac
                   2576: 
                   2577:       # Get the absolute pathname.
                   2578:       absdir=`cd "$dir" && pwd`
                   2579:       test -n "$absdir" && dir="$absdir"
                   2580: 
                   2581:       # Now add the directory to shlibpath_var.
                   2582:       if eval "test -z \"\$$shlibpath_var\""; then
                   2583:        eval "$shlibpath_var=\"\$dir\""
                   2584:       else
                   2585:        eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
                   2586:       fi
                   2587:     done
                   2588: 
                   2589:     # This variable tells wrapper scripts just to set shlibpath_var
                   2590:     # rather than running their programs.
                   2591:     libtool_execute_magic="$magic"
                   2592: 
                   2593:     # Check if any of the arguments is a wrapper script.
                   2594:     args=
                   2595:     for file
                   2596:     do
                   2597:       case $file in
                   2598:       -* | *.la | *.lo ) ;;
                   2599:       *)
                   2600:        # Do a test to see if this is really a libtool program.
                   2601:        if func_ltwrapper_script_p "$file"; then
                   2602:          func_source "$file"
                   2603:          # Transform arg to wrapped name.
                   2604:          file="$progdir/$program"
                   2605:        elif func_ltwrapper_executable_p "$file"; then
                   2606:          func_ltwrapper_scriptname "$file"
                   2607:          func_source "$func_ltwrapper_scriptname_result"
                   2608:          # Transform arg to wrapped name.
                   2609:          file="$progdir/$program"
                   2610:        fi
                   2611:        ;;
                   2612:       esac
                   2613:       # Quote arguments (to preserve shell metacharacters).
                   2614:       func_append_quoted args "$file"
                   2615:     done
                   2616: 
                   2617:     if test "X$opt_dry_run" = Xfalse; then
                   2618:       if test -n "$shlibpath_var"; then
                   2619:        # Export the shlibpath_var.
                   2620:        eval "export $shlibpath_var"
                   2621:       fi
                   2622: 
                   2623:       # Restore saved environment variables
                   2624:       for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
                   2625:       do
                   2626:        eval "if test \"\${save_$lt_var+set}\" = set; then
                   2627:                 $lt_var=\$save_$lt_var; export $lt_var
                   2628:              else
                   2629:                $lt_unset $lt_var
                   2630:              fi"
                   2631:       done
                   2632: 
                   2633:       # Now prepare to actually exec the command.
                   2634:       exec_cmd="\$cmd$args"
                   2635:     else
                   2636:       # Display what would be done.
                   2637:       if test -n "$shlibpath_var"; then
                   2638:        eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
                   2639:        echo "export $shlibpath_var"
                   2640:       fi
                   2641:       $ECHO "$cmd$args"
                   2642:       exit $EXIT_SUCCESS
                   2643:     fi
                   2644: }
                   2645: 
                   2646: test "$opt_mode" = execute && func_mode_execute ${1+"$@"}
                   2647: 
                   2648: 
                   2649: # func_mode_finish arg...
                   2650: func_mode_finish ()
                   2651: {
                   2652:     $opt_debug
                   2653:     libs=
                   2654:     libdirs=
                   2655:     admincmds=
                   2656: 
                   2657:     for opt in "$nonopt" ${1+"$@"}
                   2658:     do
                   2659:       if test -d "$opt"; then
                   2660:        func_append libdirs " $opt"
                   2661: 
                   2662:       elif test -f "$opt"; then
                   2663:        if func_lalib_unsafe_p "$opt"; then
                   2664:          func_append libs " $opt"
                   2665:        else
                   2666:          func_warning "\`$opt' is not a valid libtool archive"
                   2667:        fi
                   2668: 
                   2669:       else
                   2670:        func_fatal_error "invalid argument \`$opt'"
                   2671:       fi
                   2672:     done
                   2673: 
                   2674:     if test -n "$libs"; then
                   2675:       if test -n "$lt_sysroot"; then
                   2676:         sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
                   2677:         sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
                   2678:       else
                   2679:         sysroot_cmd=
                   2680:       fi
                   2681: 
                   2682:       # Remove sysroot references
                   2683:       if $opt_dry_run; then
                   2684:         for lib in $libs; do
                   2685:           echo "removing references to $lt_sysroot and \`=' prefixes from $lib"
                   2686:         done
                   2687:       else
                   2688:         tmpdir=`func_mktempdir`
                   2689:         for lib in $libs; do
                   2690:          sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
                   2691:            > $tmpdir/tmp-la
                   2692:          mv -f $tmpdir/tmp-la $lib
                   2693:        done
                   2694:         ${RM}r "$tmpdir"
                   2695:       fi
                   2696:     fi
                   2697: 
                   2698:     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
                   2699:       for libdir in $libdirs; do
                   2700:        if test -n "$finish_cmds"; then
                   2701:          # Do each command in the finish commands.
                   2702:          func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
                   2703: '"$cmd"'"'
                   2704:        fi
                   2705:        if test -n "$finish_eval"; then
                   2706:          # Do the single finish_eval.
                   2707:          eval cmds=\"$finish_eval\"
                   2708:          $opt_dry_run || eval "$cmds" || func_append admincmds "
                   2709:        $cmds"
                   2710:        fi
                   2711:       done
                   2712:     fi
                   2713: 
                   2714:     # Exit here if they wanted silent mode.
                   2715:     $opt_silent && exit $EXIT_SUCCESS
                   2716: 
                   2717:     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
                   2718:       echo "----------------------------------------------------------------------"
                   2719:       echo "Libraries have been installed in:"
                   2720:       for libdir in $libdirs; do
                   2721:        $ECHO "   $libdir"
                   2722:       done
                   2723:       echo
                   2724:       echo "If you ever happen to want to link against installed libraries"
                   2725:       echo "in a given directory, LIBDIR, you must either use libtool, and"
                   2726:       echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
                   2727:       echo "flag during linking and do at least one of the following:"
                   2728:       if test -n "$shlibpath_var"; then
                   2729:        echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
                   2730:        echo "     during execution"
                   2731:       fi
                   2732:       if test -n "$runpath_var"; then
                   2733:        echo "   - add LIBDIR to the \`$runpath_var' environment variable"
                   2734:        echo "     during linking"
                   2735:       fi
                   2736:       if test -n "$hardcode_libdir_flag_spec"; then
                   2737:        libdir=LIBDIR
                   2738:        eval flag=\"$hardcode_libdir_flag_spec\"
                   2739: 
                   2740:        $ECHO "   - use the \`$flag' linker flag"
                   2741:       fi
                   2742:       if test -n "$admincmds"; then
                   2743:        $ECHO "   - have your system administrator run these commands:$admincmds"
                   2744:       fi
                   2745:       if test -f /etc/ld.so.conf; then
                   2746:        echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
                   2747:       fi
                   2748:       echo
                   2749: 
                   2750:       echo "See any operating system documentation about shared libraries for"
                   2751:       case $host in
                   2752:        solaris2.[6789]|solaris2.1[0-9])
                   2753:          echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
                   2754:          echo "pages."
                   2755:          ;;
                   2756:        *)
                   2757:          echo "more information, such as the ld(1) and ld.so(8) manual pages."
                   2758:          ;;
                   2759:       esac
                   2760:       echo "----------------------------------------------------------------------"
                   2761:     fi
                   2762:     exit $EXIT_SUCCESS
                   2763: }
                   2764: 
                   2765: test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
                   2766: 
                   2767: 
                   2768: # func_mode_install arg...
                   2769: func_mode_install ()
                   2770: {
                   2771:     $opt_debug
                   2772:     # There may be an optional sh(1) argument at the beginning of
                   2773:     # install_prog (especially on Windows NT).
                   2774:     if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
                   2775:        # Allow the use of GNU shtool's install command.
                   2776:        case $nonopt in *shtool*) :;; *) false;; esac; then
                   2777:       # Aesthetically quote it.
                   2778:       func_quote_for_eval "$nonopt"
                   2779:       install_prog="$func_quote_for_eval_result "
                   2780:       arg=$1
                   2781:       shift
                   2782:     else
                   2783:       install_prog=
                   2784:       arg=$nonopt
                   2785:     fi
                   2786: 
                   2787:     # The real first argument should be the name of the installation program.
                   2788:     # Aesthetically quote it.
                   2789:     func_quote_for_eval "$arg"
                   2790:     func_append install_prog "$func_quote_for_eval_result"
                   2791:     install_shared_prog=$install_prog
                   2792:     case " $install_prog " in
                   2793:       *[\\\ /]cp\ *) install_cp=: ;;
                   2794:       *) install_cp=false ;;
                   2795:     esac
                   2796: 
                   2797:     # We need to accept at least all the BSD install flags.
                   2798:     dest=
                   2799:     files=
                   2800:     opts=
                   2801:     prev=
                   2802:     install_type=
                   2803:     isdir=no
                   2804:     stripme=
                   2805:     no_mode=:
                   2806:     for arg
                   2807:     do
                   2808:       arg2=
                   2809:       if test -n "$dest"; then
                   2810:        func_append files " $dest"
                   2811:        dest=$arg
                   2812:        continue
                   2813:       fi
                   2814: 
                   2815:       case $arg in
                   2816:       -d) isdir=yes ;;
                   2817:       -f)
                   2818:        if $install_cp; then :; else
                   2819:          prev=$arg
                   2820:        fi
                   2821:        ;;
                   2822:       -g | -m | -o)
                   2823:        prev=$arg
                   2824:        ;;
                   2825:       -s)
                   2826:        stripme=" -s"
                   2827:        continue
                   2828:        ;;
                   2829:       -*)
                   2830:        ;;
                   2831:       *)
                   2832:        # If the previous option needed an argument, then skip it.
                   2833:        if test -n "$prev"; then
                   2834:          if test "x$prev" = x-m && test -n "$install_override_mode"; then
                   2835:            arg2=$install_override_mode
                   2836:            no_mode=false
                   2837:          fi
                   2838:          prev=
                   2839:        else
                   2840:          dest=$arg
                   2841:          continue
                   2842:        fi
                   2843:        ;;
                   2844:       esac
                   2845: 
                   2846:       # Aesthetically quote the argument.
                   2847:       func_quote_for_eval "$arg"
                   2848:       func_append install_prog " $func_quote_for_eval_result"
                   2849:       if test -n "$arg2"; then
                   2850:        func_quote_for_eval "$arg2"
                   2851:       fi
                   2852:       func_append install_shared_prog " $func_quote_for_eval_result"
                   2853:     done
                   2854: 
                   2855:     test -z "$install_prog" && \
                   2856:       func_fatal_help "you must specify an install program"
                   2857: 
                   2858:     test -n "$prev" && \
                   2859:       func_fatal_help "the \`$prev' option requires an argument"
                   2860: 
                   2861:     if test -n "$install_override_mode" && $no_mode; then
                   2862:       if $install_cp; then :; else
                   2863:        func_quote_for_eval "$install_override_mode"
                   2864:        func_append install_shared_prog " -m $func_quote_for_eval_result"
                   2865:       fi
                   2866:     fi
                   2867: 
                   2868:     if test -z "$files"; then
                   2869:       if test -z "$dest"; then
                   2870:        func_fatal_help "no file or destination specified"
                   2871:       else
                   2872:        func_fatal_help "you must specify a destination"
                   2873:       fi
                   2874:     fi
                   2875: 
                   2876:     # Strip any trailing slash from the destination.
                   2877:     func_stripname '' '/' "$dest"
                   2878:     dest=$func_stripname_result
                   2879: 
                   2880:     # Check to see that the destination is a directory.
                   2881:     test -d "$dest" && isdir=yes
                   2882:     if test "$isdir" = yes; then
                   2883:       destdir="$dest"
                   2884:       destname=
                   2885:     else
                   2886:       func_dirname_and_basename "$dest" "" "."
                   2887:       destdir="$func_dirname_result"
                   2888:       destname="$func_basename_result"
                   2889: 
                   2890:       # Not a directory, so check to see that there is only one file specified.
                   2891:       set dummy $files; shift
                   2892:       test "$#" -gt 1 && \
                   2893:        func_fatal_help "\`$dest' is not a directory"
                   2894:     fi
                   2895:     case $destdir in
                   2896:     [\\/]* | [A-Za-z]:[\\/]*) ;;
                   2897:     *)
                   2898:       for file in $files; do
                   2899:        case $file in
                   2900:        *.lo) ;;
                   2901:        *)
                   2902:          func_fatal_help "\`$destdir' must be an absolute directory name"
                   2903:          ;;
                   2904:        esac
                   2905:       done
                   2906:       ;;
                   2907:     esac
                   2908: 
                   2909:     # This variable tells wrapper scripts just to set variables rather
                   2910:     # than running their programs.
                   2911:     libtool_install_magic="$magic"
                   2912: 
                   2913:     staticlibs=
                   2914:     future_libdirs=
                   2915:     current_libdirs=
                   2916:     for file in $files; do
                   2917: 
                   2918:       # Do each installation.
                   2919:       case $file in
                   2920:       *.$libext)
                   2921:        # Do the static libraries later.
                   2922:        func_append staticlibs " $file"
                   2923:        ;;
                   2924: 
                   2925:       *.la)
                   2926:        func_resolve_sysroot "$file"
                   2927:        file=$func_resolve_sysroot_result
                   2928: 
                   2929:        # Check to see that this really is a libtool archive.
                   2930:        func_lalib_unsafe_p "$file" \
                   2931:          || func_fatal_help "\`$file' is not a valid libtool archive"
                   2932: 
                   2933:        library_names=
                   2934:        old_library=
                   2935:        relink_command=
                   2936:        func_source "$file"
                   2937: 
                   2938:        # Add the libdir to current_libdirs if it is the destination.
                   2939:        if test "X$destdir" = "X$libdir"; then
                   2940:          case "$current_libdirs " in
                   2941:          *" $libdir "*) ;;
                   2942:          *) func_append current_libdirs " $libdir" ;;
                   2943:          esac
                   2944:        else
                   2945:          # Note the libdir as a future libdir.
                   2946:          case "$future_libdirs " in
                   2947:          *" $libdir "*) ;;
                   2948:          *) func_append future_libdirs " $libdir" ;;
                   2949:          esac
                   2950:        fi
                   2951: 
                   2952:        func_dirname "$file" "/" ""
                   2953:        dir="$func_dirname_result"
                   2954:        func_append dir "$objdir"
                   2955: 
                   2956:        if test -n "$relink_command"; then
                   2957:          # Determine the prefix the user has applied to our future dir.
                   2958:          inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
                   2959: 
                   2960:          # Don't allow the user to place us outside of our expected
                   2961:          # location b/c this prevents finding dependent libraries that
                   2962:          # are installed to the same prefix.
                   2963:          # At present, this check doesn't affect windows .dll's that
                   2964:          # are installed into $libdir/../bin (currently, that works fine)
                   2965:          # but it's something to keep an eye on.
                   2966:          test "$inst_prefix_dir" = "$destdir" && \
                   2967:            func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
                   2968: 
                   2969:          if test -n "$inst_prefix_dir"; then
                   2970:            # Stick the inst_prefix_dir data into the link command.
                   2971:            relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
                   2972:          else
                   2973:            relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
                   2974:          fi
                   2975: 
                   2976:          func_warning "relinking \`$file'"
                   2977:          func_show_eval "$relink_command" \
                   2978:            'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
                   2979:        fi
                   2980: 
                   2981:        # See the names of the shared library.
                   2982:        set dummy $library_names; shift
                   2983:        if test -n "$1"; then
                   2984:          realname="$1"
                   2985:          shift
                   2986: 
                   2987:          srcname="$realname"
                   2988:          test -n "$relink_command" && srcname="$realname"T
                   2989: 
                   2990:          # Install the shared library and build the symlinks.
                   2991:          func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
                   2992:              'exit $?'
                   2993:          tstripme="$stripme"
                   2994:          case $host_os in
                   2995:          cygwin* | mingw* | pw32* | cegcc*)
                   2996:            case $realname in
                   2997:            *.dll.a)
                   2998:              tstripme=""
                   2999:              ;;
                   3000:            esac
                   3001:            ;;
                   3002:          esac
                   3003:          if test -n "$tstripme" && test -n "$striplib"; then
                   3004:            func_show_eval "$striplib $destdir/$realname" 'exit $?'
                   3005:          fi
                   3006: 
                   3007:          if test "$#" -gt 0; then
                   3008:            # Delete the old symlinks, and create new ones.
                   3009:            # Try `ln -sf' first, because the `ln' binary might depend on
                   3010:            # the symlink we replace!  Solaris /bin/ln does not understand -f,
                   3011:            # so we also need to try rm && ln -s.
                   3012:            for linkname
                   3013:            do
                   3014:              test "$linkname" != "$realname" \
                   3015:                && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
                   3016:            done
                   3017:          fi
                   3018: 
                   3019:          # Do each command in the postinstall commands.
                   3020:          lib="$destdir/$realname"
                   3021:          func_execute_cmds "$postinstall_cmds" 'exit $?'
                   3022:        fi
                   3023: 
                   3024:        # Install the pseudo-library for information purposes.
                   3025:        func_basename "$file"
                   3026:        name="$func_basename_result"
                   3027:        instname="$dir/$name"i
                   3028:        func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
                   3029: 
                   3030:        # Maybe install the static library, too.
                   3031:        test -n "$old_library" && func_append staticlibs " $dir/$old_library"
                   3032:        ;;
                   3033: 
                   3034:       *.lo)
                   3035:        # Install (i.e. copy) a libtool object.
                   3036: 
                   3037:        # Figure out destination file name, if it wasn't already specified.
                   3038:        if test -n "$destname"; then
                   3039:          destfile="$destdir/$destname"
                   3040:        else
                   3041:          func_basename "$file"
                   3042:          destfile="$func_basename_result"
                   3043:          destfile="$destdir/$destfile"
                   3044:        fi
                   3045: 
                   3046:        # Deduce the name of the destination old-style object file.
                   3047:        case $destfile in
                   3048:        *.lo)
                   3049:          func_lo2o "$destfile"
                   3050:          staticdest=$func_lo2o_result
                   3051:          ;;
                   3052:        *.$objext)
                   3053:          staticdest="$destfile"
                   3054:          destfile=
                   3055:          ;;
                   3056:        *)
                   3057:          func_fatal_help "cannot copy a libtool object to \`$destfile'"
                   3058:          ;;
                   3059:        esac
                   3060: 
                   3061:        # Install the libtool object if requested.
                   3062:        test -n "$destfile" && \
                   3063:          func_show_eval "$install_prog $file $destfile" 'exit $?'
                   3064: 
                   3065:        # Install the old object if enabled.
                   3066:        if test "$build_old_libs" = yes; then
                   3067:          # Deduce the name of the old-style object file.
                   3068:          func_lo2o "$file"
                   3069:          staticobj=$func_lo2o_result
                   3070:          func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
                   3071:        fi
                   3072:        exit $EXIT_SUCCESS
                   3073:        ;;
                   3074: 
                   3075:       *)
                   3076:        # Figure out destination file name, if it wasn't already specified.
                   3077:        if test -n "$destname"; then
                   3078:          destfile="$destdir/$destname"
                   3079:        else
                   3080:          func_basename "$file"
                   3081:          destfile="$func_basename_result"
                   3082:          destfile="$destdir/$destfile"
                   3083:        fi
                   3084: 
                   3085:        # If the file is missing, and there is a .exe on the end, strip it
                   3086:        # because it is most likely a libtool script we actually want to
                   3087:        # install
                   3088:        stripped_ext=""
                   3089:        case $file in
                   3090:          *.exe)
                   3091:            if test ! -f "$file"; then
                   3092:              func_stripname '' '.exe' "$file"
                   3093:              file=$func_stripname_result
                   3094:              stripped_ext=".exe"
                   3095:            fi
                   3096:            ;;
                   3097:        esac
                   3098: 
                   3099:        # Do a test to see if this is really a libtool program.
                   3100:        case $host in
                   3101:        *cygwin* | *mingw*)
                   3102:            if func_ltwrapper_executable_p "$file"; then
                   3103:              func_ltwrapper_scriptname "$file"
                   3104:              wrapper=$func_ltwrapper_scriptname_result
                   3105:            else
                   3106:              func_stripname '' '.exe' "$file"
                   3107:              wrapper=$func_stripname_result
                   3108:            fi
                   3109:            ;;
                   3110:        *)
                   3111:            wrapper=$file
                   3112:            ;;
                   3113:        esac
                   3114:        if func_ltwrapper_script_p "$wrapper"; then
                   3115:          notinst_deplibs=
                   3116:          relink_command=
                   3117: 
                   3118:          func_source "$wrapper"
                   3119: 
                   3120:          # Check the variables that should have been set.
                   3121:          test -z "$generated_by_libtool_version" && \
                   3122:            func_fatal_error "invalid libtool wrapper script \`$wrapper'"
                   3123: 
                   3124:          finalize=yes
                   3125:          for lib in $notinst_deplibs; do
                   3126:            # Check to see that each library is installed.
                   3127:            libdir=
                   3128:            if test -f "$lib"; then
                   3129:              func_source "$lib"
                   3130:            fi
                   3131:            libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
                   3132:            if test -n "$libdir" && test ! -f "$libfile"; then
                   3133:              func_warning "\`$lib' has not been installed in \`$libdir'"
                   3134:              finalize=no
                   3135:            fi
                   3136:          done
                   3137: 
                   3138:          relink_command=
                   3139:          func_source "$wrapper"
                   3140: 
                   3141:          outputname=
                   3142:          if test "$fast_install" = no && test -n "$relink_command"; then
                   3143:            $opt_dry_run || {
                   3144:              if test "$finalize" = yes; then
                   3145:                tmpdir=`func_mktempdir`
                   3146:                func_basename "$file$stripped_ext"
                   3147:                file="$func_basename_result"
                   3148:                outputname="$tmpdir/$file"
                   3149:                # Replace the output file specification.
                   3150:                relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
                   3151: 
                   3152:                $opt_silent || {
                   3153:                  func_quote_for_expand "$relink_command"
                   3154:                  eval "func_echo $func_quote_for_expand_result"
                   3155:                }
                   3156:                if eval "$relink_command"; then :
                   3157:                  else
                   3158:                  func_error "error: relink \`$file' with the above command before installing it"
                   3159:                  $opt_dry_run || ${RM}r "$tmpdir"
                   3160:                  continue
                   3161:                fi
                   3162:                file="$outputname"
                   3163:              else
                   3164:                func_warning "cannot relink \`$file'"
                   3165:              fi
                   3166:            }
                   3167:          else
                   3168:            # Install the binary that we compiled earlier.
                   3169:            file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
                   3170:          fi
                   3171:        fi
                   3172: 
                   3173:        # remove .exe since cygwin /usr/bin/install will append another
                   3174:        # one anyway
                   3175:        case $install_prog,$host in
                   3176:        */usr/bin/install*,*cygwin*)
                   3177:          case $file:$destfile in
                   3178:          *.exe:*.exe)
                   3179:            # this is ok
                   3180:            ;;
                   3181:          *.exe:*)
                   3182:            destfile=$destfile.exe
                   3183:            ;;
                   3184:          *:*.exe)
                   3185:            func_stripname '' '.exe' "$destfile"
                   3186:            destfile=$func_stripname_result
                   3187:            ;;
                   3188:          esac
                   3189:          ;;
                   3190:        esac
                   3191:        func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
                   3192:        $opt_dry_run || if test -n "$outputname"; then
                   3193:          ${RM}r "$tmpdir"
                   3194:        fi
                   3195:        ;;
                   3196:       esac
                   3197:     done
                   3198: 
                   3199:     for file in $staticlibs; do
                   3200:       func_basename "$file"
                   3201:       name="$func_basename_result"
                   3202: 
                   3203:       # Set up the ranlib parameters.
                   3204:       oldlib="$destdir/$name"
                   3205:       func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
                   3206:       tool_oldlib=$func_to_tool_file_result
                   3207: 
                   3208:       func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
                   3209: 
                   3210:       if test -n "$stripme" && test -n "$old_striplib"; then
                   3211:        func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
                   3212:       fi
                   3213: 
                   3214:       # Do each command in the postinstall commands.
                   3215:       func_execute_cmds "$old_postinstall_cmds" 'exit $?'
                   3216:     done
                   3217: 
                   3218:     test -n "$future_libdirs" && \
                   3219:       func_warning "remember to run \`$progname --finish$future_libdirs'"
                   3220: 
                   3221:     if test -n "$current_libdirs"; then
                   3222:       # Maybe just do a dry run.
                   3223:       $opt_dry_run && current_libdirs=" -n$current_libdirs"
                   3224:       exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
                   3225:     else
                   3226:       exit $EXIT_SUCCESS
                   3227:     fi
                   3228: }
                   3229: 
                   3230: test "$opt_mode" = install && func_mode_install ${1+"$@"}
                   3231: 
                   3232: 
                   3233: # func_generate_dlsyms outputname originator pic_p
                   3234: # Extract symbols from dlprefiles and create ${outputname}S.o with
                   3235: # a dlpreopen symbol table.
                   3236: func_generate_dlsyms ()
                   3237: {
                   3238:     $opt_debug
                   3239:     my_outputname="$1"
                   3240:     my_originator="$2"
                   3241:     my_pic_p="${3-no}"
                   3242:     my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
                   3243:     my_dlsyms=
                   3244: 
                   3245:     if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
                   3246:       if test -n "$NM" && test -n "$global_symbol_pipe"; then
                   3247:        my_dlsyms="${my_outputname}S.c"
                   3248:       else
                   3249:        func_error "not configured to extract global symbols from dlpreopened files"
                   3250:       fi
                   3251:     fi
                   3252: 
                   3253:     if test -n "$my_dlsyms"; then
                   3254:       case $my_dlsyms in
                   3255:       "") ;;
                   3256:       *.c)
                   3257:        # Discover the nlist of each of the dlfiles.
                   3258:        nlist="$output_objdir/${my_outputname}.nm"
                   3259: 
                   3260:        func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
                   3261: 
                   3262:        # Parse the name list into a source file.
                   3263:        func_verbose "creating $output_objdir/$my_dlsyms"
                   3264: 
                   3265:        $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
                   3266: /* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
                   3267: /* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
                   3268: 
                   3269: #ifdef __cplusplus
                   3270: extern \"C\" {
                   3271: #endif
                   3272: 
                   3273: #if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
                   3274: #pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
                   3275: #endif
                   3276: 
                   3277: /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
                   3278: #if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
                   3279: /* DATA imports from DLLs on WIN32 con't be const, because runtime
                   3280:    relocations are performed -- see ld's documentation on pseudo-relocs.  */
                   3281: # define LT_DLSYM_CONST
                   3282: #elif defined(__osf__)
                   3283: /* This system does not cope well with relocations in const data.  */
                   3284: # define LT_DLSYM_CONST
                   3285: #else
                   3286: # define LT_DLSYM_CONST const
                   3287: #endif
                   3288: 
                   3289: /* External symbol declarations for the compiler. */\
                   3290: "
                   3291: 
                   3292:        if test "$dlself" = yes; then
                   3293:          func_verbose "generating symbol list for \`$output'"
                   3294: 
                   3295:          $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
                   3296: 
                   3297:          # Add our own program objects to the symbol list.
                   3298:          progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
                   3299:          for progfile in $progfiles; do
                   3300:            func_to_tool_file "$progfile" func_convert_file_msys_to_w32
                   3301:            func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"
                   3302:            $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
                   3303:          done
                   3304: 
                   3305:          if test -n "$exclude_expsyms"; then
                   3306:            $opt_dry_run || {
                   3307:              eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
                   3308:              eval '$MV "$nlist"T "$nlist"'
                   3309:            }
                   3310:          fi
                   3311: 
                   3312:          if test -n "$export_symbols_regex"; then
                   3313:            $opt_dry_run || {
                   3314:              eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
                   3315:              eval '$MV "$nlist"T "$nlist"'
                   3316:            }
                   3317:          fi
                   3318: 
                   3319:          # Prepare the list of exported symbols
                   3320:          if test -z "$export_symbols"; then
                   3321:            export_symbols="$output_objdir/$outputname.exp"
                   3322:            $opt_dry_run || {
                   3323:              $RM $export_symbols
                   3324:              eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
                   3325:              case $host in
                   3326:              *cygwin* | *mingw* | *cegcc* )
                   3327:                 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
                   3328:                 eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
                   3329:                ;;
                   3330:              esac
                   3331:            }
                   3332:          else
                   3333:            $opt_dry_run || {
                   3334:              eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
                   3335:              eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
                   3336:              eval '$MV "$nlist"T "$nlist"'
                   3337:              case $host in
                   3338:                *cygwin* | *mingw* | *cegcc* )
                   3339:                  eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
                   3340:                  eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
                   3341:                  ;;
                   3342:              esac
                   3343:            }
                   3344:          fi
                   3345:        fi
                   3346: 
                   3347:        for dlprefile in $dlprefiles; do
                   3348:          func_verbose "extracting global C symbols from \`$dlprefile'"
                   3349:          func_basename "$dlprefile"
                   3350:          name="$func_basename_result"
                   3351:           case $host in
                   3352:            *cygwin* | *mingw* | *cegcc* )
                   3353:              # if an import library, we need to obtain dlname
                   3354:              if func_win32_import_lib_p "$dlprefile"; then
                   3355:                func_tr_sh "$dlprefile"
                   3356:                eval "curr_lafile=\$libfile_$func_tr_sh_result"
                   3357:                dlprefile_dlbasename=""
                   3358:                if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
                   3359:                  # Use subshell, to avoid clobbering current variable values
                   3360:                  dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
                   3361:                  if test -n "$dlprefile_dlname" ; then
                   3362:                    func_basename "$dlprefile_dlname"
                   3363:                    dlprefile_dlbasename="$func_basename_result"
                   3364:                  else
                   3365:                    # no lafile. user explicitly requested -dlpreopen <import library>.
                   3366:                    $sharedlib_from_linklib_cmd "$dlprefile"
                   3367:                    dlprefile_dlbasename=$sharedlib_from_linklib_result
                   3368:                  fi
                   3369:                fi
                   3370:                $opt_dry_run || {
                   3371:                  if test -n "$dlprefile_dlbasename" ; then
                   3372:                    eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
                   3373:                  else
                   3374:                    func_warning "Could not compute DLL name from $name"
                   3375:                    eval '$ECHO ": $name " >> "$nlist"'
                   3376:                  fi
                   3377:                  func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
                   3378:                  eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
                   3379:                    $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
                   3380:                }
                   3381:              else # not an import lib
                   3382:                $opt_dry_run || {
                   3383:                  eval '$ECHO ": $name " >> "$nlist"'
                   3384:                  func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
                   3385:                  eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
                   3386:                }
                   3387:              fi
                   3388:            ;;
                   3389:            *)
                   3390:              $opt_dry_run || {
                   3391:                eval '$ECHO ": $name " >> "$nlist"'
                   3392:                func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
                   3393:                eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
                   3394:              }
                   3395:            ;;
                   3396:           esac
                   3397:        done
                   3398: 
                   3399:        $opt_dry_run || {
                   3400:          # Make sure we have at least an empty file.
                   3401:          test -f "$nlist" || : > "$nlist"
                   3402: 
                   3403:          if test -n "$exclude_expsyms"; then
                   3404:            $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
                   3405:            $MV "$nlist"T "$nlist"
                   3406:          fi
                   3407: 
                   3408:          # Try sorting and uniquifying the output.
                   3409:          if $GREP -v "^: " < "$nlist" |
                   3410:              if sort -k 3 </dev/null >/dev/null 2>&1; then
                   3411:                sort -k 3
                   3412:              else
                   3413:                sort +2
                   3414:              fi |
                   3415:              uniq > "$nlist"S; then
                   3416:            :
                   3417:          else
                   3418:            $GREP -v "^: " < "$nlist" > "$nlist"S
                   3419:          fi
                   3420: 
                   3421:          if test -f "$nlist"S; then
                   3422:            eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
                   3423:          else
                   3424:            echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
                   3425:          fi
                   3426: 
                   3427:          echo >> "$output_objdir/$my_dlsyms" "\
                   3428: 
                   3429: /* The mapping between symbol names and symbols.  */
                   3430: typedef struct {
                   3431:   const char *name;
                   3432:   void *address;
                   3433: } lt_dlsymlist;
                   3434: extern LT_DLSYM_CONST lt_dlsymlist
                   3435: lt_${my_prefix}_LTX_preloaded_symbols[];
                   3436: LT_DLSYM_CONST lt_dlsymlist
                   3437: lt_${my_prefix}_LTX_preloaded_symbols[] =
                   3438: {\
                   3439:   { \"$my_originator\", (void *) 0 },"
                   3440: 
                   3441:          case $need_lib_prefix in
                   3442:          no)
                   3443:            eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
                   3444:            ;;
                   3445:          *)
                   3446:            eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
                   3447:            ;;
                   3448:          esac
                   3449:          echo >> "$output_objdir/$my_dlsyms" "\
                   3450:   {0, (void *) 0}
                   3451: };
                   3452: 
                   3453: /* This works around a problem in FreeBSD linker */
                   3454: #ifdef FREEBSD_WORKAROUND
                   3455: static const void *lt_preloaded_setup() {
                   3456:   return lt_${my_prefix}_LTX_preloaded_symbols;
                   3457: }
                   3458: #endif
                   3459: 
                   3460: #ifdef __cplusplus
                   3461: }
                   3462: #endif\
                   3463: "
                   3464:        } # !$opt_dry_run
                   3465: 
                   3466:        pic_flag_for_symtable=
                   3467:        case "$compile_command " in
                   3468:        *" -static "*) ;;
                   3469:        *)
                   3470:          case $host in
                   3471:          # compiling the symbol table file with pic_flag works around
                   3472:          # a FreeBSD bug that causes programs to crash when -lm is
                   3473:          # linked before any other PIC object.  But we must not use
                   3474:          # pic_flag when linking with -static.  The problem exists in
                   3475:          # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
                   3476:          *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
                   3477:            pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
                   3478:          *-*-hpux*)
                   3479:            pic_flag_for_symtable=" $pic_flag"  ;;
                   3480:          *)
                   3481:            if test "X$my_pic_p" != Xno; then
                   3482:              pic_flag_for_symtable=" $pic_flag"
                   3483:            fi
                   3484:            ;;
                   3485:          esac
                   3486:          ;;
                   3487:        esac
                   3488:        symtab_cflags=
                   3489:        for arg in $LTCFLAGS; do
                   3490:          case $arg in
                   3491:          -pie | -fpie | -fPIE) ;;
                   3492:          *) func_append symtab_cflags " $arg" ;;
                   3493:          esac
                   3494:        done
                   3495: 
                   3496:        # Now compile the dynamic symbol file.
                   3497:        func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
                   3498: 
                   3499:        # Clean up the generated files.
                   3500:        func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
                   3501: 
                   3502:        # Transform the symbol file into the correct name.
                   3503:        symfileobj="$output_objdir/${my_outputname}S.$objext"
                   3504:        case $host in
                   3505:        *cygwin* | *mingw* | *cegcc* )
                   3506:          if test -f "$output_objdir/$my_outputname.def"; then
                   3507:            compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
                   3508:            finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
                   3509:          else
                   3510:            compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
                   3511:            finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
                   3512:          fi
                   3513:          ;;
                   3514:        *)
                   3515:          compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
                   3516:          finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
                   3517:          ;;
                   3518:        esac
                   3519:        ;;
                   3520:       *)
                   3521:        func_fatal_error "unknown suffix for \`$my_dlsyms'"
                   3522:        ;;
                   3523:       esac
                   3524:     else
                   3525:       # We keep going just in case the user didn't refer to
                   3526:       # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
                   3527:       # really was required.
                   3528: 
                   3529:       # Nullify the symbol file.
                   3530:       compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
                   3531:       finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
                   3532:     fi
                   3533: }
                   3534: 
                   3535: # func_win32_libid arg
                   3536: # return the library type of file 'arg'
                   3537: #
                   3538: # Need a lot of goo to handle *both* DLLs and import libs
                   3539: # Has to be a shell function in order to 'eat' the argument
                   3540: # that is supplied when $file_magic_command is called.
                   3541: # Despite the name, also deal with 64 bit binaries.
                   3542: func_win32_libid ()
                   3543: {
                   3544:   $opt_debug
                   3545:   win32_libid_type="unknown"
                   3546:   win32_fileres=`file -L $1 2>/dev/null`
                   3547:   case $win32_fileres in
                   3548:   *ar\ archive\ import\ library*) # definitely import
                   3549:     win32_libid_type="x86 archive import"
                   3550:     ;;
                   3551:   *ar\ archive*) # could be an import, or static
                   3552:     # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
                   3553:     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
                   3554:        $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
                   3555:       func_to_tool_file "$1" func_convert_file_msys_to_w32
                   3556:       win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
                   3557:        $SED -n -e '
                   3558:            1,100{
                   3559:                / I /{
                   3560:                    s,.*,import,
                   3561:                    p
                   3562:                    q
                   3563:                }
                   3564:            }'`
                   3565:       case $win32_nmres in
                   3566:       import*)  win32_libid_type="x86 archive import";;
                   3567:       *)        win32_libid_type="x86 archive static";;
                   3568:       esac
                   3569:     fi
                   3570:     ;;
                   3571:   *DLL*)
                   3572:     win32_libid_type="x86 DLL"
                   3573:     ;;
                   3574:   *executable*) # but shell scripts are "executable" too...
                   3575:     case $win32_fileres in
                   3576:     *MS\ Windows\ PE\ Intel*)
                   3577:       win32_libid_type="x86 DLL"
                   3578:       ;;
                   3579:     esac
                   3580:     ;;
                   3581:   esac
                   3582:   $ECHO "$win32_libid_type"
                   3583: }
                   3584: 
                   3585: # func_cygming_dll_for_implib ARG
                   3586: #
                   3587: # Platform-specific function to extract the
                   3588: # name of the DLL associated with the specified
                   3589: # import library ARG.
                   3590: # Invoked by eval'ing the libtool variable
                   3591: #    $sharedlib_from_linklib_cmd
                   3592: # Result is available in the variable
                   3593: #    $sharedlib_from_linklib_result
                   3594: func_cygming_dll_for_implib ()
                   3595: {
                   3596:   $opt_debug
                   3597:   sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
                   3598: }
                   3599: 
                   3600: # func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
                   3601: #
                   3602: # The is the core of a fallback implementation of a
                   3603: # platform-specific function to extract the name of the
                   3604: # DLL associated with the specified import library LIBNAME.
                   3605: #
                   3606: # SECTION_NAME is either .idata$6 or .idata$7, depending
                   3607: # on the platform and compiler that created the implib.
                   3608: #
                   3609: # Echos the name of the DLL associated with the
                   3610: # specified import library.
                   3611: func_cygming_dll_for_implib_fallback_core ()
                   3612: {
                   3613:   $opt_debug
                   3614:   match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
                   3615:   $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
                   3616:     $SED '/^Contents of section '"$match_literal"':/{
                   3617:       # Place marker at beginning of archive member dllname section
                   3618:       s/.*/====MARK====/
                   3619:       p
                   3620:       d
                   3621:     }
                   3622:     # These lines can sometimes be longer than 43 characters, but
                   3623:     # are always uninteresting
                   3624:     /:[         ]*file format pe[i]\{,1\}-/d
                   3625:     /^In archive [^:]*:/d
                   3626:     # Ensure marker is printed
                   3627:     /^====MARK====/p
                   3628:     # Remove all lines with less than 43 characters
                   3629:     /^.\{43\}/!d
                   3630:     # From remaining lines, remove first 43 characters
                   3631:     s/^.\{43\}//' |
                   3632:     $SED -n '
                   3633:       # Join marker and all lines until next marker into a single line
                   3634:       /^====MARK====/ b para
                   3635:       H
                   3636:       $ b para
                   3637:       b
                   3638:       :para
                   3639:       x
                   3640:       s/\n//g
                   3641:       # Remove the marker
                   3642:       s/^====MARK====//
                   3643:       # Remove trailing dots and whitespace
                   3644:       s/[\. \t]*$//
                   3645:       # Print
                   3646:       /./p' |
                   3647:     # we now have a list, one entry per line, of the stringified
                   3648:     # contents of the appropriate section of all members of the
                   3649:     # archive which possess that section. Heuristic: eliminate
                   3650:     # all those which have a first or second character that is
                   3651:     # a '.' (that is, objdump's representation of an unprintable
                   3652:     # character.) This should work for all archives with less than
                   3653:     # 0x302f exports -- but will fail for DLLs whose name actually
                   3654:     # begins with a literal '.' or a single character followed by
                   3655:     # a '.'.
                   3656:     #
                   3657:     # Of those that remain, print the first one.
                   3658:     $SED -e '/^\./d;/^.\./d;q'
                   3659: }
                   3660: 
                   3661: # func_cygming_gnu_implib_p ARG
                   3662: # This predicate returns with zero status (TRUE) if
                   3663: # ARG is a GNU/binutils-style import library. Returns
                   3664: # with nonzero status (FALSE) otherwise.
                   3665: func_cygming_gnu_implib_p ()
                   3666: {
                   3667:   $opt_debug
                   3668:   func_to_tool_file "$1" func_convert_file_msys_to_w32
                   3669:   func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'`
                   3670:   test -n "$func_cygming_gnu_implib_tmp"
                   3671: }
                   3672: 
                   3673: # func_cygming_ms_implib_p ARG
                   3674: # This predicate returns with zero status (TRUE) if
                   3675: # ARG is an MS-style import library. Returns
                   3676: # with nonzero status (FALSE) otherwise.
                   3677: func_cygming_ms_implib_p ()
                   3678: {
                   3679:   $opt_debug
                   3680:   func_to_tool_file "$1" func_convert_file_msys_to_w32
                   3681:   func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
                   3682:   test -n "$func_cygming_ms_implib_tmp"
                   3683: }
                   3684: 
                   3685: # func_cygming_dll_for_implib_fallback ARG
                   3686: # Platform-specific function to extract the
                   3687: # name of the DLL associated with the specified
                   3688: # import library ARG.
                   3689: #
                   3690: # This fallback implementation is for use when $DLLTOOL
                   3691: # does not support the --identify-strict option.
                   3692: # Invoked by eval'ing the libtool variable
                   3693: #    $sharedlib_from_linklib_cmd
                   3694: # Result is available in the variable
                   3695: #    $sharedlib_from_linklib_result
                   3696: func_cygming_dll_for_implib_fallback ()
                   3697: {
                   3698:   $opt_debug
                   3699:   if func_cygming_gnu_implib_p "$1" ; then
                   3700:     # binutils import library
                   3701:     sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
                   3702:   elif func_cygming_ms_implib_p "$1" ; then
                   3703:     # ms-generated import library
                   3704:     sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
                   3705:   else
                   3706:     # unknown
                   3707:     sharedlib_from_linklib_result=""
                   3708:   fi
                   3709: }
                   3710: 
                   3711: 
                   3712: # func_extract_an_archive dir oldlib
                   3713: func_extract_an_archive ()
                   3714: {
                   3715:     $opt_debug
                   3716:     f_ex_an_ar_dir="$1"; shift
                   3717:     f_ex_an_ar_oldlib="$1"
                   3718:     if test "$lock_old_archive_extraction" = yes; then
                   3719:       lockfile=$f_ex_an_ar_oldlib.lock
                   3720:       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
                   3721:        func_echo "Waiting for $lockfile to be removed"
                   3722:        sleep 2
                   3723:       done
                   3724:     fi
                   3725:     func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
                   3726:                   'stat=$?; rm -f "$lockfile"; exit $stat'
                   3727:     if test "$lock_old_archive_extraction" = yes; then
                   3728:       $opt_dry_run || rm -f "$lockfile"
                   3729:     fi
                   3730:     if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
                   3731:      :
                   3732:     else
                   3733:       func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
                   3734:     fi
                   3735: }
                   3736: 
                   3737: 
                   3738: # func_extract_archives gentop oldlib ...
                   3739: func_extract_archives ()
                   3740: {
                   3741:     $opt_debug
                   3742:     my_gentop="$1"; shift
                   3743:     my_oldlibs=${1+"$@"}
                   3744:     my_oldobjs=""
                   3745:     my_xlib=""
                   3746:     my_xabs=""
                   3747:     my_xdir=""
                   3748: 
                   3749:     for my_xlib in $my_oldlibs; do
                   3750:       # Extract the objects.
                   3751:       case $my_xlib in
                   3752:        [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
                   3753:        *) my_xabs=`pwd`"/$my_xlib" ;;
                   3754:       esac
                   3755:       func_basename "$my_xlib"
                   3756:       my_xlib="$func_basename_result"
                   3757:       my_xlib_u=$my_xlib
                   3758:       while :; do
                   3759:         case " $extracted_archives " in
                   3760:        *" $my_xlib_u "*)
                   3761:          func_arith $extracted_serial + 1
                   3762:          extracted_serial=$func_arith_result
                   3763:          my_xlib_u=lt$extracted_serial-$my_xlib ;;
                   3764:        *) break ;;
                   3765:        esac
                   3766:       done
                   3767:       extracted_archives="$extracted_archives $my_xlib_u"
                   3768:       my_xdir="$my_gentop/$my_xlib_u"
                   3769: 
                   3770:       func_mkdir_p "$my_xdir"
                   3771: 
                   3772:       case $host in
                   3773:       *-darwin*)
                   3774:        func_verbose "Extracting $my_xabs"
                   3775:        # Do not bother doing anything if just a dry run
                   3776:        $opt_dry_run || {
                   3777:          darwin_orig_dir=`pwd`
                   3778:          cd $my_xdir || exit $?
                   3779:          darwin_archive=$my_xabs
                   3780:          darwin_curdir=`pwd`
                   3781:          darwin_base_archive=`basename "$darwin_archive"`
                   3782:          darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
                   3783:          if test -n "$darwin_arches"; then
                   3784:            darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
                   3785:            darwin_arch=
                   3786:            func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
                   3787:            for darwin_arch in  $darwin_arches ; do
                   3788:              func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
                   3789:              $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
                   3790:              cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
                   3791:              func_extract_an_archive "`pwd`" "${darwin_base_archive}"
                   3792:              cd "$darwin_curdir"
                   3793:              $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
                   3794:            done # $darwin_arches
                   3795:             ## Okay now we've a bunch of thin objects, gotta fatten them up :)
                   3796:            darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
                   3797:            darwin_file=
                   3798:            darwin_files=
                   3799:            for darwin_file in $darwin_filelist; do
                   3800:              darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
                   3801:              $LIPO -create -output "$darwin_file" $darwin_files
                   3802:            done # $darwin_filelist
                   3803:            $RM -rf unfat-$$
                   3804:            cd "$darwin_orig_dir"
                   3805:          else
                   3806:            cd $darwin_orig_dir
                   3807:            func_extract_an_archive "$my_xdir" "$my_xabs"
                   3808:          fi # $darwin_arches
                   3809:        } # !$opt_dry_run
                   3810:        ;;
                   3811:       *)
                   3812:         func_extract_an_archive "$my_xdir" "$my_xabs"
                   3813:        ;;
                   3814:       esac
                   3815:       my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
                   3816:     done
                   3817: 
                   3818:     func_extract_archives_result="$my_oldobjs"
                   3819: }
                   3820: 
                   3821: 
                   3822: # func_emit_wrapper [arg=no]
                   3823: #
                   3824: # Emit a libtool wrapper script on stdout.
                   3825: # Don't directly open a file because we may want to
                   3826: # incorporate the script contents within a cygwin/mingw
                   3827: # wrapper executable.  Must ONLY be called from within
                   3828: # func_mode_link because it depends on a number of variables
                   3829: # set therein.
                   3830: #
                   3831: # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
                   3832: # variable will take.  If 'yes', then the emitted script
                   3833: # will assume that the directory in which it is stored is
                   3834: # the $objdir directory.  This is a cygwin/mingw-specific
                   3835: # behavior.
                   3836: func_emit_wrapper ()
                   3837: {
                   3838:        func_emit_wrapper_arg1=${1-no}
                   3839: 
                   3840:        $ECHO "\
                   3841: #! $SHELL
                   3842: 
                   3843: # $output - temporary wrapper script for $objdir/$outputname
                   3844: # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
                   3845: #
                   3846: # The $output program cannot be directly executed until all the libtool
                   3847: # libraries that it depends on are installed.
                   3848: #
                   3849: # This wrapper script should never be moved out of the build directory.
                   3850: # If it is, it will not operate correctly.
                   3851: 
                   3852: # Sed substitution that helps us do robust quoting.  It backslashifies
                   3853: # metacharacters that are still active within double-quoted strings.
                   3854: sed_quote_subst='$sed_quote_subst'
                   3855: 
                   3856: # Be Bourne compatible
                   3857: if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
                   3858:   emulate sh
                   3859:   NULLCMD=:
                   3860:   # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
                   3861:   # is contrary to our usage.  Disable this feature.
                   3862:   alias -g '\${1+\"\$@\"}'='\"\$@\"'
                   3863:   setopt NO_GLOB_SUBST
                   3864: else
                   3865:   case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
                   3866: fi
                   3867: BIN_SH=xpg4; export BIN_SH # for Tru64
                   3868: DUALCASE=1; export DUALCASE # for MKS sh
                   3869: 
                   3870: # The HP-UX ksh and POSIX shell print the target directory to stdout
                   3871: # if CDPATH is set.
                   3872: (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
                   3873: 
                   3874: relink_command=\"$relink_command\"
                   3875: 
                   3876: # This environment variable determines our operation mode.
                   3877: if test \"\$libtool_install_magic\" = \"$magic\"; then
                   3878:   # install mode needs the following variables:
                   3879:   generated_by_libtool_version='$macro_version'
                   3880:   notinst_deplibs='$notinst_deplibs'
                   3881: else
                   3882:   # When we are sourced in execute mode, \$file and \$ECHO are already set.
                   3883:   if test \"\$libtool_execute_magic\" != \"$magic\"; then
                   3884:     file=\"\$0\""
                   3885: 
                   3886:     qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
                   3887:     $ECHO "\
                   3888: 
                   3889: # A function that is used when there is no print builtin or printf.
                   3890: func_fallback_echo ()
                   3891: {
                   3892:   eval 'cat <<_LTECHO_EOF
                   3893: \$1
                   3894: _LTECHO_EOF'
                   3895: }
                   3896:     ECHO=\"$qECHO\"
                   3897:   fi
                   3898: 
                   3899: # Very basic option parsing. These options are (a) specific to
                   3900: # the libtool wrapper, (b) are identical between the wrapper
                   3901: # /script/ and the wrapper /executable/ which is used only on
                   3902: # windows platforms, and (c) all begin with the string "--lt-"
                   3903: # (application programs are unlikely to have options which match
                   3904: # this pattern).
                   3905: #
                   3906: # There are only two supported options: --lt-debug and
                   3907: # --lt-dump-script. There is, deliberately, no --lt-help.
                   3908: #
                   3909: # The first argument to this parsing function should be the
                   3910: # script's $0 value, followed by "$@".
                   3911: lt_option_debug=
                   3912: func_parse_lt_options ()
                   3913: {
                   3914:   lt_script_arg0=\$0
                   3915:   shift
                   3916:   for lt_opt
                   3917:   do
                   3918:     case \"\$lt_opt\" in
                   3919:     --lt-debug) lt_option_debug=1 ;;
                   3920:     --lt-dump-script)
                   3921:         lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
                   3922:         test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
                   3923:         lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
                   3924:         cat \"\$lt_dump_D/\$lt_dump_F\"
                   3925:         exit 0
                   3926:       ;;
                   3927:     --lt-*)
                   3928:         \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
                   3929:         exit 1
                   3930:       ;;
                   3931:     esac
                   3932:   done
                   3933: 
                   3934:   # Print the debug banner immediately:
                   3935:   if test -n \"\$lt_option_debug\"; then
                   3936:     echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
                   3937:   fi
                   3938: }
                   3939: 
                   3940: # Used when --lt-debug. Prints its arguments to stdout
                   3941: # (redirection is the responsibility of the caller)
                   3942: func_lt_dump_args ()
                   3943: {
                   3944:   lt_dump_args_N=1;
                   3945:   for lt_arg
                   3946:   do
                   3947:     \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
                   3948:     lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
                   3949:   done
                   3950: }
                   3951: 
                   3952: # Core function for launching the target application
                   3953: func_exec_program_core ()
                   3954: {
                   3955: "
                   3956:   case $host in
                   3957:   # Backslashes separate directories on plain windows
                   3958:   *-*-mingw | *-*-os2* | *-cegcc*)
                   3959:     $ECHO "\
                   3960:       if test -n \"\$lt_option_debug\"; then
                   3961:         \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
                   3962:         func_lt_dump_args \${1+\"\$@\"} 1>&2
                   3963:       fi
                   3964:       exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
                   3965: "
                   3966:     ;;
                   3967: 
                   3968:   *)
                   3969:     $ECHO "\
                   3970:       if test -n \"\$lt_option_debug\"; then
                   3971:         \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
                   3972:         func_lt_dump_args \${1+\"\$@\"} 1>&2
                   3973:       fi
                   3974:       exec \"\$progdir/\$program\" \${1+\"\$@\"}
                   3975: "
                   3976:     ;;
                   3977:   esac
                   3978:   $ECHO "\
                   3979:       \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
                   3980:       exit 1
                   3981: }
                   3982: 
                   3983: # A function to encapsulate launching the target application
                   3984: # Strips options in the --lt-* namespace from \$@ and
                   3985: # launches target application with the remaining arguments.
                   3986: func_exec_program ()
                   3987: {
                   3988:   case \" \$* \" in
                   3989:   *\\ --lt-*)
                   3990:     for lt_wr_arg
                   3991:     do
                   3992:       case \$lt_wr_arg in
                   3993:       --lt-*) ;;
                   3994:       *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
                   3995:       esac
                   3996:       shift
                   3997:     done ;;
                   3998:   esac
                   3999:   func_exec_program_core \${1+\"\$@\"}
                   4000: }
                   4001: 
                   4002:   # Parse options
                   4003:   func_parse_lt_options \"\$0\" \${1+\"\$@\"}
                   4004: 
                   4005:   # Find the directory that this script lives in.
                   4006:   thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
                   4007:   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
                   4008: 
                   4009:   # Follow symbolic links until we get to the real thisdir.
                   4010:   file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
                   4011:   while test -n \"\$file\"; do
                   4012:     destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
                   4013: 
                   4014:     # If there was a directory component, then change thisdir.
                   4015:     if test \"x\$destdir\" != \"x\$file\"; then
                   4016:       case \"\$destdir\" in
                   4017:       [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
                   4018:       *) thisdir=\"\$thisdir/\$destdir\" ;;
                   4019:       esac
                   4020:     fi
                   4021: 
                   4022:     file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
                   4023:     file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
                   4024:   done
                   4025: 
                   4026:   # Usually 'no', except on cygwin/mingw when embedded into
                   4027:   # the cwrapper.
                   4028:   WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
                   4029:   if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
                   4030:     # special case for '.'
                   4031:     if test \"\$thisdir\" = \".\"; then
                   4032:       thisdir=\`pwd\`
                   4033:     fi
                   4034:     # remove .libs from thisdir
                   4035:     case \"\$thisdir\" in
                   4036:     *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
                   4037:     $objdir )   thisdir=. ;;
                   4038:     esac
                   4039:   fi
                   4040: 
                   4041:   # Try to get the absolute directory name.
                   4042:   absdir=\`cd \"\$thisdir\" && pwd\`
                   4043:   test -n \"\$absdir\" && thisdir=\"\$absdir\"
                   4044: "
                   4045: 
                   4046:        if test "$fast_install" = yes; then
                   4047:          $ECHO "\
                   4048:   program=lt-'$outputname'$exeext
                   4049:   progdir=\"\$thisdir/$objdir\"
                   4050: 
                   4051:   if test ! -f \"\$progdir/\$program\" ||
                   4052:      { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
                   4053:        test \"X\$file\" != \"X\$progdir/\$program\"; }; then
                   4054: 
                   4055:     file=\"\$\$-\$program\"
                   4056: 
                   4057:     if test ! -d \"\$progdir\"; then
                   4058:       $MKDIR \"\$progdir\"
                   4059:     else
                   4060:       $RM \"\$progdir/\$file\"
                   4061:     fi"
                   4062: 
                   4063:          $ECHO "\
                   4064: 
                   4065:     # relink executable if necessary
                   4066:     if test -n \"\$relink_command\"; then
                   4067:       if relink_command_output=\`eval \$relink_command 2>&1\`; then :
                   4068:       else
                   4069:        $ECHO \"\$relink_command_output\" >&2
                   4070:        $RM \"\$progdir/\$file\"
                   4071:        exit 1
                   4072:       fi
                   4073:     fi
                   4074: 
                   4075:     $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
                   4076:     { $RM \"\$progdir/\$program\";
                   4077:       $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
                   4078:     $RM \"\$progdir/\$file\"
                   4079:   fi"
                   4080:        else
                   4081:          $ECHO "\
                   4082:   program='$outputname'
                   4083:   progdir=\"\$thisdir/$objdir\"
                   4084: "
                   4085:        fi
                   4086: 
                   4087:        $ECHO "\
                   4088: 
                   4089:   if test -f \"\$progdir/\$program\"; then"
                   4090: 
                   4091:        # fixup the dll searchpath if we need to.
                   4092:        #
                   4093:        # Fix the DLL searchpath if we need to.  Do this before prepending
                   4094:        # to shlibpath, because on Windows, both are PATH and uninstalled
                   4095:        # libraries must come first.
                   4096:        if test -n "$dllsearchpath"; then
                   4097:          $ECHO "\
                   4098:     # Add the dll search path components to the executable PATH
                   4099:     PATH=$dllsearchpath:\$PATH
                   4100: "
                   4101:        fi
                   4102: 
                   4103:        # Export our shlibpath_var if we have one.
                   4104:        if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
                   4105:          $ECHO "\
                   4106:     # Add our own library path to $shlibpath_var
                   4107:     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
                   4108: 
                   4109:     # Some systems cannot cope with colon-terminated $shlibpath_var
                   4110:     # The second colon is a workaround for a bug in BeOS R4 sed
                   4111:     $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
                   4112: 
                   4113:     export $shlibpath_var
                   4114: "
                   4115:        fi
                   4116: 
                   4117:        $ECHO "\
                   4118:     if test \"\$libtool_execute_magic\" != \"$magic\"; then
                   4119:       # Run the actual program with our arguments.
                   4120:       func_exec_program \${1+\"\$@\"}
                   4121:     fi
                   4122:   else
                   4123:     # The program doesn't exist.
                   4124:     \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
                   4125:     \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
                   4126:     \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
                   4127:     exit 1
                   4128:   fi
                   4129: fi\
                   4130: "
                   4131: }
                   4132: 
                   4133: 
                   4134: # func_emit_cwrapperexe_src
                   4135: # emit the source code for a wrapper executable on stdout
                   4136: # Must ONLY be called from within func_mode_link because
                   4137: # it depends on a number of variable set therein.
                   4138: func_emit_cwrapperexe_src ()
                   4139: {
                   4140:        cat <<EOF
                   4141: 
                   4142: /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
                   4143:    Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
                   4144: 
                   4145:    The $output program cannot be directly executed until all the libtool
                   4146:    libraries that it depends on are installed.
                   4147: 
                   4148:    This wrapper executable should never be moved out of the build directory.
                   4149:    If it is, it will not operate correctly.
                   4150: */
                   4151: EOF
                   4152:            cat <<"EOF"
                   4153: #ifdef _MSC_VER
                   4154: # define _CRT_SECURE_NO_DEPRECATE 1
                   4155: #endif
                   4156: #include <stdio.h>
                   4157: #include <stdlib.h>
                   4158: #ifdef _MSC_VER
                   4159: # include <direct.h>
                   4160: # include <process.h>
                   4161: # include <io.h>
                   4162: #else
                   4163: # include <unistd.h>
                   4164: # include <stdint.h>
                   4165: # ifdef __CYGWIN__
                   4166: #  include <io.h>
                   4167: # endif
                   4168: #endif
                   4169: #include <malloc.h>
                   4170: #include <stdarg.h>
                   4171: #include <assert.h>
                   4172: #include <string.h>
                   4173: #include <ctype.h>
                   4174: #include <errno.h>
                   4175: #include <fcntl.h>
                   4176: #include <sys/stat.h>
                   4177: 
                   4178: /* declarations of non-ANSI functions */
                   4179: #if defined(__MINGW32__)
                   4180: # ifdef __STRICT_ANSI__
                   4181: int _putenv (const char *);
                   4182: # endif
                   4183: #elif defined(__CYGWIN__)
                   4184: # ifdef __STRICT_ANSI__
                   4185: char *realpath (const char *, char *);
                   4186: int putenv (char *);
                   4187: int setenv (const char *, const char *, int);
                   4188: # endif
                   4189: /* #elif defined (other platforms) ... */
                   4190: #endif
                   4191: 
                   4192: /* portability defines, excluding path handling macros */
                   4193: #if defined(_MSC_VER)
                   4194: # define setmode _setmode
                   4195: # define stat    _stat
                   4196: # define chmod   _chmod
                   4197: # define getcwd  _getcwd
                   4198: # define putenv  _putenv
                   4199: # define S_IXUSR _S_IEXEC
                   4200: # ifndef _INTPTR_T_DEFINED
                   4201: #  define _INTPTR_T_DEFINED
                   4202: #  define intptr_t int
                   4203: # endif
                   4204: #elif defined(__MINGW32__)
                   4205: # define setmode _setmode
                   4206: # define stat    _stat
                   4207: # define chmod   _chmod
                   4208: # define getcwd  _getcwd
                   4209: # define putenv  _putenv
                   4210: #elif defined(__CYGWIN__)
                   4211: # define HAVE_SETENV
                   4212: # define FOPEN_WB "wb"
                   4213: /* #elif defined (other platforms) ... */
                   4214: #endif
                   4215: 
                   4216: #if defined(PATH_MAX)
                   4217: # define LT_PATHMAX PATH_MAX
                   4218: #elif defined(MAXPATHLEN)
                   4219: # define LT_PATHMAX MAXPATHLEN
                   4220: #else
                   4221: # define LT_PATHMAX 1024
                   4222: #endif
                   4223: 
                   4224: #ifndef S_IXOTH
                   4225: # define S_IXOTH 0
                   4226: #endif
                   4227: #ifndef S_IXGRP
                   4228: # define S_IXGRP 0
                   4229: #endif
                   4230: 
                   4231: /* path handling portability macros */
                   4232: #ifndef DIR_SEPARATOR
                   4233: # define DIR_SEPARATOR '/'
                   4234: # define PATH_SEPARATOR ':'
                   4235: #endif
                   4236: 
                   4237: #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
                   4238:   defined (__OS2__)
                   4239: # define HAVE_DOS_BASED_FILE_SYSTEM
                   4240: # define FOPEN_WB "wb"
                   4241: # ifndef DIR_SEPARATOR_2
                   4242: #  define DIR_SEPARATOR_2 '\\'
                   4243: # endif
                   4244: # ifndef PATH_SEPARATOR_2
                   4245: #  define PATH_SEPARATOR_2 ';'
                   4246: # endif
                   4247: #endif
                   4248: 
                   4249: #ifndef DIR_SEPARATOR_2
                   4250: # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
                   4251: #else /* DIR_SEPARATOR_2 */
                   4252: # define IS_DIR_SEPARATOR(ch) \
                   4253:        (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
                   4254: #endif /* DIR_SEPARATOR_2 */
                   4255: 
                   4256: #ifndef PATH_SEPARATOR_2
                   4257: # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
                   4258: #else /* PATH_SEPARATOR_2 */
                   4259: # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
                   4260: #endif /* PATH_SEPARATOR_2 */
                   4261: 
                   4262: #ifndef FOPEN_WB
                   4263: # define FOPEN_WB "w"
                   4264: #endif
                   4265: #ifndef _O_BINARY
                   4266: # define _O_BINARY 0
                   4267: #endif
                   4268: 
                   4269: #define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
                   4270: #define XFREE(stale) do { \
                   4271:   if (stale) { free ((void *) stale); stale = 0; } \
                   4272: } while (0)
                   4273: 
                   4274: #if defined(LT_DEBUGWRAPPER)
                   4275: static int lt_debug = 1;
                   4276: #else
                   4277: static int lt_debug = 0;
                   4278: #endif
                   4279: 
                   4280: const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
                   4281: 
                   4282: void *xmalloc (size_t num);
                   4283: char *xstrdup (const char *string);
                   4284: const char *base_name (const char *name);
                   4285: char *find_executable (const char *wrapper);
                   4286: char *chase_symlinks (const char *pathspec);
                   4287: int make_executable (const char *path);
                   4288: int check_executable (const char *path);
                   4289: char *strendzap (char *str, const char *pat);
                   4290: void lt_debugprintf (const char *file, int line, const char *fmt, ...);
                   4291: void lt_fatal (const char *file, int line, const char *message, ...);
                   4292: static const char *nonnull (const char *s);
                   4293: static const char *nonempty (const char *s);
                   4294: void lt_setenv (const char *name, const char *value);
                   4295: char *lt_extend_str (const char *orig_value, const char *add, int to_end);
                   4296: void lt_update_exe_path (const char *name, const char *value);
                   4297: void lt_update_lib_path (const char *name, const char *value);
                   4298: char **prepare_spawn (char **argv);
                   4299: void lt_dump_script (FILE *f);
                   4300: EOF
                   4301: 
                   4302:            cat <<EOF
                   4303: volatile const char * MAGIC_EXE = "$magic_exe";
                   4304: const char * LIB_PATH_VARNAME = "$shlibpath_var";
                   4305: EOF
                   4306: 
                   4307:            if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
                   4308:               func_to_host_path "$temp_rpath"
                   4309:              cat <<EOF
                   4310: const char * LIB_PATH_VALUE   = "$func_to_host_path_result";
                   4311: EOF
                   4312:            else
                   4313:              cat <<"EOF"
                   4314: const char * LIB_PATH_VALUE   = "";
                   4315: EOF
                   4316:            fi
                   4317: 
                   4318:            if test -n "$dllsearchpath"; then
                   4319:               func_to_host_path "$dllsearchpath:"
                   4320:              cat <<EOF
                   4321: const char * EXE_PATH_VARNAME = "PATH";
                   4322: const char * EXE_PATH_VALUE   = "$func_to_host_path_result";
                   4323: EOF
                   4324:            else
                   4325:              cat <<"EOF"
                   4326: const char * EXE_PATH_VARNAME = "";
                   4327: const char * EXE_PATH_VALUE   = "";
                   4328: EOF
                   4329:            fi
                   4330: 
                   4331:            if test "$fast_install" = yes; then
                   4332:              cat <<EOF
                   4333: const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
                   4334: EOF
                   4335:            else
                   4336:              cat <<EOF
                   4337: const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
                   4338: EOF
                   4339:            fi
                   4340: 
                   4341: 
                   4342:            cat <<"EOF"
                   4343: 
                   4344: #define LTWRAPPER_OPTION_PREFIX         "--lt-"
                   4345: 
                   4346: static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
                   4347: static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
                   4348: static const char *debug_opt            = LTWRAPPER_OPTION_PREFIX "debug";
                   4349: 
                   4350: int
                   4351: main (int argc, char *argv[])
                   4352: {
                   4353:   char **newargz;
                   4354:   int  newargc;
                   4355:   char *tmp_pathspec;
                   4356:   char *actual_cwrapper_path;
                   4357:   char *actual_cwrapper_name;
                   4358:   char *target_name;
                   4359:   char *lt_argv_zero;
                   4360:   intptr_t rval = 127;
                   4361: 
                   4362:   int i;
                   4363: 
                   4364:   program_name = (char *) xstrdup (base_name (argv[0]));
                   4365:   newargz = XMALLOC (char *, argc + 1);
                   4366: 
                   4367:   /* very simple arg parsing; don't want to rely on getopt
                   4368:    * also, copy all non cwrapper options to newargz, except
                   4369:    * argz[0], which is handled differently
                   4370:    */
                   4371:   newargc=0;
                   4372:   for (i = 1; i < argc; i++)
                   4373:     {
                   4374:       if (strcmp (argv[i], dumpscript_opt) == 0)
                   4375:        {
                   4376: EOF
                   4377:            case "$host" in
                   4378:              *mingw* | *cygwin* )
                   4379:                # make stdout use "unix" line endings
                   4380:                echo "          setmode(1,_O_BINARY);"
                   4381:                ;;
                   4382:              esac
                   4383: 
                   4384:            cat <<"EOF"
                   4385:          lt_dump_script (stdout);
                   4386:          return 0;
                   4387:        }
                   4388:       if (strcmp (argv[i], debug_opt) == 0)
                   4389:        {
                   4390:           lt_debug = 1;
                   4391:           continue;
                   4392:        }
                   4393:       if (strcmp (argv[i], ltwrapper_option_prefix) == 0)
                   4394:         {
                   4395:           /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
                   4396:              namespace, but it is not one of the ones we know about and
                   4397:              have already dealt with, above (inluding dump-script), then
                   4398:              report an error. Otherwise, targets might begin to believe
                   4399:              they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
                   4400:              namespace. The first time any user complains about this, we'll
                   4401:              need to make LTWRAPPER_OPTION_PREFIX a configure-time option
                   4402:              or a configure.ac-settable value.
                   4403:            */
                   4404:           lt_fatal (__FILE__, __LINE__,
                   4405:                    "unrecognized %s option: '%s'",
                   4406:                     ltwrapper_option_prefix, argv[i]);
                   4407:         }
                   4408:       /* otherwise ... */
                   4409:       newargz[++newargc] = xstrdup (argv[i]);
                   4410:     }
                   4411:   newargz[++newargc] = NULL;
                   4412: 
                   4413: EOF
                   4414:            cat <<EOF
                   4415:   /* The GNU banner must be the first non-error debug message */
                   4416:   lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");
                   4417: EOF
                   4418:            cat <<"EOF"
                   4419:   lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
                   4420:   lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
                   4421: 
                   4422:   tmp_pathspec = find_executable (argv[0]);
                   4423:   if (tmp_pathspec == NULL)
                   4424:     lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
                   4425:   lt_debugprintf (__FILE__, __LINE__,
                   4426:                   "(main) found exe (before symlink chase) at: %s\n",
                   4427:                  tmp_pathspec);
                   4428: 
                   4429:   actual_cwrapper_path = chase_symlinks (tmp_pathspec);
                   4430:   lt_debugprintf (__FILE__, __LINE__,
                   4431:                   "(main) found exe (after symlink chase) at: %s\n",
                   4432:                  actual_cwrapper_path);
                   4433:   XFREE (tmp_pathspec);
                   4434: 
                   4435:   actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
                   4436:   strendzap (actual_cwrapper_path, actual_cwrapper_name);
                   4437: 
                   4438:   /* wrapper name transforms */
                   4439:   strendzap (actual_cwrapper_name, ".exe");
                   4440:   tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
                   4441:   XFREE (actual_cwrapper_name);
                   4442:   actual_cwrapper_name = tmp_pathspec;
                   4443:   tmp_pathspec = 0;
                   4444: 
                   4445:   /* target_name transforms -- use actual target program name; might have lt- prefix */
                   4446:   target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
                   4447:   strendzap (target_name, ".exe");
                   4448:   tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
                   4449:   XFREE (target_name);
                   4450:   target_name = tmp_pathspec;
                   4451:   tmp_pathspec = 0;
                   4452: 
                   4453:   lt_debugprintf (__FILE__, __LINE__,
                   4454:                  "(main) libtool target name: %s\n",
                   4455:                  target_name);
                   4456: EOF
                   4457: 
                   4458:            cat <<EOF
                   4459:   newargz[0] =
                   4460:     XMALLOC (char, (strlen (actual_cwrapper_path) +
                   4461:                    strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
                   4462:   strcpy (newargz[0], actual_cwrapper_path);
                   4463:   strcat (newargz[0], "$objdir");
                   4464:   strcat (newargz[0], "/");
                   4465: EOF
                   4466: 
                   4467:            cat <<"EOF"
                   4468:   /* stop here, and copy so we don't have to do this twice */
                   4469:   tmp_pathspec = xstrdup (newargz[0]);
                   4470: 
                   4471:   /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
                   4472:   strcat (newargz[0], actual_cwrapper_name);
                   4473: 
                   4474:   /* DO want the lt- prefix here if it exists, so use target_name */
                   4475:   lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
                   4476:   XFREE (tmp_pathspec);
                   4477:   tmp_pathspec = NULL;
                   4478: EOF
                   4479: 
                   4480:            case $host_os in
                   4481:              mingw*)
                   4482:            cat <<"EOF"
                   4483:   {
                   4484:     char* p;
                   4485:     while ((p = strchr (newargz[0], '\\')) != NULL)
                   4486:       {
                   4487:        *p = '/';
                   4488:       }
                   4489:     while ((p = strchr (lt_argv_zero, '\\')) != NULL)
                   4490:       {
                   4491:        *p = '/';
                   4492:       }
                   4493:   }
                   4494: EOF
                   4495:            ;;
                   4496:            esac
                   4497: 
                   4498:            cat <<"EOF"
                   4499:   XFREE (target_name);
                   4500:   XFREE (actual_cwrapper_path);
                   4501:   XFREE (actual_cwrapper_name);
                   4502: 
                   4503:   lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
                   4504:   lt_setenv ("DUALCASE", "1");  /* for MSK sh */
                   4505:   /* Update the DLL searchpath.  EXE_PATH_VALUE ($dllsearchpath) must
                   4506:      be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
                   4507:      because on Windows, both *_VARNAMEs are PATH but uninstalled
                   4508:      libraries must come first. */
                   4509:   lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
                   4510:   lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
                   4511: 
                   4512:   lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
                   4513:                  nonnull (lt_argv_zero));
                   4514:   for (i = 0; i < newargc; i++)
                   4515:     {
                   4516:       lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
                   4517:                      i, nonnull (newargz[i]));
                   4518:     }
                   4519: 
                   4520: EOF
                   4521: 
                   4522:            case $host_os in
                   4523:              mingw*)
                   4524:                cat <<"EOF"
                   4525:   /* execv doesn't actually work on mingw as expected on unix */
                   4526:   newargz = prepare_spawn (newargz);
                   4527:   rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
                   4528:   if (rval == -1)
                   4529:     {
                   4530:       /* failed to start process */
                   4531:       lt_debugprintf (__FILE__, __LINE__,
                   4532:                      "(main) failed to launch target \"%s\": %s\n",
                   4533:                      lt_argv_zero, nonnull (strerror (errno)));
                   4534:       return 127;
                   4535:     }
                   4536:   return rval;
                   4537: EOF
                   4538:                ;;
                   4539:              *)
                   4540:                cat <<"EOF"
                   4541:   execv (lt_argv_zero, newargz);
                   4542:   return rval; /* =127, but avoids unused variable warning */
                   4543: EOF
                   4544:                ;;
                   4545:            esac
                   4546: 
                   4547:            cat <<"EOF"
                   4548: }
                   4549: 
                   4550: void *
                   4551: xmalloc (size_t num)
                   4552: {
                   4553:   void *p = (void *) malloc (num);
                   4554:   if (!p)
                   4555:     lt_fatal (__FILE__, __LINE__, "memory exhausted");
                   4556: 
                   4557:   return p;
                   4558: }
                   4559: 
                   4560: char *
                   4561: xstrdup (const char *string)
                   4562: {
                   4563:   return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
                   4564:                          string) : NULL;
                   4565: }
                   4566: 
                   4567: const char *
                   4568: base_name (const char *name)
                   4569: {
                   4570:   const char *base;
                   4571: 
                   4572: #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
                   4573:   /* Skip over the disk name in MSDOS pathnames. */
                   4574:   if (isalpha ((unsigned char) name[0]) && name[1] == ':')
                   4575:     name += 2;
                   4576: #endif
                   4577: 
                   4578:   for (base = name; *name; name++)
                   4579:     if (IS_DIR_SEPARATOR (*name))
                   4580:       base = name + 1;
                   4581:   return base;
                   4582: }
                   4583: 
                   4584: int
                   4585: check_executable (const char *path)
                   4586: {
                   4587:   struct stat st;
                   4588: 
                   4589:   lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
                   4590:                   nonempty (path));
                   4591:   if ((!path) || (!*path))
                   4592:     return 0;
                   4593: 
                   4594:   if ((stat (path, &st) >= 0)
                   4595:       && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
                   4596:     return 1;
                   4597:   else
                   4598:     return 0;
                   4599: }
                   4600: 
                   4601: int
                   4602: make_executable (const char *path)
                   4603: {
                   4604:   int rval = 0;
                   4605:   struct stat st;
                   4606: 
                   4607:   lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
                   4608:                   nonempty (path));
                   4609:   if ((!path) || (!*path))
                   4610:     return 0;
                   4611: 
                   4612:   if (stat (path, &st) >= 0)
                   4613:     {
                   4614:       rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
                   4615:     }
                   4616:   return rval;
                   4617: }
                   4618: 
                   4619: /* Searches for the full path of the wrapper.  Returns
                   4620:    newly allocated full path name if found, NULL otherwise
                   4621:    Does not chase symlinks, even on platforms that support them.
                   4622: */
                   4623: char *
                   4624: find_executable (const char *wrapper)
                   4625: {
                   4626:   int has_slash = 0;
                   4627:   const char *p;
                   4628:   const char *p_next;
                   4629:   /* static buffer for getcwd */
                   4630:   char tmp[LT_PATHMAX + 1];
                   4631:   int tmp_len;
                   4632:   char *concat_name;
                   4633: 
                   4634:   lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
                   4635:                   nonempty (wrapper));
                   4636: 
                   4637:   if ((wrapper == NULL) || (*wrapper == '\0'))
                   4638:     return NULL;
                   4639: 
                   4640:   /* Absolute path? */
                   4641: #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
                   4642:   if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
                   4643:     {
                   4644:       concat_name = xstrdup (wrapper);
                   4645:       if (check_executable (concat_name))
                   4646:        return concat_name;
                   4647:       XFREE (concat_name);
                   4648:     }
                   4649:   else
                   4650:     {
                   4651: #endif
                   4652:       if (IS_DIR_SEPARATOR (wrapper[0]))
                   4653:        {
                   4654:          concat_name = xstrdup (wrapper);
                   4655:          if (check_executable (concat_name))
                   4656:            return concat_name;
                   4657:          XFREE (concat_name);
                   4658:        }
                   4659: #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
                   4660:     }
                   4661: #endif
                   4662: 
                   4663:   for (p = wrapper; *p; p++)
                   4664:     if (*p == '/')
                   4665:       {
                   4666:        has_slash = 1;
                   4667:        break;
                   4668:       }
                   4669:   if (!has_slash)
                   4670:     {
                   4671:       /* no slashes; search PATH */
                   4672:       const char *path = getenv ("PATH");
                   4673:       if (path != NULL)
                   4674:        {
                   4675:          for (p = path; *p; p = p_next)
                   4676:            {
                   4677:              const char *q;
                   4678:              size_t p_len;
                   4679:              for (q = p; *q; q++)
                   4680:                if (IS_PATH_SEPARATOR (*q))
                   4681:                  break;
                   4682:              p_len = q - p;
                   4683:              p_next = (*q == '\0' ? q : q + 1);
                   4684:              if (p_len == 0)
                   4685:                {
                   4686:                  /* empty path: current directory */
                   4687:                  if (getcwd (tmp, LT_PATHMAX) == NULL)
                   4688:                    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
                   4689:                               nonnull (strerror (errno)));
                   4690:                  tmp_len = strlen (tmp);
                   4691:                  concat_name =
                   4692:                    XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
                   4693:                  memcpy (concat_name, tmp, tmp_len);
                   4694:                  concat_name[tmp_len] = '/';
                   4695:                  strcpy (concat_name + tmp_len + 1, wrapper);
                   4696:                }
                   4697:              else
                   4698:                {
                   4699:                  concat_name =
                   4700:                    XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
                   4701:                  memcpy (concat_name, p, p_len);
                   4702:                  concat_name[p_len] = '/';
                   4703:                  strcpy (concat_name + p_len + 1, wrapper);
                   4704:                }
                   4705:              if (check_executable (concat_name))
                   4706:                return concat_name;
                   4707:              XFREE (concat_name);
                   4708:            }
                   4709:        }
                   4710:       /* not found in PATH; assume curdir */
                   4711:     }
                   4712:   /* Relative path | not found in path: prepend cwd */
                   4713:   if (getcwd (tmp, LT_PATHMAX) == NULL)
                   4714:     lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
                   4715:               nonnull (strerror (errno)));
                   4716:   tmp_len = strlen (tmp);
                   4717:   concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
                   4718:   memcpy (concat_name, tmp, tmp_len);
                   4719:   concat_name[tmp_len] = '/';
                   4720:   strcpy (concat_name + tmp_len + 1, wrapper);
                   4721: 
                   4722:   if (check_executable (concat_name))
                   4723:     return concat_name;
                   4724:   XFREE (concat_name);
                   4725:   return NULL;
                   4726: }
                   4727: 
                   4728: char *
                   4729: chase_symlinks (const char *pathspec)
                   4730: {
                   4731: #ifndef S_ISLNK
                   4732:   return xstrdup (pathspec);
                   4733: #else
                   4734:   char buf[LT_PATHMAX];
                   4735:   struct stat s;
                   4736:   char *tmp_pathspec = xstrdup (pathspec);
                   4737:   char *p;
                   4738:   int has_symlinks = 0;
                   4739:   while (strlen (tmp_pathspec) && !has_symlinks)
                   4740:     {
                   4741:       lt_debugprintf (__FILE__, __LINE__,
                   4742:                      "checking path component for symlinks: %s\n",
                   4743:                      tmp_pathspec);
                   4744:       if (lstat (tmp_pathspec, &s) == 0)
                   4745:        {
                   4746:          if (S_ISLNK (s.st_mode) != 0)
                   4747:            {
                   4748:              has_symlinks = 1;
                   4749:              break;
                   4750:            }
                   4751: 
                   4752:          /* search backwards for last DIR_SEPARATOR */
                   4753:          p = tmp_pathspec + strlen (tmp_pathspec) - 1;
                   4754:          while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
                   4755:            p--;
                   4756:          if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
                   4757:            {
                   4758:              /* no more DIR_SEPARATORS left */
                   4759:              break;
                   4760:            }
                   4761:          *p = '\0';
                   4762:        }
                   4763:       else
                   4764:        {
                   4765:          lt_fatal (__FILE__, __LINE__,
                   4766:                    "error accessing file \"%s\": %s",
                   4767:                    tmp_pathspec, nonnull (strerror (errno)));
                   4768:        }
                   4769:     }
                   4770:   XFREE (tmp_pathspec);
                   4771: 
                   4772:   if (!has_symlinks)
                   4773:     {
                   4774:       return xstrdup (pathspec);
                   4775:     }
                   4776: 
                   4777:   tmp_pathspec = realpath (pathspec, buf);
                   4778:   if (tmp_pathspec == 0)
                   4779:     {
                   4780:       lt_fatal (__FILE__, __LINE__,
                   4781:                "could not follow symlinks for %s", pathspec);
                   4782:     }
                   4783:   return xstrdup (tmp_pathspec);
                   4784: #endif
                   4785: }
                   4786: 
                   4787: char *
                   4788: strendzap (char *str, const char *pat)
                   4789: {
                   4790:   size_t len, patlen;
                   4791: 
                   4792:   assert (str != NULL);
                   4793:   assert (pat != NULL);
                   4794: 
                   4795:   len = strlen (str);
                   4796:   patlen = strlen (pat);
                   4797: 
                   4798:   if (patlen <= len)
                   4799:     {
                   4800:       str += len - patlen;
                   4801:       if (strcmp (str, pat) == 0)
                   4802:        *str = '\0';
                   4803:     }
                   4804:   return str;
                   4805: }
                   4806: 
                   4807: void
                   4808: lt_debugprintf (const char *file, int line, const char *fmt, ...)
                   4809: {
                   4810:   va_list args;
                   4811:   if (lt_debug)
                   4812:     {
                   4813:       (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
                   4814:       va_start (args, fmt);
                   4815:       (void) vfprintf (stderr, fmt, args);
                   4816:       va_end (args);
                   4817:     }
                   4818: }
                   4819: 
                   4820: static void
                   4821: lt_error_core (int exit_status, const char *file,
                   4822:               int line, const char *mode,
                   4823:               const char *message, va_list ap)
                   4824: {
                   4825:   fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
                   4826:   vfprintf (stderr, message, ap);
                   4827:   fprintf (stderr, ".\n");
                   4828: 
                   4829:   if (exit_status >= 0)
                   4830:     exit (exit_status);
                   4831: }
                   4832: 
                   4833: void
                   4834: lt_fatal (const char *file, int line, const char *message, ...)
                   4835: {
                   4836:   va_list ap;
                   4837:   va_start (ap, message);
                   4838:   lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
                   4839:   va_end (ap);
                   4840: }
                   4841: 
                   4842: static const char *
                   4843: nonnull (const char *s)
                   4844: {
                   4845:   return s ? s : "(null)";
                   4846: }
                   4847: 
                   4848: static const char *
                   4849: nonempty (const char *s)
                   4850: {
                   4851:   return (s && !*s) ? "(empty)" : nonnull (s);
                   4852: }
                   4853: 
                   4854: void
                   4855: lt_setenv (const char *name, const char *value)
                   4856: {
                   4857:   lt_debugprintf (__FILE__, __LINE__,
                   4858:                  "(lt_setenv) setting '%s' to '%s'\n",
                   4859:                   nonnull (name), nonnull (value));
                   4860:   {
                   4861: #ifdef HAVE_SETENV
                   4862:     /* always make a copy, for consistency with !HAVE_SETENV */
                   4863:     char *str = xstrdup (value);
                   4864:     setenv (name, str, 1);
                   4865: #else
                   4866:     int len = strlen (name) + 1 + strlen (value) + 1;
                   4867:     char *str = XMALLOC (char, len);
                   4868:     sprintf (str, "%s=%s", name, value);
                   4869:     if (putenv (str) != EXIT_SUCCESS)
                   4870:       {
                   4871:         XFREE (str);
                   4872:       }
                   4873: #endif
                   4874:   }
                   4875: }
                   4876: 
                   4877: char *
                   4878: lt_extend_str (const char *orig_value, const char *add, int to_end)
                   4879: {
                   4880:   char *new_value;
                   4881:   if (orig_value && *orig_value)
                   4882:     {
                   4883:       int orig_value_len = strlen (orig_value);
                   4884:       int add_len = strlen (add);
                   4885:       new_value = XMALLOC (char, add_len + orig_value_len + 1);
                   4886:       if (to_end)
                   4887:         {
                   4888:           strcpy (new_value, orig_value);
                   4889:           strcpy (new_value + orig_value_len, add);
                   4890:         }
                   4891:       else
                   4892:         {
                   4893:           strcpy (new_value, add);
                   4894:           strcpy (new_value + add_len, orig_value);
                   4895:         }
                   4896:     }
                   4897:   else
                   4898:     {
                   4899:       new_value = xstrdup (add);
                   4900:     }
                   4901:   return new_value;
                   4902: }
                   4903: 
                   4904: void
                   4905: lt_update_exe_path (const char *name, const char *value)
                   4906: {
                   4907:   lt_debugprintf (__FILE__, __LINE__,
                   4908:                  "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
                   4909:                   nonnull (name), nonnull (value));
                   4910: 
                   4911:   if (name && *name && value && *value)
                   4912:     {
                   4913:       char *new_value = lt_extend_str (getenv (name), value, 0);
                   4914:       /* some systems can't cope with a ':'-terminated path #' */
                   4915:       int len = strlen (new_value);
                   4916:       while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
                   4917:         {
                   4918:           new_value[len-1] = '\0';
                   4919:         }
                   4920:       lt_setenv (name, new_value);
                   4921:       XFREE (new_value);
                   4922:     }
                   4923: }
                   4924: 
                   4925: void
                   4926: lt_update_lib_path (const char *name, const char *value)
                   4927: {
                   4928:   lt_debugprintf (__FILE__, __LINE__,
                   4929:                  "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
                   4930:                   nonnull (name), nonnull (value));
                   4931: 
                   4932:   if (name && *name && value && *value)
                   4933:     {
                   4934:       char *new_value = lt_extend_str (getenv (name), value, 0);
                   4935:       lt_setenv (name, new_value);
                   4936:       XFREE (new_value);
                   4937:     }
                   4938: }
                   4939: 
                   4940: EOF
                   4941:            case $host_os in
                   4942:              mingw*)
                   4943:                cat <<"EOF"
                   4944: 
                   4945: /* Prepares an argument vector before calling spawn().
                   4946:    Note that spawn() does not by itself call the command interpreter
                   4947:      (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
                   4948:       ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
                   4949:          GetVersionEx(&v);
                   4950:          v.dwPlatformId == VER_PLATFORM_WIN32_NT;
                   4951:       }) ? "cmd.exe" : "command.com").
                   4952:    Instead it simply concatenates the arguments, separated by ' ', and calls
                   4953:    CreateProcess().  We must quote the arguments since Win32 CreateProcess()
                   4954:    interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
                   4955:    special way:
                   4956:    - Space and tab are interpreted as delimiters. They are not treated as
                   4957:      delimiters if they are surrounded by double quotes: "...".
                   4958:    - Unescaped double quotes are removed from the input. Their only effect is
                   4959:      that within double quotes, space and tab are treated like normal
                   4960:      characters.
                   4961:    - Backslashes not followed by double quotes are not special.
                   4962:    - But 2*n+1 backslashes followed by a double quote become
                   4963:      n backslashes followed by a double quote (n >= 0):
                   4964:        \" -> "
                   4965:        \\\" -> \"
                   4966:        \\\\\" -> \\"
                   4967:  */
                   4968: #define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
                   4969: #define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
                   4970: char **
                   4971: prepare_spawn (char **argv)
                   4972: {
                   4973:   size_t argc;
                   4974:   char **new_argv;
                   4975:   size_t i;
                   4976: 
                   4977:   /* Count number of arguments.  */
                   4978:   for (argc = 0; argv[argc] != NULL; argc++)
                   4979:     ;
                   4980: 
                   4981:   /* Allocate new argument vector.  */
                   4982:   new_argv = XMALLOC (char *, argc + 1);
                   4983: 
                   4984:   /* Put quoted arguments into the new argument vector.  */
                   4985:   for (i = 0; i < argc; i++)
                   4986:     {
                   4987:       const char *string = argv[i];
                   4988: 
                   4989:       if (string[0] == '\0')
                   4990:        new_argv[i] = xstrdup ("\"\"");
                   4991:       else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
                   4992:        {
                   4993:          int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
                   4994:          size_t length;
                   4995:          unsigned int backslashes;
                   4996:          const char *s;
                   4997:          char *quoted_string;
                   4998:          char *p;
                   4999: 
                   5000:          length = 0;
                   5001:          backslashes = 0;
                   5002:          if (quote_around)
                   5003:            length++;
                   5004:          for (s = string; *s != '\0'; s++)
                   5005:            {
                   5006:              char c = *s;
                   5007:              if (c == '"')
                   5008:                length += backslashes + 1;
                   5009:              length++;
                   5010:              if (c == '\\')
                   5011:                backslashes++;
                   5012:              else
                   5013:                backslashes = 0;
                   5014:            }
                   5015:          if (quote_around)
                   5016:            length += backslashes + 1;
                   5017: 
                   5018:          quoted_string = XMALLOC (char, length + 1);
                   5019: 
                   5020:          p = quoted_string;
                   5021:          backslashes = 0;
                   5022:          if (quote_around)
                   5023:            *p++ = '"';
                   5024:          for (s = string; *s != '\0'; s++)
                   5025:            {
                   5026:              char c = *s;
                   5027:              if (c == '"')
                   5028:                {
                   5029:                  unsigned int j;
                   5030:                  for (j = backslashes + 1; j > 0; j--)
                   5031:                    *p++ = '\\';
                   5032:                }
                   5033:              *p++ = c;
                   5034:              if (c == '\\')
                   5035:                backslashes++;
                   5036:              else
                   5037:                backslashes = 0;
                   5038:            }
                   5039:          if (quote_around)
                   5040:            {
                   5041:              unsigned int j;
                   5042:              for (j = backslashes; j > 0; j--)
                   5043:                *p++ = '\\';
                   5044:              *p++ = '"';
                   5045:            }
                   5046:          *p = '\0';
                   5047: 
                   5048:          new_argv[i] = quoted_string;
                   5049:        }
                   5050:       else
                   5051:        new_argv[i] = (char *) string;
                   5052:     }
                   5053:   new_argv[argc] = NULL;
                   5054: 
                   5055:   return new_argv;
                   5056: }
                   5057: EOF
                   5058:                ;;
                   5059:            esac
                   5060: 
                   5061:             cat <<"EOF"
                   5062: void lt_dump_script (FILE* f)
                   5063: {
                   5064: EOF
                   5065:            func_emit_wrapper yes |
                   5066:              $SED -n -e '
                   5067: s/^\(.\{79\}\)\(..*\)/\1\
                   5068: \2/
                   5069: h
                   5070: s/\([\\"]\)/\\\1/g
                   5071: s/$/\\n/
                   5072: s/\([^\n]*\).*/  fputs ("\1", f);/p
                   5073: g
                   5074: D'
                   5075:             cat <<"EOF"
                   5076: }
                   5077: EOF
                   5078: }
                   5079: # end: func_emit_cwrapperexe_src
                   5080: 
                   5081: # func_win32_import_lib_p ARG
                   5082: # True if ARG is an import lib, as indicated by $file_magic_cmd
                   5083: func_win32_import_lib_p ()
                   5084: {
                   5085:     $opt_debug
                   5086:     case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
                   5087:     *import*) : ;;
                   5088:     *) false ;;
                   5089:     esac
                   5090: }
                   5091: 
                   5092: # func_mode_link arg...
                   5093: func_mode_link ()
                   5094: {
                   5095:     $opt_debug
                   5096:     case $host in
                   5097:     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
                   5098:       # It is impossible to link a dll without this setting, and
                   5099:       # we shouldn't force the makefile maintainer to figure out
                   5100:       # which system we are compiling for in order to pass an extra
                   5101:       # flag for every libtool invocation.
                   5102:       # allow_undefined=no
                   5103: 
                   5104:       # FIXME: Unfortunately, there are problems with the above when trying
                   5105:       # to make a dll which has undefined symbols, in which case not
                   5106:       # even a static library is built.  For now, we need to specify
                   5107:       # -no-undefined on the libtool link line when we can be certain
                   5108:       # that all symbols are satisfied, otherwise we get a static library.
                   5109:       allow_undefined=yes
                   5110:       ;;
                   5111:     *)
                   5112:       allow_undefined=yes
                   5113:       ;;
                   5114:     esac
                   5115:     libtool_args=$nonopt
                   5116:     base_compile="$nonopt $@"
                   5117:     compile_command=$nonopt
                   5118:     finalize_command=$nonopt
                   5119: 
                   5120:     compile_rpath=
                   5121:     finalize_rpath=
                   5122:     compile_shlibpath=
                   5123:     finalize_shlibpath=
                   5124:     convenience=
                   5125:     old_convenience=
                   5126:     deplibs=
                   5127:     old_deplibs=
                   5128:     compiler_flags=
                   5129:     linker_flags=
                   5130:     dllsearchpath=
                   5131:     lib_search_path=`pwd`
                   5132:     inst_prefix_dir=
                   5133:     new_inherited_linker_flags=
                   5134: 
                   5135:     avoid_version=no
                   5136:     bindir=
                   5137:     dlfiles=
                   5138:     dlprefiles=
                   5139:     dlself=no
                   5140:     export_dynamic=no
                   5141:     export_symbols=
                   5142:     export_symbols_regex=
                   5143:     generated=
                   5144:     libobjs=
                   5145:     ltlibs=
                   5146:     module=no
                   5147:     no_install=no
                   5148:     objs=
                   5149:     non_pic_objects=
                   5150:     precious_files_regex=
                   5151:     prefer_static_libs=no
                   5152:     preload=no
                   5153:     prev=
                   5154:     prevarg=
                   5155:     release=
                   5156:     rpath=
                   5157:     xrpath=
                   5158:     perm_rpath=
                   5159:     temp_rpath=
                   5160:     thread_safe=no
                   5161:     vinfo=
                   5162:     vinfo_number=no
                   5163:     weak_libs=
                   5164:     single_module="${wl}-single_module"
                   5165:     func_infer_tag $base_compile
                   5166: 
                   5167:     # We need to know -static, to get the right output filenames.
                   5168:     for arg
                   5169:     do
                   5170:       case $arg in
                   5171:       -shared)
                   5172:        test "$build_libtool_libs" != yes && \
                   5173:          func_fatal_configuration "can not build a shared library"
                   5174:        build_old_libs=no
                   5175:        break
                   5176:        ;;
                   5177:       -all-static | -static | -static-libtool-libs)
                   5178:        case $arg in
                   5179:        -all-static)
                   5180:          if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
                   5181:            func_warning "complete static linking is impossible in this configuration"
                   5182:          fi
                   5183:          if test -n "$link_static_flag"; then
                   5184:            dlopen_self=$dlopen_self_static
                   5185:          fi
                   5186:          prefer_static_libs=yes
                   5187:          ;;
                   5188:        -static)
                   5189:          if test -z "$pic_flag" && test -n "$link_static_flag"; then
                   5190:            dlopen_self=$dlopen_self_static
                   5191:          fi
                   5192:          prefer_static_libs=built
                   5193:          ;;
                   5194:        -static-libtool-libs)
                   5195:          if test -z "$pic_flag" && test -n "$link_static_flag"; then
                   5196:            dlopen_self=$dlopen_self_static
                   5197:          fi
                   5198:          prefer_static_libs=yes
                   5199:          ;;
                   5200:        esac
                   5201:        build_libtool_libs=no
                   5202:        build_old_libs=yes
                   5203:        break
                   5204:        ;;
                   5205:       esac
                   5206:     done
                   5207: 
                   5208:     # See if our shared archives depend on static archives.
                   5209:     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
                   5210: 
                   5211:     # Go through the arguments, transforming them on the way.
                   5212:     while test "$#" -gt 0; do
                   5213:       arg="$1"
                   5214:       shift
                   5215:       func_quote_for_eval "$arg"
                   5216:       qarg=$func_quote_for_eval_unquoted_result
                   5217:       func_append libtool_args " $func_quote_for_eval_result"
                   5218: 
                   5219:       # If the previous option needs an argument, assign it.
                   5220:       if test -n "$prev"; then
                   5221:        case $prev in
                   5222:        output)
                   5223:          func_append compile_command " @OUTPUT@"
                   5224:          func_append finalize_command " @OUTPUT@"
                   5225:          ;;
                   5226:        esac
                   5227: 
                   5228:        case $prev in
                   5229:        bindir)
                   5230:          bindir="$arg"
                   5231:          prev=
                   5232:          continue
                   5233:          ;;
                   5234:        dlfiles|dlprefiles)
                   5235:          if test "$preload" = no; then
                   5236:            # Add the symbol object into the linking commands.
                   5237:            func_append compile_command " @SYMFILE@"
                   5238:            func_append finalize_command " @SYMFILE@"
                   5239:            preload=yes
                   5240:          fi
                   5241:          case $arg in
                   5242:          *.la | *.lo) ;;  # We handle these cases below.
                   5243:          force)
                   5244:            if test "$dlself" = no; then
                   5245:              dlself=needless
                   5246:              export_dynamic=yes
                   5247:            fi
                   5248:            prev=
                   5249:            continue
                   5250:            ;;
                   5251:          self)
                   5252:            if test "$prev" = dlprefiles; then
                   5253:              dlself=yes
                   5254:            elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
                   5255:              dlself=yes
                   5256:            else
                   5257:              dlself=needless
                   5258:              export_dynamic=yes
                   5259:            fi
                   5260:            prev=
                   5261:            continue
                   5262:            ;;
                   5263:          *)
                   5264:            if test "$prev" = dlfiles; then
                   5265:              func_append dlfiles " $arg"
                   5266:            else
                   5267:              func_append dlprefiles " $arg"
                   5268:            fi
                   5269:            prev=
                   5270:            continue
                   5271:            ;;
                   5272:          esac
                   5273:          ;;
                   5274:        expsyms)
                   5275:          export_symbols="$arg"
                   5276:          test -f "$arg" \
                   5277:            || func_fatal_error "symbol file \`$arg' does not exist"
                   5278:          prev=
                   5279:          continue
                   5280:          ;;
                   5281:        expsyms_regex)
                   5282:          export_symbols_regex="$arg"
                   5283:          prev=
                   5284:          continue
                   5285:          ;;
                   5286:        framework)
                   5287:          case $host in
                   5288:            *-*-darwin*)
                   5289:              case "$deplibs " in
                   5290:                *" $qarg.ltframework "*) ;;
                   5291:                *) func_append deplibs " $qarg.ltframework" # this is fixed later
                   5292:                   ;;
                   5293:              esac
                   5294:              ;;
                   5295:          esac
                   5296:          prev=
                   5297:          continue
                   5298:          ;;
                   5299:        inst_prefix)
                   5300:          inst_prefix_dir="$arg"
                   5301:          prev=
                   5302:          continue
                   5303:          ;;
                   5304:        objectlist)
                   5305:          if test -f "$arg"; then
                   5306:            save_arg=$arg
                   5307:            moreargs=
                   5308:            for fil in `cat "$save_arg"`
                   5309:            do
                   5310: #            func_append moreargs " $fil"
                   5311:              arg=$fil
                   5312:              # A libtool-controlled object.
                   5313: 
                   5314:              # Check to see that this really is a libtool object.
                   5315:              if func_lalib_unsafe_p "$arg"; then
                   5316:                pic_object=
                   5317:                non_pic_object=
                   5318: 
                   5319:                # Read the .lo file
                   5320:                func_source "$arg"
                   5321: 
                   5322:                if test -z "$pic_object" ||
                   5323:                   test -z "$non_pic_object" ||
                   5324:                   test "$pic_object" = none &&
                   5325:                   test "$non_pic_object" = none; then
                   5326:                  func_fatal_error "cannot find name of object for \`$arg'"
                   5327:                fi
                   5328: 
                   5329:                # Extract subdirectory from the argument.
                   5330:                func_dirname "$arg" "/" ""
                   5331:                xdir="$func_dirname_result"
                   5332: 
                   5333:                if test "$pic_object" != none; then
                   5334:                  # Prepend the subdirectory the object is found in.
                   5335:                  pic_object="$xdir$pic_object"
                   5336: 
                   5337:                  if test "$prev" = dlfiles; then
                   5338:                    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
                   5339:                      func_append dlfiles " $pic_object"
                   5340:                      prev=
                   5341:                      continue
                   5342:                    else
                   5343:                      # If libtool objects are unsupported, then we need to preload.
                   5344:                      prev=dlprefiles
                   5345:                    fi
                   5346:                  fi
                   5347: 
                   5348:                  # CHECK ME:  I think I busted this.  -Ossama
                   5349:                  if test "$prev" = dlprefiles; then
                   5350:                    # Preload the old-style object.
                   5351:                    func_append dlprefiles " $pic_object"
                   5352:                    prev=
                   5353:                  fi
                   5354: 
                   5355:                  # A PIC object.
                   5356:                  func_append libobjs " $pic_object"
                   5357:                  arg="$pic_object"
                   5358:                fi
                   5359: 
                   5360:                # Non-PIC object.
                   5361:                if test "$non_pic_object" != none; then
                   5362:                  # Prepend the subdirectory the object is found in.
                   5363:                  non_pic_object="$xdir$non_pic_object"
                   5364: 
                   5365:                  # A standard non-PIC object
                   5366:                  func_append non_pic_objects " $non_pic_object"
                   5367:                  if test -z "$pic_object" || test "$pic_object" = none ; then
                   5368:                    arg="$non_pic_object"
                   5369:                  fi
                   5370:                else
                   5371:                  # If the PIC object exists, use it instead.
                   5372:                  # $xdir was prepended to $pic_object above.
                   5373:                  non_pic_object="$pic_object"
                   5374:                  func_append non_pic_objects " $non_pic_object"
                   5375:                fi
                   5376:              else
                   5377:                # Only an error if not doing a dry-run.
                   5378:                if $opt_dry_run; then
                   5379:                  # Extract subdirectory from the argument.
                   5380:                  func_dirname "$arg" "/" ""
                   5381:                  xdir="$func_dirname_result"
                   5382: 
                   5383:                  func_lo2o "$arg"
                   5384:                  pic_object=$xdir$objdir/$func_lo2o_result
                   5385:                  non_pic_object=$xdir$func_lo2o_result
                   5386:                  func_append libobjs " $pic_object"
                   5387:                  func_append non_pic_objects " $non_pic_object"
                   5388:                else
                   5389:                  func_fatal_error "\`$arg' is not a valid libtool object"
                   5390:                fi
                   5391:              fi
                   5392:            done
                   5393:          else
                   5394:            func_fatal_error "link input file \`$arg' does not exist"
                   5395:          fi
                   5396:          arg=$save_arg
                   5397:          prev=
                   5398:          continue
                   5399:          ;;
                   5400:        precious_regex)
                   5401:          precious_files_regex="$arg"
                   5402:          prev=
                   5403:          continue
                   5404:          ;;
                   5405:        release)
                   5406:          release="-$arg"
                   5407:          prev=
                   5408:          continue
                   5409:          ;;
                   5410:        rpath | xrpath)
                   5411:          # We need an absolute path.
                   5412:          case $arg in
                   5413:          [\\/]* | [A-Za-z]:[\\/]*) ;;
                   5414:          *)
                   5415:            func_fatal_error "only absolute run-paths are allowed"
                   5416:            ;;
                   5417:          esac
                   5418:          if test "$prev" = rpath; then
                   5419:            case "$rpath " in
                   5420:            *" $arg "*) ;;
                   5421:            *) func_append rpath " $arg" ;;
                   5422:            esac
                   5423:          else
                   5424:            case "$xrpath " in
                   5425:            *" $arg "*) ;;
                   5426:            *) func_append xrpath " $arg" ;;
                   5427:            esac
                   5428:          fi
                   5429:          prev=
                   5430:          continue
                   5431:          ;;
                   5432:        shrext)
                   5433:          shrext_cmds="$arg"
                   5434:          prev=
                   5435:          continue
                   5436:          ;;
                   5437:        weak)
                   5438:          func_append weak_libs " $arg"
                   5439:          prev=
                   5440:          continue
                   5441:          ;;
                   5442:        xcclinker)
                   5443:          func_append linker_flags " $qarg"
                   5444:          func_append compiler_flags " $qarg"
                   5445:          prev=
                   5446:          func_append compile_command " $qarg"
                   5447:          func_append finalize_command " $qarg"
                   5448:          continue
                   5449:          ;;
                   5450:        xcompiler)
                   5451:          func_append compiler_flags " $qarg"
                   5452:          prev=
                   5453:          func_append compile_command " $qarg"
                   5454:          func_append finalize_command " $qarg"
                   5455:          continue
                   5456:          ;;
                   5457:        xlinker)
                   5458:          func_append linker_flags " $qarg"
                   5459:          func_append compiler_flags " $wl$qarg"
                   5460:          prev=
                   5461:          func_append compile_command " $wl$qarg"
                   5462:          func_append finalize_command " $wl$qarg"
                   5463:          continue
                   5464:          ;;
                   5465:        *)
                   5466:          eval "$prev=\"\$arg\""
                   5467:          prev=
                   5468:          continue
                   5469:          ;;
                   5470:        esac
                   5471:       fi # test -n "$prev"
                   5472: 
                   5473:       prevarg="$arg"
                   5474: 
                   5475:       case $arg in
                   5476:       -all-static)
                   5477:        if test -n "$link_static_flag"; then
                   5478:          # See comment for -static flag below, for more details.
                   5479:          func_append compile_command " $link_static_flag"
                   5480:          func_append finalize_command " $link_static_flag"
                   5481:        fi
                   5482:        continue
                   5483:        ;;
                   5484: 
                   5485:       -allow-undefined)
                   5486:        # FIXME: remove this flag sometime in the future.
                   5487:        func_fatal_error "\`-allow-undefined' must not be used because it is the default"
                   5488:        ;;
                   5489: 
                   5490:       -avoid-version)
                   5491:        avoid_version=yes
                   5492:        continue
                   5493:        ;;
                   5494: 
                   5495:       -bindir)
                   5496:        prev=bindir
                   5497:        continue
                   5498:        ;;
                   5499: 
                   5500:       -dlopen)
                   5501:        prev=dlfiles
                   5502:        continue
                   5503:        ;;
                   5504: 
                   5505:       -dlpreopen)
                   5506:        prev=dlprefiles
                   5507:        continue
                   5508:        ;;
                   5509: 
                   5510:       -export-dynamic)
                   5511:        export_dynamic=yes
                   5512:        continue
                   5513:        ;;
                   5514: 
                   5515:       -export-symbols | -export-symbols-regex)
                   5516:        if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
                   5517:          func_fatal_error "more than one -exported-symbols argument is not allowed"
                   5518:        fi
                   5519:        if test "X$arg" = "X-export-symbols"; then
                   5520:          prev=expsyms
                   5521:        else
                   5522:          prev=expsyms_regex
                   5523:        fi
                   5524:        continue
                   5525:        ;;
                   5526: 
                   5527:       -framework)
                   5528:        prev=framework
                   5529:        continue
                   5530:        ;;
                   5531: 
                   5532:       -inst-prefix-dir)
                   5533:        prev=inst_prefix
                   5534:        continue
                   5535:        ;;
                   5536: 
                   5537:       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
                   5538:       # so, if we see these flags be careful not to treat them like -L
                   5539:       -L[A-Z][A-Z]*:*)
                   5540:        case $with_gcc/$host in
                   5541:        no/*-*-irix* | /*-*-irix*)
                   5542:          func_append compile_command " $arg"
                   5543:          func_append finalize_command " $arg"
                   5544:          ;;
                   5545:        esac
                   5546:        continue
                   5547:        ;;
                   5548: 
                   5549:       -L*)
                   5550:        func_stripname "-L" '' "$arg"
                   5551:        if test -z "$func_stripname_result"; then
                   5552:          if test "$#" -gt 0; then
                   5553:            func_fatal_error "require no space between \`-L' and \`$1'"
                   5554:          else
                   5555:            func_fatal_error "need path for \`-L' option"
                   5556:          fi
                   5557:        fi
                   5558:        func_resolve_sysroot "$func_stripname_result"
                   5559:        dir=$func_resolve_sysroot_result
                   5560:        # We need an absolute path.
                   5561:        case $dir in
                   5562:        [\\/]* | [A-Za-z]:[\\/]*) ;;
                   5563:        *)
                   5564:          absdir=`cd "$dir" && pwd`
                   5565:          test -z "$absdir" && \
                   5566:            func_fatal_error "cannot determine absolute directory name of \`$dir'"
                   5567:          dir="$absdir"
                   5568:          ;;
                   5569:        esac
                   5570:        case "$deplibs " in
                   5571:        *" -L$dir "* | *" $arg "*)
                   5572:          # Will only happen for absolute or sysroot arguments
                   5573:          ;;
                   5574:        *)
                   5575:          # Preserve sysroot, but never include relative directories
                   5576:          case $dir in
                   5577:            [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
                   5578:            *) func_append deplibs " -L$dir" ;;
                   5579:          esac
                   5580:          func_append lib_search_path " $dir"
                   5581:          ;;
                   5582:        esac
                   5583:        case $host in
                   5584:        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
                   5585:          testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
                   5586:          case :$dllsearchpath: in
                   5587:          *":$dir:"*) ;;
                   5588:          ::) dllsearchpath=$dir;;
                   5589:          *) func_append dllsearchpath ":$dir";;
                   5590:          esac
                   5591:          case :$dllsearchpath: in
                   5592:          *":$testbindir:"*) ;;
                   5593:          ::) dllsearchpath=$testbindir;;
                   5594:          *) func_append dllsearchpath ":$testbindir";;
                   5595:          esac
                   5596:          ;;
                   5597:        esac
                   5598:        continue
                   5599:        ;;
                   5600: 
                   5601:       -l*)
                   5602:        if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
                   5603:          case $host in
                   5604:          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
                   5605:            # These systems don't actually have a C or math library (as such)
                   5606:            continue
                   5607:            ;;
                   5608:          *-*-os2*)
                   5609:            # These systems don't actually have a C library (as such)
                   5610:            test "X$arg" = "X-lc" && continue
                   5611:            ;;
                   5612:          *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
                   5613:            # Do not include libc due to us having libc/libc_r.
                   5614:            test "X$arg" = "X-lc" && continue
                   5615:            ;;
                   5616:          *-*-rhapsody* | *-*-darwin1.[012])
                   5617:            # Rhapsody C and math libraries are in the System framework
                   5618:            func_append deplibs " System.ltframework"
                   5619:            continue
                   5620:            ;;
                   5621:          *-*-sco3.2v5* | *-*-sco5v6*)
                   5622:            # Causes problems with __ctype
                   5623:            test "X$arg" = "X-lc" && continue
                   5624:            ;;
                   5625:          *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
                   5626:            # Compiler inserts libc in the correct place for threads to work
                   5627:            test "X$arg" = "X-lc" && continue
                   5628:            ;;
                   5629:          esac
                   5630:        elif test "X$arg" = "X-lc_r"; then
                   5631:         case $host in
                   5632:         *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
                   5633:           # Do not include libc_r directly, use -pthread flag.
                   5634:           continue
                   5635:           ;;
                   5636:         esac
                   5637:        fi
                   5638:        func_append deplibs " $arg"
                   5639:        continue
                   5640:        ;;
                   5641: 
                   5642:       -module)
                   5643:        module=yes
                   5644:        continue
                   5645:        ;;
                   5646: 
                   5647:       # Tru64 UNIX uses -model [arg] to determine the layout of C++
                   5648:       # classes, name mangling, and exception handling.
                   5649:       # Darwin uses the -arch flag to determine output architecture.
                   5650:       -model|-arch|-isysroot|--sysroot)
                   5651:        func_append compiler_flags " $arg"
                   5652:        func_append compile_command " $arg"
                   5653:        func_append finalize_command " $arg"
                   5654:        prev=xcompiler
                   5655:        continue
                   5656:        ;;
                   5657: 
                   5658:       -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
                   5659:       |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
                   5660:        func_append compiler_flags " $arg"
                   5661:        func_append compile_command " $arg"
                   5662:        func_append finalize_command " $arg"
                   5663:        case "$new_inherited_linker_flags " in
                   5664:            *" $arg "*) ;;
                   5665:            * ) func_append new_inherited_linker_flags " $arg" ;;
                   5666:        esac
                   5667:        continue
                   5668:        ;;
                   5669: 
                   5670:       -multi_module)
                   5671:        single_module="${wl}-multi_module"
                   5672:        continue
                   5673:        ;;
                   5674: 
                   5675:       -no-fast-install)
                   5676:        fast_install=no
                   5677:        continue
                   5678:        ;;
                   5679: 
                   5680:       -no-install)
                   5681:        case $host in
                   5682:        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
                   5683:          # The PATH hackery in wrapper scripts is required on Windows
                   5684:          # and Darwin in order for the loader to find any dlls it needs.
                   5685:          func_warning "\`-no-install' is ignored for $host"
                   5686:          func_warning "assuming \`-no-fast-install' instead"
                   5687:          fast_install=no
                   5688:          ;;
                   5689:        *) no_install=yes ;;
                   5690:        esac
                   5691:        continue
                   5692:        ;;
                   5693: 
                   5694:       -no-undefined)
                   5695:        allow_undefined=no
                   5696:        continue
                   5697:        ;;
                   5698: 
                   5699:       -objectlist)
                   5700:        prev=objectlist
                   5701:        continue
                   5702:        ;;
                   5703: 
                   5704:       -o) prev=output ;;
                   5705: 
                   5706:       -precious-files-regex)
                   5707:        prev=precious_regex
                   5708:        continue
                   5709:        ;;
                   5710: 
                   5711:       -release)
                   5712:        prev=release
                   5713:        continue
                   5714:        ;;
                   5715: 
                   5716:       -rpath)
                   5717:        prev=rpath
                   5718:        continue
                   5719:        ;;
                   5720: 
                   5721:       -R)
                   5722:        prev=xrpath
                   5723:        continue
                   5724:        ;;
                   5725: 
                   5726:       -R*)
                   5727:        func_stripname '-R' '' "$arg"
                   5728:        dir=$func_stripname_result
                   5729:        # We need an absolute path.
                   5730:        case $dir in
                   5731:        [\\/]* | [A-Za-z]:[\\/]*) ;;
                   5732:        =*)
                   5733:          func_stripname '=' '' "$dir"
                   5734:          dir=$lt_sysroot$func_stripname_result
                   5735:          ;;
                   5736:        *)
                   5737:          func_fatal_error "only absolute run-paths are allowed"
                   5738:          ;;
                   5739:        esac
                   5740:        case "$xrpath " in
                   5741:        *" $dir "*) ;;
                   5742:        *) func_append xrpath " $dir" ;;
                   5743:        esac
                   5744:        continue
                   5745:        ;;
                   5746: 
                   5747:       -shared)
                   5748:        # The effects of -shared are defined in a previous loop.
                   5749:        continue
                   5750:        ;;
                   5751: 
                   5752:       -shrext)
                   5753:        prev=shrext
                   5754:        continue
                   5755:        ;;
                   5756: 
                   5757:       -static | -static-libtool-libs)
                   5758:        # The effects of -static are defined in a previous loop.
                   5759:        # We used to do the same as -all-static on platforms that
                   5760:        # didn't have a PIC flag, but the assumption that the effects
                   5761:        # would be equivalent was wrong.  It would break on at least
                   5762:        # Digital Unix and AIX.
                   5763:        continue
                   5764:        ;;
                   5765: 
                   5766:       -thread-safe)
                   5767:        thread_safe=yes
                   5768:        continue
                   5769:        ;;
                   5770: 
                   5771:       -version-info)
                   5772:        prev=vinfo
                   5773:        continue
                   5774:        ;;
                   5775: 
                   5776:       -version-number)
                   5777:        prev=vinfo
                   5778:        vinfo_number=yes
                   5779:        continue
                   5780:        ;;
                   5781: 
                   5782:       -weak)
                   5783:         prev=weak
                   5784:        continue
                   5785:        ;;
                   5786: 
                   5787:       -Wc,*)
                   5788:        func_stripname '-Wc,' '' "$arg"
                   5789:        args=$func_stripname_result
                   5790:        arg=
                   5791:        save_ifs="$IFS"; IFS=','
                   5792:        for flag in $args; do
                   5793:          IFS="$save_ifs"
                   5794:           func_quote_for_eval "$flag"
                   5795:          func_append arg " $func_quote_for_eval_result"
                   5796:          func_append compiler_flags " $func_quote_for_eval_result"
                   5797:        done
                   5798:        IFS="$save_ifs"
                   5799:        func_stripname ' ' '' "$arg"
                   5800:        arg=$func_stripname_result
                   5801:        ;;
                   5802: 
                   5803:       -Wl,*)
                   5804:        func_stripname '-Wl,' '' "$arg"
                   5805:        args=$func_stripname_result
                   5806:        arg=
                   5807:        save_ifs="$IFS"; IFS=','
                   5808:        for flag in $args; do
                   5809:          IFS="$save_ifs"
                   5810:           func_quote_for_eval "$flag"
                   5811:          func_append arg " $wl$func_quote_for_eval_result"
                   5812:          func_append compiler_flags " $wl$func_quote_for_eval_result"
                   5813:          func_append linker_flags " $func_quote_for_eval_result"
                   5814:        done
                   5815:        IFS="$save_ifs"
                   5816:        func_stripname ' ' '' "$arg"
                   5817:        arg=$func_stripname_result
                   5818:        ;;
                   5819: 
                   5820:       -Xcompiler)
                   5821:        prev=xcompiler
                   5822:        continue
                   5823:        ;;
                   5824: 
                   5825:       -Xlinker)
                   5826:        prev=xlinker
                   5827:        continue
                   5828:        ;;
                   5829: 
                   5830:       -XCClinker)
                   5831:        prev=xcclinker
                   5832:        continue
                   5833:        ;;
                   5834: 
                   5835:       # -msg_* for osf cc
                   5836:       -msg_*)
                   5837:        func_quote_for_eval "$arg"
                   5838:        arg="$func_quote_for_eval_result"
                   5839:        ;;
                   5840: 
                   5841:       # Flags to be passed through unchanged, with rationale:
                   5842:       # -64, -mips[0-9]      enable 64-bit mode for the SGI compiler
                   5843:       # -r[0-9][0-9]*        specify processor for the SGI compiler
                   5844:       # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
                   5845:       # +DA*, +DD*           enable 64-bit mode for the HP compiler
                   5846:       # -q*                  compiler args for the IBM compiler
                   5847:       # -m*, -t[45]*, -txscale* architecture-specific flags for GCC
                   5848:       # -F/path              path to uninstalled frameworks, gcc on darwin
                   5849:       # -p, -pg, --coverage, -fprofile-*  profiling flags for GCC
                   5850:       # @file                GCC response files
                   5851:       # -tp=*                Portland pgcc target processor selection
                   5852:       # --sysroot=*          for sysroot support
                   5853:       # -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
                   5854:       -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
                   5855:       -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
                   5856:       -O*|-flto*|-fwhopr*|-fuse-linker-plugin)
                   5857:         func_quote_for_eval "$arg"
                   5858:        arg="$func_quote_for_eval_result"
                   5859:         func_append compile_command " $arg"
                   5860:         func_append finalize_command " $arg"
                   5861:         func_append compiler_flags " $arg"
                   5862:         continue
                   5863:         ;;
                   5864: 
                   5865:       # Some other compiler flag.
                   5866:       -* | +*)
                   5867:         func_quote_for_eval "$arg"
                   5868:        arg="$func_quote_for_eval_result"
                   5869:        ;;
                   5870: 
                   5871:       *.$objext)
                   5872:        # A standard object.
                   5873:        func_append objs " $arg"
                   5874:        ;;
                   5875: 
                   5876:       *.lo)
                   5877:        # A libtool-controlled object.
                   5878: 
                   5879:        # Check to see that this really is a libtool object.
                   5880:        if func_lalib_unsafe_p "$arg"; then
                   5881:          pic_object=
                   5882:          non_pic_object=
                   5883: 
                   5884:          # Read the .lo file
                   5885:          func_source "$arg"
                   5886: 
                   5887:          if test -z "$pic_object" ||
                   5888:             test -z "$non_pic_object" ||
                   5889:             test "$pic_object" = none &&
                   5890:             test "$non_pic_object" = none; then
                   5891:            func_fatal_error "cannot find name of object for \`$arg'"
                   5892:          fi
                   5893: 
                   5894:          # Extract subdirectory from the argument.
                   5895:          func_dirname "$arg" "/" ""
                   5896:          xdir="$func_dirname_result"
                   5897: 
                   5898:          if test "$pic_object" != none; then
                   5899:            # Prepend the subdirectory the object is found in.
                   5900:            pic_object="$xdir$pic_object"
                   5901: 
                   5902:            if test "$prev" = dlfiles; then
                   5903:              if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
                   5904:                func_append dlfiles " $pic_object"
                   5905:                prev=
                   5906:                continue
                   5907:              else
                   5908:                # If libtool objects are unsupported, then we need to preload.
                   5909:                prev=dlprefiles
                   5910:              fi
                   5911:            fi
                   5912: 
                   5913:            # CHECK ME:  I think I busted this.  -Ossama
                   5914:            if test "$prev" = dlprefiles; then
                   5915:              # Preload the old-style object.
                   5916:              func_append dlprefiles " $pic_object"
                   5917:              prev=
                   5918:            fi
                   5919: 
                   5920:            # A PIC object.
                   5921:            func_append libobjs " $pic_object"
                   5922:            arg="$pic_object"
                   5923:          fi
                   5924: 
                   5925:          # Non-PIC object.
                   5926:          if test "$non_pic_object" != none; then
                   5927:            # Prepend the subdirectory the object is found in.
                   5928:            non_pic_object="$xdir$non_pic_object"
                   5929: 
                   5930:            # A standard non-PIC object
                   5931:            func_append non_pic_objects " $non_pic_object"
                   5932:            if test -z "$pic_object" || test "$pic_object" = none ; then
                   5933:              arg="$non_pic_object"
                   5934:            fi
                   5935:          else
                   5936:            # If the PIC object exists, use it instead.
                   5937:            # $xdir was prepended to $pic_object above.
                   5938:            non_pic_object="$pic_object"
                   5939:            func_append non_pic_objects " $non_pic_object"
                   5940:          fi
                   5941:        else
                   5942:          # Only an error if not doing a dry-run.
                   5943:          if $opt_dry_run; then
                   5944:            # Extract subdirectory from the argument.
                   5945:            func_dirname "$arg" "/" ""
                   5946:            xdir="$func_dirname_result"
                   5947: 
                   5948:            func_lo2o "$arg"
                   5949:            pic_object=$xdir$objdir/$func_lo2o_result
                   5950:            non_pic_object=$xdir$func_lo2o_result
                   5951:            func_append libobjs " $pic_object"
                   5952:            func_append non_pic_objects " $non_pic_object"
                   5953:          else
                   5954:            func_fatal_error "\`$arg' is not a valid libtool object"
                   5955:          fi
                   5956:        fi
                   5957:        ;;
                   5958: 
                   5959:       *.$libext)
                   5960:        # An archive.
                   5961:        func_append deplibs " $arg"
                   5962:        func_append old_deplibs " $arg"
                   5963:        continue
                   5964:        ;;
                   5965: 
                   5966:       *.la)
                   5967:        # A libtool-controlled library.
                   5968: 
                   5969:        func_resolve_sysroot "$arg"
                   5970:        if test "$prev" = dlfiles; then
                   5971:          # This library was specified with -dlopen.
                   5972:          func_append dlfiles " $func_resolve_sysroot_result"
                   5973:          prev=
                   5974:        elif test "$prev" = dlprefiles; then
                   5975:          # The library was specified with -dlpreopen.
                   5976:          func_append dlprefiles " $func_resolve_sysroot_result"
                   5977:          prev=
                   5978:        else
                   5979:          func_append deplibs " $func_resolve_sysroot_result"
                   5980:        fi
                   5981:        continue
                   5982:        ;;
                   5983: 
                   5984:       # Some other compiler argument.
                   5985:       *)
                   5986:        # Unknown arguments in both finalize_command and compile_command need
                   5987:        # to be aesthetically quoted because they are evaled later.
                   5988:        func_quote_for_eval "$arg"
                   5989:        arg="$func_quote_for_eval_result"
                   5990:        ;;
                   5991:       esac # arg
                   5992: 
                   5993:       # Now actually substitute the argument into the commands.
                   5994:       if test -n "$arg"; then
                   5995:        func_append compile_command " $arg"
                   5996:        func_append finalize_command " $arg"
                   5997:       fi
                   5998:     done # argument parsing loop
                   5999: 
                   6000:     test -n "$prev" && \
                   6001:       func_fatal_help "the \`$prevarg' option requires an argument"
                   6002: 
                   6003:     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
                   6004:       eval arg=\"$export_dynamic_flag_spec\"
                   6005:       func_append compile_command " $arg"
                   6006:       func_append finalize_command " $arg"
                   6007:     fi
                   6008: 
                   6009:     oldlibs=
                   6010:     # calculate the name of the file, without its directory
                   6011:     func_basename "$output"
                   6012:     outputname="$func_basename_result"
                   6013:     libobjs_save="$libobjs"
                   6014: 
                   6015:     if test -n "$shlibpath_var"; then
                   6016:       # get the directories listed in $shlibpath_var
                   6017:       eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
                   6018:     else
                   6019:       shlib_search_path=
                   6020:     fi
                   6021:     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
                   6022:     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
                   6023: 
                   6024:     func_dirname "$output" "/" ""
                   6025:     output_objdir="$func_dirname_result$objdir"
                   6026:     func_to_tool_file "$output_objdir/"
                   6027:     tool_output_objdir=$func_to_tool_file_result
                   6028:     # Create the object directory.
                   6029:     func_mkdir_p "$output_objdir"
                   6030: 
                   6031:     # Determine the type of output
                   6032:     case $output in
                   6033:     "")
                   6034:       func_fatal_help "you must specify an output file"
                   6035:       ;;
                   6036:     *.$libext) linkmode=oldlib ;;
                   6037:     *.lo | *.$objext) linkmode=obj ;;
                   6038:     *.la) linkmode=lib ;;
                   6039:     *) linkmode=prog ;; # Anything else should be a program.
                   6040:     esac
                   6041: 
                   6042:     specialdeplibs=
                   6043: 
                   6044:     libs=
                   6045:     # Find all interdependent deplibs by searching for libraries
                   6046:     # that are linked more than once (e.g. -la -lb -la)
                   6047:     for deplib in $deplibs; do
                   6048:       if $opt_preserve_dup_deps ; then
                   6049:        case "$libs " in
                   6050:        *" $deplib "*) func_append specialdeplibs " $deplib" ;;
                   6051:        esac
                   6052:       fi
                   6053:       func_append libs " $deplib"
                   6054:     done
                   6055: 
                   6056:     if test "$linkmode" = lib; then
                   6057:       libs="$predeps $libs $compiler_lib_search_path $postdeps"
                   6058: 
                   6059:       # Compute libraries that are listed more than once in $predeps
                   6060:       # $postdeps and mark them as special (i.e., whose duplicates are
                   6061:       # not to be eliminated).
                   6062:       pre_post_deps=
                   6063:       if $opt_duplicate_compiler_generated_deps; then
                   6064:        for pre_post_dep in $predeps $postdeps; do
                   6065:          case "$pre_post_deps " in
                   6066:          *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
                   6067:          esac
                   6068:          func_append pre_post_deps " $pre_post_dep"
                   6069:        done
                   6070:       fi
                   6071:       pre_post_deps=
                   6072:     fi
                   6073: 
                   6074:     deplibs=
                   6075:     newdependency_libs=
                   6076:     newlib_search_path=
                   6077:     need_relink=no # whether we're linking any uninstalled libtool libraries
                   6078:     notinst_deplibs= # not-installed libtool libraries
                   6079:     notinst_path= # paths that contain not-installed libtool libraries
                   6080: 
                   6081:     case $linkmode in
                   6082:     lib)
                   6083:        passes="conv dlpreopen link"
                   6084:        for file in $dlfiles $dlprefiles; do
                   6085:          case $file in
                   6086:          *.la) ;;
                   6087:          *)
                   6088:            func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
                   6089:            ;;
                   6090:          esac
                   6091:        done
                   6092:        ;;
                   6093:     prog)
                   6094:        compile_deplibs=
                   6095:        finalize_deplibs=
                   6096:        alldeplibs=no
                   6097:        newdlfiles=
                   6098:        newdlprefiles=
                   6099:        passes="conv scan dlopen dlpreopen link"
                   6100:        ;;
                   6101:     *)  passes="conv"
                   6102:        ;;
                   6103:     esac
                   6104: 
                   6105:     for pass in $passes; do
                   6106:       # The preopen pass in lib mode reverses $deplibs; put it back here
                   6107:       # so that -L comes before libs that need it for instance...
                   6108:       if test "$linkmode,$pass" = "lib,link"; then
                   6109:        ## FIXME: Find the place where the list is rebuilt in the wrong
                   6110:        ##        order, and fix it there properly
                   6111:         tmp_deplibs=
                   6112:        for deplib in $deplibs; do
                   6113:          tmp_deplibs="$deplib $tmp_deplibs"
                   6114:        done
                   6115:        deplibs="$tmp_deplibs"
                   6116:       fi
                   6117: 
                   6118:       if test "$linkmode,$pass" = "lib,link" ||
                   6119:         test "$linkmode,$pass" = "prog,scan"; then
                   6120:        libs="$deplibs"
                   6121:        deplibs=
                   6122:       fi
                   6123:       if test "$linkmode" = prog; then
                   6124:        case $pass in
                   6125:        dlopen) libs="$dlfiles" ;;
                   6126:        dlpreopen) libs="$dlprefiles" ;;
                   6127:        link)
                   6128:          libs="$deplibs %DEPLIBS%"
                   6129:          test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
                   6130:          ;;
                   6131:        esac
                   6132:       fi
                   6133:       if test "$linkmode,$pass" = "lib,dlpreopen"; then
                   6134:        # Collect and forward deplibs of preopened libtool libs
                   6135:        for lib in $dlprefiles; do
                   6136:          # Ignore non-libtool-libs
                   6137:          dependency_libs=
                   6138:          func_resolve_sysroot "$lib"
                   6139:          case $lib in
                   6140:          *.la) func_source "$func_resolve_sysroot_result" ;;
                   6141:          esac
                   6142: 
                   6143:          # Collect preopened libtool deplibs, except any this library
                   6144:          # has declared as weak libs
                   6145:          for deplib in $dependency_libs; do
                   6146:            func_basename "$deplib"
                   6147:             deplib_base=$func_basename_result
                   6148:            case " $weak_libs " in
                   6149:            *" $deplib_base "*) ;;
                   6150:            *) func_append deplibs " $deplib" ;;
                   6151:            esac
                   6152:          done
                   6153:        done
                   6154:        libs="$dlprefiles"
                   6155:       fi
                   6156:       if test "$pass" = dlopen; then
                   6157:        # Collect dlpreopened libraries
                   6158:        save_deplibs="$deplibs"
                   6159:        deplibs=
                   6160:       fi
                   6161: 
                   6162:       for deplib in $libs; do
                   6163:        lib=
                   6164:        found=no
                   6165:        case $deplib in
                   6166:        -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
                   6167:         |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
                   6168:          if test "$linkmode,$pass" = "prog,link"; then
                   6169:            compile_deplibs="$deplib $compile_deplibs"
                   6170:            finalize_deplibs="$deplib $finalize_deplibs"
                   6171:          else
                   6172:            func_append compiler_flags " $deplib"
                   6173:            if test "$linkmode" = lib ; then
                   6174:                case "$new_inherited_linker_flags " in
                   6175:                    *" $deplib "*) ;;
                   6176:                    * ) func_append new_inherited_linker_flags " $deplib" ;;
                   6177:                esac
                   6178:            fi
                   6179:          fi
                   6180:          continue
                   6181:          ;;
                   6182:        -l*)
                   6183:          if test "$linkmode" != lib && test "$linkmode" != prog; then
                   6184:            func_warning "\`-l' is ignored for archives/objects"
                   6185:            continue
                   6186:          fi
                   6187:          func_stripname '-l' '' "$deplib"
                   6188:          name=$func_stripname_result
                   6189:          if test "$linkmode" = lib; then
                   6190:            searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
                   6191:          else
                   6192:            searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
                   6193:          fi
                   6194:          for searchdir in $searchdirs; do
                   6195:            for search_ext in .la $std_shrext .so .a; do
                   6196:              # Search the libtool library
                   6197:              lib="$searchdir/lib${name}${search_ext}"
                   6198:              if test -f "$lib"; then
                   6199:                if test "$search_ext" = ".la"; then
                   6200:                  found=yes
                   6201:                else
                   6202:                  found=no
                   6203:                fi
                   6204:                break 2
                   6205:              fi
                   6206:            done
                   6207:          done
                   6208:          if test "$found" != yes; then
                   6209:            # deplib doesn't seem to be a libtool library
                   6210:            if test "$linkmode,$pass" = "prog,link"; then
                   6211:              compile_deplibs="$deplib $compile_deplibs"
                   6212:              finalize_deplibs="$deplib $finalize_deplibs"
                   6213:            else
                   6214:              deplibs="$deplib $deplibs"
                   6215:              test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
                   6216:            fi
                   6217:            continue
                   6218:          else # deplib is a libtool library
                   6219:            # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
                   6220:            # We need to do some special things here, and not later.
                   6221:            if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
                   6222:              case " $predeps $postdeps " in
                   6223:              *" $deplib "*)
                   6224:                if func_lalib_p "$lib"; then
                   6225:                  library_names=
                   6226:                  old_library=
                   6227:                  func_source "$lib"
                   6228:                  for l in $old_library $library_names; do
                   6229:                    ll="$l"
                   6230:                  done
                   6231:                  if test "X$ll" = "X$old_library" ; then # only static version available
                   6232:                    found=no
                   6233:                    func_dirname "$lib" "" "."
                   6234:                    ladir="$func_dirname_result"
                   6235:                    lib=$ladir/$old_library
                   6236:                    if test "$linkmode,$pass" = "prog,link"; then
                   6237:                      compile_deplibs="$deplib $compile_deplibs"
                   6238:                      finalize_deplibs="$deplib $finalize_deplibs"
                   6239:                    else
                   6240:                      deplibs="$deplib $deplibs"
                   6241:                      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
                   6242:                    fi
                   6243:                    continue
                   6244:                  fi
                   6245:                fi
                   6246:                ;;
                   6247:              *) ;;
                   6248:              esac
                   6249:            fi
                   6250:          fi
                   6251:          ;; # -l
                   6252:        *.ltframework)
                   6253:          if test "$linkmode,$pass" = "prog,link"; then
                   6254:            compile_deplibs="$deplib $compile_deplibs"
                   6255:            finalize_deplibs="$deplib $finalize_deplibs"
                   6256:          else
                   6257:            deplibs="$deplib $deplibs"
                   6258:            if test "$linkmode" = lib ; then
                   6259:                case "$new_inherited_linker_flags " in
                   6260:                    *" $deplib "*) ;;
                   6261:                    * ) func_append new_inherited_linker_flags " $deplib" ;;
                   6262:                esac
                   6263:            fi
                   6264:          fi
                   6265:          continue
                   6266:          ;;
                   6267:        -L*)
                   6268:          case $linkmode in
                   6269:          lib)
                   6270:            deplibs="$deplib $deplibs"
                   6271:            test "$pass" = conv && continue
                   6272:            newdependency_libs="$deplib $newdependency_libs"
                   6273:            func_stripname '-L' '' "$deplib"
                   6274:            func_resolve_sysroot "$func_stripname_result"
                   6275:            func_append newlib_search_path " $func_resolve_sysroot_result"
                   6276:            ;;
                   6277:          prog)
                   6278:            if test "$pass" = conv; then
                   6279:              deplibs="$deplib $deplibs"
                   6280:              continue
                   6281:            fi
                   6282:            if test "$pass" = scan; then
                   6283:              deplibs="$deplib $deplibs"
                   6284:            else
                   6285:              compile_deplibs="$deplib $compile_deplibs"
                   6286:              finalize_deplibs="$deplib $finalize_deplibs"
                   6287:            fi
                   6288:            func_stripname '-L' '' "$deplib"
                   6289:            func_resolve_sysroot "$func_stripname_result"
                   6290:            func_append newlib_search_path " $func_resolve_sysroot_result"
                   6291:            ;;
                   6292:          *)
                   6293:            func_warning "\`-L' is ignored for archives/objects"
                   6294:            ;;
                   6295:          esac # linkmode
                   6296:          continue
                   6297:          ;; # -L
                   6298:        -R*)
                   6299:          if test "$pass" = link; then
                   6300:            func_stripname '-R' '' "$deplib"
                   6301:            func_resolve_sysroot "$func_stripname_result"
                   6302:            dir=$func_resolve_sysroot_result
                   6303:            # Make sure the xrpath contains only unique directories.
                   6304:            case "$xrpath " in
                   6305:            *" $dir "*) ;;
                   6306:            *) func_append xrpath " $dir" ;;
                   6307:            esac
                   6308:          fi
                   6309:          deplibs="$deplib $deplibs"
                   6310:          continue
                   6311:          ;;
                   6312:        *.la)
                   6313:          func_resolve_sysroot "$deplib"
                   6314:          lib=$func_resolve_sysroot_result
                   6315:          ;;
                   6316:        *.$libext)
                   6317:          if test "$pass" = conv; then
                   6318:            deplibs="$deplib $deplibs"
                   6319:            continue
                   6320:          fi
                   6321:          case $linkmode in
                   6322:          lib)
                   6323:            # Linking convenience modules into shared libraries is allowed,
                   6324:            # but linking other static libraries is non-portable.
                   6325:            case " $dlpreconveniencelibs " in
                   6326:            *" $deplib "*) ;;
                   6327:            *)
                   6328:              valid_a_lib=no
                   6329:              case $deplibs_check_method in
                   6330:                match_pattern*)
                   6331:                  set dummy $deplibs_check_method; shift
                   6332:                  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
                   6333:                  if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
                   6334:                    | $EGREP "$match_pattern_regex" > /dev/null; then
                   6335:                    valid_a_lib=yes
                   6336:                  fi
                   6337:                ;;
                   6338:                pass_all)
                   6339:                  valid_a_lib=yes
                   6340:                ;;
                   6341:              esac
                   6342:              if test "$valid_a_lib" != yes; then
                   6343:                echo
                   6344:                $ECHO "*** Warning: Trying to link with static lib archive $deplib."
                   6345:                echo "*** I have the capability to make that library automatically link in when"
                   6346:                echo "*** you link to this library.  But I can only do this if you have a"
                   6347:                echo "*** shared version of the library, which you do not appear to have"
                   6348:                echo "*** because the file extensions .$libext of this argument makes me believe"
                   6349:                echo "*** that it is just a static archive that I should not use here."
                   6350:              else
                   6351:                echo
                   6352:                $ECHO "*** Warning: Linking the shared library $output against the"
                   6353:                $ECHO "*** static library $deplib is not portable!"
                   6354:                deplibs="$deplib $deplibs"
                   6355:              fi
                   6356:              ;;
                   6357:            esac
                   6358:            continue
                   6359:            ;;
                   6360:          prog)
                   6361:            if test "$pass" != link; then
                   6362:              deplibs="$deplib $deplibs"
                   6363:            else
                   6364:              compile_deplibs="$deplib $compile_deplibs"
                   6365:              finalize_deplibs="$deplib $finalize_deplibs"
                   6366:            fi
                   6367:            continue
                   6368:            ;;
                   6369:          esac # linkmode
                   6370:          ;; # *.$libext
                   6371:        *.lo | *.$objext)
                   6372:          if test "$pass" = conv; then
                   6373:            deplibs="$deplib $deplibs"
                   6374:          elif test "$linkmode" = prog; then
                   6375:            if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
                   6376:              # If there is no dlopen support or we're linking statically,
                   6377:              # we need to preload.
                   6378:              func_append newdlprefiles " $deplib"
                   6379:              compile_deplibs="$deplib $compile_deplibs"
                   6380:              finalize_deplibs="$deplib $finalize_deplibs"
                   6381:            else
                   6382:              func_append newdlfiles " $deplib"
                   6383:            fi
                   6384:          fi
                   6385:          continue
                   6386:          ;;
                   6387:        %DEPLIBS%)
                   6388:          alldeplibs=yes
                   6389:          continue
                   6390:          ;;
                   6391:        esac # case $deplib
                   6392: 
                   6393:        if test "$found" = yes || test -f "$lib"; then :
                   6394:        else
                   6395:          func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
                   6396:        fi
                   6397: 
                   6398:        # Check to see that this really is a libtool archive.
                   6399:        func_lalib_unsafe_p "$lib" \
                   6400:          || func_fatal_error "\`$lib' is not a valid libtool archive"
                   6401: 
                   6402:        func_dirname "$lib" "" "."
                   6403:        ladir="$func_dirname_result"
                   6404: 
                   6405:        dlname=
                   6406:        dlopen=
                   6407:        dlpreopen=
                   6408:        libdir=
                   6409:        library_names=
                   6410:        old_library=
                   6411:        inherited_linker_flags=
                   6412:        # If the library was installed with an old release of libtool,
                   6413:        # it will not redefine variables installed, or shouldnotlink
                   6414:        installed=yes
                   6415:        shouldnotlink=no
                   6416:        avoidtemprpath=
                   6417: 
                   6418: 
                   6419:        # Read the .la file
                   6420:        func_source "$lib"
                   6421: 
                   6422:        # Convert "-framework foo" to "foo.ltframework"
                   6423:        if test -n "$inherited_linker_flags"; then
                   6424:          tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
                   6425:          for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
                   6426:            case " $new_inherited_linker_flags " in
                   6427:              *" $tmp_inherited_linker_flag "*) ;;
                   6428:              *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
                   6429:            esac
                   6430:          done
                   6431:        fi
                   6432:        dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
                   6433:        if test "$linkmode,$pass" = "lib,link" ||
                   6434:           test "$linkmode,$pass" = "prog,scan" ||
                   6435:           { test "$linkmode" != prog && test "$linkmode" != lib; }; then
                   6436:          test -n "$dlopen" && func_append dlfiles " $dlopen"
                   6437:          test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
                   6438:        fi
                   6439: 
                   6440:        if test "$pass" = conv; then
                   6441:          # Only check for convenience libraries
                   6442:          deplibs="$lib $deplibs"
                   6443:          if test -z "$libdir"; then
                   6444:            if test -z "$old_library"; then
                   6445:              func_fatal_error "cannot find name of link library for \`$lib'"
                   6446:            fi
                   6447:            # It is a libtool convenience library, so add in its objects.
                   6448:            func_append convenience " $ladir/$objdir/$old_library"
                   6449:            func_append old_convenience " $ladir/$objdir/$old_library"
                   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:          elif test "$linkmode" != prog && test "$linkmode" != lib; then
                   6461:            func_fatal_error "\`$lib' is not a convenience library"
                   6462:          fi
                   6463:          continue
                   6464:        fi # $pass = conv
                   6465: 
                   6466: 
                   6467:        # Get the name of the library we link against.
                   6468:        linklib=
                   6469:        if test -n "$old_library" &&
                   6470:           { test "$prefer_static_libs" = yes ||
                   6471:             test "$prefer_static_libs,$installed" = "built,no"; }; then
                   6472:          linklib=$old_library
                   6473:        else
                   6474:          for l in $old_library $library_names; do
                   6475:            linklib="$l"
                   6476:          done
                   6477:        fi
                   6478:        if test -z "$linklib"; then
                   6479:          func_fatal_error "cannot find name of link library for \`$lib'"
                   6480:        fi
                   6481: 
                   6482:        # This library was specified with -dlopen.
                   6483:        if test "$pass" = dlopen; then
                   6484:          if test -z "$libdir"; then
                   6485:            func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
                   6486:          fi
                   6487:          if test -z "$dlname" ||
                   6488:             test "$dlopen_support" != yes ||
                   6489:             test "$build_libtool_libs" = no; then
                   6490:            # If there is no dlname, no dlopen support or we're linking
                   6491:            # statically, we need to preload.  We also need to preload any
                   6492:            # dependent libraries so libltdl's deplib preloader doesn't
                   6493:            # bomb out in the load deplibs phase.
                   6494:            func_append dlprefiles " $lib $dependency_libs"
                   6495:          else
                   6496:            func_append newdlfiles " $lib"
                   6497:          fi
                   6498:          continue
                   6499:        fi # $pass = dlopen
                   6500: 
                   6501:        # We need an absolute path.
                   6502:        case $ladir in
                   6503:        [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
                   6504:        *)
                   6505:          abs_ladir=`cd "$ladir" && pwd`
                   6506:          if test -z "$abs_ladir"; then
                   6507:            func_warning "cannot determine absolute directory name of \`$ladir'"
                   6508:            func_warning "passing it literally to the linker, although it might fail"
                   6509:            abs_ladir="$ladir"
                   6510:          fi
                   6511:          ;;
                   6512:        esac
                   6513:        func_basename "$lib"
                   6514:        laname="$func_basename_result"
                   6515: 
                   6516:        # Find the relevant object directory and library name.
                   6517:        if test "X$installed" = Xyes; then
                   6518:          if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
                   6519:            func_warning "library \`$lib' was moved."
                   6520:            dir="$ladir"
                   6521:            absdir="$abs_ladir"
                   6522:            libdir="$abs_ladir"
                   6523:          else
                   6524:            dir="$lt_sysroot$libdir"
                   6525:            absdir="$lt_sysroot$libdir"
                   6526:          fi
                   6527:          test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
                   6528:        else
                   6529:          if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
                   6530:            dir="$ladir"
                   6531:            absdir="$abs_ladir"
                   6532:            # Remove this search path later
                   6533:            func_append notinst_path " $abs_ladir"
                   6534:          else
                   6535:            dir="$ladir/$objdir"
                   6536:            absdir="$abs_ladir/$objdir"
                   6537:            # Remove this search path later
                   6538:            func_append notinst_path " $abs_ladir"
                   6539:          fi
                   6540:        fi # $installed = yes
                   6541:        func_stripname 'lib' '.la' "$laname"
                   6542:        name=$func_stripname_result
                   6543: 
                   6544:        # This library was specified with -dlpreopen.
                   6545:        if test "$pass" = dlpreopen; then
                   6546:          if test -z "$libdir" && test "$linkmode" = prog; then
                   6547:            func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
                   6548:          fi
                   6549:          case "$host" in
                   6550:            # special handling for platforms with PE-DLLs.
                   6551:            *cygwin* | *mingw* | *cegcc* )
                   6552:              # Linker will automatically link against shared library if both
                   6553:              # static and shared are present.  Therefore, ensure we extract
                   6554:              # symbols from the import library if a shared library is present
                   6555:              # (otherwise, the dlopen module name will be incorrect).  We do
                   6556:              # this by putting the import library name into $newdlprefiles.
                   6557:              # We recover the dlopen module name by 'saving' the la file
                   6558:              # name in a special purpose variable, and (later) extracting the
                   6559:              # dlname from the la file.
                   6560:              if test -n "$dlname"; then
                   6561:                func_tr_sh "$dir/$linklib"
                   6562:                eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
                   6563:                func_append newdlprefiles " $dir/$linklib"
                   6564:              else
                   6565:                func_append newdlprefiles " $dir/$old_library"
                   6566:                # Keep a list of preopened convenience libraries to check
                   6567:                # that they are being used correctly in the link pass.
                   6568:                test -z "$libdir" && \
                   6569:                  func_append dlpreconveniencelibs " $dir/$old_library"
                   6570:              fi
                   6571:            ;;
                   6572:            * )
                   6573:              # Prefer using a static library (so that no silly _DYNAMIC symbols
                   6574:              # are required to link).
                   6575:              if test -n "$old_library"; then
                   6576:                func_append newdlprefiles " $dir/$old_library"
                   6577:                # Keep a list of preopened convenience libraries to check
                   6578:                # that they are being used correctly in the link pass.
                   6579:                test -z "$libdir" && \
                   6580:                  func_append dlpreconveniencelibs " $dir/$old_library"
                   6581:              # Otherwise, use the dlname, so that lt_dlopen finds it.
                   6582:              elif test -n "$dlname"; then
                   6583:                func_append newdlprefiles " $dir/$dlname"
                   6584:              else
                   6585:                func_append newdlprefiles " $dir/$linklib"
                   6586:              fi
                   6587:            ;;
                   6588:          esac
                   6589:        fi # $pass = dlpreopen
                   6590: 
                   6591:        if test -z "$libdir"; then
                   6592:          # Link the convenience library
                   6593:          if test "$linkmode" = lib; then
                   6594:            deplibs="$dir/$old_library $deplibs"
                   6595:          elif test "$linkmode,$pass" = "prog,link"; then
                   6596:            compile_deplibs="$dir/$old_library $compile_deplibs"
                   6597:            finalize_deplibs="$dir/$old_library $finalize_deplibs"
                   6598:          else
                   6599:            deplibs="$lib $deplibs" # used for prog,scan pass
                   6600:          fi
                   6601:          continue
                   6602:        fi
                   6603: 
                   6604: 
                   6605:        if test "$linkmode" = prog && test "$pass" != link; then
                   6606:          func_append newlib_search_path " $ladir"
                   6607:          deplibs="$lib $deplibs"
                   6608: 
                   6609:          linkalldeplibs=no
                   6610:          if test "$link_all_deplibs" != no || test -z "$library_names" ||
                   6611:             test "$build_libtool_libs" = no; then
                   6612:            linkalldeplibs=yes
                   6613:          fi
                   6614: 
                   6615:          tmp_libs=
                   6616:          for deplib in $dependency_libs; do
                   6617:            case $deplib in
                   6618:            -L*) func_stripname '-L' '' "$deplib"
                   6619:                 func_resolve_sysroot "$func_stripname_result"
                   6620:                 func_append newlib_search_path " $func_resolve_sysroot_result"
                   6621:                 ;;
                   6622:            esac
                   6623:            # Need to link against all dependency_libs?
                   6624:            if test "$linkalldeplibs" = yes; then
                   6625:              deplibs="$deplib $deplibs"
                   6626:            else
                   6627:              # Need to hardcode shared library paths
                   6628:              # or/and link against static libraries
                   6629:              newdependency_libs="$deplib $newdependency_libs"
                   6630:            fi
                   6631:            if $opt_preserve_dup_deps ; then
                   6632:              case "$tmp_libs " in
                   6633:              *" $deplib "*) func_append specialdeplibs " $deplib" ;;
                   6634:              esac
                   6635:            fi
                   6636:            func_append tmp_libs " $deplib"
                   6637:          done # for deplib
                   6638:          continue
                   6639:        fi # $linkmode = prog...
                   6640: 
                   6641:        if test "$linkmode,$pass" = "prog,link"; then
                   6642:          if test -n "$library_names" &&
                   6643:             { { test "$prefer_static_libs" = no ||
                   6644:                 test "$prefer_static_libs,$installed" = "built,yes"; } ||
                   6645:               test -z "$old_library"; }; then
                   6646:            # We need to hardcode the library path
                   6647:            if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
                   6648:              # Make sure the rpath contains only unique directories.
                   6649:              case "$temp_rpath:" in
                   6650:              *"$absdir:"*) ;;
                   6651:              *) func_append temp_rpath "$absdir:" ;;
                   6652:              esac
                   6653:            fi
                   6654: 
                   6655:            # Hardcode the library path.
                   6656:            # Skip directories that are in the system default run-time
                   6657:            # search path.
                   6658:            case " $sys_lib_dlsearch_path " in
                   6659:            *" $absdir "*) ;;
                   6660:            *)
                   6661:              case "$compile_rpath " in
                   6662:              *" $absdir "*) ;;
                   6663:              *) func_append compile_rpath " $absdir" ;;
                   6664:              esac
                   6665:              ;;
                   6666:            esac
                   6667:            case " $sys_lib_dlsearch_path " in
                   6668:            *" $libdir "*) ;;
                   6669:            *)
                   6670:              case "$finalize_rpath " in
                   6671:              *" $libdir "*) ;;
                   6672:              *) func_append finalize_rpath " $libdir" ;;
                   6673:              esac
                   6674:              ;;
                   6675:            esac
                   6676:          fi # $linkmode,$pass = prog,link...
                   6677: 
                   6678:          if test "$alldeplibs" = yes &&
                   6679:             { test "$deplibs_check_method" = pass_all ||
                   6680:               { test "$build_libtool_libs" = yes &&
                   6681:                 test -n "$library_names"; }; }; then
                   6682:            # We only need to search for static libraries
                   6683:            continue
                   6684:          fi
                   6685:        fi
                   6686: 
                   6687:        link_static=no # Whether the deplib will be linked statically
                   6688:        use_static_libs=$prefer_static_libs
                   6689:        if test "$use_static_libs" = built && test "$installed" = yes; then
                   6690:          use_static_libs=no
                   6691:        fi
                   6692:        if test -n "$library_names" &&
                   6693:           { test "$use_static_libs" = no || test -z "$old_library"; }; then
                   6694:          case $host in
                   6695:          *cygwin* | *mingw* | *cegcc*)
                   6696:              # No point in relinking DLLs because paths are not encoded
                   6697:              func_append notinst_deplibs " $lib"
                   6698:              need_relink=no
                   6699:            ;;
                   6700:          *)
                   6701:            if test "$installed" = no; then
                   6702:              func_append notinst_deplibs " $lib"
                   6703:              need_relink=yes
                   6704:            fi
                   6705:            ;;
                   6706:          esac
                   6707:          # This is a shared library
                   6708: 
                   6709:          # Warn about portability, can't link against -module's on some
                   6710:          # systems (darwin).  Don't bleat about dlopened modules though!
                   6711:          dlopenmodule=""
                   6712:          for dlpremoduletest in $dlprefiles; do
                   6713:            if test "X$dlpremoduletest" = "X$lib"; then
                   6714:              dlopenmodule="$dlpremoduletest"
                   6715:              break
                   6716:            fi
                   6717:          done
                   6718:          if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
                   6719:            echo
                   6720:            if test "$linkmode" = prog; then
                   6721:              $ECHO "*** Warning: Linking the executable $output against the loadable module"
                   6722:            else
                   6723:              $ECHO "*** Warning: Linking the shared library $output against the loadable module"
                   6724:            fi
                   6725:            $ECHO "*** $linklib is not portable!"
                   6726:          fi
                   6727:          if test "$linkmode" = lib &&
                   6728:             test "$hardcode_into_libs" = yes; then
                   6729:            # Hardcode the library path.
                   6730:            # Skip directories that are in the system default run-time
                   6731:            # search path.
                   6732:            case " $sys_lib_dlsearch_path " in
                   6733:            *" $absdir "*) ;;
                   6734:            *)
                   6735:              case "$compile_rpath " in
                   6736:              *" $absdir "*) ;;
                   6737:              *) func_append compile_rpath " $absdir" ;;
                   6738:              esac
                   6739:              ;;
                   6740:            esac
                   6741:            case " $sys_lib_dlsearch_path " in
                   6742:            *" $libdir "*) ;;
                   6743:            *)
                   6744:              case "$finalize_rpath " in
                   6745:              *" $libdir "*) ;;
                   6746:              *) func_append finalize_rpath " $libdir" ;;
                   6747:              esac
                   6748:              ;;
                   6749:            esac
                   6750:          fi
                   6751: 
                   6752:          if test -n "$old_archive_from_expsyms_cmds"; then
                   6753:            # figure out the soname
                   6754:            set dummy $library_names
                   6755:            shift
                   6756:            realname="$1"
                   6757:            shift
                   6758:            libname=`eval "\\$ECHO \"$libname_spec\""`
                   6759:            # use dlname if we got it. it's perfectly good, no?
                   6760:            if test -n "$dlname"; then
                   6761:              soname="$dlname"
                   6762:            elif test -n "$soname_spec"; then
                   6763:              # bleh windows
                   6764:              case $host in
                   6765:              *cygwin* | mingw* | *cegcc*)
                   6766:                func_arith $current - $age
                   6767:                major=$func_arith_result
                   6768:                versuffix="-$major"
                   6769:                ;;
                   6770:              esac
                   6771:              eval soname=\"$soname_spec\"
                   6772:            else
                   6773:              soname="$realname"
                   6774:            fi
                   6775: 
                   6776:            # Make a new name for the extract_expsyms_cmds to use
                   6777:            soroot="$soname"
                   6778:            func_basename "$soroot"
                   6779:            soname="$func_basename_result"
                   6780:            func_stripname 'lib' '.dll' "$soname"
                   6781:            newlib=libimp-$func_stripname_result.a
                   6782: 
                   6783:            # If the library has no export list, then create one now
                   6784:            if test -f "$output_objdir/$soname-def"; then :
                   6785:            else
                   6786:              func_verbose "extracting exported symbol list from \`$soname'"
                   6787:              func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
                   6788:            fi
                   6789: 
                   6790:            # Create $newlib
                   6791:            if test -f "$output_objdir/$newlib"; then :; else
                   6792:              func_verbose "generating import library for \`$soname'"
                   6793:              func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
                   6794:            fi
                   6795:            # make sure the library variables are pointing to the new library
                   6796:            dir=$output_objdir
                   6797:            linklib=$newlib
                   6798:          fi # test -n "$old_archive_from_expsyms_cmds"
                   6799: 
                   6800:          if test "$linkmode" = prog || test "$opt_mode" != relink; then
                   6801:            add_shlibpath=
                   6802:            add_dir=
                   6803:            add=
                   6804:            lib_linked=yes
                   6805:            case $hardcode_action in
                   6806:            immediate | unsupported)
                   6807:              if test "$hardcode_direct" = no; then
                   6808:                add="$dir/$linklib"
                   6809:                case $host in
                   6810:                  *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
                   6811:                  *-*-sysv4*uw2*) add_dir="-L$dir" ;;
                   6812:                  *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
                   6813:                    *-*-unixware7*) add_dir="-L$dir" ;;
                   6814:                  *-*-darwin* )
                   6815:                    # if the lib is a (non-dlopened) module then we can not
                   6816:                    # link against it, someone is ignoring the earlier warnings
                   6817:                    if /usr/bin/file -L $add 2> /dev/null |
                   6818:                         $GREP ": [^:]* bundle" >/dev/null ; then
                   6819:                      if test "X$dlopenmodule" != "X$lib"; then
                   6820:                        $ECHO "*** Warning: lib $linklib is a module, not a shared library"
                   6821:                        if test -z "$old_library" ; then
                   6822:                          echo
                   6823:                          echo "*** And there doesn't seem to be a static archive available"
                   6824:                          echo "*** The link will probably fail, sorry"
                   6825:                        else
                   6826:                          add="$dir/$old_library"
                   6827:                        fi
                   6828:                      elif test -n "$old_library"; then
                   6829:                        add="$dir/$old_library"
                   6830:                      fi
                   6831:                    fi
                   6832:                esac
                   6833:              elif test "$hardcode_minus_L" = no; then
                   6834:                case $host in
                   6835:                *-*-sunos*) add_shlibpath="$dir" ;;
                   6836:                esac
                   6837:                add_dir="-L$dir"
                   6838:                add="-l$name"
                   6839:              elif test "$hardcode_shlibpath_var" = no; then
                   6840:                add_shlibpath="$dir"
                   6841:                add="-l$name"
                   6842:              else
                   6843:                lib_linked=no
                   6844:              fi
                   6845:              ;;
                   6846:            relink)
                   6847:              if test "$hardcode_direct" = yes &&
                   6848:                 test "$hardcode_direct_absolute" = no; then
                   6849:                add="$dir/$linklib"
                   6850:              elif test "$hardcode_minus_L" = yes; then
                   6851:                add_dir="-L$absdir"
                   6852:                # Try looking first in the location we're being installed to.
                   6853:                if test -n "$inst_prefix_dir"; then
                   6854:                  case $libdir in
                   6855:                    [\\/]*)
                   6856:                      func_append add_dir " -L$inst_prefix_dir$libdir"
                   6857:                      ;;
                   6858:                  esac
                   6859:                fi
                   6860:                add="-l$name"
                   6861:              elif test "$hardcode_shlibpath_var" = yes; then
                   6862:                add_shlibpath="$dir"
                   6863:                add="-l$name"
                   6864:              else
                   6865:                lib_linked=no
                   6866:              fi
                   6867:              ;;
                   6868:            *) lib_linked=no ;;
                   6869:            esac
                   6870: 
                   6871:            if test "$lib_linked" != yes; then
                   6872:              func_fatal_configuration "unsupported hardcode properties"
                   6873:            fi
                   6874: 
                   6875:            if test -n "$add_shlibpath"; then
                   6876:              case :$compile_shlibpath: in
                   6877:              *":$add_shlibpath:"*) ;;
                   6878:              *) func_append compile_shlibpath "$add_shlibpath:" ;;
                   6879:              esac
                   6880:            fi
                   6881:            if test "$linkmode" = prog; then
                   6882:              test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
                   6883:              test -n "$add" && compile_deplibs="$add $compile_deplibs"
                   6884:            else
                   6885:              test -n "$add_dir" && deplibs="$add_dir $deplibs"
                   6886:              test -n "$add" && deplibs="$add $deplibs"
                   6887:              if test "$hardcode_direct" != yes &&
                   6888:                 test "$hardcode_minus_L" != yes &&
                   6889:                 test "$hardcode_shlibpath_var" = yes; then
                   6890:                case :$finalize_shlibpath: in
                   6891:                *":$libdir:"*) ;;
                   6892:                *) func_append finalize_shlibpath "$libdir:" ;;
                   6893:                esac
                   6894:              fi
                   6895:            fi
                   6896:          fi
                   6897: 
                   6898:          if test "$linkmode" = prog || test "$opt_mode" = relink; then
                   6899:            add_shlibpath=
                   6900:            add_dir=
                   6901:            add=
                   6902:            # Finalize command for both is simple: just hardcode it.
                   6903:            if test "$hardcode_direct" = yes &&
                   6904:               test "$hardcode_direct_absolute" = no; then
                   6905:              add="$libdir/$linklib"
                   6906:            elif test "$hardcode_minus_L" = yes; then
                   6907:              add_dir="-L$libdir"
                   6908:              add="-l$name"
                   6909:            elif test "$hardcode_shlibpath_var" = yes; then
                   6910:              case :$finalize_shlibpath: in
                   6911:              *":$libdir:"*) ;;
                   6912:              *) func_append finalize_shlibpath "$libdir:" ;;
                   6913:              esac
                   6914:              add="-l$name"
                   6915:            elif test "$hardcode_automatic" = yes; then
                   6916:              if test -n "$inst_prefix_dir" &&
                   6917:                 test -f "$inst_prefix_dir$libdir/$linklib" ; then
                   6918:                add="$inst_prefix_dir$libdir/$linklib"
                   6919:              else
                   6920:                add="$libdir/$linklib"
                   6921:              fi
                   6922:            else
                   6923:              # We cannot seem to hardcode it, guess we'll fake it.
                   6924:              add_dir="-L$libdir"
                   6925:              # Try looking first in the location we're being installed to.
                   6926:              if test -n "$inst_prefix_dir"; then
                   6927:                case $libdir in
                   6928:                  [\\/]*)
                   6929:                    func_append add_dir " -L$inst_prefix_dir$libdir"
                   6930:                    ;;
                   6931:                esac
                   6932:              fi
                   6933:              add="-l$name"
                   6934:            fi
                   6935: 
                   6936:            if test "$linkmode" = prog; then
                   6937:              test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
                   6938:              test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
                   6939:            else
                   6940:              test -n "$add_dir" && deplibs="$add_dir $deplibs"
                   6941:              test -n "$add" && deplibs="$add $deplibs"
                   6942:            fi
                   6943:          fi
                   6944:        elif test "$linkmode" = prog; then
                   6945:          # Here we assume that one of hardcode_direct or hardcode_minus_L
                   6946:          # is not unsupported.  This is valid on all known static and
                   6947:          # shared platforms.
                   6948:          if test "$hardcode_direct" != unsupported; then
                   6949:            test -n "$old_library" && linklib="$old_library"
                   6950:            compile_deplibs="$dir/$linklib $compile_deplibs"
                   6951:            finalize_deplibs="$dir/$linklib $finalize_deplibs"
                   6952:          else
                   6953:            compile_deplibs="-l$name -L$dir $compile_deplibs"
                   6954:            finalize_deplibs="-l$name -L$dir $finalize_deplibs"
                   6955:          fi
                   6956:        elif test "$build_libtool_libs" = yes; then
                   6957:          # Not a shared library
                   6958:          if test "$deplibs_check_method" != pass_all; then
                   6959:            # We're trying link a shared library against a static one
                   6960:            # but the system doesn't support it.
                   6961: 
                   6962:            # Just print a warning and add the library to dependency_libs so
                   6963:            # that the program can be linked against the static library.
                   6964:            echo
                   6965:            $ECHO "*** Warning: This system can not link to static lib archive $lib."
                   6966:            echo "*** I have the capability to make that library automatically link in when"
                   6967:            echo "*** you link to this library.  But I can only do this if you have a"
                   6968:            echo "*** shared version of the library, which you do not appear to have."
                   6969:            if test "$module" = yes; then
                   6970:              echo "*** But as you try to build a module library, libtool will still create "
                   6971:              echo "*** a static module, that should work as long as the dlopening application"
                   6972:              echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
                   6973:              if test -z "$global_symbol_pipe"; then
                   6974:                echo
                   6975:                echo "*** However, this would only work if libtool was able to extract symbol"
                   6976:                echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
                   6977:                echo "*** not find such a program.  So, this module is probably useless."
                   6978:                echo "*** \`nm' from GNU binutils and a full rebuild may help."
                   6979:              fi
                   6980:              if test "$build_old_libs" = no; then
                   6981:                build_libtool_libs=module
                   6982:                build_old_libs=yes
                   6983:              else
                   6984:                build_libtool_libs=no
                   6985:              fi
                   6986:            fi
                   6987:          else
                   6988:            deplibs="$dir/$old_library $deplibs"
                   6989:            link_static=yes
                   6990:          fi
                   6991:        fi # link shared/static library?
                   6992: 
                   6993:        if test "$linkmode" = lib; then
                   6994:          if test -n "$dependency_libs" &&
                   6995:             { test "$hardcode_into_libs" != yes ||
                   6996:               test "$build_old_libs" = yes ||
                   6997:               test "$link_static" = yes; }; then
                   6998:            # Extract -R from dependency_libs
                   6999:            temp_deplibs=
                   7000:            for libdir in $dependency_libs; do
                   7001:              case $libdir in
                   7002:              -R*) func_stripname '-R' '' "$libdir"
                   7003:                   temp_xrpath=$func_stripname_result
                   7004:                   case " $xrpath " in
                   7005:                   *" $temp_xrpath "*) ;;
                   7006:                   *) func_append xrpath " $temp_xrpath";;
                   7007:                   esac;;
                   7008:              *) func_append temp_deplibs " $libdir";;
                   7009:              esac
                   7010:            done
                   7011:            dependency_libs="$temp_deplibs"
                   7012:          fi
                   7013: 
                   7014:          func_append newlib_search_path " $absdir"
                   7015:          # Link against this library
                   7016:          test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
                   7017:          # ... and its dependency_libs
                   7018:          tmp_libs=
                   7019:          for deplib in $dependency_libs; do
                   7020:            newdependency_libs="$deplib $newdependency_libs"
                   7021:            case $deplib in
                   7022:               -L*) func_stripname '-L' '' "$deplib"
                   7023:                    func_resolve_sysroot "$func_stripname_result";;
                   7024:               *) func_resolve_sysroot "$deplib" ;;
                   7025:             esac
                   7026:            if $opt_preserve_dup_deps ; then
                   7027:              case "$tmp_libs " in
                   7028:              *" $func_resolve_sysroot_result "*)
                   7029:                 func_append specialdeplibs " $func_resolve_sysroot_result" ;;
                   7030:              esac
                   7031:            fi
                   7032:            func_append tmp_libs " $func_resolve_sysroot_result"
                   7033:          done
                   7034: 
                   7035:          if test "$link_all_deplibs" != no; then
                   7036:            # Add the search paths of all dependency libraries
                   7037:            for deplib in $dependency_libs; do
                   7038:              path=
                   7039:              case $deplib in
                   7040:              -L*) path="$deplib" ;;
                   7041:              *.la)
                   7042:                func_resolve_sysroot "$deplib"
                   7043:                deplib=$func_resolve_sysroot_result
                   7044:                func_dirname "$deplib" "" "."
                   7045:                dir=$func_dirname_result
                   7046:                # We need an absolute path.
                   7047:                case $dir in
                   7048:                [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
                   7049:                *)
                   7050:                  absdir=`cd "$dir" && pwd`
                   7051:                  if test -z "$absdir"; then
                   7052:                    func_warning "cannot determine absolute directory name of \`$dir'"
                   7053:                    absdir="$dir"
                   7054:                  fi
                   7055:                  ;;
                   7056:                esac
                   7057:                if $GREP "^installed=no" $deplib > /dev/null; then
                   7058:                case $host in
                   7059:                *-*-darwin*)
                   7060:                  depdepl=
                   7061:                  eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
                   7062:                  if test -n "$deplibrary_names" ; then
                   7063:                    for tmp in $deplibrary_names ; do
                   7064:                      depdepl=$tmp
                   7065:                    done
                   7066:                    if test -f "$absdir/$objdir/$depdepl" ; then
                   7067:                      depdepl="$absdir/$objdir/$depdepl"
                   7068:                      darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
                   7069:                       if test -z "$darwin_install_name"; then
                   7070:                           darwin_install_name=`${OTOOL64} -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
                   7071:                       fi
                   7072:                      func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
                   7073:                      func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"
                   7074:                      path=
                   7075:                    fi
                   7076:                  fi
                   7077:                  ;;
                   7078:                *)
                   7079:                  path="-L$absdir/$objdir"
                   7080:                  ;;
                   7081:                esac
                   7082:                else
                   7083:                  eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
                   7084:                  test -z "$libdir" && \
                   7085:                    func_fatal_error "\`$deplib' is not a valid libtool archive"
                   7086:                  test "$absdir" != "$libdir" && \
                   7087:                    func_warning "\`$deplib' seems to be moved"
                   7088: 
                   7089:                  path="-L$absdir"
                   7090:                fi
                   7091:                ;;
                   7092:              esac
                   7093:              case " $deplibs " in
                   7094:              *" $path "*) ;;
                   7095:              *) deplibs="$path $deplibs" ;;
                   7096:              esac
                   7097:            done
                   7098:          fi # link_all_deplibs != no
                   7099:        fi # linkmode = lib
                   7100:       done # for deplib in $libs
                   7101:       if test "$pass" = link; then
                   7102:        if test "$linkmode" = "prog"; then
                   7103:          compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
                   7104:          finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
                   7105:        else
                   7106:          compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
                   7107:        fi
                   7108:       fi
                   7109:       dependency_libs="$newdependency_libs"
                   7110:       if test "$pass" = dlpreopen; then
                   7111:        # Link the dlpreopened libraries before other libraries
                   7112:        for deplib in $save_deplibs; do
                   7113:          deplibs="$deplib $deplibs"
                   7114:        done
                   7115:       fi
                   7116:       if test "$pass" != dlopen; then
                   7117:        if test "$pass" != conv; then
                   7118:          # Make sure lib_search_path contains only unique directories.
                   7119:          lib_search_path=
                   7120:          for dir in $newlib_search_path; do
                   7121:            case "$lib_search_path " in
                   7122:            *" $dir "*) ;;
                   7123:            *) func_append lib_search_path " $dir" ;;
                   7124:            esac
                   7125:          done
                   7126:          newlib_search_path=
                   7127:        fi
                   7128: 
                   7129:        if test "$linkmode,$pass" != "prog,link"; then
                   7130:          vars="deplibs"
                   7131:        else
                   7132:          vars="compile_deplibs finalize_deplibs"
                   7133:        fi
                   7134:        for var in $vars dependency_libs; do
                   7135:          # Add libraries to $var in reverse order
                   7136:          eval tmp_libs=\"\$$var\"
                   7137:          new_libs=
                   7138:          for deplib in $tmp_libs; do
                   7139:            # FIXME: Pedantically, this is the right thing to do, so
                   7140:            #        that some nasty dependency loop isn't accidentally
                   7141:            #        broken:
                   7142:            #new_libs="$deplib $new_libs"
                   7143:            # Pragmatically, this seems to cause very few problems in
                   7144:            # practice:
                   7145:            case $deplib in
                   7146:            -L*) new_libs="$deplib $new_libs" ;;
                   7147:            -R*) ;;
                   7148:            *)
                   7149:              # And here is the reason: when a library appears more
                   7150:              # than once as an explicit dependence of a library, or
                   7151:              # is implicitly linked in more than once by the
                   7152:              # compiler, it is considered special, and multiple
                   7153:              # occurrences thereof are not removed.  Compare this
                   7154:              # with having the same library being listed as a
                   7155:              # dependency of multiple other libraries: in this case,
                   7156:              # we know (pedantically, we assume) the library does not
                   7157:              # need to be listed more than once, so we keep only the
                   7158:              # last copy.  This is not always right, but it is rare
                   7159:              # enough that we require users that really mean to play
                   7160:              # such unportable linking tricks to link the library
                   7161:              # using -Wl,-lname, so that libtool does not consider it
                   7162:              # for duplicate removal.
                   7163:              case " $specialdeplibs " in
                   7164:              *" $deplib "*) new_libs="$deplib $new_libs" ;;
                   7165:              *)
                   7166:                case " $new_libs " in
                   7167:                *" $deplib "*) ;;
                   7168:                *) new_libs="$deplib $new_libs" ;;
                   7169:                esac
                   7170:                ;;
                   7171:              esac
                   7172:              ;;
                   7173:            esac
                   7174:          done
                   7175:          tmp_libs=
                   7176:          for deplib in $new_libs; do
                   7177:            case $deplib in
                   7178:            -L*)
                   7179:              case " $tmp_libs " in
                   7180:              *" $deplib "*) ;;
                   7181:              *) func_append tmp_libs " $deplib" ;;
                   7182:              esac
                   7183:              ;;
                   7184:            *) func_append tmp_libs " $deplib" ;;
                   7185:            esac
                   7186:          done
                   7187:          eval $var=\"$tmp_libs\"
                   7188:        done # for var
                   7189:       fi
                   7190:       # Last step: remove runtime libs from dependency_libs
                   7191:       # (they stay in deplibs)
                   7192:       tmp_libs=
                   7193:       for i in $dependency_libs ; do
                   7194:        case " $predeps $postdeps $compiler_lib_search_path " in
                   7195:        *" $i "*)
                   7196:          i=""
                   7197:          ;;
                   7198:        esac
                   7199:        if test -n "$i" ; then
                   7200:          func_append tmp_libs " $i"
                   7201:        fi
                   7202:       done
                   7203:       dependency_libs=$tmp_libs
                   7204:     done # for pass
                   7205:     if test "$linkmode" = prog; then
                   7206:       dlfiles="$newdlfiles"
                   7207:     fi
                   7208:     if test "$linkmode" = prog || test "$linkmode" = lib; then
                   7209:       dlprefiles="$newdlprefiles"
                   7210:     fi
                   7211: 
                   7212:     case $linkmode in
                   7213:     oldlib)
                   7214:       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
                   7215:        func_warning "\`-dlopen' is ignored for archives"
                   7216:       fi
                   7217: 
                   7218:       case " $deplibs" in
                   7219:       *\ -l* | *\ -L*)
                   7220:        func_warning "\`-l' and \`-L' are ignored for archives" ;;
                   7221:       esac
                   7222: 
                   7223:       test -n "$rpath" && \
                   7224:        func_warning "\`-rpath' is ignored for archives"
                   7225: 
                   7226:       test -n "$xrpath" && \
                   7227:        func_warning "\`-R' is ignored for archives"
                   7228: 
                   7229:       test -n "$vinfo" && \
                   7230:        func_warning "\`-version-info/-version-number' is ignored for archives"
                   7231: 
                   7232:       test -n "$release" && \
                   7233:        func_warning "\`-release' is ignored for archives"
                   7234: 
                   7235:       test -n "$export_symbols$export_symbols_regex" && \
                   7236:        func_warning "\`-export-symbols' is ignored for archives"
                   7237: 
                   7238:       # Now set the variables for building old libraries.
                   7239:       build_libtool_libs=no
                   7240:       oldlibs="$output"
                   7241:       func_append objs "$old_deplibs"
                   7242:       ;;
                   7243: 
                   7244:     lib)
                   7245:       # Make sure we only generate libraries of the form `libNAME.la'.
                   7246:       case $outputname in
                   7247:       lib*)
                   7248:        func_stripname 'lib' '.la' "$outputname"
                   7249:        name=$func_stripname_result
                   7250:        eval shared_ext=\"$shrext_cmds\"
                   7251:        eval libname=\"$libname_spec\"
                   7252:        ;;
                   7253:       *)
                   7254:        test "$module" = no && \
                   7255:          func_fatal_help "libtool library \`$output' must begin with \`lib'"
                   7256: 
                   7257:        if test "$need_lib_prefix" != no; then
                   7258:          # Add the "lib" prefix for modules if required
                   7259:          func_stripname '' '.la' "$outputname"
                   7260:          name=$func_stripname_result
                   7261:          eval shared_ext=\"$shrext_cmds\"
                   7262:          eval libname=\"$libname_spec\"
                   7263:        else
                   7264:          func_stripname '' '.la' "$outputname"
                   7265:          libname=$func_stripname_result
                   7266:        fi
                   7267:        ;;
                   7268:       esac
                   7269: 
                   7270:       if test -n "$objs"; then
                   7271:        if test "$deplibs_check_method" != pass_all; then
                   7272:          func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
                   7273:        else
                   7274:          echo
                   7275:          $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
                   7276:          $ECHO "*** objects $objs is not portable!"
                   7277:          func_append libobjs " $objs"
                   7278:        fi
                   7279:       fi
                   7280: 
                   7281:       test "$dlself" != no && \
                   7282:        func_warning "\`-dlopen self' is ignored for libtool libraries"
                   7283: 
                   7284:       set dummy $rpath
                   7285:       shift
                   7286:       test "$#" -gt 1 && \
                   7287:        func_warning "ignoring multiple \`-rpath's for a libtool library"
                   7288: 
                   7289:       install_libdir="$1"
                   7290: 
                   7291:       oldlibs=
                   7292:       if test -z "$rpath"; then
                   7293:        if test "$build_libtool_libs" = yes; then
                   7294:          # Building a libtool convenience library.
                   7295:          # Some compilers have problems with a `.al' extension so
                   7296:          # convenience libraries should have the same extension an
                   7297:          # archive normally would.
                   7298:          oldlibs="$output_objdir/$libname.$libext $oldlibs"
                   7299:          build_libtool_libs=convenience
                   7300:          build_old_libs=yes
                   7301:        fi
                   7302: 
                   7303:        test -n "$vinfo" && \
                   7304:          func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
                   7305: 
                   7306:        test -n "$release" && \
                   7307:          func_warning "\`-release' is ignored for convenience libraries"
                   7308:       else
                   7309: 
                   7310:        # Parse the version information argument.
                   7311:        save_ifs="$IFS"; IFS=':'
                   7312:        set dummy $vinfo 0 0 0
                   7313:        shift
                   7314:        IFS="$save_ifs"
                   7315: 
                   7316:        test -n "$7" && \
                   7317:          func_fatal_help "too many parameters to \`-version-info'"
                   7318: 
                   7319:        # convert absolute version numbers to libtool ages
                   7320:        # this retains compatibility with .la files and attempts
                   7321:        # to make the code below a bit more comprehensible
                   7322: 
                   7323:        case $vinfo_number in
                   7324:        yes)
                   7325:          number_major="$1"
                   7326:          number_minor="$2"
                   7327:          number_revision="$3"
                   7328:          #
                   7329:          # There are really only two kinds -- those that
                   7330:          # use the current revision as the major version
                   7331:          # and those that subtract age and use age as
                   7332:          # a minor version.  But, then there is irix
                   7333:          # which has an extra 1 added just for fun
                   7334:          #
                   7335:          case $version_type in
                   7336:          # correct linux to gnu/linux during the next big refactor
                   7337:          darwin|linux|osf|windows|none)
                   7338:            func_arith $number_major + $number_minor
                   7339:            current=$func_arith_result
                   7340:            age="$number_minor"
                   7341:            revision="$number_revision"
                   7342:            ;;
                   7343:          freebsd-aout|freebsd-elf|qnx|sunos)
                   7344:            current="$number_major"
                   7345:            revision="$number_minor"
                   7346:            age="0"
                   7347:            ;;
                   7348:          irix|nonstopux)
                   7349:            func_arith $number_major + $number_minor
                   7350:            current=$func_arith_result
                   7351:            age="$number_minor"
                   7352:            revision="$number_minor"
                   7353:            lt_irix_increment=no
                   7354:            ;;
                   7355:          *)
                   7356:            func_fatal_configuration "$modename: unknown library version type \`$version_type'"
                   7357:            ;;
                   7358:          esac
                   7359:          ;;
                   7360:        no)
                   7361:          current="$1"
                   7362:          revision="$2"
                   7363:          age="$3"
                   7364:          ;;
                   7365:        esac
                   7366: 
                   7367:        # Check that each of the things are valid numbers.
                   7368:        case $current in
                   7369:        0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
                   7370:        *)
                   7371:          func_error "CURRENT \`$current' must be a nonnegative integer"
                   7372:          func_fatal_error "\`$vinfo' is not valid version information"
                   7373:          ;;
                   7374:        esac
                   7375: 
                   7376:        case $revision in
                   7377:        0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
                   7378:        *)
                   7379:          func_error "REVISION \`$revision' must be a nonnegative integer"
                   7380:          func_fatal_error "\`$vinfo' is not valid version information"
                   7381:          ;;
                   7382:        esac
                   7383: 
                   7384:        case $age in
                   7385:        0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
                   7386:        *)
                   7387:          func_error "AGE \`$age' must be a nonnegative integer"
                   7388:          func_fatal_error "\`$vinfo' is not valid version information"
                   7389:          ;;
                   7390:        esac
                   7391: 
                   7392:        if test "$age" -gt "$current"; then
                   7393:          func_error "AGE \`$age' is greater than the current interface number \`$current'"
                   7394:          func_fatal_error "\`$vinfo' is not valid version information"
                   7395:        fi
                   7396: 
                   7397:        # Calculate the version variables.
                   7398:        major=
                   7399:        versuffix=
                   7400:        verstring=
                   7401:        case $version_type in
                   7402:        none) ;;
                   7403: 
                   7404:        darwin)
                   7405:          # Like Linux, but with the current version available in
                   7406:          # verstring for coding it into the library header
                   7407:          func_arith $current - $age
                   7408:          major=.$func_arith_result
                   7409:          versuffix="$major.$age.$revision"
                   7410:          # Darwin ld doesn't like 0 for these options...
                   7411:          func_arith $current + 1
                   7412:          minor_current=$func_arith_result
                   7413:          xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
                   7414:          verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
                   7415:          ;;
                   7416: 
                   7417:        freebsd-aout)
                   7418:          major=".$current"
                   7419:          versuffix=".$current.$revision";
                   7420:          ;;
                   7421: 
                   7422:        freebsd-elf)
                   7423:          major=".$current"
                   7424:          versuffix=".$current"
                   7425:          ;;
                   7426: 
                   7427:        irix | nonstopux)
                   7428:          if test "X$lt_irix_increment" = "Xno"; then
                   7429:            func_arith $current - $age
                   7430:          else
                   7431:            func_arith $current - $age + 1
                   7432:          fi
                   7433:          major=$func_arith_result
                   7434: 
                   7435:          case $version_type in
                   7436:            nonstopux) verstring_prefix=nonstopux ;;
                   7437:            *)         verstring_prefix=sgi ;;
                   7438:          esac
                   7439:          verstring="$verstring_prefix$major.$revision"
                   7440: 
                   7441:          # Add in all the interfaces that we are compatible with.
                   7442:          loop=$revision
                   7443:          while test "$loop" -ne 0; do
                   7444:            func_arith $revision - $loop
                   7445:            iface=$func_arith_result
                   7446:            func_arith $loop - 1
                   7447:            loop=$func_arith_result
                   7448:            verstring="$verstring_prefix$major.$iface:$verstring"
                   7449:          done
                   7450: 
                   7451:          # Before this point, $major must not contain `.'.
                   7452:          major=.$major
                   7453:          versuffix="$major.$revision"
                   7454:          ;;
                   7455: 
                   7456:        linux) # correct to gnu/linux during the next big refactor
                   7457:          func_arith $current - $age
                   7458:          major=.$func_arith_result
                   7459:          versuffix="$major.$age.$revision"
                   7460:          ;;
                   7461: 
                   7462:        osf)
                   7463:          func_arith $current - $age
                   7464:          major=.$func_arith_result
                   7465:          versuffix=".$current.$age.$revision"
                   7466:          verstring="$current.$age.$revision"
                   7467: 
                   7468:          # Add in all the interfaces that we are compatible with.
                   7469:          loop=$age
                   7470:          while test "$loop" -ne 0; do
                   7471:            func_arith $current - $loop
                   7472:            iface=$func_arith_result
                   7473:            func_arith $loop - 1
                   7474:            loop=$func_arith_result
                   7475:            verstring="$verstring:${iface}.0"
                   7476:          done
                   7477: 
                   7478:          # Make executables depend on our current version.
                   7479:          func_append verstring ":${current}.0"
                   7480:          ;;
                   7481: 
                   7482:        qnx)
                   7483:          major=".$current"
                   7484:          versuffix=".$current"
                   7485:          ;;
                   7486: 
                   7487:        sunos)
                   7488:          major=".$current"
                   7489:          versuffix=".$current.$revision"
                   7490:          ;;
                   7491: 
                   7492:        windows)
                   7493:          # Use '-' rather than '.', since we only want one
                   7494:          # extension on DOS 8.3 filesystems.
                   7495:          func_arith $current - $age
                   7496:          major=$func_arith_result
                   7497:          versuffix="-$major"
                   7498:          ;;
                   7499: 
                   7500:        *)
                   7501:          func_fatal_configuration "unknown library version type \`$version_type'"
                   7502:          ;;
                   7503:        esac
                   7504: 
                   7505:        # Clear the version info if we defaulted, and they specified a release.
                   7506:        if test -z "$vinfo" && test -n "$release"; then
                   7507:          major=
                   7508:          case $version_type in
                   7509:          darwin)
                   7510:            # we can't check for "0.0" in archive_cmds due to quoting
                   7511:            # problems, so we reset it completely
                   7512:            verstring=
                   7513:            ;;
                   7514:          *)
                   7515:            verstring="0.0"
                   7516:            ;;
                   7517:          esac
                   7518:          if test "$need_version" = no; then
                   7519:            versuffix=
                   7520:          else
                   7521:            versuffix=".0.0"
                   7522:          fi
                   7523:        fi
                   7524: 
                   7525:        # Remove version info from name if versioning should be avoided
                   7526:        if test "$avoid_version" = yes && test "$need_version" = no; then
                   7527:          major=
                   7528:          versuffix=
                   7529:          verstring=""
                   7530:        fi
                   7531: 
                   7532:        # Check to see if the archive will have undefined symbols.
                   7533:        if test "$allow_undefined" = yes; then
                   7534:          if test "$allow_undefined_flag" = unsupported; then
                   7535:            func_warning "undefined symbols not allowed in $host shared libraries"
                   7536:            build_libtool_libs=no
                   7537:            build_old_libs=yes
                   7538:          fi
                   7539:        else
                   7540:          # Don't allow undefined symbols.
                   7541:          allow_undefined_flag="$no_undefined_flag"
                   7542:        fi
                   7543: 
                   7544:       fi
                   7545: 
                   7546:       func_generate_dlsyms "$libname" "$libname" "yes"
                   7547:       func_append libobjs " $symfileobj"
                   7548:       test "X$libobjs" = "X " && libobjs=
                   7549: 
                   7550:       if test "$opt_mode" != relink; then
                   7551:        # Remove our outputs, but don't remove object files since they
                   7552:        # may have been created when compiling PIC objects.
                   7553:        removelist=
                   7554:        tempremovelist=`$ECHO "$output_objdir/*"`
                   7555:        for p in $tempremovelist; do
                   7556:          case $p in
                   7557:            *.$objext | *.gcno)
                   7558:               ;;
                   7559:            $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
                   7560:               if test "X$precious_files_regex" != "X"; then
                   7561:                 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
                   7562:                 then
                   7563:                   continue
                   7564:                 fi
                   7565:               fi
                   7566:               func_append removelist " $p"
                   7567:               ;;
                   7568:            *) ;;
                   7569:          esac
                   7570:        done
                   7571:        test -n "$removelist" && \
                   7572:          func_show_eval "${RM}r \$removelist"
                   7573:       fi
                   7574: 
                   7575:       # Now set the variables for building old libraries.
                   7576:       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
                   7577:        func_append oldlibs " $output_objdir/$libname.$libext"
                   7578: 
                   7579:        # Transform .lo files to .o files.
                   7580:        oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
                   7581:       fi
                   7582: 
                   7583:       # Eliminate all temporary directories.
                   7584:       #for path in $notinst_path; do
                   7585:       #        lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
                   7586:       #        deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
                   7587:       #        dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
                   7588:       #done
                   7589: 
                   7590:       if test -n "$xrpath"; then
                   7591:        # If the user specified any rpath flags, then add them.
                   7592:        temp_xrpath=
                   7593:        for libdir in $xrpath; do
                   7594:          func_replace_sysroot "$libdir"
                   7595:          func_append temp_xrpath " -R$func_replace_sysroot_result"
                   7596:          case "$finalize_rpath " in
                   7597:          *" $libdir "*) ;;
                   7598:          *) func_append finalize_rpath " $libdir" ;;
                   7599:          esac
                   7600:        done
                   7601:        if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
                   7602:          dependency_libs="$temp_xrpath $dependency_libs"
                   7603:        fi
                   7604:       fi
                   7605: 
                   7606:       # Make sure dlfiles contains only unique files that won't be dlpreopened
                   7607:       old_dlfiles="$dlfiles"
                   7608:       dlfiles=
                   7609:       for lib in $old_dlfiles; do
                   7610:        case " $dlprefiles $dlfiles " in
                   7611:        *" $lib "*) ;;
                   7612:        *) func_append dlfiles " $lib" ;;
                   7613:        esac
                   7614:       done
                   7615: 
                   7616:       # Make sure dlprefiles contains only unique files
                   7617:       old_dlprefiles="$dlprefiles"
                   7618:       dlprefiles=
                   7619:       for lib in $old_dlprefiles; do
                   7620:        case "$dlprefiles " in
                   7621:        *" $lib "*) ;;
                   7622:        *) func_append dlprefiles " $lib" ;;
                   7623:        esac
                   7624:       done
                   7625: 
                   7626:       if test "$build_libtool_libs" = yes; then
                   7627:        if test -n "$rpath"; then
                   7628:          case $host in
                   7629:          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
                   7630:            # these systems don't actually have a c library (as such)!
                   7631:            ;;
                   7632:          *-*-rhapsody* | *-*-darwin1.[012])
                   7633:            # Rhapsody C library is in the System framework
                   7634:            func_append deplibs " System.ltframework"
                   7635:            ;;
                   7636:          *-*-netbsd*)
                   7637:            # Don't link with libc until the a.out ld.so is fixed.
                   7638:            ;;
                   7639:          *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
                   7640:            # Do not include libc due to us having libc/libc_r.
                   7641:            ;;
                   7642:          *-*-sco3.2v5* | *-*-sco5v6*)
                   7643:            # Causes problems with __ctype
                   7644:            ;;
                   7645:          *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
                   7646:            # Compiler inserts libc in the correct place for threads to work
                   7647:            ;;
                   7648:          *)
                   7649:            # Add libc to deplibs on all other systems if necessary.
                   7650:            if test "$build_libtool_need_lc" = "yes"; then
                   7651:              func_append deplibs " -lc"
                   7652:            fi
                   7653:            ;;
                   7654:          esac
                   7655:        fi
                   7656: 
                   7657:        # Transform deplibs into only deplibs that can be linked in shared.
                   7658:        name_save=$name
                   7659:        libname_save=$libname
                   7660:        release_save=$release
                   7661:        versuffix_save=$versuffix
                   7662:        major_save=$major
                   7663:        # I'm not sure if I'm treating the release correctly.  I think
                   7664:        # release should show up in the -l (ie -lgmp5) so we don't want to
                   7665:        # add it in twice.  Is that correct?
                   7666:        release=""
                   7667:        versuffix=""
                   7668:        major=""
                   7669:        newdeplibs=
                   7670:        droppeddeps=no
                   7671:        case $deplibs_check_method in
                   7672:        pass_all)
                   7673:          # Don't check for shared/static.  Everything works.
                   7674:          # This might be a little naive.  We might want to check
                   7675:          # whether the library exists or not.  But this is on
                   7676:          # osf3 & osf4 and I'm not really sure... Just
                   7677:          # implementing what was already the behavior.
                   7678:          newdeplibs=$deplibs
                   7679:          ;;
                   7680:        test_compile)
                   7681:          # This code stresses the "libraries are programs" paradigm to its
                   7682:          # limits. Maybe even breaks it.  We compile a program, linking it
                   7683:          # against the deplibs as a proxy for the library.  Then we can check
                   7684:          # whether they linked in statically or dynamically with ldd.
                   7685:          $opt_dry_run || $RM conftest.c
                   7686:          cat > conftest.c <<EOF
                   7687:          int main() { return 0; }
                   7688: EOF
                   7689:          $opt_dry_run || $RM conftest
                   7690:          if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
                   7691:            ldd_output=`ldd conftest`
                   7692:            for i in $deplibs; do
                   7693:              case $i in
                   7694:              -l*)
                   7695:                func_stripname -l '' "$i"
                   7696:                name=$func_stripname_result
                   7697:                if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
                   7698:                  case " $predeps $postdeps " in
                   7699:                  *" $i "*)
                   7700:                    func_append newdeplibs " $i"
                   7701:                    i=""
                   7702:                    ;;
                   7703:                  esac
                   7704:                fi
                   7705:                if test -n "$i" ; then
                   7706:                  libname=`eval "\\$ECHO \"$libname_spec\""`
                   7707:                  deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
                   7708:                  set dummy $deplib_matches; shift
                   7709:                  deplib_match=$1
                   7710:                  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
                   7711:                    func_append newdeplibs " $i"
                   7712:                  else
                   7713:                    droppeddeps=yes
                   7714:                    echo
                   7715:                    $ECHO "*** Warning: dynamic linker does not accept needed library $i."
                   7716:                    echo "*** I have the capability to make that library automatically link in when"
                   7717:                    echo "*** you link to this library.  But I can only do this if you have a"
                   7718:                    echo "*** shared version of the library, which I believe you do not have"
                   7719:                    echo "*** because a test_compile did reveal that the linker did not use it for"
                   7720:                    echo "*** its dynamic dependency list that programs get resolved with at runtime."
                   7721:                  fi
                   7722:                fi
                   7723:                ;;
                   7724:              *)
                   7725:                func_append newdeplibs " $i"
                   7726:                ;;
                   7727:              esac
                   7728:            done
                   7729:          else
                   7730:            # Error occurred in the first compile.  Let's try to salvage
                   7731:            # the situation: Compile a separate program for each library.
                   7732:            for i in $deplibs; do
                   7733:              case $i in
                   7734:              -l*)
                   7735:                func_stripname -l '' "$i"
                   7736:                name=$func_stripname_result
                   7737:                $opt_dry_run || $RM conftest
                   7738:                if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
                   7739:                  ldd_output=`ldd conftest`
                   7740:                  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
                   7741:                    case " $predeps $postdeps " in
                   7742:                    *" $i "*)
                   7743:                      func_append newdeplibs " $i"
                   7744:                      i=""
                   7745:                      ;;
                   7746:                    esac
                   7747:                  fi
                   7748:                  if test -n "$i" ; then
                   7749:                    libname=`eval "\\$ECHO \"$libname_spec\""`
                   7750:                    deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
                   7751:                    set dummy $deplib_matches; shift
                   7752:                    deplib_match=$1
                   7753:                    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
                   7754:                      func_append newdeplibs " $i"
                   7755:                    else
                   7756:                      droppeddeps=yes
                   7757:                      echo
                   7758:                      $ECHO "*** Warning: dynamic linker does not accept needed library $i."
                   7759:                      echo "*** I have the capability to make that library automatically link in when"
                   7760:                      echo "*** you link to this library.  But I can only do this if you have a"
                   7761:                      echo "*** shared version of the library, which you do not appear to have"
                   7762:                      echo "*** because a test_compile did reveal that the linker did not use this one"
                   7763:                      echo "*** as a dynamic dependency that programs can get resolved with at runtime."
                   7764:                    fi
                   7765:                  fi
                   7766:                else
                   7767:                  droppeddeps=yes
                   7768:                  echo
                   7769:                  $ECHO "*** Warning!  Library $i is needed by this library but I was not able to"
                   7770:                  echo "*** make it link in!  You will probably need to install it or some"
                   7771:                  echo "*** library that it depends on before this library will be fully"
                   7772:                  echo "*** functional.  Installing it before continuing would be even better."
                   7773:                fi
                   7774:                ;;
                   7775:              *)
                   7776:                func_append newdeplibs " $i"
                   7777:                ;;
                   7778:              esac
                   7779:            done
                   7780:          fi
                   7781:          ;;
                   7782:        file_magic*)
                   7783:          set dummy $deplibs_check_method; shift
                   7784:          file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
                   7785:          for a_deplib in $deplibs; do
                   7786:            case $a_deplib in
                   7787:            -l*)
                   7788:              func_stripname -l '' "$a_deplib"
                   7789:              name=$func_stripname_result
                   7790:              if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
                   7791:                case " $predeps $postdeps " in
                   7792:                *" $a_deplib "*)
                   7793:                  func_append newdeplibs " $a_deplib"
                   7794:                  a_deplib=""
                   7795:                  ;;
                   7796:                esac
                   7797:              fi
                   7798:              if test -n "$a_deplib" ; then
                   7799:                libname=`eval "\\$ECHO \"$libname_spec\""`
                   7800:                if test -n "$file_magic_glob"; then
                   7801:                  libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
                   7802:                else
                   7803:                  libnameglob=$libname
                   7804:                fi
                   7805:                test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`
                   7806:                for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
                   7807:                  if test "$want_nocaseglob" = yes; then
                   7808:                    shopt -s nocaseglob
                   7809:                    potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
                   7810:                    $nocaseglob
                   7811:                  else
                   7812:                    potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
                   7813:                  fi
                   7814:                  for potent_lib in $potential_libs; do
                   7815:                      # Follow soft links.
                   7816:                      if ls -lLd "$potent_lib" 2>/dev/null |
                   7817:                         $GREP " -> " >/dev/null; then
                   7818:                        continue
                   7819:                      fi
                   7820:                      # The statement above tries to avoid entering an
                   7821:                      # endless loop below, in case of cyclic links.
                   7822:                      # We might still enter an endless loop, since a link
                   7823:                      # loop can be closed while we follow links,
                   7824:                      # but so what?
                   7825:                      potlib="$potent_lib"
                   7826:                      while test -h "$potlib" 2>/dev/null; do
                   7827:                        potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
                   7828:                        case $potliblink in
                   7829:                        [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
                   7830:                        *) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
                   7831:                        esac
                   7832:                      done
                   7833:                      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
                   7834:                         $SED -e 10q |
                   7835:                         $EGREP "$file_magic_regex" > /dev/null; then
                   7836:                        func_append newdeplibs " $a_deplib"
                   7837:                        a_deplib=""
                   7838:                        break 2
                   7839:                      fi
                   7840:                  done
                   7841:                done
                   7842:              fi
                   7843:              if test -n "$a_deplib" ; then
                   7844:                droppeddeps=yes
                   7845:                echo
                   7846:                $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
                   7847:                echo "*** I have the capability to make that library automatically link in when"
                   7848:                echo "*** you link to this library.  But I can only do this if you have a"
                   7849:                echo "*** shared version of the library, which you do not appear to have"
                   7850:                echo "*** because I did check the linker path looking for a file starting"
                   7851:                if test -z "$potlib" ; then
                   7852:                  $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
                   7853:                else
                   7854:                  $ECHO "*** with $libname and none of the candidates passed a file format test"
                   7855:                  $ECHO "*** using a file magic. Last file checked: $potlib"
                   7856:                fi
                   7857:              fi
                   7858:              ;;
                   7859:            *)
                   7860:              # Add a -L argument.
                   7861:              func_append newdeplibs " $a_deplib"
                   7862:              ;;
                   7863:            esac
                   7864:          done # Gone through all deplibs.
                   7865:          ;;
                   7866:        match_pattern*)
                   7867:          set dummy $deplibs_check_method; shift
                   7868:          match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
                   7869:          for a_deplib in $deplibs; do
                   7870:            case $a_deplib in
                   7871:            -l*)
                   7872:              func_stripname -l '' "$a_deplib"
                   7873:              name=$func_stripname_result
                   7874:              if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
                   7875:                case " $predeps $postdeps " in
                   7876:                *" $a_deplib "*)
                   7877:                  func_append newdeplibs " $a_deplib"
                   7878:                  a_deplib=""
                   7879:                  ;;
                   7880:                esac
                   7881:              fi
                   7882:              if test -n "$a_deplib" ; then
                   7883:                libname=`eval "\\$ECHO \"$libname_spec\""`
                   7884:                for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
                   7885:                  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
                   7886:                  for potent_lib in $potential_libs; do
                   7887:                    potlib="$potent_lib" # see symlink-check above in file_magic test
                   7888:                    if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
                   7889:                       $EGREP "$match_pattern_regex" > /dev/null; then
                   7890:                      func_append newdeplibs " $a_deplib"
                   7891:                      a_deplib=""
                   7892:                      break 2
                   7893:                    fi
                   7894:                  done
                   7895:                done
                   7896:              fi
                   7897:              if test -n "$a_deplib" ; then
                   7898:                droppeddeps=yes
                   7899:                echo
                   7900:                $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
                   7901:                echo "*** I have the capability to make that library automatically link in when"
                   7902:                echo "*** you link to this library.  But I can only do this if you have a"
                   7903:                echo "*** shared version of the library, which you do not appear to have"
                   7904:                echo "*** because I did check the linker path looking for a file starting"
                   7905:                if test -z "$potlib" ; then
                   7906:                  $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
                   7907:                else
                   7908:                  $ECHO "*** with $libname and none of the candidates passed a file format test"
                   7909:                  $ECHO "*** using a regex pattern. Last file checked: $potlib"
                   7910:                fi
                   7911:              fi
                   7912:              ;;
                   7913:            *)
                   7914:              # Add a -L argument.
                   7915:              func_append newdeplibs " $a_deplib"
                   7916:              ;;
                   7917:            esac
                   7918:          done # Gone through all deplibs.
                   7919:          ;;
                   7920:        none | unknown | *)
                   7921:          newdeplibs=""
                   7922:          tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
                   7923:          if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
                   7924:            for i in $predeps $postdeps ; do
                   7925:              # can't use Xsed below, because $i might contain '/'
                   7926:              tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
                   7927:            done
                   7928:          fi
                   7929:          case $tmp_deplibs in
                   7930:          *[!\  \ ]*)
                   7931:            echo
                   7932:            if test "X$deplibs_check_method" = "Xnone"; then
                   7933:              echo "*** Warning: inter-library dependencies are not supported in this platform."
                   7934:            else
                   7935:              echo "*** Warning: inter-library dependencies are not known to be supported."
                   7936:            fi
                   7937:            echo "*** All declared inter-library dependencies are being dropped."
                   7938:            droppeddeps=yes
                   7939:            ;;
                   7940:          esac
                   7941:          ;;
                   7942:        esac
                   7943:        versuffix=$versuffix_save
                   7944:        major=$major_save
                   7945:        release=$release_save
                   7946:        libname=$libname_save
                   7947:        name=$name_save
                   7948: 
                   7949:        case $host in
                   7950:        *-*-rhapsody* | *-*-darwin1.[012])
                   7951:          # On Rhapsody replace the C library with the System framework
                   7952:          newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
                   7953:          ;;
                   7954:        esac
                   7955: 
                   7956:        if test "$droppeddeps" = yes; then
                   7957:          if test "$module" = yes; then
                   7958:            echo
                   7959:            echo "*** Warning: libtool could not satisfy all declared inter-library"
                   7960:            $ECHO "*** dependencies of module $libname.  Therefore, libtool will create"
                   7961:            echo "*** a static module, that should work as long as the dlopening"
                   7962:            echo "*** application is linked with the -dlopen flag."
                   7963:            if test -z "$global_symbol_pipe"; then
                   7964:              echo
                   7965:              echo "*** However, this would only work if libtool was able to extract symbol"
                   7966:              echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
                   7967:              echo "*** not find such a program.  So, this module is probably useless."
                   7968:              echo "*** \`nm' from GNU binutils and a full rebuild may help."
                   7969:            fi
                   7970:            if test "$build_old_libs" = no; then
                   7971:              oldlibs="$output_objdir/$libname.$libext"
                   7972:              build_libtool_libs=module
                   7973:              build_old_libs=yes
                   7974:            else
                   7975:              build_libtool_libs=no
                   7976:            fi
                   7977:          else
                   7978:            echo "*** The inter-library dependencies that have been dropped here will be"
                   7979:            echo "*** automatically added whenever a program is linked with this library"
                   7980:            echo "*** or is declared to -dlopen it."
                   7981: 
                   7982:            if test "$allow_undefined" = no; then
                   7983:              echo
                   7984:              echo "*** Since this library must not contain undefined symbols,"
                   7985:              echo "*** because either the platform does not support them or"
                   7986:              echo "*** it was explicitly requested with -no-undefined,"
                   7987:              echo "*** libtool will only create a static version of it."
                   7988:              if test "$build_old_libs" = no; then
                   7989:                oldlibs="$output_objdir/$libname.$libext"
                   7990:                build_libtool_libs=module
                   7991:                build_old_libs=yes
                   7992:              else
                   7993:                build_libtool_libs=no
                   7994:              fi
                   7995:            fi
                   7996:          fi
                   7997:        fi
                   7998:        # Done checking deplibs!
                   7999:        deplibs=$newdeplibs
                   8000:       fi
                   8001:       # Time to change all our "foo.ltframework" stuff back to "-framework foo"
                   8002:       case $host in
                   8003:        *-*-darwin*)
                   8004:          newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
                   8005:          new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
                   8006:          deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
                   8007:          ;;
                   8008:       esac
                   8009: 
                   8010:       # move library search paths that coincide with paths to not yet
                   8011:       # installed libraries to the beginning of the library search list
                   8012:       new_libs=
                   8013:       for path in $notinst_path; do
                   8014:        case " $new_libs " in
                   8015:        *" -L$path/$objdir "*) ;;
                   8016:        *)
                   8017:          case " $deplibs " in
                   8018:          *" -L$path/$objdir "*)
                   8019:            func_append new_libs " -L$path/$objdir" ;;
                   8020:          esac
                   8021:          ;;
                   8022:        esac
                   8023:       done
                   8024:       for deplib in $deplibs; do
                   8025:        case $deplib in
                   8026:        -L*)
                   8027:          case " $new_libs " in
                   8028:          *" $deplib "*) ;;
                   8029:          *) func_append new_libs " $deplib" ;;
                   8030:          esac
                   8031:          ;;
                   8032:        *) func_append new_libs " $deplib" ;;
                   8033:        esac
                   8034:       done
                   8035:       deplibs="$new_libs"
                   8036: 
                   8037:       # All the library-specific variables (install_libdir is set above).
                   8038:       library_names=
                   8039:       old_library=
                   8040:       dlname=
                   8041: 
                   8042:       # Test again, we may have decided not to build it any more
                   8043:       if test "$build_libtool_libs" = yes; then
                   8044:        # Remove ${wl} instances when linking with ld.
                   8045:        # FIXME: should test the right _cmds variable.
                   8046:        case $archive_cmds in
                   8047:          *\$LD\ *) wl= ;;
                   8048:         esac
                   8049:        if test "$hardcode_into_libs" = yes; then
                   8050:          # Hardcode the library paths
                   8051:          hardcode_libdirs=
                   8052:          dep_rpath=
                   8053:          rpath="$finalize_rpath"
                   8054:          test "$opt_mode" != relink && rpath="$compile_rpath$rpath"
                   8055:          for libdir in $rpath; do
                   8056:            if test -n "$hardcode_libdir_flag_spec"; then
                   8057:              if test -n "$hardcode_libdir_separator"; then
                   8058:                func_replace_sysroot "$libdir"
                   8059:                libdir=$func_replace_sysroot_result
                   8060:                if test -z "$hardcode_libdirs"; then
                   8061:                  hardcode_libdirs="$libdir"
                   8062:                else
                   8063:                  # Just accumulate the unique libdirs.
                   8064:                  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
                   8065:                  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
                   8066:                    ;;
                   8067:                  *)
                   8068:                    func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
                   8069:                    ;;
                   8070:                  esac
                   8071:                fi
                   8072:              else
                   8073:                eval flag=\"$hardcode_libdir_flag_spec\"
                   8074:                func_append dep_rpath " $flag"
                   8075:              fi
                   8076:            elif test -n "$runpath_var"; then
                   8077:              case "$perm_rpath " in
                   8078:              *" $libdir "*) ;;
                   8079:              *) func_append perm_rpath " $libdir" ;;
                   8080:              esac
                   8081:            fi
                   8082:          done
                   8083:          # Substitute the hardcoded libdirs into the rpath.
                   8084:          if test -n "$hardcode_libdir_separator" &&
                   8085:             test -n "$hardcode_libdirs"; then
                   8086:            libdir="$hardcode_libdirs"
                   8087:            eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
                   8088:          fi
                   8089:          if test -n "$runpath_var" && test -n "$perm_rpath"; then
                   8090:            # We should set the runpath_var.
                   8091:            rpath=
                   8092:            for dir in $perm_rpath; do
                   8093:              func_append rpath "$dir:"
                   8094:            done
                   8095:            eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
                   8096:          fi
                   8097:          test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
                   8098:        fi
                   8099: 
                   8100:        shlibpath="$finalize_shlibpath"
                   8101:        test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
                   8102:        if test -n "$shlibpath"; then
                   8103:          eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
                   8104:        fi
                   8105: 
                   8106:        # Get the real and link names of the library.
                   8107:        eval shared_ext=\"$shrext_cmds\"
                   8108:        eval library_names=\"$library_names_spec\"
                   8109:        set dummy $library_names
                   8110:        shift
                   8111:        realname="$1"
                   8112:        shift
                   8113: 
                   8114:        if test -n "$soname_spec"; then
                   8115:          eval soname=\"$soname_spec\"
                   8116:        else
                   8117:          soname="$realname"
                   8118:        fi
                   8119:        if test -z "$dlname"; then
                   8120:          dlname=$soname
                   8121:        fi
                   8122: 
                   8123:        lib="$output_objdir/$realname"
                   8124:        linknames=
                   8125:        for link
                   8126:        do
                   8127:          func_append linknames " $link"
                   8128:        done
                   8129: 
                   8130:        # Use standard objects if they are pic
                   8131:        test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
                   8132:        test "X$libobjs" = "X " && libobjs=
                   8133: 
                   8134:        delfiles=
                   8135:        if test -n "$export_symbols" && test -n "$include_expsyms"; then
                   8136:          $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
                   8137:          export_symbols="$output_objdir/$libname.uexp"
                   8138:          func_append delfiles " $export_symbols"
                   8139:        fi
                   8140: 
                   8141:        orig_export_symbols=
                   8142:        case $host_os in
                   8143:        cygwin* | mingw* | cegcc*)
                   8144:          if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
                   8145:            # exporting using user supplied symfile
                   8146:            if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
                   8147:              # and it's NOT already a .def file. Must figure out
                   8148:              # which of the given symbols are data symbols and tag
                   8149:              # them as such. So, trigger use of export_symbols_cmds.
                   8150:              # export_symbols gets reassigned inside the "prepare
                   8151:              # the list of exported symbols" if statement, so the
                   8152:              # include_expsyms logic still works.
                   8153:              orig_export_symbols="$export_symbols"
                   8154:              export_symbols=
                   8155:              always_export_symbols=yes
                   8156:            fi
                   8157:          fi
                   8158:          ;;
                   8159:        esac
                   8160: 
                   8161:        # Prepare the list of exported symbols
                   8162:        if test -z "$export_symbols"; then
                   8163:          if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
                   8164:            func_verbose "generating symbol list for \`$libname.la'"
                   8165:            export_symbols="$output_objdir/$libname.exp"
                   8166:            $opt_dry_run || $RM $export_symbols
                   8167:            cmds=$export_symbols_cmds
                   8168:            save_ifs="$IFS"; IFS='~'
                   8169:            for cmd1 in $cmds; do
                   8170:              IFS="$save_ifs"
                   8171:              # Take the normal branch if the nm_file_list_spec branch
                   8172:              # doesn't work or if tool conversion is not needed.
                   8173:              case $nm_file_list_spec~$to_tool_file_cmd in
                   8174:                *~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
                   8175:                  try_normal_branch=yes
                   8176:                  eval cmd=\"$cmd1\"
                   8177:                  func_len " $cmd"
                   8178:                  len=$func_len_result
                   8179:                  ;;
                   8180:                *)
                   8181:                  try_normal_branch=no
                   8182:                  ;;
                   8183:              esac
                   8184:              if test "$try_normal_branch" = yes \
                   8185:                 && { test "$len" -lt "$max_cmd_len" \
                   8186:                      || test "$max_cmd_len" -le -1; }
                   8187:              then
                   8188:                func_show_eval "$cmd" 'exit $?'
                   8189:                skipped_export=false
                   8190:              elif test -n "$nm_file_list_spec"; then
                   8191:                func_basename "$output"
                   8192:                output_la=$func_basename_result
                   8193:                save_libobjs=$libobjs
                   8194:                save_output=$output
                   8195:                output=${output_objdir}/${output_la}.nm
                   8196:                func_to_tool_file "$output"
                   8197:                libobjs=$nm_file_list_spec$func_to_tool_file_result
                   8198:                func_append delfiles " $output"
                   8199:                func_verbose "creating $NM input file list: $output"
                   8200:                for obj in $save_libobjs; do
                   8201:                  func_to_tool_file "$obj"
                   8202:                  $ECHO "$func_to_tool_file_result"
                   8203:                done > "$output"
                   8204:                eval cmd=\"$cmd1\"
                   8205:                func_show_eval "$cmd" 'exit $?'
                   8206:                output=$save_output
                   8207:                libobjs=$save_libobjs
                   8208:                skipped_export=false
                   8209:              else
                   8210:                # The command line is too long to execute in one step.
                   8211:                func_verbose "using reloadable object file for export list..."
                   8212:                skipped_export=:
                   8213:                # Break out early, otherwise skipped_export may be
                   8214:                # set to false by a later but shorter cmd.
                   8215:                break
                   8216:              fi
                   8217:            done
                   8218:            IFS="$save_ifs"
                   8219:            if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
                   8220:              func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
                   8221:              func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
                   8222:            fi
                   8223:          fi
                   8224:        fi
                   8225: 
                   8226:        if test -n "$export_symbols" && test -n "$include_expsyms"; then
                   8227:          tmp_export_symbols="$export_symbols"
                   8228:          test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
                   8229:          $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
                   8230:        fi
                   8231: 
                   8232:        if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
                   8233:          # The given exports_symbols file has to be filtered, so filter it.
                   8234:          func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
                   8235:          # FIXME: $output_objdir/$libname.filter potentially contains lots of
                   8236:          # 's' commands which not all seds can handle. GNU sed should be fine
                   8237:          # though. Also, the filter scales superlinearly with the number of
                   8238:          # global variables. join(1) would be nice here, but unfortunately
                   8239:          # isn't a blessed tool.
                   8240:          $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
                   8241:          func_append delfiles " $export_symbols $output_objdir/$libname.filter"
                   8242:          export_symbols=$output_objdir/$libname.def
                   8243:          $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
                   8244:        fi
                   8245: 
                   8246:        tmp_deplibs=
                   8247:        for test_deplib in $deplibs; do
                   8248:          case " $convenience " in
                   8249:          *" $test_deplib "*) ;;
                   8250:          *)
                   8251:            func_append tmp_deplibs " $test_deplib"
                   8252:            ;;
                   8253:          esac
                   8254:        done
                   8255:        deplibs="$tmp_deplibs"
                   8256: 
                   8257:        if test -n "$convenience"; then
                   8258:          if test -n "$whole_archive_flag_spec" &&
                   8259:            test "$compiler_needs_object" = yes &&
                   8260:            test -z "$libobjs"; then
                   8261:            # extract the archives, so we have objects to list.
                   8262:            # TODO: could optimize this to just extract one archive.
                   8263:            whole_archive_flag_spec=
                   8264:          fi
                   8265:          if test -n "$whole_archive_flag_spec"; then
                   8266:            save_libobjs=$libobjs
                   8267:            eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
                   8268:            test "X$libobjs" = "X " && libobjs=
                   8269:          else
                   8270:            gentop="$output_objdir/${outputname}x"
                   8271:            func_append generated " $gentop"
                   8272: 
                   8273:            func_extract_archives $gentop $convenience
                   8274:            func_append libobjs " $func_extract_archives_result"
                   8275:            test "X$libobjs" = "X " && libobjs=
                   8276:          fi
                   8277:        fi
                   8278: 
                   8279:        if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
                   8280:          eval flag=\"$thread_safe_flag_spec\"
                   8281:          func_append linker_flags " $flag"
                   8282:        fi
                   8283: 
                   8284:        # Make a backup of the uninstalled library when relinking
                   8285:        if test "$opt_mode" = relink; then
                   8286:          $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
                   8287:        fi
                   8288: 
                   8289:        # Do each of the archive commands.
                   8290:        if test "$module" = yes && test -n "$module_cmds" ; then
                   8291:          if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
                   8292:            eval test_cmds=\"$module_expsym_cmds\"
                   8293:            cmds=$module_expsym_cmds
                   8294:          else
                   8295:            eval test_cmds=\"$module_cmds\"
                   8296:            cmds=$module_cmds
                   8297:          fi
                   8298:        else
                   8299:          if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
                   8300:            eval test_cmds=\"$archive_expsym_cmds\"
                   8301:            cmds=$archive_expsym_cmds
                   8302:          else
                   8303:            eval test_cmds=\"$archive_cmds\"
                   8304:            cmds=$archive_cmds
                   8305:          fi
                   8306:        fi
                   8307: 
                   8308:        if test "X$skipped_export" != "X:" &&
                   8309:           func_len " $test_cmds" &&
                   8310:           len=$func_len_result &&
                   8311:           test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
                   8312:          :
                   8313:        else
                   8314:          # The command line is too long to link in one step, link piecewise
                   8315:          # or, if using GNU ld and skipped_export is not :, use a linker
                   8316:          # script.
                   8317: 
                   8318:          # Save the value of $output and $libobjs because we want to
                   8319:          # use them later.  If we have whole_archive_flag_spec, we
                   8320:          # want to use save_libobjs as it was before
                   8321:          # whole_archive_flag_spec was expanded, because we can't
                   8322:          # assume the linker understands whole_archive_flag_spec.
                   8323:          # This may have to be revisited, in case too many
                   8324:          # convenience libraries get linked in and end up exceeding
                   8325:          # the spec.
                   8326:          if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
                   8327:            save_libobjs=$libobjs
                   8328:          fi
                   8329:          save_output=$output
                   8330:          func_basename "$output"
                   8331:          output_la=$func_basename_result
                   8332: 
                   8333:          # Clear the reloadable object creation command queue and
                   8334:          # initialize k to one.
                   8335:          test_cmds=
                   8336:          concat_cmds=
                   8337:          objlist=
                   8338:          last_robj=
                   8339:          k=1
                   8340: 
                   8341:          if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
                   8342:            output=${output_objdir}/${output_la}.lnkscript
                   8343:            func_verbose "creating GNU ld script: $output"
                   8344:            echo 'INPUT (' > $output
                   8345:            for obj in $save_libobjs
                   8346:            do
                   8347:              func_to_tool_file "$obj"
                   8348:              $ECHO "$func_to_tool_file_result" >> $output
                   8349:            done
                   8350:            echo ')' >> $output
                   8351:            func_append delfiles " $output"
                   8352:            func_to_tool_file "$output"
                   8353:            output=$func_to_tool_file_result
                   8354:          elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
                   8355:            output=${output_objdir}/${output_la}.lnk
                   8356:            func_verbose "creating linker input file list: $output"
                   8357:            : > $output
                   8358:            set x $save_libobjs
                   8359:            shift
                   8360:            firstobj=
                   8361:            if test "$compiler_needs_object" = yes; then
                   8362:              firstobj="$1 "
                   8363:              shift
                   8364:            fi
                   8365:            for obj
                   8366:            do
                   8367:              func_to_tool_file "$obj"
                   8368:              $ECHO "$func_to_tool_file_result" >> $output
                   8369:            done
                   8370:            func_append delfiles " $output"
                   8371:            func_to_tool_file "$output"
                   8372:            output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
                   8373:          else
                   8374:            if test -n "$save_libobjs"; then
                   8375:              func_verbose "creating reloadable object files..."
                   8376:              output=$output_objdir/$output_la-${k}.$objext
                   8377:              eval test_cmds=\"$reload_cmds\"
                   8378:              func_len " $test_cmds"
                   8379:              len0=$func_len_result
                   8380:              len=$len0
                   8381: 
                   8382:              # Loop over the list of objects to be linked.
                   8383:              for obj in $save_libobjs
                   8384:              do
                   8385:                func_len " $obj"
                   8386:                func_arith $len + $func_len_result
                   8387:                len=$func_arith_result
                   8388:                if test "X$objlist" = X ||
                   8389:                   test "$len" -lt "$max_cmd_len"; then
                   8390:                  func_append objlist " $obj"
                   8391:                else
                   8392:                  # The command $test_cmds is almost too long, add a
                   8393:                  # command to the queue.
                   8394:                  if test "$k" -eq 1 ; then
                   8395:                    # The first file doesn't have a previous command to add.
                   8396:                    reload_objs=$objlist
                   8397:                    eval concat_cmds=\"$reload_cmds\"
                   8398:                  else
                   8399:                    # All subsequent reloadable object files will link in
                   8400:                    # the last one created.
                   8401:                    reload_objs="$objlist $last_robj"
                   8402:                    eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
                   8403:                  fi
                   8404:                  last_robj=$output_objdir/$output_la-${k}.$objext
                   8405:                  func_arith $k + 1
                   8406:                  k=$func_arith_result
                   8407:                  output=$output_objdir/$output_la-${k}.$objext
                   8408:                  objlist=" $obj"
                   8409:                  func_len " $last_robj"
                   8410:                  func_arith $len0 + $func_len_result
                   8411:                  len=$func_arith_result
                   8412:                fi
                   8413:              done
                   8414:              # Handle the remaining objects by creating one last
                   8415:              # reloadable object file.  All subsequent reloadable object
                   8416:              # files will link in the last one created.
                   8417:              test -z "$concat_cmds" || concat_cmds=$concat_cmds~
                   8418:              reload_objs="$objlist $last_robj"
                   8419:              eval concat_cmds=\"\${concat_cmds}$reload_cmds\"
                   8420:              if test -n "$last_robj"; then
                   8421:                eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
                   8422:              fi
                   8423:              func_append delfiles " $output"
                   8424: 
                   8425:            else
                   8426:              output=
                   8427:            fi
                   8428: 
                   8429:            if ${skipped_export-false}; then
                   8430:              func_verbose "generating symbol list for \`$libname.la'"
                   8431:              export_symbols="$output_objdir/$libname.exp"
                   8432:              $opt_dry_run || $RM $export_symbols
                   8433:              libobjs=$output
                   8434:              # Append the command to create the export file.
                   8435:              test -z "$concat_cmds" || concat_cmds=$concat_cmds~
                   8436:              eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
                   8437:              if test -n "$last_robj"; then
                   8438:                eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
                   8439:              fi
                   8440:            fi
                   8441: 
                   8442:            test -n "$save_libobjs" &&
                   8443:              func_verbose "creating a temporary reloadable object file: $output"
                   8444: 
                   8445:            # Loop through the commands generated above and execute them.
                   8446:            save_ifs="$IFS"; IFS='~'
                   8447:            for cmd in $concat_cmds; do
                   8448:              IFS="$save_ifs"
                   8449:              $opt_silent || {
                   8450:                  func_quote_for_expand "$cmd"
                   8451:                  eval "func_echo $func_quote_for_expand_result"
                   8452:              }
                   8453:              $opt_dry_run || eval "$cmd" || {
                   8454:                lt_exit=$?
                   8455: 
                   8456:                # Restore the uninstalled library and exit
                   8457:                if test "$opt_mode" = relink; then
                   8458:                  ( cd "$output_objdir" && \
                   8459:                    $RM "${realname}T" && \
                   8460:                    $MV "${realname}U" "$realname" )
                   8461:                fi
                   8462: 
                   8463:                exit $lt_exit
                   8464:              }
                   8465:            done
                   8466:            IFS="$save_ifs"
                   8467: 
                   8468:            if test -n "$export_symbols_regex" && ${skipped_export-false}; then
                   8469:              func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
                   8470:              func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
                   8471:            fi
                   8472:          fi
                   8473: 
                   8474:           if ${skipped_export-false}; then
                   8475:            if test -n "$export_symbols" && test -n "$include_expsyms"; then
                   8476:              tmp_export_symbols="$export_symbols"
                   8477:              test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
                   8478:              $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
                   8479:            fi
                   8480: 
                   8481:            if test -n "$orig_export_symbols"; then
                   8482:              # The given exports_symbols file has to be filtered, so filter it.
                   8483:              func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
                   8484:              # FIXME: $output_objdir/$libname.filter potentially contains lots of
                   8485:              # 's' commands which not all seds can handle. GNU sed should be fine
                   8486:              # though. Also, the filter scales superlinearly with the number of
                   8487:              # global variables. join(1) would be nice here, but unfortunately
                   8488:              # isn't a blessed tool.
                   8489:              $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
                   8490:              func_append delfiles " $export_symbols $output_objdir/$libname.filter"
                   8491:              export_symbols=$output_objdir/$libname.def
                   8492:              $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
                   8493:            fi
                   8494:          fi
                   8495: 
                   8496:          libobjs=$output
                   8497:          # Restore the value of output.
                   8498:          output=$save_output
                   8499: 
                   8500:          if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
                   8501:            eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
                   8502:            test "X$libobjs" = "X " && libobjs=
                   8503:          fi
                   8504:          # Expand the library linking commands again to reset the
                   8505:          # value of $libobjs for piecewise linking.
                   8506: 
                   8507:          # Do each of the archive commands.
                   8508:          if test "$module" = yes && test -n "$module_cmds" ; then
                   8509:            if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
                   8510:              cmds=$module_expsym_cmds
                   8511:            else
                   8512:              cmds=$module_cmds
                   8513:            fi
                   8514:          else
                   8515:            if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
                   8516:              cmds=$archive_expsym_cmds
                   8517:            else
                   8518:              cmds=$archive_cmds
                   8519:            fi
                   8520:          fi
                   8521:        fi
                   8522: 
                   8523:        if test -n "$delfiles"; then
                   8524:          # Append the command to remove temporary files to $cmds.
                   8525:          eval cmds=\"\$cmds~\$RM $delfiles\"
                   8526:        fi
                   8527: 
                   8528:        # Add any objects from preloaded convenience libraries
                   8529:        if test -n "$dlprefiles"; then
                   8530:          gentop="$output_objdir/${outputname}x"
                   8531:          func_append generated " $gentop"
                   8532: 
                   8533:          func_extract_archives $gentop $dlprefiles
                   8534:          func_append libobjs " $func_extract_archives_result"
                   8535:          test "X$libobjs" = "X " && libobjs=
                   8536:        fi
                   8537: 
                   8538:        save_ifs="$IFS"; IFS='~'
                   8539:        for cmd in $cmds; do
                   8540:          IFS="$save_ifs"
                   8541:          eval cmd=\"$cmd\"
                   8542:          $opt_silent || {
                   8543:            func_quote_for_expand "$cmd"
                   8544:            eval "func_echo $func_quote_for_expand_result"
                   8545:          }
                   8546:          $opt_dry_run || eval "$cmd" || {
                   8547:            lt_exit=$?
                   8548: 
                   8549:            # Restore the uninstalled library and exit
                   8550:            if test "$opt_mode" = relink; then
                   8551:              ( cd "$output_objdir" && \
                   8552:                $RM "${realname}T" && \
                   8553:                $MV "${realname}U" "$realname" )
                   8554:            fi
                   8555: 
                   8556:            exit $lt_exit
                   8557:          }
                   8558:        done
                   8559:        IFS="$save_ifs"
                   8560: 
                   8561:        # Restore the uninstalled library and exit
                   8562:        if test "$opt_mode" = relink; then
                   8563:          $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
                   8564: 
                   8565:          if test -n "$convenience"; then
                   8566:            if test -z "$whole_archive_flag_spec"; then
                   8567:              func_show_eval '${RM}r "$gentop"'
                   8568:            fi
                   8569:          fi
                   8570: 
                   8571:          exit $EXIT_SUCCESS
                   8572:        fi
                   8573: 
                   8574:        # Create links to the real library.
                   8575:        for linkname in $linknames; do
                   8576:          if test "$realname" != "$linkname"; then
                   8577:            func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
                   8578:          fi
                   8579:        done
                   8580: 
                   8581:        # If -module or -export-dynamic was specified, set the dlname.
                   8582:        if test "$module" = yes || test "$export_dynamic" = yes; then
                   8583:          # On all known operating systems, these are identical.
                   8584:          dlname="$soname"
                   8585:        fi
                   8586:       fi
                   8587:       ;;
                   8588: 
                   8589:     obj)
                   8590:       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
                   8591:        func_warning "\`-dlopen' is ignored for objects"
                   8592:       fi
                   8593: 
                   8594:       case " $deplibs" in
                   8595:       *\ -l* | *\ -L*)
                   8596:        func_warning "\`-l' and \`-L' are ignored for objects" ;;
                   8597:       esac
                   8598: 
                   8599:       test -n "$rpath" && \
                   8600:        func_warning "\`-rpath' is ignored for objects"
                   8601: 
                   8602:       test -n "$xrpath" && \
                   8603:        func_warning "\`-R' is ignored for objects"
                   8604: 
                   8605:       test -n "$vinfo" && \
                   8606:        func_warning "\`-version-info' is ignored for objects"
                   8607: 
                   8608:       test -n "$release" && \
                   8609:        func_warning "\`-release' is ignored for objects"
                   8610: 
                   8611:       case $output in
                   8612:       *.lo)
                   8613:        test -n "$objs$old_deplibs" && \
                   8614:          func_fatal_error "cannot build library object \`$output' from non-libtool objects"
                   8615: 
                   8616:        libobj=$output
                   8617:        func_lo2o "$libobj"
                   8618:        obj=$func_lo2o_result
                   8619:        ;;
                   8620:       *)
                   8621:        libobj=
                   8622:        obj="$output"
                   8623:        ;;
                   8624:       esac
                   8625: 
                   8626:       # Delete the old objects.
                   8627:       $opt_dry_run || $RM $obj $libobj
                   8628: 
                   8629:       # Objects from convenience libraries.  This assumes
                   8630:       # single-version convenience libraries.  Whenever we create
                   8631:       # different ones for PIC/non-PIC, this we'll have to duplicate
                   8632:       # the extraction.
                   8633:       reload_conv_objs=
                   8634:       gentop=
                   8635:       # reload_cmds runs $LD directly, so let us get rid of
                   8636:       # -Wl from whole_archive_flag_spec and hope we can get by with
                   8637:       # turning comma into space..
                   8638:       wl=
                   8639: 
                   8640:       if test -n "$convenience"; then
                   8641:        if test -n "$whole_archive_flag_spec"; then
                   8642:          eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
                   8643:          reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
                   8644:        else
                   8645:          gentop="$output_objdir/${obj}x"
                   8646:          func_append generated " $gentop"
                   8647: 
                   8648:          func_extract_archives $gentop $convenience
                   8649:          reload_conv_objs="$reload_objs $func_extract_archives_result"
                   8650:        fi
                   8651:       fi
                   8652: 
                   8653:       # If we're not building shared, we need to use non_pic_objs
                   8654:       test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"
                   8655: 
                   8656:       # Create the old-style object.
                   8657:       reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
                   8658: 
                   8659:       output="$obj"
                   8660:       func_execute_cmds "$reload_cmds" 'exit $?'
                   8661: 
                   8662:       # Exit if we aren't doing a library object file.
                   8663:       if test -z "$libobj"; then
                   8664:        if test -n "$gentop"; then
                   8665:          func_show_eval '${RM}r "$gentop"'
                   8666:        fi
                   8667: 
                   8668:        exit $EXIT_SUCCESS
                   8669:       fi
                   8670: 
                   8671:       if test "$build_libtool_libs" != yes; then
                   8672:        if test -n "$gentop"; then
                   8673:          func_show_eval '${RM}r "$gentop"'
                   8674:        fi
                   8675: 
                   8676:        # Create an invalid libtool object if no PIC, so that we don't
                   8677:        # accidentally link it into a program.
                   8678:        # $show "echo timestamp > $libobj"
                   8679:        # $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
                   8680:        exit $EXIT_SUCCESS
                   8681:       fi
                   8682: 
                   8683:       if test -n "$pic_flag" || test "$pic_mode" != default; then
                   8684:        # Only do commands if we really have different PIC objects.
                   8685:        reload_objs="$libobjs $reload_conv_objs"
                   8686:        output="$libobj"
                   8687:        func_execute_cmds "$reload_cmds" 'exit $?'
                   8688:       fi
                   8689: 
                   8690:       if test -n "$gentop"; then
                   8691:        func_show_eval '${RM}r "$gentop"'
                   8692:       fi
                   8693: 
                   8694:       exit $EXIT_SUCCESS
                   8695:       ;;
                   8696: 
                   8697:     prog)
                   8698:       case $host in
                   8699:        *cygwin*) func_stripname '' '.exe' "$output"
                   8700:                  output=$func_stripname_result.exe;;
                   8701:       esac
                   8702:       test -n "$vinfo" && \
                   8703:        func_warning "\`-version-info' is ignored for programs"
                   8704: 
                   8705:       test -n "$release" && \
                   8706:        func_warning "\`-release' is ignored for programs"
                   8707: 
                   8708:       test "$preload" = yes \
                   8709:         && test "$dlopen_support" = unknown \
                   8710:        && test "$dlopen_self" = unknown \
                   8711:        && test "$dlopen_self_static" = unknown && \
                   8712:          func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
                   8713: 
                   8714:       case $host in
                   8715:       *-*-rhapsody* | *-*-darwin1.[012])
                   8716:        # On Rhapsody replace the C library is the System framework
                   8717:        compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
                   8718:        finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
                   8719:        ;;
                   8720:       esac
                   8721: 
                   8722:       case $host in
                   8723:       *-*-darwin*)
                   8724:        # Don't allow lazy linking, it breaks C++ global constructors
                   8725:        # But is supposedly fixed on 10.4 or later (yay!).
                   8726:        if test "$tagname" = CXX ; then
                   8727:          case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
                   8728:            10.[0123])
                   8729:              func_append compile_command " ${wl}-bind_at_load"
                   8730:              func_append finalize_command " ${wl}-bind_at_load"
                   8731:            ;;
                   8732:          esac
                   8733:        fi
                   8734:        # Time to change all our "foo.ltframework" stuff back to "-framework foo"
                   8735:        compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
                   8736:        finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
                   8737:        ;;
                   8738:       esac
                   8739: 
                   8740: 
                   8741:       # move library search paths that coincide with paths to not yet
                   8742:       # installed libraries to the beginning of the library search list
                   8743:       new_libs=
                   8744:       for path in $notinst_path; do
                   8745:        case " $new_libs " in
                   8746:        *" -L$path/$objdir "*) ;;
                   8747:        *)
                   8748:          case " $compile_deplibs " in
                   8749:          *" -L$path/$objdir "*)
                   8750:            func_append new_libs " -L$path/$objdir" ;;
                   8751:          esac
                   8752:          ;;
                   8753:        esac
                   8754:       done
                   8755:       for deplib in $compile_deplibs; do
                   8756:        case $deplib in
                   8757:        -L*)
                   8758:          case " $new_libs " in
                   8759:          *" $deplib "*) ;;
                   8760:          *) func_append new_libs " $deplib" ;;
                   8761:          esac
                   8762:          ;;
                   8763:        *) func_append new_libs " $deplib" ;;
                   8764:        esac
                   8765:       done
                   8766:       compile_deplibs="$new_libs"
                   8767: 
                   8768: 
                   8769:       func_append compile_command " $compile_deplibs"
                   8770:       func_append finalize_command " $finalize_deplibs"
                   8771: 
                   8772:       if test -n "$rpath$xrpath"; then
                   8773:        # If the user specified any rpath flags, then add them.
                   8774:        for libdir in $rpath $xrpath; do
                   8775:          # This is the magic to use -rpath.
                   8776:          case "$finalize_rpath " in
                   8777:          *" $libdir "*) ;;
                   8778:          *) func_append finalize_rpath " $libdir" ;;
                   8779:          esac
                   8780:        done
                   8781:       fi
                   8782: 
                   8783:       # Now hardcode the library paths
                   8784:       rpath=
                   8785:       hardcode_libdirs=
                   8786:       for libdir in $compile_rpath $finalize_rpath; do
                   8787:        if test -n "$hardcode_libdir_flag_spec"; then
                   8788:          if test -n "$hardcode_libdir_separator"; then
                   8789:            if test -z "$hardcode_libdirs"; then
                   8790:              hardcode_libdirs="$libdir"
                   8791:            else
                   8792:              # Just accumulate the unique libdirs.
                   8793:              case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
                   8794:              *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
                   8795:                ;;
                   8796:              *)
                   8797:                func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
                   8798:                ;;
                   8799:              esac
                   8800:            fi
                   8801:          else
                   8802:            eval flag=\"$hardcode_libdir_flag_spec\"
                   8803:            func_append rpath " $flag"
                   8804:          fi
                   8805:        elif test -n "$runpath_var"; then
                   8806:          case "$perm_rpath " in
                   8807:          *" $libdir "*) ;;
                   8808:          *) func_append perm_rpath " $libdir" ;;
                   8809:          esac
                   8810:        fi
                   8811:        case $host in
                   8812:        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
                   8813:          testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
                   8814:          case :$dllsearchpath: in
                   8815:          *":$libdir:"*) ;;
                   8816:          ::) dllsearchpath=$libdir;;
                   8817:          *) func_append dllsearchpath ":$libdir";;
                   8818:          esac
                   8819:          case :$dllsearchpath: in
                   8820:          *":$testbindir:"*) ;;
                   8821:          ::) dllsearchpath=$testbindir;;
                   8822:          *) func_append dllsearchpath ":$testbindir";;
                   8823:          esac
                   8824:          ;;
                   8825:        esac
                   8826:       done
                   8827:       # Substitute the hardcoded libdirs into the rpath.
                   8828:       if test -n "$hardcode_libdir_separator" &&
                   8829:         test -n "$hardcode_libdirs"; then
                   8830:        libdir="$hardcode_libdirs"
                   8831:        eval rpath=\" $hardcode_libdir_flag_spec\"
                   8832:       fi
                   8833:       compile_rpath="$rpath"
                   8834: 
                   8835:       rpath=
                   8836:       hardcode_libdirs=
                   8837:       for libdir in $finalize_rpath; do
                   8838:        if test -n "$hardcode_libdir_flag_spec"; then
                   8839:          if test -n "$hardcode_libdir_separator"; then
                   8840:            if test -z "$hardcode_libdirs"; then
                   8841:              hardcode_libdirs="$libdir"
                   8842:            else
                   8843:              # Just accumulate the unique libdirs.
                   8844:              case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
                   8845:              *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
                   8846:                ;;
                   8847:              *)
                   8848:                func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
                   8849:                ;;
                   8850:              esac
                   8851:            fi
                   8852:          else
                   8853:            eval flag=\"$hardcode_libdir_flag_spec\"
                   8854:            func_append rpath " $flag"
                   8855:          fi
                   8856:        elif test -n "$runpath_var"; then
                   8857:          case "$finalize_perm_rpath " in
                   8858:          *" $libdir "*) ;;
                   8859:          *) func_append finalize_perm_rpath " $libdir" ;;
                   8860:          esac
                   8861:        fi
                   8862:       done
                   8863:       # Substitute the hardcoded libdirs into the rpath.
                   8864:       if test -n "$hardcode_libdir_separator" &&
                   8865:         test -n "$hardcode_libdirs"; then
                   8866:        libdir="$hardcode_libdirs"
                   8867:        eval rpath=\" $hardcode_libdir_flag_spec\"
                   8868:       fi
                   8869:       finalize_rpath="$rpath"
                   8870: 
                   8871:       if test -n "$libobjs" && test "$build_old_libs" = yes; then
                   8872:        # Transform all the library objects into standard objects.
                   8873:        compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
                   8874:        finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
                   8875:       fi
                   8876: 
                   8877:       func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
                   8878: 
                   8879:       # template prelinking step
                   8880:       if test -n "$prelink_cmds"; then
                   8881:        func_execute_cmds "$prelink_cmds" 'exit $?'
                   8882:       fi
                   8883: 
                   8884:       wrappers_required=yes
                   8885:       case $host in
                   8886:       *cegcc* | *mingw32ce*)
                   8887:         # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
                   8888:         wrappers_required=no
                   8889:         ;;
                   8890:       *cygwin* | *mingw* )
                   8891:         if test "$build_libtool_libs" != yes; then
                   8892:           wrappers_required=no
                   8893:         fi
                   8894:         ;;
                   8895:       *)
                   8896:         if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
                   8897:           wrappers_required=no
                   8898:         fi
                   8899:         ;;
                   8900:       esac
                   8901:       if test "$wrappers_required" = no; then
                   8902:        # Replace the output file specification.
                   8903:        compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
                   8904:        link_command="$compile_command$compile_rpath"
                   8905: 
                   8906:        # We have no uninstalled library dependencies, so finalize right now.
                   8907:        exit_status=0
                   8908:        func_show_eval "$link_command" 'exit_status=$?'
                   8909: 
                   8910:        if test -n "$postlink_cmds"; then
                   8911:          func_to_tool_file "$output"
                   8912:          postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
                   8913:          func_execute_cmds "$postlink_cmds" 'exit $?'
                   8914:        fi
                   8915: 
                   8916:        # Delete the generated files.
                   8917:        if test -f "$output_objdir/${outputname}S.${objext}"; then
                   8918:          func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
                   8919:        fi
                   8920: 
                   8921:        exit $exit_status
                   8922:       fi
                   8923: 
                   8924:       if test -n "$compile_shlibpath$finalize_shlibpath"; then
                   8925:        compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
                   8926:       fi
                   8927:       if test -n "$finalize_shlibpath"; then
                   8928:        finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
                   8929:       fi
                   8930: 
                   8931:       compile_var=
                   8932:       finalize_var=
                   8933:       if test -n "$runpath_var"; then
                   8934:        if test -n "$perm_rpath"; then
                   8935:          # We should set the runpath_var.
                   8936:          rpath=
                   8937:          for dir in $perm_rpath; do
                   8938:            func_append rpath "$dir:"
                   8939:          done
                   8940:          compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
                   8941:        fi
                   8942:        if test -n "$finalize_perm_rpath"; then
                   8943:          # We should set the runpath_var.
                   8944:          rpath=
                   8945:          for dir in $finalize_perm_rpath; do
                   8946:            func_append rpath "$dir:"
                   8947:          done
                   8948:          finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
                   8949:        fi
                   8950:       fi
                   8951: 
                   8952:       if test "$no_install" = yes; then
                   8953:        # We don't need to create a wrapper script.
                   8954:        link_command="$compile_var$compile_command$compile_rpath"
                   8955:        # Replace the output file specification.
                   8956:        link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
                   8957:        # Delete the old output file.
                   8958:        $opt_dry_run || $RM $output
                   8959:        # Link the executable and exit
                   8960:        func_show_eval "$link_command" 'exit $?'
                   8961: 
                   8962:        if test -n "$postlink_cmds"; then
                   8963:          func_to_tool_file "$output"
                   8964:          postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
                   8965:          func_execute_cmds "$postlink_cmds" 'exit $?'
                   8966:        fi
                   8967: 
                   8968:        exit $EXIT_SUCCESS
                   8969:       fi
                   8970: 
                   8971:       if test "$hardcode_action" = relink; then
                   8972:        # Fast installation is not supported
                   8973:        link_command="$compile_var$compile_command$compile_rpath"
                   8974:        relink_command="$finalize_var$finalize_command$finalize_rpath"
                   8975: 
                   8976:        func_warning "this platform does not like uninstalled shared libraries"
                   8977:        func_warning "\`$output' will be relinked during installation"
                   8978:       else
                   8979:        if test "$fast_install" != no; then
                   8980:          link_command="$finalize_var$compile_command$finalize_rpath"
                   8981:          if test "$fast_install" = yes; then
                   8982:            relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
                   8983:          else
                   8984:            # fast_install is set to needless
                   8985:            relink_command=
                   8986:          fi
                   8987:        else
                   8988:          link_command="$compile_var$compile_command$compile_rpath"
                   8989:          relink_command="$finalize_var$finalize_command$finalize_rpath"
                   8990:        fi
                   8991:       fi
                   8992: 
                   8993:       # Replace the output file specification.
                   8994:       link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
                   8995: 
                   8996:       # Delete the old output files.
                   8997:       $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
                   8998: 
                   8999:       func_show_eval "$link_command" 'exit $?'
                   9000: 
                   9001:       if test -n "$postlink_cmds"; then
                   9002:        func_to_tool_file "$output_objdir/$outputname"
                   9003:        postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
                   9004:        func_execute_cmds "$postlink_cmds" 'exit $?'
                   9005:       fi
                   9006: 
                   9007:       # Now create the wrapper script.
                   9008:       func_verbose "creating $output"
                   9009: 
                   9010:       # Quote the relink command for shipping.
                   9011:       if test -n "$relink_command"; then
                   9012:        # Preserve any variables that may affect compiler behavior
                   9013:        for var in $variables_saved_for_relink; do
                   9014:          if eval test -z \"\${$var+set}\"; then
                   9015:            relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
                   9016:          elif eval var_value=\$$var; test -z "$var_value"; then
                   9017:            relink_command="$var=; export $var; $relink_command"
                   9018:          else
                   9019:            func_quote_for_eval "$var_value"
                   9020:            relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
                   9021:          fi
                   9022:        done
                   9023:        relink_command="(cd `pwd`; $relink_command)"
                   9024:        relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
                   9025:       fi
                   9026: 
                   9027:       # Only actually do things if not in dry run mode.
                   9028:       $opt_dry_run || {
                   9029:        # win32 will think the script is a binary if it has
                   9030:        # a .exe suffix, so we strip it off here.
                   9031:        case $output in
                   9032:          *.exe) func_stripname '' '.exe' "$output"
                   9033:                 output=$func_stripname_result ;;
                   9034:        esac
                   9035:        # test for cygwin because mv fails w/o .exe extensions
                   9036:        case $host in
                   9037:          *cygwin*)
                   9038:            exeext=.exe
                   9039:            func_stripname '' '.exe' "$outputname"
                   9040:            outputname=$func_stripname_result ;;
                   9041:          *) exeext= ;;
                   9042:        esac
                   9043:        case $host in
                   9044:          *cygwin* | *mingw* )
                   9045:            func_dirname_and_basename "$output" "" "."
                   9046:            output_name=$func_basename_result
                   9047:            output_path=$func_dirname_result
                   9048:            cwrappersource="$output_path/$objdir/lt-$output_name.c"
                   9049:            cwrapper="$output_path/$output_name.exe"
                   9050:            $RM $cwrappersource $cwrapper
                   9051:            trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
                   9052: 
                   9053:            func_emit_cwrapperexe_src > $cwrappersource
                   9054: 
                   9055:            # The wrapper executable is built using the $host compiler,
                   9056:            # because it contains $host paths and files. If cross-
                   9057:            # compiling, it, like the target executable, must be
                   9058:            # executed on the $host or under an emulation environment.
                   9059:            $opt_dry_run || {
                   9060:              $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
                   9061:              $STRIP $cwrapper
                   9062:            }
                   9063: 
                   9064:            # Now, create the wrapper script for func_source use:
                   9065:            func_ltwrapper_scriptname $cwrapper
                   9066:            $RM $func_ltwrapper_scriptname_result
                   9067:            trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
                   9068:            $opt_dry_run || {
                   9069:              # note: this script will not be executed, so do not chmod.
                   9070:              if test "x$build" = "x$host" ; then
                   9071:                $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
                   9072:              else
                   9073:                func_emit_wrapper no > $func_ltwrapper_scriptname_result
                   9074:              fi
                   9075:            }
                   9076:          ;;
                   9077:          * )
                   9078:            $RM $output
                   9079:            trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
                   9080: 
                   9081:            func_emit_wrapper no > $output
                   9082:            chmod +x $output
                   9083:          ;;
                   9084:        esac
                   9085:       }
                   9086:       exit $EXIT_SUCCESS
                   9087:       ;;
                   9088:     esac
                   9089: 
                   9090:     # See if we need to build an old-fashioned archive.
                   9091:     for oldlib in $oldlibs; do
                   9092: 
                   9093:       if test "$build_libtool_libs" = convenience; then
                   9094:        oldobjs="$libobjs_save $symfileobj"
                   9095:        addlibs="$convenience"
                   9096:        build_libtool_libs=no
                   9097:       else
                   9098:        if test "$build_libtool_libs" = module; then
                   9099:          oldobjs="$libobjs_save"
                   9100:          build_libtool_libs=no
                   9101:        else
                   9102:          oldobjs="$old_deplibs $non_pic_objects"
                   9103:          if test "$preload" = yes && test -f "$symfileobj"; then
                   9104:            func_append oldobjs " $symfileobj"
                   9105:          fi
                   9106:        fi
                   9107:        addlibs="$old_convenience"
                   9108:       fi
                   9109: 
                   9110:       if test -n "$addlibs"; then
                   9111:        gentop="$output_objdir/${outputname}x"
                   9112:        func_append generated " $gentop"
                   9113: 
                   9114:        func_extract_archives $gentop $addlibs
                   9115:        func_append oldobjs " $func_extract_archives_result"
                   9116:       fi
                   9117: 
                   9118:       # Do each command in the archive commands.
                   9119:       if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
                   9120:        cmds=$old_archive_from_new_cmds
                   9121:       else
                   9122: 
                   9123:        # Add any objects from preloaded convenience libraries
                   9124:        if test -n "$dlprefiles"; then
                   9125:          gentop="$output_objdir/${outputname}x"
                   9126:          func_append generated " $gentop"
                   9127: 
                   9128:          func_extract_archives $gentop $dlprefiles
                   9129:          func_append oldobjs " $func_extract_archives_result"
                   9130:        fi
                   9131: 
                   9132:        # POSIX demands no paths to be encoded in archives.  We have
                   9133:        # to avoid creating archives with duplicate basenames if we
                   9134:        # might have to extract them afterwards, e.g., when creating a
                   9135:        # static archive out of a convenience library, or when linking
                   9136:        # the entirety of a libtool archive into another (currently
                   9137:        # not supported by libtool).
                   9138:        if (for obj in $oldobjs
                   9139:            do
                   9140:              func_basename "$obj"
                   9141:              $ECHO "$func_basename_result"
                   9142:            done | sort | sort -uc >/dev/null 2>&1); then
                   9143:          :
                   9144:        else
                   9145:          echo "copying selected object files to avoid basename conflicts..."
                   9146:          gentop="$output_objdir/${outputname}x"
                   9147:          func_append generated " $gentop"
                   9148:          func_mkdir_p "$gentop"
                   9149:          save_oldobjs=$oldobjs
                   9150:          oldobjs=
                   9151:          counter=1
                   9152:          for obj in $save_oldobjs
                   9153:          do
                   9154:            func_basename "$obj"
                   9155:            objbase="$func_basename_result"
                   9156:            case " $oldobjs " in
                   9157:            " ") oldobjs=$obj ;;
                   9158:            *[\ /]"$objbase "*)
                   9159:              while :; do
                   9160:                # Make sure we don't pick an alternate name that also
                   9161:                # overlaps.
                   9162:                newobj=lt$counter-$objbase
                   9163:                func_arith $counter + 1
                   9164:                counter=$func_arith_result
                   9165:                case " $oldobjs " in
                   9166:                *[\ /]"$newobj "*) ;;
                   9167:                *) if test ! -f "$gentop/$newobj"; then break; fi ;;
                   9168:                esac
                   9169:              done
                   9170:              func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
                   9171:              func_append oldobjs " $gentop/$newobj"
                   9172:              ;;
                   9173:            *) func_append oldobjs " $obj" ;;
                   9174:            esac
                   9175:          done
                   9176:        fi
                   9177:        func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
                   9178:        tool_oldlib=$func_to_tool_file_result
                   9179:        eval cmds=\"$old_archive_cmds\"
                   9180: 
                   9181:        func_len " $cmds"
                   9182:        len=$func_len_result
                   9183:        if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
                   9184:          cmds=$old_archive_cmds
                   9185:        elif test -n "$archiver_list_spec"; then
                   9186:          func_verbose "using command file archive linking..."
                   9187:          for obj in $oldobjs
                   9188:          do
                   9189:            func_to_tool_file "$obj"
                   9190:            $ECHO "$func_to_tool_file_result"
                   9191:          done > $output_objdir/$libname.libcmd
                   9192:          func_to_tool_file "$output_objdir/$libname.libcmd"
                   9193:          oldobjs=" $archiver_list_spec$func_to_tool_file_result"
                   9194:          cmds=$old_archive_cmds
                   9195:        else
                   9196:          # the command line is too long to link in one step, link in parts
                   9197:          func_verbose "using piecewise archive linking..."
                   9198:          save_RANLIB=$RANLIB
                   9199:          RANLIB=:
                   9200:          objlist=
                   9201:          concat_cmds=
                   9202:          save_oldobjs=$oldobjs
                   9203:          oldobjs=
                   9204:          # Is there a better way of finding the last object in the list?
                   9205:          for obj in $save_oldobjs
                   9206:          do
                   9207:            last_oldobj=$obj
                   9208:          done
                   9209:          eval test_cmds=\"$old_archive_cmds\"
                   9210:          func_len " $test_cmds"
                   9211:          len0=$func_len_result
                   9212:          len=$len0
                   9213:          for obj in $save_oldobjs
                   9214:          do
                   9215:            func_len " $obj"
                   9216:            func_arith $len + $func_len_result
                   9217:            len=$func_arith_result
                   9218:            func_append objlist " $obj"
                   9219:            if test "$len" -lt "$max_cmd_len"; then
                   9220:              :
                   9221:            else
                   9222:              # the above command should be used before it gets too long
                   9223:              oldobjs=$objlist
                   9224:              if test "$obj" = "$last_oldobj" ; then
                   9225:                RANLIB=$save_RANLIB
                   9226:              fi
                   9227:              test -z "$concat_cmds" || concat_cmds=$concat_cmds~
                   9228:              eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
                   9229:              objlist=
                   9230:              len=$len0
                   9231:            fi
                   9232:          done
                   9233:          RANLIB=$save_RANLIB
                   9234:          oldobjs=$objlist
                   9235:          if test "X$oldobjs" = "X" ; then
                   9236:            eval cmds=\"\$concat_cmds\"
                   9237:          else
                   9238:            eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
                   9239:          fi
                   9240:        fi
                   9241:       fi
                   9242:       func_execute_cmds "$cmds" 'exit $?'
                   9243:     done
                   9244: 
                   9245:     test -n "$generated" && \
                   9246:       func_show_eval "${RM}r$generated"
                   9247: 
                   9248:     # Now create the libtool archive.
                   9249:     case $output in
                   9250:     *.la)
                   9251:       old_library=
                   9252:       test "$build_old_libs" = yes && old_library="$libname.$libext"
                   9253:       func_verbose "creating $output"
                   9254: 
                   9255:       # Preserve any variables that may affect compiler behavior
                   9256:       for var in $variables_saved_for_relink; do
                   9257:        if eval test -z \"\${$var+set}\"; then
                   9258:          relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
                   9259:        elif eval var_value=\$$var; test -z "$var_value"; then
                   9260:          relink_command="$var=; export $var; $relink_command"
                   9261:        else
                   9262:          func_quote_for_eval "$var_value"
                   9263:          relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
                   9264:        fi
                   9265:       done
                   9266:       # Quote the link command for shipping.
                   9267:       relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
                   9268:       relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
                   9269:       if test "$hardcode_automatic" = yes ; then
                   9270:        relink_command=
                   9271:       fi
                   9272: 
                   9273:       # Only create the output if not a dry run.
                   9274:       $opt_dry_run || {
                   9275:        for installed in no yes; do
                   9276:          if test "$installed" = yes; then
                   9277:            if test -z "$install_libdir"; then
                   9278:              break
                   9279:            fi
                   9280:            output="$output_objdir/$outputname"i
                   9281:            # Replace all uninstalled libtool libraries with the installed ones
                   9282:            newdependency_libs=
                   9283:            for deplib in $dependency_libs; do
                   9284:              case $deplib in
                   9285:              *.la)
                   9286:                func_basename "$deplib"
                   9287:                name="$func_basename_result"
                   9288:                func_resolve_sysroot "$deplib"
                   9289:                eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result`
                   9290:                test -z "$libdir" && \
                   9291:                  func_fatal_error "\`$deplib' is not a valid libtool archive"
                   9292:                func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
                   9293:                ;;
                   9294:              -L*)
                   9295:                func_stripname -L '' "$deplib"
                   9296:                func_replace_sysroot "$func_stripname_result"
                   9297:                func_append newdependency_libs " -L$func_replace_sysroot_result"
                   9298:                ;;
                   9299:              -R*)
                   9300:                func_stripname -R '' "$deplib"
                   9301:                func_replace_sysroot "$func_stripname_result"
                   9302:                func_append newdependency_libs " -R$func_replace_sysroot_result"
                   9303:                ;;
                   9304:              *) func_append newdependency_libs " $deplib" ;;
                   9305:              esac
                   9306:            done
                   9307:            dependency_libs="$newdependency_libs"
                   9308:            newdlfiles=
                   9309: 
                   9310:            for lib in $dlfiles; do
                   9311:              case $lib in
                   9312:              *.la)
                   9313:                func_basename "$lib"
                   9314:                name="$func_basename_result"
                   9315:                eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
                   9316:                test -z "$libdir" && \
                   9317:                  func_fatal_error "\`$lib' is not a valid libtool archive"
                   9318:                func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
                   9319:                ;;
                   9320:              *) func_append newdlfiles " $lib" ;;
                   9321:              esac
                   9322:            done
                   9323:            dlfiles="$newdlfiles"
                   9324:            newdlprefiles=
                   9325:            for lib in $dlprefiles; do
                   9326:              case $lib in
                   9327:              *.la)
                   9328:                # Only pass preopened files to the pseudo-archive (for
                   9329:                # eventual linking with the app. that links it) if we
                   9330:                # didn't already link the preopened objects directly into
                   9331:                # the library:
                   9332:                func_basename "$lib"
                   9333:                name="$func_basename_result"
                   9334:                eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
                   9335:                test -z "$libdir" && \
                   9336:                  func_fatal_error "\`$lib' is not a valid libtool archive"
                   9337:                func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
                   9338:                ;;
                   9339:              esac
                   9340:            done
                   9341:            dlprefiles="$newdlprefiles"
                   9342:          else
                   9343:            newdlfiles=
                   9344:            for lib in $dlfiles; do
                   9345:              case $lib in
                   9346:                [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
                   9347:                *) abs=`pwd`"/$lib" ;;
                   9348:              esac
                   9349:              func_append newdlfiles " $abs"
                   9350:            done
                   9351:            dlfiles="$newdlfiles"
                   9352:            newdlprefiles=
                   9353:            for lib in $dlprefiles; do
                   9354:              case $lib in
                   9355:                [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
                   9356:                *) abs=`pwd`"/$lib" ;;
                   9357:              esac
                   9358:              func_append newdlprefiles " $abs"
                   9359:            done
                   9360:            dlprefiles="$newdlprefiles"
                   9361:          fi
                   9362:          $RM $output
                   9363:          # place dlname in correct position for cygwin
                   9364:          # In fact, it would be nice if we could use this code for all target
                   9365:          # systems that can't hard-code library paths into their executables
                   9366:          # and that have no shared library path variable independent of PATH,
                   9367:          # but it turns out we can't easily determine that from inspecting
                   9368:          # libtool variables, so we have to hard-code the OSs to which it
                   9369:          # applies here; at the moment, that means platforms that use the PE
                   9370:          # object format with DLL files.  See the long comment at the top of
                   9371:          # tests/bindir.at for full details.
                   9372:          tdlname=$dlname
                   9373:          case $host,$output,$installed,$module,$dlname in
                   9374:            *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
                   9375:              # If a -bindir argument was supplied, place the dll there.
                   9376:              if test "x$bindir" != x ;
                   9377:              then
                   9378:                func_relative_path "$install_libdir" "$bindir"
                   9379:                tdlname=$func_relative_path_result$dlname
                   9380:              else
                   9381:                # Otherwise fall back on heuristic.
                   9382:                tdlname=../bin/$dlname
                   9383:              fi
                   9384:              ;;
                   9385:          esac
                   9386:          $ECHO > $output "\
                   9387: # $outputname - a libtool library file
                   9388: # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
                   9389: #
                   9390: # Please DO NOT delete this file!
                   9391: # It is necessary for linking the library.
                   9392: 
                   9393: # The name that we can dlopen(3).
                   9394: dlname='$tdlname'
                   9395: 
                   9396: # Names of this library.
                   9397: library_names='$library_names'
                   9398: 
                   9399: # The name of the static archive.
                   9400: old_library='$old_library'
                   9401: 
                   9402: # Linker flags that can not go in dependency_libs.
                   9403: inherited_linker_flags='$new_inherited_linker_flags'
                   9404: 
                   9405: # Libraries that this one depends upon.
                   9406: dependency_libs='$dependency_libs'
                   9407: 
                   9408: # Names of additional weak libraries provided by this library
                   9409: weak_library_names='$weak_libs'
                   9410: 
                   9411: # Version information for $libname.
                   9412: current=$current
                   9413: age=$age
                   9414: revision=$revision
                   9415: 
                   9416: # Is this an already installed library?
                   9417: installed=$installed
                   9418: 
                   9419: # Should we warn about portability when linking against -modules?
                   9420: shouldnotlink=$module
                   9421: 
                   9422: # Files to dlopen/dlpreopen
                   9423: dlopen='$dlfiles'
                   9424: dlpreopen='$dlprefiles'
                   9425: 
                   9426: # Directory that this library needs to be installed in:
                   9427: libdir='$install_libdir'"
                   9428:          if test "$installed" = no && test "$need_relink" = yes; then
                   9429:            $ECHO >> $output "\
                   9430: relink_command=\"$relink_command\""
                   9431:          fi
                   9432:        done
                   9433:       }
                   9434: 
                   9435:       # Do a symbolic link so that the libtool archive can be found in
                   9436:       # LD_LIBRARY_PATH before the program is installed.
                   9437:       func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
                   9438:       ;;
                   9439:     esac
                   9440:     exit $EXIT_SUCCESS
                   9441: }
                   9442: 
                   9443: { test "$opt_mode" = link || test "$opt_mode" = relink; } &&
                   9444:     func_mode_link ${1+"$@"}
                   9445: 
                   9446: 
                   9447: # func_mode_uninstall arg...
                   9448: func_mode_uninstall ()
                   9449: {
                   9450:     $opt_debug
                   9451:     RM="$nonopt"
                   9452:     files=
                   9453:     rmforce=
                   9454:     exit_status=0
                   9455: 
                   9456:     # This variable tells wrapper scripts just to set variables rather
                   9457:     # than running their programs.
                   9458:     libtool_install_magic="$magic"
                   9459: 
                   9460:     for arg
                   9461:     do
                   9462:       case $arg in
                   9463:       -f) func_append RM " $arg"; rmforce=yes ;;
                   9464:       -*) func_append RM " $arg" ;;
                   9465:       *) func_append files " $arg" ;;
                   9466:       esac
                   9467:     done
                   9468: 
                   9469:     test -z "$RM" && \
                   9470:       func_fatal_help "you must specify an RM program"
                   9471: 
                   9472:     rmdirs=
                   9473: 
                   9474:     for file in $files; do
                   9475:       func_dirname "$file" "" "."
                   9476:       dir="$func_dirname_result"
                   9477:       if test "X$dir" = X.; then
                   9478:        odir="$objdir"
                   9479:       else
                   9480:        odir="$dir/$objdir"
                   9481:       fi
                   9482:       func_basename "$file"
                   9483:       name="$func_basename_result"
                   9484:       test "$opt_mode" = uninstall && odir="$dir"
                   9485: 
                   9486:       # Remember odir for removal later, being careful to avoid duplicates
                   9487:       if test "$opt_mode" = clean; then
                   9488:        case " $rmdirs " in
                   9489:          *" $odir "*) ;;
                   9490:          *) func_append rmdirs " $odir" ;;
                   9491:        esac
                   9492:       fi
                   9493: 
                   9494:       # Don't error if the file doesn't exist and rm -f was used.
                   9495:       if { test -L "$file"; } >/dev/null 2>&1 ||
                   9496:         { test -h "$file"; } >/dev/null 2>&1 ||
                   9497:         test -f "$file"; then
                   9498:        :
                   9499:       elif test -d "$file"; then
                   9500:        exit_status=1
                   9501:        continue
                   9502:       elif test "$rmforce" = yes; then
                   9503:        continue
                   9504:       fi
                   9505: 
                   9506:       rmfiles="$file"
                   9507: 
                   9508:       case $name in
                   9509:       *.la)
                   9510:        # Possibly a libtool archive, so verify it.
                   9511:        if func_lalib_p "$file"; then
                   9512:          func_source $dir/$name
                   9513: 
                   9514:          # Delete the libtool libraries and symlinks.
                   9515:          for n in $library_names; do
                   9516:            func_append rmfiles " $odir/$n"
                   9517:          done
                   9518:          test -n "$old_library" && func_append rmfiles " $odir/$old_library"
                   9519: 
                   9520:          case "$opt_mode" in
                   9521:          clean)
                   9522:            case " $library_names " in
                   9523:            *" $dlname "*) ;;
                   9524:            *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
                   9525:            esac
                   9526:            test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
                   9527:            ;;
                   9528:          uninstall)
                   9529:            if test -n "$library_names"; then
                   9530:              # Do each command in the postuninstall commands.
                   9531:              func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
                   9532:            fi
                   9533: 
                   9534:            if test -n "$old_library"; then
                   9535:              # Do each command in the old_postuninstall commands.
                   9536:              func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
                   9537:            fi
                   9538:            # FIXME: should reinstall the best remaining shared library.
                   9539:            ;;
                   9540:          esac
                   9541:        fi
                   9542:        ;;
                   9543: 
                   9544:       *.lo)
                   9545:        # Possibly a libtool object, so verify it.
                   9546:        if func_lalib_p "$file"; then
                   9547: 
                   9548:          # Read the .lo file
                   9549:          func_source $dir/$name
                   9550: 
                   9551:          # Add PIC object to the list of files to remove.
                   9552:          if test -n "$pic_object" &&
                   9553:             test "$pic_object" != none; then
                   9554:            func_append rmfiles " $dir/$pic_object"
                   9555:          fi
                   9556: 
                   9557:          # Add non-PIC object to the list of files to remove.
                   9558:          if test -n "$non_pic_object" &&
                   9559:             test "$non_pic_object" != none; then
                   9560:            func_append rmfiles " $dir/$non_pic_object"
                   9561:          fi
                   9562:        fi
                   9563:        ;;
                   9564: 
                   9565:       *)
                   9566:        if test "$opt_mode" = clean ; then
                   9567:          noexename=$name
                   9568:          case $file in
                   9569:          *.exe)
                   9570:            func_stripname '' '.exe' "$file"
                   9571:            file=$func_stripname_result
                   9572:            func_stripname '' '.exe' "$name"
                   9573:            noexename=$func_stripname_result
                   9574:            # $file with .exe has already been added to rmfiles,
                   9575:            # add $file without .exe
                   9576:            func_append rmfiles " $file"
                   9577:            ;;
                   9578:          esac
                   9579:          # Do a test to see if this is a libtool program.
                   9580:          if func_ltwrapper_p "$file"; then
                   9581:            if func_ltwrapper_executable_p "$file"; then
                   9582:              func_ltwrapper_scriptname "$file"
                   9583:              relink_command=
                   9584:              func_source $func_ltwrapper_scriptname_result
                   9585:              func_append rmfiles " $func_ltwrapper_scriptname_result"
                   9586:            else
                   9587:              relink_command=
                   9588:              func_source $dir/$noexename
                   9589:            fi
                   9590: 
                   9591:            # note $name still contains .exe if it was in $file originally
                   9592:            # as does the version of $file that was added into $rmfiles
                   9593:            func_append rmfiles " $odir/$name $odir/${name}S.${objext}"
                   9594:            if test "$fast_install" = yes && test -n "$relink_command"; then
                   9595:              func_append rmfiles " $odir/lt-$name"
                   9596:            fi
                   9597:            if test "X$noexename" != "X$name" ; then
                   9598:              func_append rmfiles " $odir/lt-${noexename}.c"
                   9599:            fi
                   9600:          fi
                   9601:        fi
                   9602:        ;;
                   9603:       esac
                   9604:       func_show_eval "$RM $rmfiles" 'exit_status=1'
                   9605:     done
                   9606: 
                   9607:     # Try to remove the ${objdir}s in the directories where we deleted files
                   9608:     for dir in $rmdirs; do
                   9609:       if test -d "$dir"; then
                   9610:        func_show_eval "rmdir $dir >/dev/null 2>&1"
                   9611:       fi
                   9612:     done
                   9613: 
                   9614:     exit $exit_status
                   9615: }
                   9616: 
                   9617: { test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&
                   9618:     func_mode_uninstall ${1+"$@"}
                   9619: 
                   9620: test -z "$opt_mode" && {
                   9621:   help="$generic_help"
                   9622:   func_fatal_help "you must specify a MODE"
                   9623: }
                   9624: 
                   9625: test -z "$exec_cmd" && \
                   9626:   func_fatal_help "invalid operation mode \`$opt_mode'"
                   9627: 
                   9628: if test -n "$exec_cmd"; then
                   9629:   eval exec "$exec_cmd"
                   9630:   exit $EXIT_FAILURE
                   9631: fi
                   9632: 
                   9633: exit $exit_status
                   9634: 
                   9635: 
                   9636: # The TAGs below are defined such that we never get into a situation
                   9637: # in which we disable both kinds of libraries.  Given conflicting
                   9638: # choices, we go for a static library, that is the most portable,
                   9639: # since we can't tell whether shared libraries were disabled because
                   9640: # the user asked for that or because the platform doesn't support
                   9641: # them.  This is particularly important on AIX, because we don't
                   9642: # support having both static and shared libraries enabled at the same
                   9643: # time on that platform, so we default to a shared-only configuration.
                   9644: # If a disable-shared tag is given, we'll fallback to a static-only
                   9645: # configuration.  But we'll never go from static-only to shared-only.
                   9646: 
                   9647: # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
                   9648: build_libtool_libs=no
                   9649: build_old_libs=yes
                   9650: # ### END LIBTOOL TAG CONFIG: disable-shared
                   9651: 
                   9652: # ### BEGIN LIBTOOL TAG CONFIG: disable-static
                   9653: build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
                   9654: # ### END LIBTOOL TAG CONFIG: disable-static
                   9655: 
                   9656: # Local Variables:
                   9657: # mode:shell-script
                   9658: # sh-indentation:2
                   9659: # End:
                   9660: # vi:sw=2
                   9661: 

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>