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