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