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