1# Generated from ltmain.m4sh. 2 3# ltmain.sh (GNU libtool) 2.2.4 4# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996 5 6# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007 2008 Free Software Foundation, Inc. 7# This is free software; see the source for copying conditions. There is NO 8# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 9 10# GNU Libtool is free software; you can redistribute it and/or modify 11# it under the terms of the GNU General Public License as published by 12# the Free Software Foundation; either version 2 of the License, or 13# (at your option) any later version. 14# 15# As a special exception to the GNU General Public License, 16# if you distribute this file as part of a program or library that 17# is built using GNU Libtool, you may include this file under the 18# same distribution terms that you use for the rest of that program. 19# 20# GNU Libtool is distributed in the hope that it will be useful, but 21# WITHOUT ANY WARRANTY; without even the implied warranty of 22# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 23# General Public License for more details. 24# 25# You should have received a copy of the GNU General Public License 26# along with GNU Libtool; see the file COPYING. If not, a copy 27# can be downloaded from http://www.gnu.org/licenses/gpl.html, 28# or obtained by writing to the Free Software Foundation, Inc., 29# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 30 31# Usage: $progname [OPTION]... [MODE-ARG]... 32# 33# Provide generalized library-building support services. 34# 35# --config show all configuration variables 36# --debug enable verbose shell tracing 37# -n, --dry-run display commands without modifying any files 38# --features display basic configuration information and exit 39# --mode=MODE use operation mode MODE 40# --preserve-dup-deps don't remove duplicate dependency libraries 41# --quiet, --silent don't print informational messages 42# --tag=TAG use configuration variables from tag TAG 43# -v, --verbose print informational messages (default) 44# --version print version information 45# -h, --help print short or long help message 46# 47# MODE must be one of the following: 48# 49# clean remove files from the build directory 50# compile compile a source file into a libtool object 51# execute automatically set library path, then run a program 52# finish complete the installation of libtool libraries 53# install install libraries or executables 54# link create a library or an executable 55# uninstall remove libraries from an installed directory 56# 57# MODE-ARGS vary depending on the MODE. 58# Try `$progname --help --mode=MODE' for a more detailed description of MODE. 59# 60# When reporting a bug, please describe a test case to reproduce it and 61# include the following information: 62# 63# host-triplet: $host 64# shell: $SHELL 65# compiler: $LTCC 66# compiler flags: $LTCFLAGS 67# linker: $LD (gnu? $with_gnu_ld) 68# $progname: (GNU libtool) 2.2.4 Debian-2.2.4-0ubuntu4 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.4 Debian-2.2.4-0ubuntu4" 77TIMESTAMP="" 78package_revision=1.2976 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="/bin/grep -E"} 120: ${FGREP="/bin/grep -F"} 121: ${GREP="/bin/grep"} 122: ${LN_S="ln -s"} 123: ${MAKE="make"} 124: ${MKDIR="mkdir"} 125: ${MV="mv -f"} 126: ${RM="rm -f"} 127: ${SED="/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) 4510 libs="$deplibs %DEPLIBS%" 4511 test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs" 4512 ;; 4513 esac 4514 fi 4515 if test "$linkmode,$pass" = "lib,dlpreopen"; then 4516 # Collect and forward deplibs of preopened libtool libs 4517 for lib in $dlprefiles; do 4518 # Ignore non-libtool-libs 4519 dependency_libs= 4520 case $lib in 4521 *.la) func_source "$lib" ;; 4522 esac 4523 4524 # Collect preopened libtool deplibs, except any this library 4525 # has declared as weak libs 4526 for deplib in $dependency_libs; do 4527 deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"` 4528 case " $weak_libs " in 4529 *" $deplib_base "*) ;; 4530 *) deplibs="$deplibs $deplib" ;; 4531 esac 4532 done 4533 done 4534 libs="$dlprefiles" 4535 fi 4536 if test "$pass" = dlopen; then 4537 # Collect dlpreopened libraries 4538 save_deplibs="$deplibs" 4539 deplibs= 4540 fi 4541 4542 for deplib in $libs; do 4543 lib= 4544 found=no 4545 case $deplib in 4546 -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads) 4547 if test "$linkmode,$pass" = "prog,link"; then 4548 compile_deplibs="$deplib $compile_deplibs" 4549 finalize_deplibs="$deplib $finalize_deplibs" 4550 else 4551 compiler_flags="$compiler_flags $deplib" 4552 if test "$linkmode" = lib ; then 4553 case "$new_inherited_linker_flags " in 4554 *" $deplib "*) ;; 4555 * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;; 4556 esac 4557 fi 4558 fi 4559 continue 4560 ;; 4561 -l*) 4562 if test "$linkmode" != lib && test "$linkmode" != prog; then 4563 func_warning "\`-l' is ignored for archives/objects" 4564 continue 4565 fi 4566 func_stripname '-l' '' "$deplib" 4567 name=$func_stripname_result 4568 if test "$linkmode" = lib; then 4569 searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path" 4570 else 4571 searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path" 4572 fi 4573 for searchdir in $searchdirs; do 4574 for search_ext in .la $std_shrext .so .a; do 4575 # Search the libtool library 4576 lib="$searchdir/lib${name}${search_ext}" 4577 if test -f "$lib"; then 4578 if test "$search_ext" = ".la"; then 4579 found=yes 4580 else 4581 found=no 4582 fi 4583 break 2 4584 fi 4585 done 4586 done 4587 if test "$found" != yes; then 4588 # deplib doesn't seem to be a libtool library 4589 if test "$linkmode,$pass" = "prog,link"; then 4590 compile_deplibs="$deplib $compile_deplibs" 4591 finalize_deplibs="$deplib $finalize_deplibs" 4592 else 4593 deplibs="$deplib $deplibs" 4594 test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs" 4595 fi 4596 continue 4597 else # deplib is a libtool library 4598 # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib, 4599 # We need to do some special things here, and not later. 4600 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then 4601 case " $predeps $postdeps " in 4602 *" $deplib "*) 4603 if func_lalib_p "$lib"; then 4604 library_names= 4605 old_library= 4606 func_source "$lib" 4607 for l in $old_library $library_names; do 4608 ll="$l" 4609 done 4610 if test "X$ll" = "X$old_library" ; then # only static version available 4611 found=no 4612 func_dirname "$lib" "" "." 4613 ladir="$func_dirname_result" 4614 lib=$ladir/$old_library 4615 if test "$linkmode,$pass" = "prog,link"; then 4616 compile_deplibs="$deplib $compile_deplibs" 4617 finalize_deplibs="$deplib $finalize_deplibs" 4618 else 4619 deplibs="$deplib $deplibs" 4620 test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs" 4621 fi 4622 continue 4623 fi 4624 fi 4625 ;; 4626 *) ;; 4627 esac 4628 fi 4629 fi 4630 ;; # -l 4631 *.ltframework) 4632 if test "$linkmode,$pass" = "prog,link"; then 4633 compile_deplibs="$deplib $compile_deplibs" 4634 finalize_deplibs="$deplib $finalize_deplibs" 4635 else 4636 deplibs="$deplib $deplibs" 4637 if test "$linkmode" = lib ; then 4638 case "$new_inherited_linker_flags " in 4639 *" $deplib "*) ;; 4640 * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;; 4641 esac 4642 fi 4643 fi 4644 continue 4645 ;; 4646 -L*) 4647 case $linkmode in 4648 lib) 4649 deplibs="$deplib $deplibs" 4650 test "$pass" = conv && continue 4651 newdependency_libs="$deplib $newdependency_libs" 4652 func_stripname '-L' '' "$deplib" 4653 newlib_search_path="$newlib_search_path $func_stripname_result" 4654 ;; 4655 prog) 4656 if test "$pass" = conv; then 4657 deplibs="$deplib $deplibs" 4658 continue 4659 fi 4660 if test "$pass" = scan; then 4661 deplibs="$deplib $deplibs" 4662 else 4663 compile_deplibs="$deplib $compile_deplibs" 4664 finalize_deplibs="$deplib $finalize_deplibs" 4665 fi 4666 func_stripname '-L' '' "$deplib" 4667 newlib_search_path="$newlib_search_path $func_stripname_result" 4668 ;; 4669 *) 4670 func_warning "\`-L' is ignored for archives/objects" 4671 ;; 4672 esac # linkmode 4673 continue 4674 ;; # -L 4675 -R*) 4676 if test "$pass" = link; then 4677 func_stripname '-R' '' "$deplib" 4678 dir=$func_stripname_result 4679 # Make sure the xrpath contains only unique directories. 4680 case "$xrpath " in 4681 *" $dir "*) ;; 4682 *) xrpath="$xrpath $dir" ;; 4683 esac 4684 fi 4685 deplibs="$deplib $deplibs" 4686 continue 4687 ;; 4688 *.la) lib="$deplib" ;; 4689 *.$libext) 4690 if test "$pass" = conv; then 4691 deplibs="$deplib $deplibs" 4692 continue 4693 fi 4694 case $linkmode in 4695 lib) 4696 # Linking convenience modules into shared libraries is allowed, 4697 # but linking other static libraries is non-portable. 4698 case " $dlpreconveniencelibs " in 4699 *" $deplib "*) ;; 4700 *) 4701 valid_a_lib=no 4702 case $deplibs_check_method in 4703 match_pattern*) 4704 set dummy $deplibs_check_method; shift 4705 match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"` 4706 if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \ 4707 | $EGREP "$match_pattern_regex" > /dev/null; then 4708 valid_a_lib=yes 4709 fi 4710 ;; 4711 pass_all) 4712 valid_a_lib=yes 4713 ;; 4714 esac 4715 if test "$valid_a_lib" != yes; then 4716 $ECHO 4717 $ECHO "*** Warning: Trying to link with static lib archive $deplib." 4718 $ECHO "*** I have the capability to make that library automatically link in when" 4719 $ECHO "*** you link to this library. But I can only do this if you have a" 4720 $ECHO "*** shared version of the library, which you do not appear to have" 4721 $ECHO "*** because the file extensions .$libext of this argument makes me believe" 4722 $ECHO "*** that it is just a static archive that I should not use here." 4723 else 4724 $ECHO 4725 $ECHO "*** Warning: Linking the shared library $output against the" 4726 $ECHO "*** static library $deplib is not portable!" 4727 deplibs="$deplib $deplibs" 4728 fi 4729 ;; 4730 esac 4731 continue 4732 ;; 4733 prog) 4734 if test "$pass" != link; then 4735 deplibs="$deplib $deplibs" 4736 else 4737 compile_deplibs="$deplib $compile_deplibs" 4738 finalize_deplibs="$deplib $finalize_deplibs" 4739 fi 4740 continue 4741 ;; 4742 esac # linkmode 4743 ;; # *.$libext 4744 *.lo | *.$objext) 4745 if test "$pass" = conv; then 4746 deplibs="$deplib $deplibs" 4747 elif test "$linkmode" = prog; then 4748 if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then 4749 # If there is no dlopen support or we're linking statically, 4750 # we need to preload. 4751 newdlprefiles="$newdlprefiles $deplib" 4752 compile_deplibs="$deplib $compile_deplibs" 4753 finalize_deplibs="$deplib $finalize_deplibs" 4754 else 4755 newdlfiles="$newdlfiles $deplib" 4756 fi 4757 fi 4758 continue 4759 ;; 4760 %DEPLIBS%) 4761 alldeplibs=yes 4762 continue 4763 ;; 4764 esac # case $deplib 4765 4766 if test "$found" = yes || test -f "$lib"; then : 4767 else 4768 func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'" 4769 fi 4770 4771 # Check to see that this really is a libtool archive. 4772 func_lalib_unsafe_p "$lib" \ 4773 || func_fatal_error "\`$lib' is not a valid libtool archive" 4774 4775 func_dirname "$lib" "" "." 4776 ladir="$func_dirname_result" 4777 4778 dlname= 4779 dlopen= 4780 dlpreopen= 4781 libdir= 4782 library_names= 4783 old_library= 4784 inherited_linker_flags= 4785 # If the library was installed with an old release of libtool, 4786 # it will not redefine variables installed, or shouldnotlink 4787 installed=yes 4788 shouldnotlink=no 4789 avoidtemprpath= 4790 4791 4792 # Read the .la file 4793 func_source "$lib" 4794 4795 # Convert "-framework foo" to "foo.ltframework" 4796 if test -n "$inherited_linker_flags"; then 4797 tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework \([^ $]*\)/\1.ltframework/g'` 4798 for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do 4799 case " $new_inherited_linker_flags " in 4800 *" $tmp_inherited_linker_flag "*) ;; 4801 *) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";; 4802 esac 4803 done 4804 fi 4805 dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'` 4806 if test "$linkmode,$pass" = "lib,link" || 4807 test "$linkmode,$pass" = "prog,scan" || 4808 { test "$linkmode" != prog && test "$linkmode" != lib; }; then 4809 test -n "$dlopen" && dlfiles="$dlfiles $dlopen" 4810 test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen" 4811 fi 4812 4813 if test "$pass" = conv; then 4814 # Only check for convenience libraries 4815 deplibs="$lib $deplibs" 4816 if test -z "$libdir"; then 4817 if test -z "$old_library"; then 4818 func_fatal_error "cannot find name of link library for \`$lib'" 4819 fi 4820 # It is a libtool convenience library, so add in its objects. 4821 convenience="$convenience $ladir/$objdir/$old_library" 4822 old_convenience="$old_convenience $ladir/$objdir/$old_library" 4823 elif test "$linkmode" != prog && test "$linkmode" != lib; then 4824 func_fatal_error "\`$lib' is not a convenience library" 4825 fi 4826 tmp_libs= 4827 for deplib in $dependency_libs; do 4828 deplibs="$deplib $deplibs" 4829 if $opt_duplicate_deps ; then 4830 case "$tmp_libs " in 4831 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;; 4832 esac 4833 fi 4834 tmp_libs="$tmp_libs $deplib" 4835 done 4836 continue 4837 fi # $pass = conv 4838 4839 4840 # Get the name of the library we link against. 4841 linklib= 4842 for l in $old_library $library_names; do 4843 linklib="$l" 4844 done 4845 if test -z "$linklib"; then 4846 func_fatal_error "cannot find name of link library for \`$lib'" 4847 fi 4848 4849 # This library was specified with -dlopen. 4850 if test "$pass" = dlopen; then 4851 if test -z "$libdir"; then 4852 func_fatal_error "cannot -dlopen a convenience library: \`$lib'" 4853 fi 4854 if test -z "$dlname" || 4855 test "$dlopen_support" != yes || 4856 test "$build_libtool_libs" = no; then 4857 # If there is no dlname, no dlopen support or we're linking 4858 # statically, we need to preload. We also need to preload any 4859 # dependent libraries so libltdl's deplib preloader doesn't 4860 # bomb out in the load deplibs phase. 4861 dlprefiles="$dlprefiles $lib $dependency_libs" 4862 else 4863 newdlfiles="$newdlfiles $lib" 4864 fi 4865 continue 4866 fi # $pass = dlopen 4867 4868 # We need an absolute path. 4869 case $ladir in 4870 [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;; 4871 *) 4872 abs_ladir=`cd "$ladir" && pwd` 4873 if test -z "$abs_ladir"; then 4874 func_warning "cannot determine absolute directory name of \`$ladir'" 4875 func_warning "passing it literally to the linker, although it might fail" 4876 abs_ladir="$ladir" 4877 fi 4878 ;; 4879 esac 4880 func_basename "$lib" 4881 laname="$func_basename_result" 4882 4883 # Find the relevant object directory and library name. 4884 if test "X$installed" = Xyes; then 4885 if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then 4886 func_warning "library \`$lib' was moved." 4887 dir="$ladir" 4888 absdir="$abs_ladir" 4889 libdir="$abs_ladir" 4890 else 4891 dir="$libdir" 4892 absdir="$libdir" 4893 fi 4894 test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes 4895 else 4896 if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then 4897 dir="$ladir" 4898 absdir="$abs_ladir" 4899 # Remove this search path later 4900 notinst_path="$notinst_path $abs_ladir" 4901 else 4902 dir="$ladir/$objdir" 4903 absdir="$abs_ladir/$objdir" 4904 # Remove this search path later 4905 notinst_path="$notinst_path $abs_ladir" 4906 fi 4907 fi # $installed = yes 4908 func_stripname 'lib' '.la' "$laname" 4909 name=$func_stripname_result 4910 4911 # This library was specified with -dlpreopen. 4912 if test "$pass" = dlpreopen; then 4913 if test -z "$libdir" && test "$linkmode" = prog; then 4914 func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'" 4915 fi 4916 # Prefer using a static library (so that no silly _DYNAMIC symbols 4917 # are required to link). 4918 if test -n "$old_library"; then 4919 newdlprefiles="$newdlprefiles $dir/$old_library" 4920 # Keep a list of preopened convenience libraries to check 4921 # that they are being used correctly in the link pass. 4922 test -z "$libdir" && \ 4923 dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library" 4924 # Otherwise, use the dlname, so that lt_dlopen finds it. 4925 elif test -n "$dlname"; then 4926 newdlprefiles="$newdlprefiles $dir/$dlname" 4927 else 4928 newdlprefiles="$newdlprefiles $dir/$linklib" 4929 fi 4930 fi # $pass = dlpreopen 4931 4932 if test -z "$libdir"; then 4933 # Link the convenience library 4934 if test "$linkmode" = lib; then 4935 deplibs="$dir/$old_library $deplibs" 4936 elif test "$linkmode,$pass" = "prog,link"; then 4937 compile_deplibs="$dir/$old_library $compile_deplibs" 4938 finalize_deplibs="$dir/$old_library $finalize_deplibs" 4939 else 4940 deplibs="$lib $deplibs" # used for prog,scan pass 4941 fi 4942 continue 4943 fi 4944 4945 4946 if test "$linkmode" = prog && test "$pass" != link; then 4947 newlib_search_path="$newlib_search_path $ladir" 4948 deplibs="$lib $deplibs" 4949 4950 linkalldeplibs=no 4951 if test "$link_all_deplibs" != no || test -z "$library_names" || 4952 test "$build_libtool_libs" = no; then 4953 linkalldeplibs=yes 4954 fi 4955 4956 tmp_libs= 4957 for deplib in $dependency_libs; do 4958 case $deplib in 4959 -L*) func_stripname '-L' '' "$deplib" 4960 newlib_search_path="$newlib_search_path $func_stripname_result" 4961 ;; 4962 esac 4963 # Need to link against all dependency_libs? 4964 if test "$linkalldeplibs" = yes; then 4965 deplibs="$deplib $deplibs" 4966 else 4967 # Need to hardcode shared library paths 4968 # or/and link against static libraries 4969 newdependency_libs="$deplib $newdependency_libs" 4970 fi 4971 if $opt_duplicate_deps ; then 4972 case "$tmp_libs " in 4973 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;; 4974 esac 4975 fi 4976 tmp_libs="$tmp_libs $deplib" 4977 done # for deplib 4978 continue 4979 fi # $linkmode = prog... 4980 4981 if test "$linkmode,$pass" = "prog,link"; then 4982 if test -n "$library_names" && 4983 { { test "$prefer_static_libs" = no || 4984 test "$prefer_static_libs,$installed" = "built,yes"; } || 4985 test -z "$old_library"; }; then 4986 # We need to hardcode the library path 4987 if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then 4988 # Make sure the rpath contains only unique directories. 4989 case "$temp_rpath:" in 4990 *"$absdir:"*) ;; 4991 *) temp_rpath="$temp_rpath$absdir:" ;; 4992 esac 4993 fi 4994 4995 # Hardcode the library path. 4996 # Skip directories that are in the system default run-time 4997 # search path. 4998 case " $sys_lib_dlsearch_path " in 4999 *" $absdir "*) ;; 5000 *) 5001 case "$compile_rpath " in 5002 *" $absdir "*) ;; 5003 *) compile_rpath="$compile_rpath $absdir" 5004 esac 5005 ;; 5006 esac 5007 case " $sys_lib_dlsearch_path " in 5008 *" $libdir "*) ;; 5009 *) 5010 case "$finalize_rpath " in 5011 *" $libdir "*) ;; 5012 *) finalize_rpath="$finalize_rpath $libdir" 5013 esac 5014 ;; 5015 esac 5016 fi # $linkmode,$pass = prog,link... 5017 5018 if test "$alldeplibs" = yes && 5019 { test "$deplibs_check_method" = pass_all || 5020 { test "$build_libtool_libs" = yes && 5021 test -n "$library_names"; }; }; then 5022 # We only need to search for static libraries 5023 continue 5024 fi 5025 fi 5026 5027 link_static=no # Whether the deplib will be linked statically 5028 use_static_libs=$prefer_static_libs 5029 if test "$use_static_libs" = built && test "$installed" = yes; then 5030 use_static_libs=no 5031 fi 5032 if test -n "$library_names" && 5033 { test "$use_static_libs" = no || test -z "$old_library"; }; then 5034 case $host in 5035 *cygwin* | *mingw*) 5036 # No point in relinking DLLs because paths are not encoded 5037 notinst_deplibs="$notinst_deplibs $lib" 5038 need_relink=no 5039 ;; 5040 *) 5041 if test "$installed" = no; then 5042 notinst_deplibs="$notinst_deplibs $lib" 5043 need_relink=yes 5044 fi 5045 ;; 5046 esac 5047 # This is a shared library 5048 5049 # Warn about portability, can't link against -module's on some 5050 # systems (darwin). Don't bleat about dlopened modules though! 5051 dlopenmodule="" 5052 for dlpremoduletest in $dlprefiles; do 5053 if test "X$dlpremoduletest" = "X$lib"; then 5054 dlopenmodule="$dlpremoduletest" 5055 break 5056 fi 5057 done 5058 if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then 5059 $ECHO 5060 if test "$linkmode" = prog; then 5061 $ECHO "*** Warning: Linking the executable $output against the loadable module" 5062 else 5063 $ECHO "*** Warning: Linking the shared library $output against the loadable module" 5064 fi 5065 $ECHO "*** $linklib is not portable!" 5066 fi 5067 if test "$linkmode" = lib && 5068 test "$hardcode_into_libs" = yes; then 5069 # Hardcode the library path. 5070 # Skip directories that are in the system default run-time 5071 # search path. 5072 case " $sys_lib_dlsearch_path " in 5073 *" $absdir "*) ;; 5074 *) 5075 case "$compile_rpath " in 5076 *" $absdir "*) ;; 5077 *) compile_rpath="$compile_rpath $absdir" 5078 esac 5079 ;; 5080 esac 5081 case " $sys_lib_dlsearch_path " in 5082 *" $libdir "*) ;; 5083 *) 5084 case "$finalize_rpath " in 5085 *" $libdir "*) ;; 5086 *) finalize_rpath="$finalize_rpath $libdir" 5087 esac 5088 ;; 5089 esac 5090 fi 5091 5092 if test -n "$old_archive_from_expsyms_cmds"; then 5093 # figure out the soname 5094 set dummy $library_names 5095 shift 5096 realname="$1" 5097 shift 5098 libname=`eval "\\$ECHO \"$libname_spec\""` 5099 # use dlname if we got it. it's perfectly good, no? 5100 if test -n "$dlname"; then 5101 soname="$dlname" 5102 elif test -n "$soname_spec"; then 5103 # bleh windows 5104 case $host in 5105 *cygwin* | mingw*) 5106 func_arith $current - $age 5107 major=$func_arith_result 5108 versuffix="-$major" 5109 ;; 5110 esac 5111 eval soname=\"$soname_spec\" 5112 else 5113 soname="$realname" 5114 fi 5115 5116 # Make a new name for the extract_expsyms_cmds to use 5117 soroot="$soname" 5118 func_basename "$soroot" 5119 soname="$func_basename_result" 5120 func_stripname 'lib' '.dll' "$soname" 5121 newlib=libimp-$func_stripname_result.a 5122 5123 # If the library has no export list, then create one now 5124 if test -f "$output_objdir/$soname-def"; then : 5125 else 5126 func_verbose "extracting exported symbol list from \`$soname'" 5127 func_execute_cmds "$extract_expsyms_cmds" 'exit $?' 5128 fi 5129 5130 # Create $newlib 5131 if test -f "$output_objdir/$newlib"; then :; else 5132 func_verbose "generating import library for \`$soname'" 5133 func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?' 5134 fi 5135 # make sure the library variables are pointing to the new library 5136 dir=$output_objdir 5137 linklib=$newlib 5138 fi # test -n "$old_archive_from_expsyms_cmds" 5139 5140 if test "$linkmode" = prog || test "$mode" != relink; then 5141 add_shlibpath= 5142 add_dir= 5143 add= 5144 lib_linked=yes 5145 case $hardcode_action in 5146 immediate | unsupported) 5147 if test "$hardcode_direct" = no; then 5148 add="$dir/$linklib" 5149 case $host in 5150 *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;; 5151 *-*-sysv4*uw2*) add_dir="-L$dir" ;; 5152 *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \ 5153 *-*-unixware7*) add_dir="-L$dir" ;; 5154 *-*-darwin* ) 5155 # if the lib is a (non-dlopened) module then we can not 5156 # link against it, someone is ignoring the earlier warnings 5157 if /usr/bin/file -L $add 2> /dev/null | 5158 $GREP ": [^:]* bundle" >/dev/null ; then 5159 if test "X$dlopenmodule" != "X$lib"; then 5160 $ECHO "*** Warning: lib $linklib is a module, not a shared library" 5161 if test -z "$old_library" ; then 5162 $ECHO 5163 $ECHO "*** And there doesn't seem to be a static archive available" 5164 $ECHO "*** The link will probably fail, sorry" 5165 else 5166 add="$dir/$old_library" 5167 fi 5168 elif test -n "$old_library"; then 5169 add="$dir/$old_library" 5170 fi 5171 fi 5172 esac 5173 elif test "$hardcode_minus_L" = no; then 5174 case $host in 5175 *-*-sunos*) add_shlibpath="$dir" ;; 5176 esac 5177 add_dir="-L$dir" 5178 add="-l$name" 5179 elif test "$hardcode_shlibpath_var" = no; then 5180 add_shlibpath="$dir" 5181 add="-l$name" 5182 else 5183 lib_linked=no 5184 fi 5185 ;; 5186 relink) 5187 if test "$hardcode_direct" = yes && 5188 test "$hardcode_direct_absolute" = no; then 5189 add="$dir/$linklib" 5190 elif test "$hardcode_minus_L" = yes; then 5191 add_dir="-L$dir" 5192 # Try looking first in the location we're being installed to. 5193 if test -n "$inst_prefix_dir"; then 5194 case $libdir in 5195 [\\/]*) 5196 add_dir="$add_dir -L$inst_prefix_dir$libdir" 5197 ;; 5198 esac 5199 fi 5200 add="-l$name" 5201 elif test "$hardcode_shlibpath_var" = yes; then 5202 add_shlibpath="$dir" 5203 add="-l$name" 5204 else 5205 lib_linked=no 5206 fi 5207 ;; 5208 *) lib_linked=no ;; 5209 esac 5210 5211 if test "$lib_linked" != yes; then 5212 func_fatal_configuration "unsupported hardcode properties" 5213 fi 5214 5215 if test -n "$add_shlibpath"; then 5216 case :$compile_shlibpath: in 5217 *":$add_shlibpath:"*) ;; 5218 *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;; 5219 esac 5220 fi 5221 if test "$linkmode" = prog; then 5222 test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs" 5223 test -n "$add" && compile_deplibs="$add $compile_deplibs" 5224 else 5225 test -n "$add_dir" && deplibs="$add_dir $deplibs" 5226 test -n "$add" && deplibs="$add $deplibs" 5227 if test "$hardcode_direct" != yes && 5228 test "$hardcode_minus_L" != yes && 5229 test "$hardcode_shlibpath_var" = yes; then 5230 case :$finalize_shlibpath: in 5231 *":$libdir:"*) ;; 5232 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;; 5233 esac 5234 fi 5235 fi 5236 fi 5237 5238 if test "$linkmode" = prog || test "$mode" = relink; then 5239 add_shlibpath= 5240 add_dir= 5241 add= 5242 # Finalize command for both is simple: just hardcode it. 5243 if test "$hardcode_direct" = yes && 5244 test "$hardcode_direct_absolute" = no; then 5245 add="$libdir/$linklib" 5246 elif test "$hardcode_minus_L" = yes; then 5247 add_dir="-L$libdir" 5248 add="-l$name" 5249 elif test "$hardcode_shlibpath_var" = yes; then 5250 case :$finalize_shlibpath: in 5251 *":$libdir:"*) ;; 5252 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;; 5253 esac 5254 add="-l$name" 5255 elif test "$hardcode_automatic" = yes; then 5256 if test -n "$inst_prefix_dir" && 5257 test -f "$inst_prefix_dir$libdir/$linklib" ; then 5258 add="$inst_prefix_dir$libdir/$linklib" 5259 else 5260 add="$libdir/$linklib" 5261 fi 5262 else 5263 # We cannot seem to hardcode it, guess we'll fake it. 5264 add_dir="-L$libdir" 5265 # Try looking first in the location we're being installed to. 5266 if test -n "$inst_prefix_dir"; then 5267 case $libdir in 5268 [\\/]*) 5269 add_dir="$add_dir -L$inst_prefix_dir$libdir" 5270 ;; 5271 esac 5272 fi 5273 add="-l$name" 5274 fi 5275 5276 if test "$linkmode" = prog; then 5277 test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs" 5278 test -n "$add" && finalize_deplibs="$add $finalize_deplibs" 5279 else 5280 test -n "$add_dir" && deplibs="$add_dir $deplibs" 5281 test -n "$add" && deplibs="$add $deplibs" 5282 fi 5283 fi 5284 elif test "$linkmode" = prog; then 5285 # Here we assume that one of hardcode_direct or hardcode_minus_L 5286 # is not unsupported. This is valid on all known static and 5287 # shared platforms. 5288 if test "$hardcode_direct" != unsupported; then 5289 test -n "$old_library" && linklib="$old_library" 5290 compile_deplibs="$dir/$linklib $compile_deplibs" 5291 finalize_deplibs="$dir/$linklib $finalize_deplibs" 5292 else 5293 compile_deplibs="-l$name -L$dir $compile_deplibs" 5294 finalize_deplibs="-l$name -L$dir $finalize_deplibs" 5295 fi 5296 elif test "$build_libtool_libs" = yes; then 5297 # Not a shared library 5298 if test "$deplibs_check_method" != pass_all; then 5299 # We're trying link a shared library against a static one 5300 # but the system doesn't support it. 5301 5302 # Just print a warning and add the library to dependency_libs so 5303 # that the program can be linked against the static library. 5304 $ECHO 5305 $ECHO "*** Warning: This system can not link to static lib archive $lib." 5306 $ECHO "*** I have the capability to make that library automatically link in when" 5307 $ECHO "*** you link to this library. But I can only do this if you have a" 5308 $ECHO "*** shared version of the library, which you do not appear to have." 5309 if test "$module" = yes; then 5310 $ECHO "*** But as you try to build a module library, libtool will still create " 5311 $ECHO "*** a static module, that should work as long as the dlopening application" 5312 $ECHO "*** is linked with the -dlopen flag to resolve symbols at runtime." 5313 if test -z "$global_symbol_pipe"; then 5314 $ECHO 5315 $ECHO "*** However, this would only work if libtool was able to extract symbol" 5316 $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could" 5317 $ECHO "*** not find such a program. So, this module is probably useless." 5318 $ECHO "*** \`nm' from GNU binutils and a full rebuild may help." 5319 fi 5320 if test "$build_old_libs" = no; then 5321 build_libtool_libs=module 5322 build_old_libs=yes 5323 else 5324 build_libtool_libs=no 5325 fi 5326 fi 5327 else 5328 deplibs="$dir/$old_library $deplibs" 5329 link_static=yes 5330 fi 5331 fi # link shared/static library? 5332 5333 if test "$linkmode" = lib; then 5334 if test -n "$dependency_libs" && 5335 { test "$hardcode_into_libs" != yes || 5336 test "$build_old_libs" = yes || 5337 test "$link_static" = yes; }; then 5338 # Extract -R from dependency_libs 5339 temp_deplibs= 5340 for libdir in $dependency_libs; do 5341 case $libdir in 5342 -R*) func_stripname '-R' '' "$libdir" 5343 temp_xrpath=$func_stripname_result 5344 case " $xrpath " in 5345 *" $temp_xrpath "*) ;; 5346 *) xrpath="$xrpath $temp_xrpath";; 5347 esac;; 5348 *) temp_deplibs="$temp_deplibs $libdir";; 5349 esac 5350 done 5351 dependency_libs="$temp_deplibs" 5352 fi 5353 5354 newlib_search_path="$newlib_search_path $absdir" 5355 # Link against this library 5356 test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs" 5357 # ... and its dependency_libs 5358 tmp_libs= 5359 for deplib in $dependency_libs; do 5360 newdependency_libs="$deplib $newdependency_libs" 5361 if $opt_duplicate_deps ; then 5362 case "$tmp_libs " in 5363 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;; 5364 esac 5365 fi 5366 tmp_libs="$tmp_libs $deplib" 5367 done 5368 5369 if test "$link_all_deplibs" != no; then 5370 # Add the search paths of all dependency libraries 5371 for deplib in $dependency_libs; do 5372 case $deplib in 5373 -L*) path="$deplib" ;; 5374 *.la) 5375 func_dirname "$deplib" "" "." 5376 dir="$func_dirname_result" 5377 # We need an absolute path. 5378 case $dir in 5379 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;; 5380 *) 5381 absdir=`cd "$dir" && pwd` 5382 if test -z "$absdir"; then 5383 func_warning "cannot determine absolute directory name of \`$dir'" 5384 absdir="$dir" 5385 fi 5386 ;; 5387 esac 5388 if $GREP "^installed=no" $deplib > /dev/null; then 5389 case $host in 5390 *-*-darwin*) 5391 depdepl= 5392 eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib` 5393 if test -n "$deplibrary_names" ; then 5394 for tmp in $deplibrary_names ; do 5395 depdepl=$tmp 5396 done 5397 if test -f "$absdir/$objdir/$depdepl" ; then 5398 depdepl="$absdir/$objdir/$depdepl" 5399 darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'` 5400 if test -z "$darwin_install_name"; then 5401 darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'` 5402 fi 5403 compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}" 5404 linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}" 5405 path= 5406 fi 5407 fi 5408 ;; 5409 *) 5410 path="-L$absdir/$objdir" 5411 ;; 5412 esac 5413 else 5414 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib` 5415 test -z "$libdir" && \ 5416 func_fatal_error "\`$deplib' is not a valid libtool archive" 5417 test "$absdir" != "$libdir" && \ 5418 func_warning "\`$deplib' seems to be moved" 5419 5420 path="-L$absdir" 5421 fi 5422 ;; 5423 esac 5424 case " $deplibs " in 5425 *" $path "*) ;; 5426 *) deplibs="$path $deplibs" ;; 5427 esac 5428 done 5429 fi # link_all_deplibs != no 5430 fi # linkmode = lib 5431 done # for deplib in $libs 5432 if test "$pass" = link; then 5433 if test "$linkmode" = "prog"; then 5434 compile_deplibs="$new_inherited_linker_flags $compile_deplibs" 5435 finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs" 5436 else 5437 compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'` 5438 fi 5439 fi 5440 dependency_libs="$newdependency_libs" 5441 if test "$pass" = dlpreopen; then 5442 # Link the dlpreopened libraries before other libraries 5443 for deplib in $save_deplibs; do 5444 deplibs="$deplib $deplibs" 5445 done 5446 fi 5447 if test "$pass" != dlopen; then 5448 if test "$pass" != conv; then 5449 # Make sure lib_search_path contains only unique directories. 5450 lib_search_path= 5451 for dir in $newlib_search_path; do 5452 case "$lib_search_path " in 5453 *" $dir "*) ;; 5454 *) lib_search_path="$lib_search_path $dir" ;; 5455 esac 5456 done 5457 newlib_search_path= 5458 fi 5459 5460 if test "$linkmode,$pass" != "prog,link"; then 5461 vars="deplibs" 5462 else 5463 vars="compile_deplibs finalize_deplibs" 5464 fi 5465 for var in $vars dependency_libs; do 5466 # Add libraries to $var in reverse order 5467 eval tmp_libs=\"\$$var\" 5468 new_libs= 5469 for deplib in $tmp_libs; do 5470 # FIXME: Pedantically, this is the right thing to do, so 5471 # that some nasty dependency loop isn't accidentally 5472 # broken: 5473 #new_libs="$deplib $new_libs" 5474 # Pragmatically, this seems to cause very few problems in 5475 # practice: 5476 case $deplib in 5477 -L*) new_libs="$deplib $new_libs" ;; 5478 -R*) ;; 5479 *) 5480 # And here is the reason: when a library appears more 5481 # than once as an explicit dependence of a library, or 5482 # is implicitly linked in more than once by the 5483 # compiler, it is considered special, and multiple 5484 # occurrences thereof are not removed. Compare this 5485 # with having the same library being listed as a 5486 # dependency of multiple other libraries: in this case, 5487 # we know (pedantically, we assume) the library does not 5488 # need to be listed more than once, so we keep only the 5489 # last copy. This is not always right, but it is rare 5490 # enough that we require users that really mean to play 5491 # such unportable linking tricks to link the library 5492 # using -Wl,-lname, so that libtool does not consider it 5493 # for duplicate removal. 5494 case " $specialdeplibs " in 5495 *" $deplib "*) new_libs="$deplib $new_libs" ;; 5496 *) 5497 case " $new_libs " in 5498 *" $deplib "*) ;; 5499 *) new_libs="$deplib $new_libs" ;; 5500 esac 5501 ;; 5502 esac 5503 ;; 5504 esac 5505 done 5506 tmp_libs= 5507 for deplib in $new_libs; do 5508 case $deplib in 5509 -L*) 5510 case " $tmp_libs " in 5511 *" $deplib "*) ;; 5512 *) tmp_libs="$tmp_libs $deplib" ;; 5513 esac 5514 ;; 5515 *) tmp_libs="$tmp_libs $deplib" ;; 5516 esac 5517 done 5518 eval $var=\"$tmp_libs\" 5519 done # for var 5520 fi 5521 # Last step: remove runtime libs from dependency_libs 5522 # (they stay in deplibs) 5523 tmp_libs= 5524 for i in $dependency_libs ; do 5525 case " $predeps $postdeps $compiler_lib_search_path " in 5526 *" $i "*) 5527 i="" 5528 ;; 5529 esac 5530 if test -n "$i" ; then 5531 tmp_libs="$tmp_libs $i" 5532 fi 5533 done 5534 dependency_libs=$tmp_libs 5535 done # for pass 5536 if test "$linkmode" = prog; then 5537 dlfiles="$newdlfiles" 5538 fi 5539 if test "$linkmode" = prog || test "$linkmode" = lib; then 5540 dlprefiles="$newdlprefiles" 5541 fi 5542 5543 case $linkmode in 5544 oldlib) 5545 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then 5546 func_warning "\`-dlopen' is ignored for archives" 5547 fi 5548 5549 case " $deplibs" in 5550 *\ -l* | *\ -L*) 5551 func_warning "\`-l' and \`-L' are ignored for archives" ;; 5552 esac 5553 5554 test -n "$rpath" && \ 5555 func_warning "\`-rpath' is ignored for archives" 5556 5557 test -n "$xrpath" && \ 5558 func_warning "\`-R' is ignored for archives" 5559 5560 test -n "$vinfo" && \ 5561 func_warning "\`-version-info/-version-number' is ignored for archives" 5562 5563 test -n "$release" && \ 5564 func_warning "\`-release' is ignored for archives" 5565 5566 test -n "$export_symbols$export_symbols_regex" && \ 5567 func_warning "\`-export-symbols' is ignored for archives" 5568 5569 # Now set the variables for building old libraries. 5570 build_libtool_libs=no 5571 oldlibs="$output" 5572 objs="$objs$old_deplibs" 5573 ;; 5574 5575 lib) 5576 # Make sure we only generate libraries of the form `libNAME.la'. 5577 case $outputname in 5578 lib*) 5579 func_stripname 'lib' '.la' "$outputname" 5580 name=$func_stripname_result 5581 eval shared_ext=\"$shrext_cmds\" 5582 eval libname=\"$libname_spec\" 5583 ;; 5584 *) 5585 test "$module" = no && \ 5586 func_fatal_help "libtool library \`$output' must begin with \`lib'" 5587 5588 if test "$need_lib_prefix" != no; then 5589 # Add the "lib" prefix for modules if required 5590 func_stripname '' '.la' "$outputname" 5591 name=$func_stripname_result 5592 eval shared_ext=\"$shrext_cmds\" 5593 eval libname=\"$libname_spec\" 5594 else 5595 func_stripname '' '.la' "$outputname" 5596 libname=$func_stripname_result 5597 fi 5598 ;; 5599 esac 5600 5601 if test -n "$objs"; then 5602 if test "$deplibs_check_method" != pass_all; then 5603 func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 5604 else 5605 $ECHO 5606 $ECHO "*** Warning: Linking the shared library $output against the non-libtool" 5607 $ECHO "*** objects $objs is not portable!" 5608 libobjs="$libobjs $objs" 5609 fi 5610 fi 5611 5612 test "$dlself" != no && \ 5613 func_warning "\`-dlopen self' is ignored for libtool libraries" 5614 5615 set dummy $rpath 5616 shift 5617 test "$#" -gt 1 && \ 5618 func_warning "ignoring multiple \`-rpath's for a libtool library" 5619 5620 install_libdir="$1" 5621 5622 oldlibs= 5623 if test -z "$rpath"; then 5624 if test "$build_libtool_libs" = yes; then 5625 # Building a libtool convenience library. 5626 # Some compilers have problems with a `.al' extension so 5627 # convenience libraries should have the same extension an 5628 # archive normally would. 5629 oldlibs="$output_objdir/$libname.$libext $oldlibs" 5630 build_libtool_libs=convenience 5631 build_old_libs=yes 5632 fi 5633 5634 test -n "$vinfo" && \ 5635 func_warning "\`-version-info/-version-number' is ignored for convenience libraries" 5636 5637 test -n "$release" && \ 5638 func_warning "\`-release' is ignored for convenience libraries" 5639 else 5640 5641 # Parse the version information argument. 5642 save_ifs="$IFS"; IFS=':' 5643 set dummy $vinfo 0 0 0 5644 shift 5645 IFS="$save_ifs" 5646 5647 test -n "$7" && \ 5648 func_fatal_help "too many parameters to \`-version-info'" 5649 5650 # convert absolute version numbers to libtool ages 5651 # this retains compatibility with .la files and attempts 5652 # to make the code below a bit more comprehensible 5653 5654 case $vinfo_number in 5655 yes) 5656 number_major="$1" 5657 number_minor="$2" 5658 number_revision="$3" 5659 # 5660 # There are really only two kinds -- those that 5661 # use the current revision as the major version 5662 # and those that subtract age and use age as 5663 # a minor version. But, then there is irix 5664 # which has an extra 1 added just for fun 5665 # 5666 case $version_type in 5667 darwin|linux|osf|windows|none) 5668 func_arith $number_major + $number_minor 5669 current=$func_arith_result 5670 age="$number_minor" 5671 revision="$number_revision" 5672 ;; 5673 freebsd-aout|freebsd-elf|sunos) 5674 current="$number_major" 5675 revision="$number_minor" 5676 age="0" 5677 ;; 5678 irix|nonstopux) 5679 func_arith $number_major + $number_minor 5680 current=$func_arith_result 5681 age="$number_minor" 5682 revision="$number_minor" 5683 lt_irix_increment=no 5684 ;; 5685 *) 5686 func_fatal_configuration "$modename: unknown library version type \`$version_type'" 5687 ;; 5688 esac 5689 ;; 5690 no) 5691 current="$1" 5692 revision="$2" 5693 age="$3" 5694 ;; 5695 esac 5696 5697 # Check that each of the things are valid numbers. 5698 case $current in 5699 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]) ;; 5700 *) 5701 func_error "CURRENT \`$current' must be a nonnegative integer" 5702 func_fatal_error "\`$vinfo' is not valid version information" 5703 ;; 5704 esac 5705 5706 case $revision in 5707 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]) ;; 5708 *) 5709 func_error "REVISION \`$revision' must be a nonnegative integer" 5710 func_fatal_error "\`$vinfo' is not valid version information" 5711 ;; 5712 esac 5713 5714 case $age in 5715 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]) ;; 5716 *) 5717 func_error "AGE \`$age' must be a nonnegative integer" 5718 func_fatal_error "\`$vinfo' is not valid version information" 5719 ;; 5720 esac 5721 5722 if test "$age" -gt "$current"; then 5723 func_error "AGE \`$age' is greater than the current interface number \`$current'" 5724 func_fatal_error "\`$vinfo' is not valid version information" 5725 fi 5726 5727 # Calculate the version variables. 5728 major= 5729 versuffix= 5730 verstring= 5731 case $version_type in 5732 none) ;; 5733 5734 darwin) 5735 # Like Linux, but with the current version available in 5736 # verstring for coding it into the library header 5737 func_arith $current - $age 5738 major=.$func_arith_result 5739 versuffix="$major.$age.$revision" 5740 # Darwin ld doesn't like 0 for these options... 5741 func_arith $current + 1 5742 minor_current=$func_arith_result 5743 xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision" 5744 verstring="-compatibility_version $minor_current -current_version $minor_current.$revision" 5745 ;; 5746 5747 freebsd-aout) 5748 major=".$current" 5749 versuffix=".$current.$revision"; 5750 ;; 5751 5752 freebsd-elf) 5753 major=".$current" 5754 versuffix=".$current" 5755 ;; 5756 5757 irix | nonstopux) 5758 if test "X$lt_irix_increment" = "Xno"; then 5759 func_arith $current - $age 5760 else 5761 func_arith $current - $age + 1 5762 fi 5763 major=$func_arith_result 5764 5765 case $version_type in 5766 nonstopux) verstring_prefix=nonstopux ;; 5767 *) verstring_prefix=sgi ;; 5768 esac 5769 verstring="$verstring_prefix$major.$revision" 5770 5771 # Add in all the interfaces that we are compatible with. 5772 loop=$revision 5773 while test "$loop" -ne 0; do 5774 func_arith $revision - $loop 5775 iface=$func_arith_result 5776 func_arith $loop - 1 5777 loop=$func_arith_result 5778 verstring="$verstring_prefix$major.$iface:$verstring" 5779 done 5780 5781 # Before this point, $major must not contain `.'. 5782 major=.$major 5783 versuffix="$major.$revision" 5784 ;; 5785 5786 linux) 5787 func_arith $current - $age 5788 major=.$func_arith_result 5789 versuffix="$major.$age.$revision" 5790 ;; 5791 5792 osf) 5793 func_arith $current - $age 5794 major=.$func_arith_result 5795 versuffix=".$current.$age.$revision" 5796 verstring="$current.$age.$revision" 5797 5798 # Add in all the interfaces that we are compatible with. 5799 loop=$age 5800 while test "$loop" -ne 0; do 5801 func_arith $current - $loop 5802 iface=$func_arith_result 5803 func_arith $loop - 1 5804 loop=$func_arith_result 5805 verstring="$verstring:${iface}.0" 5806 done 5807 5808 # Make executables depend on our current version. 5809 verstring="$verstring:${current}.0" 5810 ;; 5811 5812 qnx) 5813 major=".$current" 5814 versuffix=".$current" 5815 ;; 5816 5817 sunos) 5818 major=".$current" 5819 versuffix=".$current.$revision" 5820 ;; 5821 5822 windows) 5823 # Use '-' rather than '.', since we only want one 5824 # extension on DOS 8.3 filesystems. 5825 func_arith $current - $age 5826 major=$func_arith_result 5827 versuffix="-$major" 5828 ;; 5829 5830 *) 5831 func_fatal_configuration "unknown library version type \`$version_type'" 5832 ;; 5833 esac 5834 5835 # Clear the version info if we defaulted, and they specified a release. 5836 if test -z "$vinfo" && test -n "$release"; then 5837 major= 5838 case $version_type in 5839 darwin) 5840 # we can't check for "0.0" in archive_cmds due to quoting 5841 # problems, so we reset it completely 5842 verstring= 5843 ;; 5844 *) 5845 verstring="0.0" 5846 ;; 5847 esac 5848 if test "$need_version" = no; then 5849 versuffix= 5850 else 5851 versuffix=".0.0" 5852 fi 5853 fi 5854 5855 # Remove version info from name if versioning should be avoided 5856 if test "$avoid_version" = yes && test "$need_version" = no; then 5857 major= 5858 versuffix= 5859 verstring="" 5860 fi 5861 5862 # Check to see if the archive will have undefined symbols. 5863 if test "$allow_undefined" = yes; then 5864 if test "$allow_undefined_flag" = unsupported; then 5865 func_warning "undefined symbols not allowed in $host shared libraries" 5866 build_libtool_libs=no 5867 build_old_libs=yes 5868 fi 5869 else 5870 # Don't allow undefined symbols. 5871 allow_undefined_flag="$no_undefined_flag" 5872 fi 5873 5874 fi 5875 5876 func_generate_dlsyms "$libname" "$libname" "yes" 5877 libobjs="$libobjs $symfileobj" 5878 test "X$libobjs" = "X " && libobjs= 5879 5880 if test "$mode" != relink; then 5881 # Remove our outputs, but don't remove object files since they 5882 # may have been created when compiling PIC objects. 5883 removelist= 5884 tempremovelist=`$ECHO "$output_objdir/*"` 5885 for p in $tempremovelist; do 5886 case $p in 5887 *.$objext) 5888 ;; 5889 $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*) 5890 if test "X$precious_files_regex" != "X"; then 5891 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1 5892 then 5893 continue 5894 fi 5895 fi 5896 removelist="$removelist $p" 5897 ;; 5898 *) ;; 5899 esac 5900 done 5901 test -n "$removelist" && \ 5902 func_show_eval "${RM}r \$removelist" 5903 fi 5904 5905 # Now set the variables for building old libraries. 5906 if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then 5907 oldlibs="$oldlibs $output_objdir/$libname.$libext" 5908 5909 # Transform .lo files to .o files. 5910 oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP` 5911 fi 5912 5913 # Eliminate all temporary directories. 5914 #for path in $notinst_path; do 5915 # lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"` 5916 # deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"` 5917 # dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"` 5918 #done 5919 5920 if test -n "$xrpath"; then 5921 # If the user specified any rpath flags, then add them. 5922 temp_xrpath= 5923 for libdir in $xrpath; do 5924 temp_xrpath="$temp_xrpath -R$libdir" 5925 case "$finalize_rpath " in 5926 *" $libdir "*) ;; 5927 *) finalize_rpath="$finalize_rpath $libdir" ;; 5928 esac 5929 done 5930 if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then 5931 dependency_libs="$temp_xrpath $dependency_libs" 5932 fi 5933 fi 5934 5935 # Make sure dlfiles contains only unique files that won't be dlpreopened 5936 old_dlfiles="$dlfiles" 5937 dlfiles= 5938 for lib in $old_dlfiles; do 5939 case " $dlprefiles $dlfiles " in 5940 *" $lib "*) ;; 5941 *) dlfiles="$dlfiles $lib" ;; 5942 esac 5943 done 5944 5945 # Make sure dlprefiles contains only unique files 5946 old_dlprefiles="$dlprefiles" 5947 dlprefiles= 5948 for lib in $old_dlprefiles; do 5949 case "$dlprefiles " in 5950 *" $lib "*) ;; 5951 *) dlprefiles="$dlprefiles $lib" ;; 5952 esac 5953 done 5954 5955 if test "$build_libtool_libs" = yes; then 5956 if test -n "$rpath"; then 5957 case $host in 5958 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*) 5959 # these systems don't actually have a c library (as such)! 5960 ;; 5961 *-*-rhapsody* | *-*-darwin1.[012]) 5962 # Rhapsody C library is in the System framework 5963 deplibs="$deplibs System.ltframework" 5964 ;; 5965 *-*-netbsd*) 5966 # Don't link with libc until the a.out ld.so is fixed. 5967 ;; 5968 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*) 5969 # Do not include libc due to us having libc/libc_r. 5970 ;; 5971 *-*-sco3.2v5* | *-*-sco5v6*) 5972 # Causes problems with __ctype 5973 ;; 5974 *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*) 5975 # Compiler inserts libc in the correct place for threads to work 5976 ;; 5977 *) 5978 # Add libc to deplibs on all other systems if necessary. 5979 if test "$build_libtool_need_lc" = "yes"; then 5980 deplibs="$deplibs -lc" 5981 fi 5982 ;; 5983 esac 5984 fi 5985 5986 # Transform deplibs into only deplibs that can be linked in shared. 5987 name_save=$name 5988 libname_save=$libname 5989 release_save=$release 5990 versuffix_save=$versuffix 5991 major_save=$major 5992 # I'm not sure if I'm treating the release correctly. I think 5993 # release should show up in the -l (ie -lgmp5) so we don't want to 5994 # add it in twice. Is that correct? 5995 release="" 5996 versuffix="" 5997 major="" 5998 newdeplibs= 5999 droppeddeps=no 6000 case $deplibs_check_method in 6001 pass_all) 6002 # Don't check for shared/static. Everything works. 6003 # This might be a little naive. We might want to check 6004 # whether the library exists or not. But this is on 6005 # osf3 & osf4 and I'm not really sure... Just 6006 # implementing what was already the behavior. 6007 newdeplibs=$deplibs 6008 ;; 6009 test_compile) 6010 # This code stresses the "libraries are programs" paradigm to its 6011 # limits. Maybe even breaks it. We compile a program, linking it 6012 # against the deplibs as a proxy for the library. Then we can check 6013 # whether they linked in statically or dynamically with ldd. 6014 $opt_dry_run || $RM conftest.c 6015 cat > conftest.c <<EOF 6016 int main() { return 0; } 6017EOF 6018 $opt_dry_run || $RM conftest 6019 if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then 6020 ldd_output=`ldd conftest` 6021 for i in $deplibs; do 6022 case $i in 6023 -l*) 6024 func_stripname -l '' "$i" 6025 name=$func_stripname_result 6026 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then 6027 case " $predeps $postdeps " in 6028 *" $i "*) 6029 newdeplibs="$newdeplibs $i" 6030 i="" 6031 ;; 6032 esac 6033 fi 6034 if test -n "$i" ; then 6035 libname=`eval "\\$ECHO \"$libname_spec\""` 6036 deplib_matches=`eval "\\$ECHO \"$library_names_spec\""` 6037 set dummy $deplib_matches; shift 6038 deplib_match=$1 6039 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then 6040 newdeplibs="$newdeplibs $i" 6041 else 6042 droppeddeps=yes 6043 $ECHO 6044 $ECHO "*** Warning: dynamic linker does not accept needed library $i." 6045 $ECHO "*** I have the capability to make that library automatically link in when" 6046 $ECHO "*** you link to this library. But I can only do this if you have a" 6047 $ECHO "*** shared version of the library, which I believe you do not have" 6048 $ECHO "*** because a test_compile did reveal that the linker did not use it for" 6049 $ECHO "*** its dynamic dependency list that programs get resolved with at runtime." 6050 fi 6051 fi 6052 ;; 6053 *) 6054 newdeplibs="$newdeplibs $i" 6055 ;; 6056 esac 6057 done 6058 else 6059 # Error occurred in the first compile. Let's try to salvage 6060 # the situation: Compile a separate program for each library. 6061 for i in $deplibs; do 6062 case $i in 6063 -l*) 6064 func_stripname -l '' "$i" 6065 name=$func_stripname_result 6066 $opt_dry_run || $RM conftest 6067 if $LTCC $LTCFLAGS -o conftest conftest.c $i; then 6068 ldd_output=`ldd conftest` 6069 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then 6070 case " $predeps $postdeps " in 6071 *" $i "*) 6072 newdeplibs="$newdeplibs $i" 6073 i="" 6074 ;; 6075 esac 6076 fi 6077 if test -n "$i" ; then 6078 libname=`eval "\\$ECHO \"$libname_spec\""` 6079 deplib_matches=`eval "\\$ECHO \"$library_names_spec\""` 6080 set dummy $deplib_matches; shift 6081 deplib_match=$1 6082 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then 6083 newdeplibs="$newdeplibs $i" 6084 else 6085 droppeddeps=yes 6086 $ECHO 6087 $ECHO "*** Warning: dynamic linker does not accept needed library $i." 6088 $ECHO "*** I have the capability to make that library automatically link in when" 6089 $ECHO "*** you link to this library. But I can only do this if you have a" 6090 $ECHO "*** shared version of the library, which you do not appear to have" 6091 $ECHO "*** because a test_compile did reveal that the linker did not use this one" 6092 $ECHO "*** as a dynamic dependency that programs can get resolved with at runtime." 6093 fi 6094 fi 6095 else 6096 droppeddeps=yes 6097 $ECHO 6098 $ECHO "*** Warning! Library $i is needed by this library but I was not able to" 6099 $ECHO "*** make it link in! You will probably need to install it or some" 6100 $ECHO "*** library that it depends on before this library will be fully" 6101 $ECHO "*** functional. Installing it before continuing would be even better." 6102 fi 6103 ;; 6104 *) 6105 newdeplibs="$newdeplibs $i" 6106 ;; 6107 esac 6108 done 6109 fi 6110 ;; 6111 file_magic*) 6112 set dummy $deplibs_check_method; shift 6113 file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"` 6114 for a_deplib in $deplibs; do 6115 case $a_deplib in 6116 -l*) 6117 func_stripname -l '' "$a_deplib" 6118 name=$func_stripname_result 6119 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then 6120 case " $predeps $postdeps " in 6121 *" $a_deplib "*) 6122 newdeplibs="$newdeplibs $a_deplib" 6123 a_deplib="" 6124 ;; 6125 esac 6126 fi 6127 if test -n "$a_deplib" ; then 6128 libname=`eval "\\$ECHO \"$libname_spec\""` 6129 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do 6130 potential_libs=`ls $i/$libname[.-]* 2>/dev/null` 6131 for potent_lib in $potential_libs; do 6132 # Follow soft links. 6133 if ls -lLd "$potent_lib" 2>/dev/null | 6134 $GREP " -> " >/dev/null; then 6135 continue 6136 fi 6137 # The statement above tries to avoid entering an 6138 # endless loop below, in case of cyclic links. 6139 # We might still enter an endless loop, since a link 6140 # loop can be closed while we follow links, 6141 # but so what? 6142 potlib="$potent_lib" 6143 while test -h "$potlib" 2>/dev/null; do 6144 potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'` 6145 case $potliblink in 6146 [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";; 6147 *) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";; 6148 esac 6149 done 6150 if eval $file_magic_cmd \"\$potlib\" 2>/dev/null | 6151 $SED -e 10q | 6152 $EGREP "$file_magic_regex" > /dev/null; then 6153 newdeplibs="$newdeplibs $a_deplib" 6154 a_deplib="" 6155 break 2 6156 fi 6157 done 6158 done 6159 fi 6160 if test -n "$a_deplib" ; then 6161 droppeddeps=yes 6162 $ECHO 6163 $ECHO "*** Warning: linker path does not have real file for library $a_deplib." 6164 $ECHO "*** I have the capability to make that library automatically link in when" 6165 $ECHO "*** you link to this library. But I can only do this if you have a" 6166 $ECHO "*** shared version of the library, which you do not appear to have" 6167 $ECHO "*** because I did check the linker path looking for a file starting" 6168 if test -z "$potlib" ; then 6169 $ECHO "*** with $libname but no candidates were found. (...for file magic test)" 6170 else 6171 $ECHO "*** with $libname and none of the candidates passed a file format test" 6172 $ECHO "*** using a file magic. Last file checked: $potlib" 6173 fi 6174 fi 6175 ;; 6176 *) 6177 # Add a -L argument. 6178 newdeplibs="$newdeplibs $a_deplib" 6179 ;; 6180 esac 6181 done # Gone through all deplibs. 6182 ;; 6183 match_pattern*) 6184 set dummy $deplibs_check_method; shift 6185 match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"` 6186 for a_deplib in $deplibs; do 6187 case $a_deplib in 6188 -l*) 6189 func_stripname -l '' "$a_deplib" 6190 name=$func_stripname_result 6191 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then 6192 case " $predeps $postdeps " in 6193 *" $a_deplib "*) 6194 newdeplibs="$newdeplibs $a_deplib" 6195 a_deplib="" 6196 ;; 6197 esac 6198 fi 6199 if test -n "$a_deplib" ; then 6200 libname=`eval "\\$ECHO \"$libname_spec\""` 6201 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do 6202 potential_libs=`ls $i/$libname[.-]* 2>/dev/null` 6203 for potent_lib in $potential_libs; do 6204 potlib="$potent_lib" # see symlink-check above in file_magic test 6205 if eval "\$ECHO \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \ 6206 $EGREP "$match_pattern_regex" > /dev/null; then 6207 newdeplibs="$newdeplibs $a_deplib" 6208 a_deplib="" 6209 break 2 6210 fi 6211 done 6212 done 6213 fi 6214 if test -n "$a_deplib" ; then 6215 droppeddeps=yes 6216 $ECHO 6217 $ECHO "*** Warning: linker path does not have real file for library $a_deplib." 6218 $ECHO "*** I have the capability to make that library automatically link in when" 6219 $ECHO "*** you link to this library. But I can only do this if you have a" 6220 $ECHO "*** shared version of the library, which you do not appear to have" 6221 $ECHO "*** because I did check the linker path looking for a file starting" 6222 if test -z "$potlib" ; then 6223 $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)" 6224 else 6225 $ECHO "*** with $libname and none of the candidates passed a file format test" 6226 $ECHO "*** using a regex pattern. Last file checked: $potlib" 6227 fi 6228 fi 6229 ;; 6230 *) 6231 # Add a -L argument. 6232 newdeplibs="$newdeplibs $a_deplib" 6233 ;; 6234 esac 6235 done # Gone through all deplibs. 6236 ;; 6237 none | unknown | *) 6238 newdeplibs="" 6239 tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \ 6240 -e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'` 6241 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then 6242 for i in $predeps $postdeps ; do 6243 # can't use Xsed below, because $i might contain '/' 6244 tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"` 6245 done 6246 fi 6247 if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[ ]//g' | 6248 $GREP . >/dev/null; then 6249 $ECHO 6250 if test "X$deplibs_check_method" = "Xnone"; then 6251 $ECHO "*** Warning: inter-library dependencies are not supported in this platform." 6252 else 6253 $ECHO "*** Warning: inter-library dependencies are not known to be supported." 6254 fi 6255 $ECHO "*** All declared inter-library dependencies are being dropped." 6256 droppeddeps=yes 6257 fi 6258 ;; 6259 esac 6260 versuffix=$versuffix_save 6261 major=$major_save 6262 release=$release_save 6263 libname=$libname_save 6264 name=$name_save 6265 6266 case $host in 6267 *-*-rhapsody* | *-*-darwin1.[012]) 6268 # On Rhapsody replace the C library with the System framework 6269 newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'` 6270 ;; 6271 esac 6272 6273 if test "$droppeddeps" = yes; then 6274 if test "$module" = yes; then 6275 $ECHO 6276 $ECHO "*** Warning: libtool could not satisfy all declared inter-library" 6277 $ECHO "*** dependencies of module $libname. Therefore, libtool will create" 6278 $ECHO "*** a static module, that should work as long as the dlopening" 6279 $ECHO "*** application is linked with the -dlopen flag." 6280 if test -z "$global_symbol_pipe"; then 6281 $ECHO 6282 $ECHO "*** However, this would only work if libtool was able to extract symbol" 6283 $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could" 6284 $ECHO "*** not find such a program. So, this module is probably useless." 6285 $ECHO "*** \`nm' from GNU binutils and a full rebuild may help." 6286 fi 6287 if test "$build_old_libs" = no; then 6288 oldlibs="$output_objdir/$libname.$libext" 6289 build_libtool_libs=module 6290 build_old_libs=yes 6291 else 6292 build_libtool_libs=no 6293 fi 6294 else 6295 $ECHO "*** The inter-library dependencies that have been dropped here will be" 6296 $ECHO "*** automatically added whenever a program is linked with this library" 6297 $ECHO "*** or is declared to -dlopen it." 6298 6299 if test "$allow_undefined" = no; then 6300 $ECHO 6301 $ECHO "*** Since this library must not contain undefined symbols," 6302 $ECHO "*** because either the platform does not support them or" 6303 $ECHO "*** it was explicitly requested with -no-undefined," 6304 $ECHO "*** libtool will only create a static version of it." 6305 if test "$build_old_libs" = no; then 6306 oldlibs="$output_objdir/$libname.$libext" 6307 build_libtool_libs=module 6308 build_old_libs=yes 6309 else 6310 build_libtool_libs=no 6311 fi 6312 fi 6313 fi 6314 fi 6315 # Done checking deplibs! 6316 deplibs=$newdeplibs 6317 fi 6318 # Time to change all our "foo.ltframework" stuff back to "-framework foo" 6319 case $host in 6320 *-*-darwin*) 6321 newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'` 6322 new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'` 6323 deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'` 6324 ;; 6325 esac 6326 6327 # move library search paths that coincide with paths to not yet 6328 # installed libraries to the beginning of the library search list 6329 new_libs= 6330 for path in $notinst_path; do 6331 case " $new_libs " in 6332 *" -L$path/$objdir "*) ;; 6333 *) 6334 case " $deplibs " in 6335 *" -L$path/$objdir "*) 6336 new_libs="$new_libs -L$path/$objdir" ;; 6337 esac 6338 ;; 6339 esac 6340 done 6341 for deplib in $deplibs; do 6342 case $deplib in 6343 -L*) 6344 case " $new_libs " in 6345 *" $deplib "*) ;; 6346 *) new_libs="$new_libs $deplib" ;; 6347 esac 6348 ;; 6349 *) new_libs="$new_libs $deplib" ;; 6350 esac 6351 done 6352 deplibs="$new_libs" 6353 6354 # All the library-specific variables (install_libdir is set above). 6355 library_names= 6356 old_library= 6357 dlname= 6358 6359 # Test again, we may have decided not to build it any more 6360 if test "$build_libtool_libs" = yes; then 6361 if test "$hardcode_into_libs" = yes; then 6362 # Hardcode the library paths 6363 hardcode_libdirs= 6364 dep_rpath= 6365 rpath="$finalize_rpath" 6366 test "$mode" != relink && rpath="$compile_rpath$rpath" 6367 for libdir in $rpath; do 6368 if test -n "$hardcode_libdir_flag_spec"; then 6369 if test -n "$hardcode_libdir_separator"; then 6370 if test -z "$hardcode_libdirs"; then 6371 hardcode_libdirs="$libdir" 6372 else 6373 # Just accumulate the unique libdirs. 6374 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in 6375 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) 6376 ;; 6377 *) 6378 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir" 6379 ;; 6380 esac 6381 fi 6382 else 6383 eval flag=\"$hardcode_libdir_flag_spec\" 6384 dep_rpath="$dep_rpath $flag" 6385 fi 6386 elif test -n "$runpath_var"; then 6387 case "$perm_rpath " in 6388 *" $libdir "*) ;; 6389 *) perm_rpath="$perm_rpath $libdir" ;; 6390 esac 6391 fi 6392 done 6393 # Substitute the hardcoded libdirs into the rpath. 6394 if test -n "$hardcode_libdir_separator" && 6395 test -n "$hardcode_libdirs"; then 6396 libdir="$hardcode_libdirs" 6397 if test -n "$hardcode_libdir_flag_spec_ld"; then 6398 eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\" 6399 else 6400 eval dep_rpath=\"$hardcode_libdir_flag_spec\" 6401 fi 6402 fi 6403 if test -n "$runpath_var" && test -n "$perm_rpath"; then 6404 # We should set the runpath_var. 6405 rpath= 6406 for dir in $perm_rpath; do 6407 rpath="$rpath$dir:" 6408 done 6409 eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var" 6410 fi 6411 test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs" 6412 fi 6413 6414 shlibpath="$finalize_shlibpath" 6415 test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath" 6416 if test -n "$shlibpath"; then 6417 eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var" 6418 fi 6419 6420 # Get the real and link names of the library. 6421 eval shared_ext=\"$shrext_cmds\" 6422 eval library_names=\"$library_names_spec\" 6423 set dummy $library_names 6424 shift 6425 realname="$1" 6426 shift 6427 6428 if test -n "$soname_spec"; then 6429 eval soname=\"$soname_spec\" 6430 else 6431 soname="$realname" 6432 fi 6433 if test -z "$dlname"; then 6434 dlname=$soname 6435 fi 6436 6437 lib="$output_objdir/$realname" 6438 linknames= 6439 for link 6440 do 6441 linknames="$linknames $link" 6442 done 6443 6444 # Use standard objects if they are pic 6445 test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP` 6446 test "X$libobjs" = "X " && libobjs= 6447 6448 delfiles= 6449 if test -n "$export_symbols" && test -n "$include_expsyms"; then 6450 $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp" 6451 export_symbols="$output_objdir/$libname.uexp" 6452 delfiles="$delfiles $export_symbols" 6453 fi 6454 6455 orig_export_symbols= 6456 case $host_os in 6457 cygwin* | mingw*) 6458 if test -n "$export_symbols" && test -z "$export_symbols_regex"; then 6459 # exporting using user supplied symfile 6460 if test "x`$SED 1q $export_symbols`" != xEXPORTS; then 6461 # and it's NOT already a .def file. Must figure out 6462 # which of the given symbols are data symbols and tag 6463 # them as such. So, trigger use of export_symbols_cmds. 6464 # export_symbols gets reassigned inside the "prepare 6465 # the list of exported symbols" if statement, so the 6466 # include_expsyms logic still works. 6467 orig_export_symbols="$export_symbols" 6468 export_symbols= 6469 always_export_symbols=yes 6470 fi 6471 fi 6472 ;; 6473 esac 6474 6475 # Prepare the list of exported symbols 6476 if test -z "$export_symbols"; then 6477 if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then 6478 func_verbose "generating symbol list for \`$libname.la'" 6479 export_symbols="$output_objdir/$libname.exp" 6480 $opt_dry_run || $RM $export_symbols 6481 cmds=$export_symbols_cmds 6482 save_ifs="$IFS"; IFS='~' 6483 for cmd in $cmds; do 6484 IFS="$save_ifs" 6485 eval cmd=\"$cmd\" 6486 func_len " $cmd" 6487 len=$func_len_result 6488 if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then 6489 func_show_eval "$cmd" 'exit $?' 6490 skipped_export=false 6491 else 6492 # The command line is too long to execute in one step. 6493 func_verbose "using reloadable object file for export list..." 6494 skipped_export=: 6495 # Break out early, otherwise skipped_export may be 6496 # set to false by a later but shorter cmd. 6497 break 6498 fi 6499 done 6500 IFS="$save_ifs" 6501 if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then 6502 func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"' 6503 func_show_eval '$MV "${export_symbols}T" "$export_symbols"' 6504 fi 6505 fi 6506 fi 6507 6508 if test -n "$export_symbols" && test -n "$include_expsyms"; then 6509 tmp_export_symbols="$export_symbols" 6510 test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols" 6511 $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"' 6512 fi 6513 6514 if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then 6515 # The given exports_symbols file has to be filtered, so filter it. 6516 func_verbose "filter symbol list for \`$libname.la' to tag DATA exports" 6517 # FIXME: $output_objdir/$libname.filter potentially contains lots of 6518 # 's' commands which not all seds can handle. GNU sed should be fine 6519 # though. Also, the filter scales superlinearly with the number of 6520 # global variables. join(1) would be nice here, but unfortunately 6521 # isn't a blessed tool. 6522 $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter 6523 delfiles="$delfiles $export_symbols $output_objdir/$libname.filter" 6524 export_symbols=$output_objdir/$libname.def 6525 $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols 6526 fi 6527 6528 tmp_deplibs= 6529 for test_deplib in $deplibs; do 6530 case " $convenience " in 6531 *" $test_deplib "*) ;; 6532 *) 6533 tmp_deplibs="$tmp_deplibs $test_deplib" 6534 ;; 6535 esac 6536 done 6537 deplibs="$tmp_deplibs" 6538 6539 if test -n "$convenience"; then 6540 if test -n "$whole_archive_flag_spec" && 6541 test "$compiler_needs_object" = yes && 6542 test -z "$libobjs"; then 6543 # extract the archives, so we have objects to list. 6544 # TODO: could optimize this to just extract one archive. 6545 whole_archive_flag_spec= 6546 fi 6547 if test -n "$whole_archive_flag_spec"; then 6548 save_libobjs=$libobjs 6549 eval libobjs=\"\$libobjs $whole_archive_flag_spec\" 6550 test "X$libobjs" = "X " && libobjs= 6551 else 6552 gentop="$output_objdir/${outputname}x" 6553 generated="$generated $gentop" 6554 6555 func_extract_archives $gentop $convenience 6556 libobjs="$libobjs $func_extract_archives_result" 6557 test "X$libobjs" = "X " && libobjs= 6558 fi 6559 fi 6560 6561 if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then 6562 eval flag=\"$thread_safe_flag_spec\" 6563 linker_flags="$linker_flags $flag" 6564 fi 6565 6566 # Make a backup of the uninstalled library when relinking 6567 if test "$mode" = relink; then 6568 $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $? 6569 fi 6570 6571 # Do each of the archive commands. 6572 if test "$module" = yes && test -n "$module_cmds" ; then 6573 if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then 6574 eval test_cmds=\"$module_expsym_cmds\" 6575 cmds=$module_expsym_cmds 6576 else 6577 eval test_cmds=\"$module_cmds\" 6578 cmds=$module_cmds 6579 fi 6580 else 6581 if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then 6582 eval test_cmds=\"$archive_expsym_cmds\" 6583 cmds=$archive_expsym_cmds 6584 else 6585 eval test_cmds=\"$archive_cmds\" 6586 cmds=$archive_cmds 6587 fi 6588 fi 6589 6590 if test "X$skipped_export" != "X:" && 6591 func_len " $test_cmds" && 6592 len=$func_len_result && 6593 test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then 6594 : 6595 else 6596 # The command line is too long to link in one step, link piecewise 6597 # or, if using GNU ld and skipped_export is not :, use a linker 6598 # script. 6599 6600 # Save the value of $output and $libobjs because we want to 6601 # use them later. If we have whole_archive_flag_spec, we 6602 # want to use save_libobjs as it was before 6603 # whole_archive_flag_spec was expanded, because we can't 6604 # assume the linker understands whole_archive_flag_spec. 6605 # This may have to be revisited, in case too many 6606 # convenience libraries get linked in and end up exceeding 6607 # the spec. 6608 if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then 6609 save_libobjs=$libobjs 6610 fi 6611 save_output=$output 6612 output_la=`$ECHO "X$output" | $Xsed -e "$basename"` 6613 6614 # Clear the reloadable object creation command queue and 6615 # initialize k to one. 6616 test_cmds= 6617 concat_cmds= 6618 objlist= 6619 last_robj= 6620 k=1 6621 6622 if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then 6623 output=${output_objdir}/${output_la}.lnkscript 6624 func_verbose "creating GNU ld script: $output" 6625 $ECHO 'INPUT (' > $output 6626 for obj in $save_libobjs 6627 do 6628 $ECHO "$obj" >> $output 6629 done 6630 $ECHO ')' >> $output 6631 delfiles="$delfiles $output" 6632 elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then 6633 output=${output_objdir}/${output_la}.lnk 6634 func_verbose "creating linker input file list: $output" 6635 : > $output 6636 set x $save_libobjs 6637 shift 6638 firstobj= 6639 if test "$compiler_needs_object" = yes; then 6640 firstobj="$1 " 6641 shift 6642 fi 6643 for obj 6644 do 6645 $ECHO "$obj" >> $output 6646 done 6647 delfiles="$delfiles $output" 6648 output=$firstobj\"$file_list_spec$output\" 6649 else 6650 if test -n "$save_libobjs"; then 6651 func_verbose "creating reloadable object files..." 6652 output=$output_objdir/$output_la-${k}.$objext 6653 eval test_cmds=\"$reload_cmds\" 6654 func_len " $test_cmds" 6655 len0=$func_len_result 6656 len=$len0 6657 6658 # Loop over the list of objects to be linked. 6659 for obj in $save_libobjs 6660 do 6661 func_len " $obj" 6662 func_arith $len + $func_len_result 6663 len=$func_arith_result 6664 if test "X$objlist" = X || 6665 test "$len" -lt "$max_cmd_len"; then 6666 func_append objlist " $obj" 6667 else 6668 # The command $test_cmds is almost too long, add a 6669 # command to the queue. 6670 if test "$k" -eq 1 ; then 6671 # The first file doesn't have a previous command to add. 6672 eval concat_cmds=\"$reload_cmds $objlist $last_robj\" 6673 else 6674 # All subsequent reloadable object files will link in 6675 # the last one created. 6676 eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj~\$RM $last_robj\" 6677 fi 6678 last_robj=$output_objdir/$output_la-${k}.$objext 6679 func_arith $k + 1 6680 k=$func_arith_result 6681 output=$output_objdir/$output_la-${k}.$objext 6682 objlist=$obj 6683 func_len " $last_robj" 6684 func_arith $len0 + $func_len_result 6685 len=$func_arith_result 6686 fi 6687 done 6688 # Handle the remaining objects by creating one last 6689 # reloadable object file. All subsequent reloadable object 6690 # files will link in the last one created. 6691 test -z "$concat_cmds" || concat_cmds=$concat_cmds~ 6692 eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\" 6693 if test -n "$last_robj"; then 6694 eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\" 6695 fi 6696 delfiles="$delfiles $output" 6697 6698 else 6699 output= 6700 fi 6701 6702 if ${skipped_export-false}; then 6703 func_verbose "generating symbol list for \`$libname.la'" 6704 export_symbols="$output_objdir/$libname.exp" 6705 $opt_dry_run || $RM $export_symbols 6706 libobjs=$output 6707 # Append the command to create the export file. 6708 test -z "$concat_cmds" || concat_cmds=$concat_cmds~ 6709 eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\" 6710 if test -n "$last_robj"; then 6711 eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\" 6712 fi 6713 fi 6714 6715 test -n "$save_libobjs" && 6716 func_verbose "creating a temporary reloadable object file: $output" 6717 6718 # Loop through the commands generated above and execute them. 6719 save_ifs="$IFS"; IFS='~' 6720 for cmd in $concat_cmds; do 6721 IFS="$save_ifs" 6722 $opt_silent || { 6723 func_quote_for_expand "$cmd" 6724 eval "func_echo $func_quote_for_expand_result" 6725 } 6726 $opt_dry_run || eval "$cmd" || { 6727 lt_exit=$? 6728 6729 # Restore the uninstalled library and exit 6730 if test "$mode" = relink; then 6731 ( cd "$output_objdir" && \ 6732 $RM "${realname}T" && \ 6733 $MV "${realname}U" "$realname" ) 6734 fi 6735 6736 exit $lt_exit 6737 } 6738 done 6739 IFS="$save_ifs" 6740 6741 if test -n "$export_symbols_regex" && ${skipped_export-false}; then 6742 func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"' 6743 func_show_eval '$MV "${export_symbols}T" "$export_symbols"' 6744 fi 6745 fi 6746 6747 if ${skipped_export-false}; then 6748 if test -n "$export_symbols" && test -n "$include_expsyms"; then 6749 tmp_export_symbols="$export_symbols" 6750 test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols" 6751 $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"' 6752 fi 6753 6754 if test -n "$orig_export_symbols"; then 6755 # The given exports_symbols file has to be filtered, so filter it. 6756 func_verbose "filter symbol list for \`$libname.la' to tag DATA exports" 6757 # FIXME: $output_objdir/$libname.filter potentially contains lots of 6758 # 's' commands which not all seds can handle. GNU sed should be fine 6759 # though. Also, the filter scales superlinearly with the number of 6760 # global variables. join(1) would be nice here, but unfortunately 6761 # isn't a blessed tool. 6762 $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter 6763 delfiles="$delfiles $export_symbols $output_objdir/$libname.filter" 6764 export_symbols=$output_objdir/$libname.def 6765 $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols 6766 fi 6767 fi 6768 6769 libobjs=$output 6770 # Restore the value of output. 6771 output=$save_output 6772 6773 if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then 6774 eval libobjs=\"\$libobjs $whole_archive_flag_spec\" 6775 test "X$libobjs" = "X " && libobjs= 6776 fi 6777 # Expand the library linking commands again to reset the 6778 # value of $libobjs for piecewise linking. 6779 6780 # Do each of the archive commands. 6781 if test "$module" = yes && test -n "$module_cmds" ; then 6782 if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then 6783 cmds=$module_expsym_cmds 6784 else 6785 cmds=$module_cmds 6786 fi 6787 else 6788 if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then 6789 cmds=$archive_expsym_cmds 6790 else 6791 cmds=$archive_cmds 6792 fi 6793 fi 6794 fi 6795 6796 if test -n "$delfiles"; then 6797 # Append the command to remove temporary files to $cmds. 6798 eval cmds=\"\$cmds~\$RM $delfiles\" 6799 fi 6800 6801 # Add any objects from preloaded convenience libraries 6802 if test -n "$dlprefiles"; then 6803 gentop="$output_objdir/${outputname}x" 6804 generated="$generated $gentop" 6805 6806 func_extract_archives $gentop $dlprefiles 6807 libobjs="$libobjs $func_extract_archives_result" 6808 test "X$libobjs" = "X " && libobjs= 6809 fi 6810 6811 save_ifs="$IFS"; IFS='~' 6812 for cmd in $cmds; do 6813 IFS="$save_ifs" 6814 eval cmd=\"$cmd\" 6815 $opt_silent || { 6816 func_quote_for_expand "$cmd" 6817 eval "func_echo $func_quote_for_expand_result" 6818 } 6819 $opt_dry_run || eval "$cmd" || { 6820 lt_exit=$? 6821 6822 # Restore the uninstalled library and exit 6823 if test "$mode" = relink; then 6824 ( cd "$output_objdir" && \ 6825 $RM "${realname}T" && \ 6826 $MV "${realname}U" "$realname" ) 6827 fi 6828 6829 exit $lt_exit 6830 } 6831 done 6832 IFS="$save_ifs" 6833 6834 # Restore the uninstalled library and exit 6835 if test "$mode" = relink; then 6836 $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $? 6837 6838 if test -n "$convenience"; then 6839 if test -z "$whole_archive_flag_spec"; then 6840 func_show_eval '${RM}r "$gentop"' 6841 fi 6842 fi 6843 6844 exit $EXIT_SUCCESS 6845 fi 6846 6847 # Create links to the real library. 6848 for linkname in $linknames; do 6849 if test "$realname" != "$linkname"; then 6850 func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?' 6851 fi 6852 done 6853 6854 # If -module or -export-dynamic was specified, set the dlname. 6855 if test "$module" = yes || test "$export_dynamic" = yes; then 6856 # On all known operating systems, these are identical. 6857 dlname="$soname" 6858 fi 6859 fi 6860 ;; 6861 6862 obj) 6863 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then 6864 func_warning "\`-dlopen' is ignored for objects" 6865 fi 6866 6867 case " $deplibs" in 6868 *\ -l* | *\ -L*) 6869 func_warning "\`-l' and \`-L' are ignored for objects" ;; 6870 esac 6871 6872 test -n "$rpath" && \ 6873 func_warning "\`-rpath' is ignored for objects" 6874 6875 test -n "$xrpath" && \ 6876 func_warning "\`-R' is ignored for objects" 6877 6878 test -n "$vinfo" && \ 6879 func_warning "\`-version-info' is ignored for objects" 6880 6881 test -n "$release" && \ 6882 func_warning "\`-release' is ignored for objects" 6883 6884 case $output in 6885 *.lo) 6886 test -n "$objs$old_deplibs" && \ 6887 func_fatal_error "cannot build library object \`$output' from non-libtool objects" 6888 6889 libobj=$output 6890 func_lo2o "$libobj" 6891 obj=$func_lo2o_result 6892 ;; 6893 *) 6894 libobj= 6895 obj="$output" 6896 ;; 6897 esac 6898 6899 # Delete the old objects. 6900 $opt_dry_run || $RM $obj $libobj 6901 6902 # Objects from convenience libraries. This assumes 6903 # single-version convenience libraries. Whenever we create 6904 # different ones for PIC/non-PIC, this we'll have to duplicate 6905 # the extraction. 6906 reload_conv_objs= 6907 gentop= 6908 # reload_cmds runs $LD directly, so let us get rid of 6909 # -Wl from whole_archive_flag_spec and hope we can get by with 6910 # turning comma into space.. 6911 wl= 6912 6913 if test -n "$convenience"; then 6914 if test -n "$whole_archive_flag_spec"; then 6915 eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\" 6916 reload_conv_objs=$reload_objs\ `$ECHO "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'` 6917 else 6918 gentop="$output_objdir/${obj}x" 6919 generated="$generated $gentop" 6920 6921 func_extract_archives $gentop $convenience 6922 reload_conv_objs="$reload_objs $func_extract_archives_result" 6923 fi 6924 fi 6925 6926 # Create the old-style object. 6927 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 6928 6929 output="$obj" 6930 func_execute_cmds "$reload_cmds" 'exit $?' 6931 6932 # Exit if we aren't doing a library object file. 6933 if test -z "$libobj"; then 6934 if test -n "$gentop"; then 6935 func_show_eval '${RM}r "$gentop"' 6936 fi 6937 6938 exit $EXIT_SUCCESS 6939 fi 6940 6941 if test "$build_libtool_libs" != yes; then 6942 if test -n "$gentop"; then 6943 func_show_eval '${RM}r "$gentop"' 6944 fi 6945 6946 # Create an invalid libtool object if no PIC, so that we don't 6947 # accidentally link it into a program. 6948 # $show "echo timestamp > $libobj" 6949 # $opt_dry_run || eval "echo timestamp > $libobj" || exit $? 6950 exit $EXIT_SUCCESS 6951 fi 6952 6953 if test -n "$pic_flag" || test "$pic_mode" != default; then 6954 # Only do commands if we really have different PIC objects. 6955 reload_objs="$libobjs $reload_conv_objs" 6956 output="$libobj" 6957 func_execute_cmds "$reload_cmds" 'exit $?' 6958 fi 6959 6960 if test -n "$gentop"; then 6961 func_show_eval '${RM}r "$gentop"' 6962 fi 6963 6964 exit $EXIT_SUCCESS 6965 ;; 6966 6967 prog) 6968 case $host in 6969 *cygwin*) func_stripname '' '.exe' "$output" 6970 output=$func_stripname_result.exe;; 6971 esac 6972 test -n "$vinfo" && \ 6973 func_warning "\`-version-info' is ignored for programs" 6974 6975 test -n "$release" && \ 6976 func_warning "\`-release' is ignored for programs" 6977 6978 test "$preload" = yes \ 6979 && test "$dlopen_support" = unknown \ 6980 && test "$dlopen_self" = unknown \ 6981 && test "$dlopen_self_static" = unknown && \ 6982 func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support." 6983 6984 case $host in 6985 *-*-rhapsody* | *-*-darwin1.[012]) 6986 # On Rhapsody replace the C library is the System framework 6987 compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'` 6988 finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'` 6989 ;; 6990 esac 6991 6992 case $host in 6993 *-*-darwin*) 6994 # Don't allow lazy linking, it breaks C++ global constructors 6995 # But is supposedly fixed on 10.4 or later (yay!). 6996 if test "$tagname" = CXX ; then 6997 case ${MACOSX_DEPLOYMENT_TARGET-10.0} in 6998 10.[0123]) 6999 compile_command="$compile_command ${wl}-bind_at_load" 7000 finalize_command="$finalize_command ${wl}-bind_at_load" 7001 ;; 7002 esac 7003 fi 7004 # Time to change all our "foo.ltframework" stuff back to "-framework foo" 7005 compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'` 7006 finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'` 7007 ;; 7008 esac 7009 7010 7011 # move library search paths that coincide with paths to not yet 7012 # installed libraries to the beginning of the library search list 7013 new_libs= 7014 for path in $notinst_path; do 7015 case " $new_libs " in 7016 *" -L$path/$objdir "*) ;; 7017 *) 7018 case " $compile_deplibs " in 7019 *" -L$path/$objdir "*) 7020 new_libs="$new_libs -L$path/$objdir" ;; 7021 esac 7022 ;; 7023 esac 7024 done 7025 for deplib in $compile_deplibs; do 7026 case $deplib in 7027 -L*) 7028 case " $new_libs " in 7029 *" $deplib "*) ;; 7030 *) new_libs="$new_libs $deplib" ;; 7031 esac 7032 ;; 7033 *) new_libs="$new_libs $deplib" ;; 7034 esac 7035 done 7036 compile_deplibs="$new_libs" 7037 7038 7039 compile_command="$compile_command $compile_deplibs" 7040 finalize_command="$finalize_command $finalize_deplibs" 7041 7042 if test -n "$rpath$xrpath"; then 7043 # If the user specified any rpath flags, then add them. 7044 for libdir in $rpath $xrpath; do 7045 # This is the magic to use -rpath. 7046 case "$finalize_rpath " in 7047 *" $libdir "*) ;; 7048 *) finalize_rpath="$finalize_rpath $libdir" ;; 7049 esac 7050 done 7051 fi 7052 7053 # Now hardcode the library paths 7054 rpath= 7055 hardcode_libdirs= 7056 for libdir in $compile_rpath $finalize_rpath; do 7057 if test -n "$hardcode_libdir_flag_spec"; then 7058 if test -n "$hardcode_libdir_separator"; then 7059 if test -z "$hardcode_libdirs"; then 7060 hardcode_libdirs="$libdir" 7061 else 7062 # Just accumulate the unique libdirs. 7063 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in 7064 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) 7065 ;; 7066 *) 7067 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir" 7068 ;; 7069 esac 7070 fi 7071 else 7072 eval flag=\"$hardcode_libdir_flag_spec\" 7073 rpath="$rpath $flag" 7074 fi 7075 elif test -n "$runpath_var"; then 7076 case "$perm_rpath " in 7077 *" $libdir "*) ;; 7078 *) perm_rpath="$perm_rpath $libdir" ;; 7079 esac 7080 fi 7081 case $host in 7082 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*) 7083 testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'` 7084 case :$dllsearchpath: in 7085 *":$libdir:"*) ;; 7086 *) dllsearchpath="$dllsearchpath:$libdir";; 7087 esac 7088 case :$dllsearchpath: in 7089 *":$testbindir:"*) ;; 7090 *) dllsearchpath="$dllsearchpath:$testbindir";; 7091 esac 7092 ;; 7093 esac 7094 done 7095 # Substitute the hardcoded libdirs into the rpath. 7096 if test -n "$hardcode_libdir_separator" && 7097 test -n "$hardcode_libdirs"; then 7098 libdir="$hardcode_libdirs" 7099 eval rpath=\" $hardcode_libdir_flag_spec\" 7100 fi 7101 compile_rpath="$rpath" 7102 7103 rpath= 7104 hardcode_libdirs= 7105 for libdir in $finalize_rpath; do 7106 if test -n "$hardcode_libdir_flag_spec"; then 7107 if test -n "$hardcode_libdir_separator"; then 7108 if test -z "$hardcode_libdirs"; then 7109 hardcode_libdirs="$libdir" 7110 else 7111 # Just accumulate the unique libdirs. 7112 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in 7113 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) 7114 ;; 7115 *) 7116 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir" 7117 ;; 7118 esac 7119 fi 7120 else 7121 eval flag=\"$hardcode_libdir_flag_spec\" 7122 rpath="$rpath $flag" 7123 fi 7124 elif test -n "$runpath_var"; then 7125 case "$finalize_perm_rpath " in 7126 *" $libdir "*) ;; 7127 *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;; 7128 esac 7129 fi 7130 done 7131 # Substitute the hardcoded libdirs into the rpath. 7132 if test -n "$hardcode_libdir_separator" && 7133 test -n "$hardcode_libdirs"; then 7134 libdir="$hardcode_libdirs" 7135 eval rpath=\" $hardcode_libdir_flag_spec\" 7136 fi 7137 finalize_rpath="$rpath" 7138 7139 if test -n "$libobjs" && test "$build_old_libs" = yes; then 7140 # Transform all the library objects into standard objects. 7141 compile_command=`$ECHO "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP` 7142 finalize_command=`$ECHO "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP` 7143 fi 7144 7145 func_generate_dlsyms "$outputname" "@PROGRAM@" "no" 7146 7147 # template prelinking step 7148 if test -n "$prelink_cmds"; then 7149 func_execute_cmds "$prelink_cmds" 'exit $?' 7150 fi 7151 7152 wrappers_required=yes 7153 case $host in 7154 *cygwin* | *mingw* ) 7155 if test "$build_libtool_libs" != yes; then 7156 wrappers_required=no 7157 fi 7158 ;; 7159 *) 7160 if test "$need_relink" = no || test "$build_libtool_libs" != yes; then 7161 wrappers_required=no 7162 fi 7163 ;; 7164 esac 7165 if test "$wrappers_required" = no; then 7166 # Replace the output file specification. 7167 compile_command=`$ECHO "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'` 7168 link_command="$compile_command$compile_rpath" 7169 7170 # We have no uninstalled library dependencies, so finalize right now. 7171 exit_status=0 7172 func_show_eval "$link_command" 'exit_status=$?' 7173 7174 # Delete the generated files. 7175 if test -f "$output_objdir/${outputname}S.${objext}"; then 7176 func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"' 7177 fi 7178 7179 exit $exit_status 7180 fi 7181 7182 if test -n "$compile_shlibpath$finalize_shlibpath"; then 7183 compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command" 7184 fi 7185 if test -n "$finalize_shlibpath"; then 7186 finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command" 7187 fi 7188 7189 compile_var= 7190 finalize_var= 7191 if test -n "$runpath_var"; then 7192 if test -n "$perm_rpath"; then 7193 # We should set the runpath_var. 7194 rpath= 7195 for dir in $perm_rpath; do 7196 rpath="$rpath$dir:" 7197 done 7198 compile_var="$runpath_var=\"$rpath\$$runpath_var\" " 7199 fi 7200 if test -n "$finalize_perm_rpath"; then 7201 # We should set the runpath_var. 7202 rpath= 7203 for dir in $finalize_perm_rpath; do 7204 rpath="$rpath$dir:" 7205 done 7206 finalize_var="$runpath_var=\"$rpath\$$runpath_var\" " 7207 fi 7208 fi 7209 7210 if test "$no_install" = yes; then 7211 # We don't need to create a wrapper script. 7212 link_command="$compile_var$compile_command$compile_rpath" 7213 # Replace the output file specification. 7214 link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'` 7215 # Delete the old output file. 7216 $opt_dry_run || $RM $output 7217 # Link the executable and exit 7218 func_show_eval "$link_command" 'exit $?' 7219 exit $EXIT_SUCCESS 7220 fi 7221 7222 if test "$hardcode_action" = relink; then 7223 # Fast installation is not supported 7224 link_command="$compile_var$compile_command$compile_rpath" 7225 relink_command="$finalize_var$finalize_command$finalize_rpath" 7226 7227 func_warning "this platform does not like uninstalled shared libraries" 7228 func_warning "\`$output' will be relinked during installation" 7229 else 7230 if test "$fast_install" != no; then 7231 link_command="$finalize_var$compile_command$finalize_rpath" 7232 if test "$fast_install" = yes; then 7233 relink_command=`$ECHO "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'` 7234 else 7235 # fast_install is set to needless 7236 relink_command= 7237 fi 7238 else 7239 link_command="$compile_var$compile_command$compile_rpath" 7240 relink_command="$finalize_var$finalize_command$finalize_rpath" 7241 fi 7242 fi 7243 7244 # Replace the output file specification. 7245 link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'` 7246 7247 # Delete the old output files. 7248 $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname 7249 7250 func_show_eval "$link_command" 'exit $?' 7251 7252 # Now create the wrapper script. 7253 func_verbose "creating $output" 7254 7255 # Quote the relink command for shipping. 7256 if test -n "$relink_command"; then 7257 # Preserve any variables that may affect compiler behavior 7258 for var in $variables_saved_for_relink; do 7259 if eval test -z \"\${$var+set}\"; then 7260 relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command" 7261 elif eval var_value=\$$var; test -z "$var_value"; then 7262 relink_command="$var=; export $var; $relink_command" 7263 else 7264 func_quote_for_eval "$var_value" 7265 relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command" 7266 fi 7267 done 7268 relink_command="(cd `pwd`; $relink_command)" 7269 relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"` 7270 fi 7271 7272 # Quote $ECHO for shipping. 7273 if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then 7274 case $progpath in 7275 [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";; 7276 *) qecho="$SHELL `pwd`/$progpath --fallback-echo";; 7277 esac 7278 qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"` 7279 else 7280 qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"` 7281 fi 7282 7283 # Only actually do things if not in dry run mode. 7284 $opt_dry_run || { 7285 # win32 will think the script is a binary if it has 7286 # a .exe suffix, so we strip it off here. 7287 case $output in 7288 *.exe) func_stripname '' '.exe' "$output" 7289 output=$func_stripname_result ;; 7290 esac 7291 # test for cygwin because mv fails w/o .exe extensions 7292 case $host in 7293 *cygwin*) 7294 exeext=.exe 7295 func_stripname '' '.exe' "$outputname" 7296 outputname=$func_stripname_result ;; 7297 *) exeext= ;; 7298 esac 7299 case $host in 7300 *cygwin* | *mingw* ) 7301 func_dirname_and_basename "$output" "" "." 7302 output_name=$func_basename_result 7303 output_path=$func_dirname_result 7304 cwrappersource="$output_path/$objdir/lt-$output_name.c" 7305 cwrapper="$output_path/$output_name.exe" 7306 $RM $cwrappersource $cwrapper 7307 trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15 7308 7309 func_emit_cwrapperexe_src > $cwrappersource 7310 7311 # we should really use a build-platform specific compiler 7312 # here, but OTOH, the wrappers (shell script and this C one) 7313 # are only useful if you want to execute the "real" binary. 7314 # Since the "real" binary is built for $host, then this 7315 # wrapper might as well be built for $host, too. 7316 $opt_dry_run || { 7317 $LTCC $LTCFLAGS -o $cwrapper $cwrappersource 7318 $STRIP $cwrapper 7319 } 7320 7321 # Now, create the wrapper script for func_source use: 7322 func_ltwrapper_scriptname $cwrapper 7323 $RM $func_ltwrapper_scriptname_result 7324 trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15 7325 $opt_dry_run || { 7326 # note: this script will not be executed, so do not chmod. 7327 if test "x$build" = "x$host" ; then 7328 $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result 7329 else 7330 func_emit_wrapper no > $func_ltwrapper_scriptname_result 7331 fi 7332 } 7333 ;; 7334 * ) 7335 $RM $output 7336 trap "$RM $output; exit $EXIT_FAILURE" 1 2 15 7337 7338 func_emit_wrapper no > $output 7339 chmod +x $output 7340 ;; 7341 esac 7342 } 7343 exit $EXIT_SUCCESS 7344 ;; 7345 esac 7346 7347 # See if we need to build an old-fashioned archive. 7348 for oldlib in $oldlibs; do 7349 7350 if test "$build_libtool_libs" = convenience; then 7351 oldobjs="$libobjs_save $symfileobj" 7352 addlibs="$convenience" 7353 build_libtool_libs=no 7354 else 7355 if test "$build_libtool_libs" = module; then 7356 oldobjs="$libobjs_save" 7357 build_libtool_libs=no 7358 else 7359 oldobjs="$old_deplibs $non_pic_objects" 7360 if test "$preload" = yes && test -f "$symfileobj"; then 7361 oldobjs="$oldobjs $symfileobj" 7362 fi 7363 fi 7364 addlibs="$old_convenience" 7365 fi 7366 7367 if test -n "$addlibs"; then 7368 gentop="$output_objdir/${outputname}x" 7369 generated="$generated $gentop" 7370 7371 func_extract_archives $gentop $addlibs 7372 oldobjs="$oldobjs $func_extract_archives_result" 7373 fi 7374 7375 # Do each command in the archive commands. 7376 if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then 7377 cmds=$old_archive_from_new_cmds 7378 else 7379 7380 # Add any objects from preloaded convenience libraries 7381 if test -n "$dlprefiles"; then 7382 gentop="$output_objdir/${outputname}x" 7383 generated="$generated $gentop" 7384 7385 func_extract_archives $gentop $dlprefiles 7386 oldobjs="$oldobjs $func_extract_archives_result" 7387 fi 7388 7389 # POSIX demands no paths to be encoded in archives. We have 7390 # to avoid creating archives with duplicate basenames if we 7391 # might have to extract them afterwards, e.g., when creating a 7392 # static archive out of a convenience library, or when linking 7393 # the entirety of a libtool archive into another (currently 7394 # not supported by libtool). 7395 if (for obj in $oldobjs 7396 do 7397 func_basename "$obj" 7398 $ECHO "$func_basename_result" 7399 done | sort | sort -uc >/dev/null 2>&1); then 7400 : 7401 else 7402 $ECHO "copying selected object files to avoid basename conflicts..." 7403 gentop="$output_objdir/${outputname}x" 7404 generated="$generated $gentop" 7405 func_mkdir_p "$gentop" 7406 save_oldobjs=$oldobjs 7407 oldobjs= 7408 counter=1 7409 for obj in $save_oldobjs 7410 do 7411 func_basename "$obj" 7412 objbase="$func_basename_result" 7413 case " $oldobjs " in 7414 " ") oldobjs=$obj ;; 7415 *[\ /]"$objbase "*) 7416 while :; do 7417 # Make sure we don't pick an alternate name that also 7418 # overlaps. 7419 newobj=lt$counter-$objbase 7420 func_arith $counter + 1 7421 counter=$func_arith_result 7422 case " $oldobjs " in 7423 *[\ /]"$newobj "*) ;; 7424 *) if test ! -f "$gentop/$newobj"; then break; fi ;; 7425 esac 7426 done 7427 func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj" 7428 oldobjs="$oldobjs $gentop/$newobj" 7429 ;; 7430 *) oldobjs="$oldobjs $obj" ;; 7431 esac 7432 done 7433 fi 7434 eval cmds=\"$old_archive_cmds\" 7435 7436 func_len " $cmds" 7437 len=$func_len_result 7438 if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then 7439 cmds=$old_archive_cmds 7440 else 7441 # the command line is too long to link in one step, link in parts 7442 func_verbose "using piecewise archive linking..." 7443 save_RANLIB=$RANLIB 7444 RANLIB=: 7445 objlist= 7446 concat_cmds= 7447 save_oldobjs=$oldobjs 7448 oldobjs= 7449 # Is there a better way of finding the last object in the list? 7450 for obj in $save_oldobjs 7451 do 7452 last_oldobj=$obj 7453 done 7454 eval test_cmds=\"$old_archive_cmds\" 7455 func_len " $test_cmds" 7456 len0=$func_len_result 7457 len=$len0 7458 for obj in $save_oldobjs 7459 do 7460 func_len " $obj" 7461 func_arith $len + $func_len_result 7462 len=$func_arith_result 7463 func_append objlist " $obj" 7464 if test "$len" -lt "$max_cmd_len"; then 7465 : 7466 else 7467 # the above command should be used before it gets too long 7468 oldobjs=$objlist 7469 if test "$obj" = "$last_oldobj" ; then 7470 RANLIB=$save_RANLIB 7471 fi 7472 test -z "$concat_cmds" || concat_cmds=$concat_cmds~ 7473 eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\" 7474 objlist= 7475 len=$len0 7476 fi 7477 done 7478 RANLIB=$save_RANLIB 7479 oldobjs=$objlist 7480 if test "X$oldobjs" = "X" ; then 7481 eval cmds=\"\$concat_cmds\" 7482 else 7483 eval cmds=\"\$concat_cmds~\$old_archive_cmds\" 7484 fi 7485 fi 7486 fi 7487 func_execute_cmds "$cmds" 'exit $?' 7488 done 7489 7490 test -n "$generated" && \ 7491 func_show_eval "${RM}r$generated" 7492 7493 # Now create the libtool archive. 7494 case $output in 7495 *.la) 7496 old_library= 7497 test "$build_old_libs" = yes && old_library="$libname.$libext" 7498 func_verbose "creating $output" 7499 7500 # Preserve any variables that may affect compiler behavior 7501 for var in $variables_saved_for_relink; do 7502 if eval test -z \"\${$var+set}\"; then 7503 relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command" 7504 elif eval var_value=\$$var; test -z "$var_value"; then 7505 relink_command="$var=; export $var; $relink_command" 7506 else 7507 func_quote_for_eval "$var_value" 7508 relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command" 7509 fi 7510 done 7511 # Quote the link command for shipping. 7512 relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)" 7513 relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"` 7514 if test "$hardcode_automatic" = yes ; then 7515 relink_command= 7516 fi 7517 7518 # Only create the output if not a dry run. 7519 $opt_dry_run || { 7520 for installed in no yes; do 7521 if test "$installed" = yes; then 7522 if test -z "$install_libdir"; then 7523 break 7524 fi 7525 output="$output_objdir/$outputname"i 7526 # Replace all uninstalled libtool libraries with the installed ones 7527 newdependency_libs= 7528 for deplib in $dependency_libs; do 7529 case $deplib in 7530 *.la) 7531 func_basename "$deplib" 7532 name="$func_basename_result" 7533 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib` 7534 test -z "$libdir" && \ 7535 func_fatal_error "\`$deplib' is not a valid libtool archive" 7536 newdependency_libs="$newdependency_libs $libdir/$name" 7537 ;; 7538 *) newdependency_libs="$newdependency_libs $deplib" ;; 7539 esac 7540 done 7541 dependency_libs="$newdependency_libs" 7542 newdlfiles= 7543 7544 for lib in $dlfiles; do 7545 case $lib in 7546 *.la) 7547 func_basename "$lib" 7548 name="$func_basename_result" 7549 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib` 7550 test -z "$libdir" && \ 7551 func_fatal_error "\`$lib' is not a valid libtool archive" 7552 newdlfiles="$newdlfiles $libdir/$name" 7553 ;; 7554 *) newdlfiles="$newdlfiles $lib" ;; 7555 esac 7556 done 7557 dlfiles="$newdlfiles" 7558 newdlprefiles= 7559 for lib in $dlprefiles; do 7560 case $lib in 7561 *.la) 7562 # Only pass preopened files to the pseudo-archive (for 7563 # eventual linking with the app. that links it) if we 7564 # didn't already link the preopened objects directly into 7565 # the library: 7566 func_basename "$lib" 7567 name="$func_basename_result" 7568 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib` 7569 test -z "$libdir" && \ 7570 func_fatal_error "\`$lib' is not a valid libtool archive" 7571 newdlprefiles="$newdlprefiles $libdir/$name" 7572 ;; 7573 esac 7574 done 7575 dlprefiles="$newdlprefiles" 7576 else 7577 newdlfiles= 7578 for lib in $dlfiles; do 7579 case $lib in 7580 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;; 7581 *) abs=`pwd`"/$lib" ;; 7582 esac 7583 newdlfiles="$newdlfiles $abs" 7584 done 7585 dlfiles="$newdlfiles" 7586 newdlprefiles= 7587 for lib in $dlprefiles; do 7588 case $lib in 7589 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;; 7590 *) abs=`pwd`"/$lib" ;; 7591 esac 7592 newdlprefiles="$newdlprefiles $abs" 7593 done 7594 dlprefiles="$newdlprefiles" 7595 fi 7596 $RM $output 7597 # place dlname in correct position for cygwin 7598 tdlname=$dlname 7599 case $host,$output,$installed,$module,$dlname in 7600 *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;; 7601 esac 7602 $ECHO > $output "\ 7603# $outputname - a libtool library file 7604# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION 7605# 7606# Please DO NOT delete this file! 7607# It is necessary for linking the library. 7608 7609# The name that we can dlopen(3). 7610dlname='$tdlname' 7611 7612# Names of this library. 7613library_names='$library_names' 7614 7615# The name of the static archive. 7616old_library='$old_library' 7617 7618# Linker flags that can not go in dependency_libs. 7619inherited_linker_flags='$new_inherited_linker_flags' 7620 7621# Libraries that this one depends upon. 7622dependency_libs='$dependency_libs' 7623 7624# Names of additional weak libraries provided by this library 7625weak_library_names='$weak_libs' 7626 7627# Version information for $libname. 7628current=$current 7629age=$age 7630revision=$revision 7631 7632# Is this an already installed library? 7633installed=$installed 7634 7635# Should we warn about portability when linking against -modules? 7636shouldnotlink=$module 7637 7638# Files to dlopen/dlpreopen 7639dlopen='$dlfiles' 7640dlpreopen='$dlprefiles' 7641 7642# Directory that this library needs to be installed in: 7643libdir='$install_libdir'" 7644 if test "$installed" = no && test "$need_relink" = yes; then 7645 $ECHO >> $output "\ 7646relink_command=\"$relink_command\"" 7647 fi 7648 done 7649 } 7650 7651 # Do a symbolic link so that the libtool archive can be found in 7652 # LD_LIBRARY_PATH before the program is installed. 7653 func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?' 7654 ;; 7655 esac 7656 exit $EXIT_SUCCESS 7657} 7658 7659{ test "$mode" = link || test "$mode" = relink; } && 7660 func_mode_link ${1+"$@"} 7661 7662 7663# func_mode_uninstall arg... 7664func_mode_uninstall () 7665{ 7666 $opt_debug 7667 RM="$nonopt" 7668 files= 7669 rmforce= 7670 exit_status=0 7671 7672 # This variable tells wrapper scripts just to set variables rather 7673 # than running their programs. 7674 libtool_install_magic="$magic" 7675 7676 for arg 7677 do 7678 case $arg in 7679 -f) RM="$RM $arg"; rmforce=yes ;; 7680 -*) RM="$RM $arg" ;; 7681 *) files="$files $arg" ;; 7682 esac 7683 done 7684 7685 test -z "$RM" && \ 7686 func_fatal_help "you must specify an RM program" 7687 7688 rmdirs= 7689 7690 origobjdir="$objdir" 7691 for file in $files; do 7692 func_dirname "$file" "" "." 7693 dir="$func_dirname_result" 7694 if test "X$dir" = X.; then 7695 objdir="$origobjdir" 7696 else 7697 objdir="$dir/$origobjdir" 7698 fi 7699 func_basename "$file" 7700 name="$func_basename_result" 7701 test "$mode" = uninstall && objdir="$dir" 7702 7703 # Remember objdir for removal later, being careful to avoid duplicates 7704 if test "$mode" = clean; then 7705 case " $rmdirs " in 7706 *" $objdir "*) ;; 7707 *) rmdirs="$rmdirs $objdir" ;; 7708 esac 7709 fi 7710 7711 # Don't error if the file doesn't exist and rm -f was used. 7712 if { test -L "$file"; } >/dev/null 2>&1 || 7713 { test -h "$file"; } >/dev/null 2>&1 || 7714 test -f "$file"; then 7715 : 7716 elif test -d "$file"; then 7717 exit_status=1 7718 continue 7719 elif test "$rmforce" = yes; then 7720 continue 7721 fi 7722 7723 rmfiles="$file" 7724 7725 case $name in 7726 *.la) 7727 # Possibly a libtool archive, so verify it. 7728 if func_lalib_p "$file"; then 7729 func_source $dir/$name 7730 7731 # Delete the libtool libraries and symlinks. 7732 for n in $library_names; do 7733 rmfiles="$rmfiles $objdir/$n" 7734 done 7735 test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library" 7736 7737 case "$mode" in 7738 clean) 7739 case " $library_names " in 7740 # " " in the beginning catches empty $dlname 7741 *" $dlname "*) ;; 7742 *) rmfiles="$rmfiles $objdir/$dlname" ;; 7743 esac 7744 test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i" 7745 ;; 7746 uninstall) 7747 if test -n "$library_names"; then 7748 # Do each command in the postuninstall commands. 7749 func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1' 7750 fi 7751 7752 if test -n "$old_library"; then 7753 # Do each command in the old_postuninstall commands. 7754 func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1' 7755 fi 7756 # FIXME: should reinstall the best remaining shared library. 7757 ;; 7758 esac 7759 fi 7760 ;; 7761 7762 *.lo) 7763 # Possibly a libtool object, so verify it. 7764 if func_lalib_p "$file"; then 7765 7766 # Read the .lo file 7767 func_source $dir/$name 7768 7769 # Add PIC object to the list of files to remove. 7770 if test -n "$pic_object" && 7771 test "$pic_object" != none; then 7772 rmfiles="$rmfiles $dir/$pic_object" 7773 fi 7774 7775 # Add non-PIC object to the list of files to remove. 7776 if test -n "$non_pic_object" && 7777 test "$non_pic_object" != none; then 7778 rmfiles="$rmfiles $dir/$non_pic_object" 7779 fi 7780 fi 7781 ;; 7782 7783 *) 7784 if test "$mode" = clean ; then 7785 noexename=$name 7786 case $file in 7787 *.exe) 7788 func_stripname '' '.exe' "$file" 7789 file=$func_stripname_result 7790 func_stripname '' '.exe' "$name" 7791 noexename=$func_stripname_result 7792 # $file with .exe has already been added to rmfiles, 7793 # add $file without .exe 7794 rmfiles="$rmfiles $file" 7795 ;; 7796 esac 7797 # Do a test to see if this is a libtool program. 7798 if func_ltwrapper_p "$file"; then 7799 if func_ltwrapper_executable_p "$file"; then 7800 func_ltwrapper_scriptname "$file" 7801 relink_command= 7802 func_source $func_ltwrapper_scriptname_result 7803 rmfiles="$rmfiles $func_ltwrapper_scriptname_result" 7804 else 7805 relink_command= 7806 func_source $dir/$noexename 7807 fi 7808 7809 # note $name still contains .exe if it was in $file originally 7810 # as does the version of $file that was added into $rmfiles 7811 rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}" 7812 if test "$fast_install" = yes && test -n "$relink_command"; then 7813 rmfiles="$rmfiles $objdir/lt-$name" 7814 fi 7815 if test "X$noexename" != "X$name" ; then 7816 rmfiles="$rmfiles $objdir/lt-${noexename}.c" 7817 fi 7818 fi 7819 fi 7820 ;; 7821 esac 7822 func_show_eval "$RM $rmfiles" 'exit_status=1' 7823 done 7824 objdir="$origobjdir" 7825 7826 # Try to remove the ${objdir}s in the directories where we deleted files 7827 for dir in $rmdirs; do 7828 if test -d "$dir"; then 7829 func_show_eval "rmdir $dir >/dev/null 2>&1" 7830 fi 7831 done 7832 7833 exit $exit_status 7834} 7835 7836{ test "$mode" = uninstall || test "$mode" = clean; } && 7837 func_mode_uninstall ${1+"$@"} 7838 7839test -z "$mode" && { 7840 help="$generic_help" 7841 func_fatal_help "you must specify a MODE" 7842} 7843 7844test -z "$exec_cmd" && \ 7845 func_fatal_help "invalid operation mode \`$mode'" 7846 7847if test -n "$exec_cmd"; then 7848 eval exec "$exec_cmd" 7849 exit $EXIT_FAILURE 7850fi 7851 7852exit $exit_status 7853 7854 7855# The TAGs below are defined such that we never get into a situation 7856# in which we disable both kinds of libraries. Given conflicting 7857# choices, we go for a static library, that is the most portable, 7858# since we can't tell whether shared libraries were disabled because 7859# the user asked for that or because the platform doesn't support 7860# them. This is particularly important on AIX, because we don't 7861# support having both static and shared libraries enabled at the same 7862# time on that platform, so we default to a shared-only configuration. 7863# If a disable-shared tag is given, we'll fallback to a static-only 7864# configuration. But we'll never go from static-only to shared-only. 7865 7866# ### BEGIN LIBTOOL TAG CONFIG: disable-shared 7867build_libtool_libs=no 7868build_old_libs=yes 7869# ### END LIBTOOL TAG CONFIG: disable-shared 7870 7871# ### BEGIN LIBTOOL TAG CONFIG: disable-static 7872build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac` 7873# ### END LIBTOOL TAG CONFIG: disable-static 7874 7875# Local Variables: 7876# mode:shell-script 7877# sh-indentation:2 7878# End: 7879# vi:sw=2 7880 7881