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