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